awslabs/aidlc-workflows v2.11.4 on GitHub

Summary

AI-DLC 2.11.4 makes Kiro one harness. aidlc config --harness kiro now sets up a single install that serves Kiro IDE and Kiro CLI on its v3 engine; Kiro CLI on its V2 engine is now --harness kiro-v2. Up to 2.11.3, kiro meant Kiro CLI (V2) and the shared harness was kiro-ide, a name that still works. A refresh keeps the Kiro harness a project has, so only people and scripts that type --harness kiro for Kiro CLI (V2) change what they type. On Kiro you also approve fewer of AI-DLC's commands, and a long request pasted after /aidlc reaches the work whole. Also in this release: in team work each hand-over between people is one question, and the three gaps 2.11.3 listed for team Units are closed; Inception reads your team's documents and asks only what they leave open, and the knowledge base reads Word, Excel and PDF files with nothing to install; Copilot CLI on Linux and macOS runs AI-DLC's routine commands without a dialog; plugins can add their own commands and house rules; /aidlc-issue-report gathers what a run left behind, with sensitive details removed; and corrections on every harness, Windows included.

Compatibility: breaking for scripts. Scripts are affected if they: pass --harness kiro for Kiro CLI (V2); allow AI-DLC's commands by name in a copilot -p job; run aidlc unit commands with no agent; pass --help or an option a command does not take to aidlc unit or aidlc system commands; add a repository by name alone, or onboard several knowledge documents in one command; read the status of aidlc doctor --json; or run unattended on the infra plan, or with an agent that installs system packages on finished work. See Script compatibility below. People on Kiro, team-owned Units, GitHub Copilot deny rules, a locked-down Windows PC or plugins have one step each below.

Upgrade

aidlc update
cd /path/to/project
aidlc config --yes
aidlc doctor

Open work carries on through the refresh. When a project contains multiple harnesses, run aidlc config --harness <name> --yes for each harness you want to refresh.

Kiro: AI-DLC has two Kiro harnesses, and a project holds one of them, in .kiro. Kiro (--harness kiro; --harness kiro-ide still works) serves Kiro IDE and Kiro CLI on its v3 engine (kiro-cli --v3). Kiro CLI (V2) (--harness kiro-v2) serves Kiro CLI on its V2 engine (kiro-cli --v2). The upgrade keeps the one your project has: aidlc config --yes, the line aidlc update prints, refreshes it as it is. If you name the harness, name the one the project has: aidlc config --harness kiro-v2 --yes for a Kiro CLI (V2) project. There, --harness kiro now asks whether to switch .kiro to Kiro in place, and with --yes it switches; aidlc/ and open work are kept, and --harness kiro-v2 switches back. On the copy channel, a Kiro project whose own tool is from 2.11.3 or earlier still reads kiro as Kiro CLI (V2): refresh it with --harness kiro-ide. On a Kiro CLI (V2) project that committed aidlc/.aidlc-forwarding-latch, take it out of git after the refresh (git rm --cached -f -- aidlc/.aidlc-forwarding-latch, then commit); doctor names the step.

Team-owned Units: no lead stays on 2.11.2 or earlier: it cannot merge a Unit published from 2.11.3 or later (its pin stops with Pinned candidate evidence is incomplete: Plan Approval fingerprint.). 2.11.3 and 2.11.4 work together both ways.

GitHub Copilot: on Copilot CLI, AI-DLC's commands now run through .aidlc/bin/aidlc-engine in the project. If you deny shell(bun) or shell(aidlc) to keep AI-DLC's commands from running, add --deny-tool='shell(.aidlc/bin/aidlc-engine)'; an administrator who blocks them in managed settings adds Shell(.aidlc/bin/aidlc-engine) and Shell(.aidlc/bin/aidlc-engine *) to the denies.

Windows: two kinds of Windows PC cannot take 2.11.4 with aidlc update and need the README's one-line installer (irm ... | iex) once: a PC where a Group Policy sets PowerShell's execution policy to AllSigned or Restricted, where aidlc update run by 2.11.3 stops on command pointer validation failed and puts 2.11.3 back (there, use that one line, not the download-and-run recipe under Fresh install, which such a policy refuses); and one where 2.11.3 stops every aidlc command with Windows uninstall recovery failed: invalid Windows uninstall journal(s) after an uninstall that stopped. After it, aidlc update, aidlc use and aidlc rollback go through.

Plugins: the test-pro plugin, and a plugin that adds an output to Functional Design or Infrastructure Design or brings agents for Kiro, take this release's fixes once built again with aidlc plugin build <harness> and installed again.

Manual-copy users must copy the complete runtime/<harness>/ tree from aidlc-copy-runtime-2.11.4.tar.gz. Copy it over the project following the copy-channel instructions. This installation path requires Bun 1.4.4 or newer but does not require the native aidlc executable.

Chat commands below use /aidlc; in Codex CLI, use $aidlc instead.

Fresh install

macOS and Linux

curl -fsSL https://github.com/awslabs/aidlc-workflows/releases/download/v2.11.4/install.sh | sh -s -- --version 2.11.4

Windows PowerShell

irm https://github.com/awslabs/aidlc-workflows/releases/download/v2.11.4/install.ps1 -OutFile install.ps1
Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass -Force
./install.ps1 -Version 2.11.4

On a PC where a Group Policy sets the PowerShell execution policy, the Set-ExecutionPolicy line can print an error saying the setting is overridden. The installer still runs unless that policy is AllSigned or Restricted; then it is refused, and your administrator can say how to install AI-DLC on that PC.

Highlights

Kiro

Which Kiro harness: use Kiro (aidlc config --harness kiro) if you work in Kiro IDE, in Kiro CLI on its v3 engine (Kiro CLI 2.24.1 or later), or both on one project. Use Kiro CLI (V2) (--harness kiro-v2) if you run Kiro CLI on its V2 engine. Setup's list names them Kiro and Kiro CLI (V2), and every command AI-DLC prints uses kiro and kiro-v2.
On a Kiro CLI (V2) project, --harness kiro first asks whether to switch .kiro to Kiro in place, and the switch goes through when Kiro CLI had upgraded AI-DLC's agent files and you had not edited them; aidlc config --help lists both names; and on Kiro CLI (V2) the agent says which command starts which engine and switches the project when you ask.
You approve fewer of AI-DLC's commands on Kiro: the aidlc agent and its helpers read and list your files with their file tools and check a Unit's changed files with an AI-DLC lookup instead of git status (in measured runs, the helpers' knowledge-folder listings went from 3 to 12 approval cards a run to none, and the git checks at Code Generation from 6 cards to 1); each AI-DLC command runs on its own; and a side-by-side build asks for its verification command before its workers start.
Shell characters in your words: a request holding $, a backtick, >, <, & or a line break reaches AI-DLC through a file instead of a command Kiro asks about; a quote escaped with a backslash keeps a later > or | inside the value on macOS and Linux; a message that only quotes an AI-DLC command in backticks is read as your words instead of running it; and on Kiro CLI (V2) a request with one double quote, or one that opens with a plan's name, gets a first call that runs.
The aidlc agent's skill ships as two files, so Kiro's 50,000-character limit on one resource file no longer cuts it; a message you type while Kiro CLI on its v3 engine works ("stop for today") is recorded as yours; and on a 200k model the chat-full line says, by Kiro's count, that a new chat on the same model will not help much.
The lines that get you going again: a switched-off hook names its file and setting for Kiro CLI; doctor's restart step ends then type /aidlc to carry on; a reply that was not recorded says you may be asked for it again; setup and doctor lead with Kiro CLI where kiro-cli is found outside Kiro IDE; for a Kiro CLI (V2) project the guide says AI-DLC's hooks run on v3 once Kiro CLI upgrades its agent files, and the recovery line says what to do when aidlc is not in /agent's list; and the Default-agent note says nothing when Approve for me is on and names /agent for Kiro CLI.
On Kiro IDE, a code plan approval is recorded where Kiro sends a plan write without its contents, a checkout that claimed a team Unit can take its steps, and in a Windows PowerShell terminal whose shell integration did not load AI-DLC keeps its replies in a file and doctor says what to check.
One Kiro guide, kiro.md, with Kiro CLI (V2) as its own section; it describes Approve for me, what Kiro CLI 3.1.0's approval card and allow rule cover, that its approve-all choice for a build's helpers can come back in the chat, and that Kiro CLI (V2) joins the lines of a request typed after /aidlc; its manual-copy steps keep your saved Kiro CLI settings when run again.

Your words and your answers

A long request pasted after /aidlc (a 30,000-character spec) reaches the work whole, line breaks kept, instead of its first 8,000 characters on Kiro; on Claude Code, Codex CLI, opencode and Kiro CLI (V2) the agent starts within seconds from the copy AI-DLC kept, instead of spending minutes retyping it (on Codex CLI a digit changed, on opencode the last line was lost); and tailoring a plan for such a request, or another request over work made from one, no longer stops on AI-DLC could not send its next step: it is ... bytes.
A question about where the work stands (/aidlc how far along are we?), with work open, parked or finished, or while a gate or question waits, is answered from the status and the decision stays open, instead of starting a stage, unparking the work or asking where your words belong.
When you type your request again in more words in a new chat while the plan question waits, the agent says I've used your newer request: "<your words>". and the work records those words; after work finishes, your next request gets its own plan question instead of being read as the answer to one you were never shown; and a setting you switch for your next work still holds after a status question.
A code plan question or stage approval put on your screen in one chat and closed unanswered is shown first in a new chat, and the pick you make there is recorded, instead of approve it typed in the new chat approving a plan that chat never showed.
An answer you gave is taken as given ("B, probably", a one-word "Postgres"), with no request to explain your pick, and how you want to answer is asked once per piece of work; a question from a questions file shows one Other choice on opencode, Cursor and GitHub Copilot; and the warning about a key in your message comes in the reply that answers it, also beside a typed /aidlc --status on both Kiro harnesses.
On Claude Code, the Claude desktop app's own notes ("The app was quit while you were working...") and a turn Claude Code starts on a timer (a /loop tick, a scheduled task) are no longer recorded as your words, so no gate is approved in such a turn and your "Request Changes" is the stage's feedback by itself.

Gates, reviews, and plan approval

At a reviewed gate with a finding still open you always hear, once, just above the question, what Approve accepts as risk and that you can ask for a fix or reject it; on Claude Code that line came about one gate in three.
A project that is not in git hears once, at its first gate, This project has no git, so AI-DLC can't undo the changes it makes to your files; to get an undo, run git init and commit them., instead of only at Code Generation after a file had changed.
Practices Discovery: the gate lists the rules Approve adds to project.md, one line each, and Approve writes exactly those (a draft saying "None." no longer becomes a rule); approving in a space made by /aidlc space create saves the practices instead of stopping on a missing heading; and an approval given beside a setting your team locked ("approve, and turn plan approval off" under a locked strict), or before the practices are saved, is recorded instead of stopping on an error.
The code plan question: an approval and a skip in one reply ("approve the plan, and skip build and test") keeps the approval and builds; a pick in a question box that also asks another question counts once; a plan approved and pushed is not asked again, or its answer blanked, on a clone (a teammate's, your second laptop, a Windows clone); turning plan approval on before a plan's build starts asks you about that plan; on Claude Code the question box shows the plan's summary lines and its path; the plan names each table or field it adds, with an Adds: line for any no requirement asks for; and AI-DLC writes the plan's Testing Contract itself, keeping a note you wrote under its heading, so the question comes even when the agent copied it wrong.
Under Guard Policy strict, lining up a finished document's Markdown table is no change; an edited finished document is asked about once a chat instead of on every step; a refusal over a changed document or plan names the files; and in a synced folder (Dropbox, OneDrive, Google Drive, Box, iCloud Drive) the refusal and doctor say sync can change files AI-DLC checks.
Reviews: under relaxed or off, the Code Generation review is told your approved plan changed after your approval and your setting did not ask again, so it no longer says an approval is missing; each review and each Unit's build starts in a new helper with the stage's rules; a stage finished in your other chat is shown at its gate ("This was finished in your other chat; here it is to approve.") instead of being written again; a stage's verdict waits for a reviewer working in the background to finish; and a recovery review whose answer was lost is retried instead of counted as used up.
Team checks in work built Unit by Unit: a blocking check runs at each Unit's checkpoint on that Unit's files and asks Fix findings or Override there, instead of only after the last Unit; an advisory check's findings come with the Unit's checkpoint question; "switch the checks off for this work" answers the check's question and the work goes on; at the end of Code Generation a failing check asks in plain words, takes "approve it anyway" the first time and is not asked again; and a check whose glob puts **/ before the file name, or whose result passes about 1 MiB (AI-DLC's own checks included), reports its findings instead of being recorded as could not run.
Requirements Analysis's summary stop is the one every stage shows; the phase-boundary traceability check runs once, in the stage that ends the phase, before you approve it; a forward jump's record no longer says traceability was verified; and a Code Generation refusal names the step in plain words instead of Plan Approval authority is ambiguous or stale.

Plans, jumps, and skips

Tailored plans: the offer names every stage the plan drops, the plan card shows the stock scope's own Guard Policy and settings, Approve creates the plan you saw even when the agent worked it out again on another base, and a plan change asked for mid-work ("what else can we cut?") leaves no hidden aidlc/.aidlc-compose-pending file, ends at its question every time and goes on after a Reject.
The infra plan now runs Code Generation and Build and Test (15 stages): Code Generation writes the Terraform or CDK under your code plan approval, Build and Test runs its static checks without applying anything, and Environment Provisioning applies what you approved, instead of reaching the Deployment Pipeline gate with no IaC written.
In Construction built Unit by Unit, a forward jump moves only the Unit in flight on and names, per Unit, the steps it skips with the way back, and Build and Test says once which Units have no code; after work finished at Code Generation, a redo (of a Unit too), an edit, a check switched off, a refresh or a plugins change goes through the first time instead of a refusal that sent you to /aidlc --doctor.
A stage run on its own (--single) hands its helpers that stage's rules and your team's; the offer to start separate work in a clean chat comes before the new work's first stage, naming your harness's own step (/chat new on Kiro CLI); and a scope command such as /aidlc-feature over finished work asks whether it is new work in your harness's own question.

Construction

Your files: the build changes a file you had before the work only when you ask or the work cannot be built without it, instead of whenever the agent's plan said so; a later Unit's line to put such a file back restores it as that Unit found it, keeping an earlier Unit's approved change; and .mjs, .scss, .less, F#, VB, Gradle, Razor and Windows script files count as code, so the build's approval no longer names your edits to them as files you had.
With the walking skeleton on, the Units after it go through their design stages instead of straight to Code Generation, and going back to another Unit while the skeleton waits asks that Unit's own code plan.
Side-by-side builds: a second Request Changes in a row at the batch checkpoint revises the plan with your new words, and a build cut off part way picks up where it stopped; a second chat leaves a build another chat started to that chat ("Your other chat started building these Units.") until you ask it to take over; the merge says it kept your change only once the Unit has landed; and under "Continue automatically" a landing the agent settled by hand reaches your next reply with its commit, git show and git revert.
Side-by-side builds no longer stop when a repository joins the work under way, when a passing test command prints more than about 1 MiB, or when a Unit has nothing to change (no empty commit is added); a Unit whose build committed AI-DLC's own files lands with its code only, on the first run; and a verification command stopped at its 30-minute limit says so instead of reading as failed.
Each Unit's notes for its stages are kept in the Unit's own folder (construction/<unit>/<stage>/memory.md), so a team Unit's notes land with it, in a run by one person too; and a ui Unit's Functional Design passes the traceability check on its design files instead of failing on business rules it does not write.
The agents' guidance matches their stages: requirements from the security and scalability templates use IDs the traceability check reads, existing code no longer pauses for a diff preview before Code Generation, Delivery Planning no longer recommends stages to skip, Reverse Engineering's Approve names the stage that really comes next, and an infra plan's CI Pipeline reads the file its Build and Test writes.

Team work and Units

The three gaps 2.11.3 listed are closed: under the end-of-Unit rhythm a skipped stage no longer stops the Unit's approval; the merge question names each stage you approved with a finding open, with its severity, instead of "passed review cleanly"; and a change you ask for to an approved stage in the claimed checkout reopens it as your change, in your words (a redo typed in words, or /aidlc --stage <stage>, reopens the Unit's own stage too).
Each hand-over between people is put to you as one question when it is due, and a yes runs it: the lead shares the plan's Units, a teammate's clone takes one (each choice says what waits on it, and "2, call us Payments" sets the team's label), a team with an approved Unit commits and publishes it, and the lead reviews, merges and pushes. "Not now" leaves a line on the board; a teammate's fresh clone no longer starts building the lead's first Unit, and /aidlc --claim <unit> typed as its first message claims the Unit there. A project in a folder of a bigger repository is told team work needs it at the repository's top, instead of being offered a share that fails.
Publish and share: the share, push and publish questions name the files of yours they commit (changed, new and deleted, up to ten) and the line after says what was committed, and a removal or rename you staged with git is committed instead of stopping on git add failed; "Commit and publish" commits only the Unit's own work and says which new files it left out (--include <path> adds one); on Windows a publish of 800 or more new files goes through; and publish, pin and land name a record the branch changes outside the Unit's folder, with the way to take it out.
Pin and land: pin takes a complete Unit in a real project, with a rule you kept while working it and a stage diary written after the review; landing leaves the Unit's review records out of main; a Unit lands only after the Units it depends on (/aidlc unit status says what it waits on); and moving main on to Build and Test once a team has taken a Unit runs Build and Test while that Unit stays open and still lands (work an earlier release already moved past the Unit stages merges nothing and says why).
Changing the Unit plan mid-Construction: asking to add, split or drop a Unit offers the go-back to Units Generation first; main runs Units Generation and Delivery Planning again, keeps every landed Unit and its reviews, sends back a plan that would drop a landed or claimed Unit, gives each new Unit its row, and leaves a published Unit current unless its own entry changed; a claim made meanwhile says the risk once; and after the go-back the teams keep their Units and their approval rhythm.
In a teammate's checkout: the Unit's last gate offers its landing, not Build and Test; "Start the stage over" and recording the Unit's completion work from the recovery question; a teammate's Unit starts beside the lead's Unit in progress; a finished Unit gets its publish or the wait ("Once it lands on main, pull main here"), never the work's Build and Test, also on a plan that ends at Code Generation; and its gate no longer asks you to mark it finished.
On a team's main that builds its own Units: your Redo is carried out instead of asked again, a bare "redo" redoes only the step the Unit is on, a skip is for that Unit only with its way back, Request Changes at an end-of-Unit approval keeps the Code Generation you skipped, a lead asking to redo a finished Unit is told it is finished and what the checkout builds, and once a team has taken a Unit a redo for every Unit reopens only your checkout's Units and says which it left; and a lead whose teams hold the Units can pause main's own work, and "approve, and stop there" stops.
The team's answer that it does not build a thin end-to-end slice first counts from the start, also in a share right after picking Several teams, so teams can take every Unit whose dependencies are done; and Delivery Planning no longer says the AI developer builds every Unit, leaving who builds them to the question at Construction.
Team work reads its branch from one - **Integration branch**: <name> line under Way of Working, never from a sentence that also names the repositories; for work begun before this release the agent reads the words once before the first team step, records the line and says which branch and file (a team on develop stays on develop).
A team Unit's approval records only that Unit's open decisions; a lead's plan approval counts after their own checkout claims the Unit; the team board and notices are shown as AI-DLC wrote them on every harness; --help on a unit command prints its usage and never commits or pushes; /aidlc unit status lists each claim with its owner and the code unit release asks for; and a team name with an apostrophe or & is recorded whole on Windows.

Knowledge base and team documents

Inception reads your team's documents in the knowledge base and puts the questions they already answer into one first question, each with its answer, document and a short quote, to confirm or change; what no document says, or two disagree on, is still asked, and a document you name when the work starts is filed for that work.
Word documents, Excel workbooks and PDFs are read with nothing to install, on every harness and platform (a PDF where pdftotext is missing); files added before are read at the next /aidlc knowledge sync, and a file AI-DLC cannot open says why.
A document the knowledge base cannot read yet (an old .xls, a scanned page) is named once per piece of work with what to do, and aidlc doctor lists them.
/aidlc knowledge onboard adds every document you name and names any it cannot add with why; onboarding a changed original again updates its copy in place, so it stays the same document; and on a copy install, on both Kiro harnesses too, a file from outside documents/ is added instead of documents does not exist.
The rule files each stage hands the agent leave out the template's comments, so most stages start in fewer round trips; and a new project's rule files say your team's practice replaces a framework default, give classic no coverage floor and ask no trace to Ideation on plans that skip it (an existing project's files are kept as they are: edit them to take the new wording).

Installs and guards

A system package install nobody asked for now waits for your go-ahead on finished and archived work too, as on running work; an install you ask for in the same message that approves runs on that message.
A project script whose text sends a report to a folder named audit is written, and a command running scripts that share helpers is checked in milliseconds instead of hanging; the code plan written through the shell (cat > plan <<'EOF', tee, or apply_patch <<'PATCH' on Codex CLI) is read as the write it is instead of refused as unreadable.
A background helper's record is kept in aidlc/.aidlc-sessions/, so git status no longer lists it and git add -A cannot commit it.

Reverse Engineering and many repositories

In a project with code of its own, a git submodule is no longer recorded as the work's repository; work from an earlier release that recorded one asks once to take it off, and the changed-files check then says only what changed.
Asking for a repository no repos.json lists asks you once for its address, instead of AI-DLC cloning a guessed git@github.com:<org>/<name>.git.
A repository that joins work under way is no longer read as changed at the code plan question, the review or the build's start; a command run from a repository inside the workspace is recorded in the workspace's work instead of leaving an aidlc/ folder there; and a Unit's changed-file list written from the workspace folder is sent back to the agent before any review, so your approval covers the code it wrote.
A folder whose code is Terraform, HCL or Bicep starts as existing code; the snapshot says a path is outside the project or names the --repo that reads it; doctor names a recorded repository with no folder in the workspace; and Reverse Engineering's helper is handed its folders, so Claude Code on Windows asks you to allow fewer commands.

Status, audit, and reports

/aidlc-issue-report ($aidlc-issue-report on Codex CLI, or ask for an issue report) gathers what AI-DLC and your harness left on this machine for a run that went wrong into one folder under aidlc/diagnostics/issue-reports/, with names, company and project details and what you wrote replaced by labels; it asks you to read its cover first and never sends anything.
Each decision of yours records your git user name (never set, no email), and /aidlc --status says Last Completed: <stage> (approved by <name>); a question's record keeps the choice the agent recommended.
/aidlc --status in work built one Unit at a time says where each Unit stands and what comes next (Unit 2 of 6: u1 done, u2 at Functional Design, ...), instead of 0/6.
aidlc doctor --export shows Construction autonomy, the Unit walk order, jumps and each Unit's progress, with Unit names hashed, and leaves out a paused Unit's reason and next-action text; aidlc doctor no longer warns about a stage waiting for your approval or a hook that fires only on rare events, and its --json and --quiet count the workflow warnings the plain report shows.
On a project worked from more than one clone, the session-cost, replay and outcomes reports count your approval right after you give it, and OUTCOMES.md no longer tells your team to discard the state file and answers.

Setup, configuration, and lifecycle

aidlc version reports 2.11.4 on all seven harnesses, and in a pinned project also names the release that runs its work.
Work begun on AI-DLC 2.1.x to 2.3.0 resumes after an update, brought up in place with every approval kept (the old record stays beside it as aidlc-state.v7.md), instead of being refused; and a project an older AI-DLC (2.1.1 to 2.7.0) copied in refreshes, telling its unchanged files from yours, and passes doctor's command-trust row.
In a new git worktree of a project (the Claude desktop app makes one per session), /aidlc carries on the space and work the main checkout is on, and a pinned project's worktree runs its pin instead of asking for aidlc config --pin again.
--help on aidlc system rollback, versions prune and versions install, and on aidlc engine runtime and plugin commands, prints the usage and changes nothing (before, versions prune --help deleted the retained releases), and aidlc config --help lists --harness with every name it takes.
aidlc config --channel says what the next aidlc update moves to; config's rerun lines never print a release mirror's address; doctor no longer warns that runtime-graph.json is out of date after aidlc config; a folder with no AI-DLC setup names aidlc config for it; reopening step 1 of Customize setup keeps your MCP answer; and a release whose provenance does not verify names the repository it was checked against.
In a project set up for more than one harness, each harness's chat gets its own steps (its hooks-off step, its way back, its clean-chat step), instead of the first setup's lines.
aidlc update of the release you already have no longer downloads its binary again; the end of a first aidlc config names every folder it wrote, and its outstanding actions open with their section instead of an internal id; doctor's Harness CLI row names your CLI's version once, on one line; and aidlc engine gen runners --check names a missing Reverse Engineering runner.
The guides: the documentation links in your project and the guides' section links open the page and section they name; the install, harness and troubleshooting pages give the setup steps the product needs (both VS Code settings for GitHub Copilot, Bun for a manual copy, copy lines that no longer nest a second .opencode/ or .agents/ folder); and the phases, scope, approval, knowledge, state, guard, bugfix and doctor pages and the reference say what the product does.

Plugins

A plugin can add commands, run as aidlc <name> in any shell and /aidlc <name> in the chat, listed by aidlc --help; and house rules, kept in a section of their own at the level it names (/aidlc plugin select --rules-level <plugin>=<org|team|project> changes it), taken out when the plugin is turned off.
A plugin's per-Unit stage runs with its Unit, before Build and Test; a stage a plugin adds after the work started gets its progress row, and a skip or add of it holds; an output a plugin adds to Functional Design or Infrastructure Design composes; the missing-plugin row says one composed from its folder keeps working; the test-pro plugin's checks run on a native install and its steps are done before the stage's approval; and aidlc plugin test without --harness runs on a project set up for one harness (a Kiro harness, GitHub Copilot or opencode).

Harness by harness

Claude Code: auto mode lets AI-DLC's agents run, each given the stage's rules as it starts, instead of refusing every one; a .claude/settings.json without AI-DLC's hooks gets aidlc config --harness claude in the hooks-off line, and one that is not valid JSON is named and left as it is; under "Continue automatically" the turn ends while a background helper works; AI-DLC's commands written with the project's full path run without a prompt; a reviewed stage run on its own after the work finished keeps its reviewer; and the cost shown prices Sonnet 5.5 cache reads and Haiku 5.5 at their list rates.
Codex CLI: a questions file letters each question A to C plus X (Other), so it fits Codex CLI's answer box, and a native install's onboarding names Codex CLI's own permissions; on Windows, a call AI-DLC's checks refuse (a code change before you approve the plan, a change to a reviewed document, a write into AI-DLC's own audit trail or hooks) is now held with the same words as on Linux, instead of Codex CLI running it anyway; and with an AGENTS.override.md in the project, doctor checks that file, the one Codex CLI loads, says what it reads there and offers to copy AI-DLC's block in, keeping your text; AI-DLC never writes it.
GitHub Copilot: on Copilot CLI on Linux and macOS, AI-DLC's routine commands and its record of your work go through without a dialog (a release journey went from 22 or more dialogs to 2 or fewer), while your code, the rules files and commands that change things still ask; a stage document saved with apply_patch is recorded, so its review starts; and its reviewer agents carry their review checklist, as on every other harness.
Cursor: under Guard Policy strict or relaxed, the helper that builds a Unit runs its builds, tests and searches instead of being refused at every build and test step; AI-DLC's checks before each tool call take about a quarter of the time; and the onboarding and guide say which stages hand work to a separate agent and what a helper is refused.
Windows: the installer works when your profile folder's name has an accented letter; installing, aidlc update, aidlc use and aidlc rollback go through under a Group Policy AllSigned or Restricted execution policy, and the install recipes allow scripts in their own window first; on a clone with Windows line endings /aidlc --scope bugfix really switches the work to the new scope's stages; after an uninstall that stopped and lost its record, commands run again and uninstall or the installer clears what it left; and aidlc uninstall --purge removes Kiro IDE's terminal records instead of listing them as files AI-DLC did not install.

Script compatibility

aidlc config --harness kiro now sets up or refreshes Kiro (Kiro IDE, and Kiro CLI on its v3 engine); pass --harness kiro-v2 for Kiro CLI (V2). On a Kiro CLI (V2) project, --harness kiro --yes switches .kiro to Kiro in place; without a terminal and without --yes, --dry-run or --plan-token it changes nothing and exits 2; and a config section with --harness kiro (such as aidlc config models --harness kiro ...) is refused with project uses kiro-v2; refusing kiro. aidlc plugin build kiro builds the Kiro plugin. The --json fields harness and distribution, harness.json and AIDLC_HARNESS_NAME keep the ids (kiro is Kiro CLI (V2)), so a script that passes a stored id back as --harness kiro now selects Kiro. On the copy channel, a refresh handed over by a project tool from 2.11.3 or earlier with --harness kiro on a Kiro project now exits 2 without a terminal instead of switching it to Kiro CLI (V2); use --harness kiro-ide.
a copilot -p job that allows exactly shell(bun) or shell(aidlc) adds --allow-tool='shell(.aidlc/bin/aidlc-engine)', or Copilot CLI refuses AI-DLC's commands; a --deny-tool of shell(bun) or shell(aidlc) no longer stops them (see the GitHub Copilot step above).
team work reads its integration branch only from a - **Integration branch**: <name> line under ## Way of Working in project.md, team.md or org.md. While a file has Way of Working words but no line (every team project from an earlier release, its org.md included), aidlc unit share pushes nothing and aidlc unit claim, status, publish, pin, gate, land and release exit 1 naming the read step, until an agent records the line. A script that runs aidlc unit commands with no agent adds the line to team.md or project.md first.
every aidlc unit command prints its usage and exits 0 for --help or -h, and exits 2 with {"error":"unit <verb> does not take <word>", ...} for a word or option it does not take, where both were ignored and the command ran; unit pin and unit land exit 1 for a claimed Unit whose dependencies have not landed on main; and the aidlc unit pin JSON's evidence.reviewers_approved_over_concerns is a list of {stage, findings} objects instead of stage names.
aidlc system rollback, aidlc system versions install and aidlc system versions prune print their usage, exit 0 and change nothing for --help or -h, and exit 2 with unknown <command> option <flag> for a flag they do not read (such as rollback --dry-run), where before the command ran; aidlc engine runtime and aidlc engine plugin list|sync with --help print their usage instead of running.
aidlc engine intent add-repo <name> with no --url, for a repository not on disk and not in repos.json, exits with an error and clones nothing, where it cloned git@github.com:<org>/<name>.git; list such a repository in repos.json ({ "name": "<name>" }) or pass --url.
aidlc engine knowledge onboard with several paths takes every path, where it took the first and exited 0; paths that together pass the batch cap add nothing and exit non-zero, and when none can be added it exits non-zero with Nothing was added: .... Its JSON adds not_added.
a system package install the agent starts on finished or archived work, which no plan you approved names, is held in unattended runs (AIDLC_UNATTENDED=1) too, as on running work since 2.11.3; install those tools in the job before AI-DLC starts.
the infra plan runs 15 stages instead of 13, adding Code Generation, with its code plan approval, and Build and Test.
aidlc doctor --json says "status": "warning", where it said "ok", when the workflow has warnings the plain report shows (such as hooks that have not run for a day), and lists each in data.checks; --quiet counts them; ok and the exit code are unchanged. aidlc engine gen runners --check exits 1 for a missing Reverse Engineering runner, and no longer for a project's own skill on a stage the install switched off.

Contributors

Thank you to everyone who contributed to this release: @wowzoo, @maksymskuibida, @vnlebaoduy, @csotomon, @Sibakeny, @szsunyuan, @xuanh251, @chiliec, @ClintEastman02, @enzo-loren, @Flolight, @fsatsuki, @kumachan99, @peepeepopapapeepeepo, @rndjams.

New Contributors

@enzo-loren made their first contribution in #3378
@peepeepopapapeepeepo made their first contribution in #3379
@Sibakeny made their first contribution in #3414
@xuanh251 made their first contribution in #3459
@ClintEastman02 made their first contribution in #3568
@rndjams made their first contribution in #3574

Promoted from v2.11.4-preview.20261112.1, source 161ddb82338f8d471063dab853cce35dbbcbefb6.

Full Changelog: v2.11.3...v2.11.4

awslabs/aidlc-workflows v2.11.4 AI-DLC 2.11.4 on GitHub