AI-DLC 2.11.2

Summary

AI-DLC 2.11.2 rolls up the user-visible changes merged since 2.11.1: your replies are read in your own words at every question and from any chat, and the record keeps the reply each decision was made on; the learnings step asks only when you corrected the agent; far fewer gates end in a question with no way on, under Guard Policy strict too; plan switches, skips, undos, jumps and single-stage runs carry on from where you are; a workspace of many repositories reaches Reverse Engineering's gate and can take a new repository at any stage; side-by-side builds start from your own branch, land back on it and bring their record edits home; Code Generation names any file you brought that it changed, with the way to put it back; aidlc config --yes asks nothing at a terminal; and corrections on every harness, Windows included.

Compatibility: breaking for scripts. Only scripts and CI jobs that refresh a copied project on a machine that also has a native aidlc, that drive AI-DLC without AIDLC_UNATTENDED=1, or that take Claude Code's Amazon Bedrock settings from the committed project are affected; see Script compatibility 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.

Manual-copy users must copy the complete runtime/<harness>/ tree from aidlc-copy-runtime-2.11.2.tar.gz. Copy it over the project following the copy-channel instructions. This installation path requires Bun 1.3.8 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.2/install.sh | sh -s -- --version 2.11.2

Windows PowerShell

irm https://github.com/awslabs/aidlc-workflows/releases/download/v2.11.2/install.ps1 -OutFile install.ps1
./install.ps1 -Version 2.11.2

Highlights

Your words and your answers

• At a stage's approval question and at AI-DLC's own questions (the code plan question, Unit and batch checkpoints, the verification command, a guard's recovery question), your reply is read in any words against the choices shown, and the record keeps that choice with your words whole: a typed 3 for "3. Approve, and add User Stories next" does what it says, "finished" or "ok I'm done" counts as done, "Nothing to add. Approve, and move on" approves from that one message, and "fix them first" at a blocking check picks Fix findings. A 2 for Request Changes at the code plan question asks once what should change instead of revising the plan from "2"; in a guided run an answer is recorded the first time, with nothing read back; and a lone letter ("a", "b") at a question shown with numbers or in a box is asked about once (Did you mean Approve or Request Changes?) instead of taken as your pick.
• Your replies count from any chat on the work: /aidlc postgres in a second chat, answering a question asked in the first, is recorded instead of starting new work; /aidlc 2 or /aidlc request changes: ... at a guard's recovery question after a resume is carried out; an approval typed while another AI-DLC question was on screen counts when the agent names that message; "looks good, build it, and turn the specialist reviewers off for the rest of this work" does both. Under "Continue automatically", /aidlc Guide me typed as an answer counts as the answer, "use bun test, and stop for today" answers and parks, "let's stop here for today" pauses the work even in a Claude Code or Codex chat whose hooks were off from its start, and a new chat shows the open question again word for word and waits.
• New words beside work in progress: at the question about where they belong, a bare "yes" asks which of the three you meant instead of starting separate new work; "Separate new piece of work" says the size of the plan it starts, or that you pick its plan next, and "2" there leads to that plan question, not the agent picking a plan (on Kiro, in a clone with no work selected, not an Unknown scope error), and "2, as express work" gets one confirmation of that plan, with its size; "Separate work, but use the classic plan" starts it on classic, and a plan you name there takes each stage you skipped or added with your request that it can, while one it already makes, or one the work starts without, is said once instead of refused or dropped unsaid; in a teammate's clone a request gets one question, which work it belongs to, naming the plan, not two; the Other answer gets a plan reshape proposed for what you said, put to you before anything moves; and another plan's name typed alone (/aidlc workshop) is read, with one question when the agent cannot tell whether you meant new work on that plan or this work moved to it.
• In a run you are driving, the turn ends where the agent waits for you, with no "AI-DLC is carrying on with ." line added. When the agent stops mid-stage with nothing to ask, say "go on". Under autonomous Construction and in unattended runs AI-DLC still carries on by itself.
• "Use the recommended answer for every question and finish the stage now. Do not ask me anything." turns the summary confirmation and the learnings step off for that piece of work (keeping no learnings until you ask for them back), says so in one line with how to turn them back on, asks nothing about the whole project, and stops at the stage's approval gate. A change you ask for at a question is made even when it differs from a practice your team recorded (the agent may say so in one line); a team's locked strict Guard Policy still holds, and its line names the file.
• A summary confirmation counts only on your reply to a summary you were shown: the agent shows the summary and ends its turn, so an "approve" typed earlier, or a "Looks correct" recorded in the same turn, no longer confirms it in your name. When the questions file was written after your reply you may be asked to confirm once more; it never loops.
• The learnings step before an approval asks only when you corrected the agent in that stage (Request Changes, or in your own words), once per correction worth keeping: You asked me to <your change>. Keep that for next time? (Yes, for this project; Yes, for the team; No). With nothing corrected, the summary goes straight to Approve or Request Changes; "approve, and next time use the shared fixtures" is kept with no question, and the agent says where; the agent's own notes are never offered; and nothing you did not keep is written to project memory; a kept correction worded as a setting (Methodology: tdd) is read as that setting, not refused.
• Questions fit each tool: on Claude Code a stage's questions file letters each question A to D plus X (Other), so it fits the question box instead of being refused, losing an option or split in two, and a one-choice question is asked, numbered, in the chat instead of a box that shows Invalid tool parameters. On Claude Code and Codex a question with more options than the box takes is asked once as a numbered list (Reply with all numbers that apply (e.g. 1, 3).) instead of split in two; on Codex a question box that closes unanswered comes back as the same question in numbered prose; a choice with a comma in it comes back whole in a new chat; and a question asked in chat shows who would answer it (Q1. [Product owner] ...).
• The record keeps what you said for what you decided: the work you start is recorded in your own words and spacing, even when the agent retypes or rewords them; each answer, summary confirmation and approval keeps the reply given for it, and a code plan approval after a resume names the message it was given in; a question box of several questions keeps every pick (on Codex also with one left blank), an empty submit records no words, a choice with a $ in it ("Show $0.00") is recorded as written (and on Claude Code asks no permission), an answer after [Answer]: in the code plan's questions file is kept on the approval's record as written, conditions included, an answer the agent chose from your message says so, a question the agent logs after your reply had answered another no longer carries that reply, and a Unit redone by AI-DLC's own recovery is recorded as a redo, not your request. Only your messages count as yours: a Claude Code helper's hand-back, Copilot's echo of AI-DLC's Stop note, opencode's note about the file open in your editor, and a Kiro workflow that failed or stopped no longer count as your reply; a message of yours that repeats AI-DLC's words is yours; on Kiro CLI a message typed while the agent works ("stop for today") is yours, so a stop parks the work on your words; and on Copilot CLI a message sent just as a helper starts counts as yours.
• A key, token or password you type in the chat is masked in AI-DLC's committed record of the work (password=[masked]), and when AI-DLC sees one it says once to change it where it was issued if it is real, since the chat still received it. It is matched by shape only (a plain "my password is hunter2" is kept as typed), a document the agent writes from your message is not masked, and records written before this release are not rewritten.
• The agent no longer reads AI-DLC's own bookkeeping aloud (field and step names, or a stray label before its first line), and with collaborators off it says the developer works alone; a line you need to hear (such as where the work picks up, or to change a key you typed) comes in the agent's last message before you reply, so claude -p, copilot -p and headless Kiro CLI give it to you too; the first summary names the depth and test strategy the work really runs at; on Kiro, after a lone "4" (Other), the agent asks what you want instead; and affirming an unchanged project rule on a later day keeps one copy of it.

Gates, reviews, and plan approval

• Far fewer " can't go ahead as things stand: which way would you like to go on?" questions with no way on: an Approve at a gate that was open when summary confirmation turned on goes through; on a stage this work runs without a review the agent opens the gate itself; a retried review that again wrote no whole review is recorded as not finished and the work moves on (on Claude Code once no reviewer still runs in the background); after Request Changes a finished review is recorded the first time, whatever round number the reviewer wrote; a revision the agent reports before its review gets the review, not an offer to start the stage over, while rejecting a finding with nothing changed since the review brings the same gate back at once, not a second review or "Start the stage over"; under relaxed or off, a review the agent starts on its own after your change no longer says the Unit can't go ahead; a parallel Functional Design whose builders skipped the questions asks you them; and under strict a test cache you excluded in the .aidlc-source-paths.json of its own folder (the project's, or a recorded checkout's) no longer blocks approval on a plan with no Units, and the refusal names what changed and which file the exclude goes in.
• Under Guard Policy strict (enterprise's default): a Unit sent back at its checkpoint, or a redo of a built Unit's Code Generation, gets its changed code reviewed and asked about again, not a refusal every round; work picked up from a fresh clone or another machine finishes Code Generation with one line, not a restart that asked every approved plan again; with plan approval off, a change to the project between handing out a side-by-side batch and setting it up no longer makes setup ask to approve a plan nobody was asked about (the first Unit's landing still stops on it, as the guide says); an edit the agent tries on its own to a document whose review was final is not made, and the agent says at the next gate what it meant to change, for you to decide; your Approve at a stage that asks its questions through a file is taken; after a recovery review passes, the approval you already gave is recorded, not asked for again; a change to a stage's documents after the reply that approves it, before your next message, is taken with that approval (an edit the agent makes there unasked is said in its own line); Reverse Engineering's open gate stays where you left it across a team clone, a copy of the project folder or a branch switch, not a full rescan; an edit no Unit claims after the last review is named first, so the Unit that made it lists it and the approval completes; a summary you confirm again after its documents exist has the agent save the rest itself, not ask you to confirm again; and with Units built one at a time, Request Changes about a finished Unit's design sends back that Unit's step only.
• The review summary before an approval says what the review found, once: a ready review with only minor points reads as ready with a suggested change; a stage's gate says which open findings Approve accepts as risk, and that you can ask for one to be fixed or reject it, saying why; findings the work was changed to fix read Changed after review (under Guard Policy off or relaxed; under strict a changed file is reviewed again); and a change after the review is said once. The record says who decided: those findings are recorded as Changed after review, and one nobody showed you (Units approved under "Continue automatically", or a finding raised after a Unit's approval) as Approved autonomously, kept open for the next review, not Accepted risk; "approve, but make sure R-03 gets handled" records Fix requested, at a gate or a Unit's checkpoint, so the next review checks it again, and a finding you reject at a checkpoint keeps your reason instead of coming back; a review signed by the wrong reviewer sends the agent back for the one you were told about, and one another helper wrote in the reviewer's place, even signed with its name, is said to you on every tool but Cursor CLI; an approval reported for a gate you were never shown, with no reply of yours in that chat, is not recorded and the question comes to you; while the code plan question waits, plan approval goes off only on a message sent after the plan is shown ("approve, and turn plan approval off" said earlier gets that plan asked once, with one line saying why); a setting changes only on a message that asked for it, so an earlier "Approve" or "that's right" to something else no longer turns learnings or the summary confirmation off in your name, and "approve, and turn plan approval off" does both in one reply; an answer you gave before a stage's document was written no longer approves its gate, which is shown to you instead; and going back to an earlier phase no longer records the phase you left as completed, while jumping past a whole phase records it as skipped.
• At the Code Generation gate, a reviewed file that changes before you answer (the agent fixing a finding it just showed) brings the gate back once with the change said, not a silent loop that undid the fix; after a compaction on Claude Code with the plan approved, the gate opens on the first report; while the code plan waits, a command line that starts by changing to the project folder (cd <project> && aidlc doctor) runs doctor, status and next (in PowerShell, quote the path or join with ;); and /aidlc --status, plain or with --intent or --space, says the work waits for your approval of the code plan (or for you to finish editing it), not Running. Stopping for the day at the code plan question no longer drops the change you had just asked for from its record (a plain resume in a new chat still asks the plan question without showing it). Approving the code plan with a change in the same reply ("A, approved. one condition: ...") puts the change into the plan first, so the approval covers it with no second question; reading the work's own files through a shell variable runs while the plan waits; with plan approval off, the plan line says you can ask to go over the plan instead of asking while the build already runs; and under relaxed, once an approved code plan changed, the line beside each build step names plan re-approval, the check relaxed lowers, not that plan approval is off.
• Accept as-is comes on offer after three change requests on the same stage, counted across parks and new chats, and /aidlc --status shows that stage's own revision count. At Requirements Analysis and Domain Design the gate can offer "Approve, and add next" when a skipped stage fits, and "Approve, and add User Stories next" on a bugfix, express, poc, infra, refactor or security-patch run adds User Stories and starts it in the same turn.
• Checks at the gate: the advisory checks run on the finished documents before the review (not yet for Units built side by side), so the agent fixes its own slips, such as a missing source tag, and the gate names only what is left; the traceability check reads requirement IDs as Requirements Analysis wrote them, so far fewer gates report traceability findings with no real gap; a file written the way its stage says reports no heading findings, a team template's headings match with or without a leading emoji, and a team's test-results.md template is checked at Build and Test and Performance Validation; the agent writes Intent Capture's [scope] tag only on the Initial Scope Signal line instead of offering to fix its own tags; picking Fix findings at a blocking check has the agent fix the document and has it reviewed again, and Override opens your gate instead of sending the agent back into the stage; a document fixed at an open gate brings its question back in the same turn; in work built Unit by Unit, Fix findings has only the Units the check named reviewed again, and a pick given after another question counts; and a check that could not run (a crashed script, or a type-check with no tsconfig.json) is said once at the gate and recorded as could not run, not as passed.

Plans, jumps, and skips

• Switching plans carries on: a scope switch while a stage runs carries on in the same turn, and "switch this to the express plan" switches in place, as --scope does, instead of going to the plan composer; a reply that approves and switches records the approval in the same turn (when the new plan still runs that stage), and one that confirms a summary and switches to a plan without that stage writes the confirmed documents first; a switch to a larger scope past a Units Generation that never ran keeps the open gate and its Approve; going back after a switch to a smaller scope leaves the stages it dropped not started, so adding one back or switching back runs it; undoing a stage you just added or skipped puts the plan back as it was; a stage you skipped and ask back later, in your words or by a jump, goes back on the plan, and one skipped where it stood and asked back just after the work moved on runs next; a skip says how long its undo holds ("until the work moves past it"); a scope switch with a skip of the stage in hand switches, skips it where it stands and carries on; "approve, and skip user stories" at Practices Discovery's gate skips the stage and asks the Practices Discovery question again, not a refusal in engine words; under "Continue automatically" your own /aidlc --skip or --add lands at once; approving a trimmed plan mid-work carries on into the next step; and a setting typed while the questions are being written goes on to them.
• Jumps: /aidlc --stage <stage> or --phase <phase> on running work outside Code Generation makes the jump and starts the stage in one step; /aidlc --scope enterprise --stage code-generation switches first, then jumps, and a setting typed with a jump is kept; a jump asked for at Code Generation's recovery question goes through on the first ask; going back to a stage whose summary you confirmed asks that summary once, and Keep for its documents then goes on to the review, instead of saying the stage can't go ahead (on Kiro IDE under strict, again and again); and a jump back to an initialization stage, or to a stage your plan leaves out, gets its refusal or question at once (the offer to scan the code again, or to run that stage on its own), not "Jump accepted." first.
• "It's existing code, but skip the reverse engineering" skips Reverse Engineering and carries on where you were, without a promise to document the code; and Reverse Engineering you ask back in the reply that approves Requirements Analysis runs right after that approval, before Code Generation.
• Tailored plans: on existing code a plan from /aidlc compose keeps Reverse Engineering on every run, also when the folder holds no code yet (the stage asks whether to reuse a code map that is still current), and proposes leaving it out only when a ready code map allows it, said at the gate for you to decide; an approved tailored plan is created with every stage, the depth, the settings and the Guard Policy it showed, and a stage change you ask for at its gate goes back to the composer and reaches the plan you approve, not dropped while the agent says it was done; the offer says once when the plan skips a stage that a kept stage uses; "Approve and save as scope" always saves the plan, with the work's creation; and the plan offer, the creation line, /aidlc --help and a saved scope give the same stage count, as do each stage's start, the progress line and status after a plan switch.
• Running one stage on its own with --single leaves your work where it was, keeps a copy of the work's documents it writes over and says where, takes a typed --depth or --test-strategy for that run only, and refuses --guard-policy or --guard.<fence> with the step to run it without them; under strict, Keep for a Unit's documents there goes on to the review, not a loop asking to save them again; a stage run on its own after the work finished records your answers, your summary and its review, and with no work yet one takes what you typed with it as its request, records those and your code plan approval, and finishes. Every step of an isolated Code Generation run names its own next, so your plan question comes back and the workflow is untouched.
• Starting and picking up: a stage you skip or add with your request (/aidlc --skip requirements-analysis <request>) stays in the plan when you go ahead or tailor one, and the plan question counts it; a bare /aidlc in a project with no work says "Tell me what to build and I'll start it." instead of an error, and in a new chat brings back first a verification command or summary question you left open; /aidlc --resume picks up the only open work in a clone without asking whether to carry on, words typed with it, or in a clone with no work selected, reach the work instead of the open stage running without them, and a setting typed with it is kept for the work you pick; asking for a redo when you come back to a gate redoes the stage, coming back between a stage's finished review and its approval brings the approval, not the stage again, and a Code Generation revision picked up in a new chat keeps what you said should change; a pull that leaves git's conflict in AI-DLC's record of the work carries on from your side, says once where the other side stands and names the git command that takes it instead; and everything after a switch that takes no value (/aidlc --new-intent fix --project-dir handling) is your request, so no folder or status you did not ask for is written or shown.

Construction

• Code kept in a worktree in a harness folder (such as .claude/worktrees/<name>) or outside the project is covered by Code Generation's review: the agent records the checkout (/aidlc intent add-checkout <path>, undone with /aidlc intent remove-checkout <path>), the approval says where the code was found, and an edit there after the review is caught.
• Units: a Redo of a Unit's step (the Unit in flight, or a built Unit's Code Generation) starts it again while the other Units keep their finished work, with its plan brought back to you once (with plan approval off it builds at once), not a loop of revisions, and a change you ask for with the redo answers that plan question; your Request Changes at a Unit checkpoint stands through the agent's own question; a jump or redo naming a Unit the work does not have asks which one you meant; /aidlc --skip functional-design while Units are built one at a time skips it for every Unit from here (or, with "for this unit", for the Unit working on it), not a refusal; a Unit that only owed its completion record no longer loops; and with team-owned Units a resume or second chat between a Unit's review and its completion goes on to the Unit's gate.
• Side-by-side builds: a yes to building the Units in parallel applies it, said as one change, and on GitHub Copilot the wave is handed out instead of each turn ending on a size error; building from your own branch, as a team clone does, starts every Unit and lands each back on that branch; a committed link to a file outside the project, or a .env or log file Git ignores, no longer stops the build starting; designing the Units side by side asks each Unit's questions in your chat first, so the designs follow your answers; each worker writes its Unit's records where AI-DLC reads them, with no stray construction/ folder; on Claude Code a Unit's review no longer says no reviewer finished when its reviewer did; each Unit starts with the design records as your project has them, committed or not, and its edits to them come home when it lands, merged line by line, a clash on the same lines saved in the Unit's Code Generation folder and named in one line; an agent left in a Unit's folder goes back to the project folder instead of saying the hooks are off; under strict, a write to your main checkout held during the build says why and that it can be made once Code Generation is over, and a file your git hook refused at a landing can be fixed and landed; and a Unit's plan changed and approved again during the build is handed on and the build goes on (also while a sent-back batch is rebuilt), while a Unit whose worker already wrote code is offered only setting that work aside and building it again, not an offer that looped.
• Your files stay yours: in a new project folder that already holds your README, LICENSE, docs or config, Code Generation is told to leave them as they are unless you ask or the build needs it, named in the plan, and the build's approval question (or each Unit's checkpoint) names any file you had before the work that the build changed or deleted (on existing code, only files that are not code), with the git command to put it back when git holds a copy; a delegated agent's brief forbids stashing, resetting, checking out over or cleaning your working tree, and installing what the plan does not name; a checkpoint check that times out or is interrupted stops the processes it started (--timeout-ms raises the 30-minute default); a Unit's claim on a route folder such as src/app/items/[itemId]/ is no longer refused for an ignored file beside it; with two pieces of work open in one checkout, each build leaves the other work's Units' files alone, not removing or flagging them; and commands in a project whose path holds audit (or an npm audit to a dated report) run instead of being refused as a write to AI-DLC's audit trail.
• When the agent edits your files before Code Generation (while the plan question is open, or in a stage that writes only AI-DLC's records), the first step after your pick, or the next approval, names them once, with the way back (Before this work started, src/app.js was changed; git checkout HEAD -- src/app.js puts it back as last committed., or During Requirements Analysis, ...), or says a file is new or that its change cannot be undone (it held uncommitted changes of yours, or is not in git); nothing is blocked, and a file put back that way counts as nobody's change in the build's review.
• Build and Test judges a project-wide coverage floor on the full test run, not on one Unit's tests, where it failed with every test passing, and keeps a browser check Unverified until it ran in a real browser and says the gap once at the gate; it owes four files every run, with the integration, performance and security test instructions only at the test strategies that call for them; and Code Generation no longer asks for a summary confirmation it does not owe.

Reverse Engineering and many repositories

• In a workspace of many repositories, Reverse Engineering starts and reaches its gate instead of stopping on a step-size error. When the work covers ten or more repositories that AI-DLC found on disk and you never named, it asks once before reading any (Read all 190, or only the ones this work needs?, with git's line count), unless your request already said which; the gate checks every repository's files in one pass, with progress, and names a missing file with its repository; and at 190 repositories the waits at each step and before the gate drop from several seconds to about one on Linux. A repository folder named with a space, an accent or an apostrophe is in the work as you named it, instead of stopping the work before it starts.
• /aidlc intent add-repo <name> [--url <address>] adds a repository to a piece of work at any stage, cloning it with your own git and credentials when it is not here yet, with one line and the way back; under strict, when Units Generation was already approved, it asks once whether its Units still stand. /aidlc intent set-repos <name,...> narrows the set in one command, and aidlc system workspace-sync prints *** for a credential in a clone address.
• At Reverse Engineering, under Guard Policy relaxed or off, a Request Changes reruns only the part you asked for instead of the whole scan; reusing the code knowledge base is recorded as your choice only once you have answered its question; an answer to its last question given in a new chat is recorded and brings its approval; and the scan runs in a project folder whose name has a space, an accent or &, and the folder keeps its name.

Setup, configuration, and lifecycle

• aidlc version reports 2.11.2 on all seven harnesses.
• aidlc config --yes at a terminal asks nothing: it sets up or refreshes the project, then shows the setup check and what still needs you, with the command for each (aidlc config alone still offers the walk). A teammate's clone with Windows line endings refreshes with git clean on all seven harnesses; a project folder that is not a git repository refreshes without asking to set AI-DLC up there; and a copied project's own config on a machine that also has a native aidlc keeps its own release and hooks and offers to download its release, instead of silently taking the native install's.
• Turning a check off or back on from the chat, in your own settings file, says one plain line in your words, without the switch name, file, command and workflow id; "turn the review freeze check back on for this project" in a new chat does it in one step; when another settings file still keeps a check off, every way of turning it back on says so, naming that file and the command that clears it there, and from the chat with no file named it clears only your own entry; and on every tool, a check switched off in your name from the chat is said to you once, in its own line, with nothing else in Codex's and opencode's tool panel.
• On Claude Code, an Amazon Bedrock answer in aidlc config goes to your own git-ignored .claude/settings.local.json, so a teammate never inherits your AWS profile; a teammate's clone gets one warning naming aidlc config providers (a project set up on 2.11.1: see Script compatibility).
• aidlc doctor: a clean project is no longer told to commit doctor's own audit entries; work pulled from another clone is a warning naming that machine, not a hooks error; an idle piece of work's hooks no longer read as frozen; an old update check says when it was checked; the export shows a skipped stage as skipped; and on a native Claude Code install, a team hook wired as aidlc engine hook <name> whose file is only in the project now fails its row, since that command never ran it, with a fix line to register it by a command that runs its own file.
• A hook killed while it took a lock no longer stalls later writes and doctor for 5 minutes; a config, update or plugin command stopped while it was taking its lock (a Ctrl-C) on a drive without hard links no longer blocks every later one, and the next command clears it with one line; a refusal to write a protected AI-DLC file names the path that matched; and a list of work you edited by hand (a trailing comma, a comment) is read, while one nothing can read is kept beside the new list, with one line, not written over.
• The guides: the install guide says how to remove AI-DLC from a project while keeping the team's own harness configuration, and the classic scope says where its approvals are in Construction, Unit by Unit.

Plugins

• On Kiro IDE and Kiro CLI v3, an agent a plugin adds gets the same tools, MCP servers and rules as AI-DLC's own agents, and a plugin stage that hands work to its own agent runs; Kiro asks before the plugin's agent is first handed work. The fix reaches a plugin once its author rebuilds it with this release and it is dropped in again; Kiro CLI V2 still needs a hand-written agent file and trust entry, now documented.
• Plugin Markdown can use {{INVOKE}} and {{TOOL_PREFIX}}, filled in for the install channel at compose and plugin sync, so a plugin stage written with them runs on a native install without Bun; the reference plugin's two stages now run aidlc engine ... instead of failing with bun: command not found. A plugin that writes bun ... itself still needs Bun.
• Removing a plugin that added a core stage to its own scope puts the shipped stage back, so the next aidlc config goes through; removing or updating a plugin, or a refresh, keeps a stage line you wrote beside the plugin's own (a refresh then treats that stage as one you changed, with the usual conflict line and its fix); and plugin select --harness-dir <dir> changes the install you name.

Harness by harness

• Claude Code: when the project's .claude/settings.json is missing or is not valid JSON, the hooks-off line names the repair (aidlc config --harness claude, or correct the file) and says to restart; and a chat started in a folder inside the project (such as src/) gets one line naming the project folder to start Claude Code in, with the line that carries your request on, instead of a loop about hooks being off (on Windows the old line may still show).
• Codex CLI: on models with Codex's second question box, AI-DLC asks in the box that stays open until you answer, and an answer you give in the other box is recorded as your words, not Codex's wrapping; on Windows, hooks trusted with Trust all count as trusted, so setup stops asking; a config.toml that cannot be read gets its own repair line; a chat started in a folder inside the project is told to start Codex in the project folder, instead of to trust hooks already trusted (on Windows the old line may still show); and on Linux and macOS a project's trust entry left on an older hook version, which read as trusted while another project's entry was current, now gets the usual trust step.
• GitHub Copilot: AI-DLC's own commands are no longer refused over and over during stage changes, and an approval no longer has to be given twice; a helper's calls are held to its own limits and the main chat's to its own; a jump back at Code Generation is told the one step that lets it through, not going round; a redo of Code Generation (at its gate, for the Unit being built, or for one or every built Unit) and a change to one go through on the first ask; copilot -p "/aidlc" at an open question is read as yours, so that question comes back first; in VS Code a question or choice holding |, an apostrophe, &, < or > asks the host's own confirmation first; in a repo set up for both Claude Code and Copilot, Copilot CLI starts without a settings warning and runs AI-DLC's hooks once; and on Copilot CLI, with work running, a question is asked in the chat instead of Copilot's question box, so your answer counts.
• Cursor: under Guard Policy strict or relaxed, Reverse Engineering's helper runs AI-DLC's own commands and the stage reaches its approval; and an edit that arrives as StrReplace is recorded and checked like any other.
• Kiro CLI and Kiro IDE: on a Kiro IDE install, Kiro CLI's own Workflows switch is asked about and turned off like Kiro IDE's (aidlc config trust --kiro-cli-workflows off), so AI-DLC's reviews and helpers run in Kiro CLI chats once Kiro CLI is started again; beside an approval question or Unit checkpoint, one line per chat offers to pause and carry on in a new chat when Kiro's own record shows the chat 80% full or summarized; and on Kiro IDE the agent goes on to a Unit's next step after its review is recorded, and there a Unit sent back to Code Generation from a failed Build and Test ("Retry with fix") stays there instead of Construction looping on Build and Test (work already stuck gets out by sending the Unit back again).
• opencode: on Windows with the native install AI-DLC's hooks start through aidlc.cmd, so the first /aidlc reaches the plan offer instead of a restart that never helped; with two chats in one window, a file write and a to-do update are recorded on their own chat's work; and a hook that ends early no longer makes opencode run print a broken-pipe error and exit 1.
• Windows: a dev server the AI left running is stopped by the AI, and one you left running makes each step wait about 10 seconds with one line to stop it, not hours; a project folder spelled with a short name (such as C:\Users\ADMINI~1\...) keeps its plan approval on Copilot and Kiro, runs AI-DLC's own steps, and holds code until you approve the plan; on Copilot CLI, AI-DLC makes the code plan's folder itself, so the plan question reaches you instead of plan approval being turned off after a run of refusals, and Code Generation makes its own record folder from PowerShell at once, not after the agent tried other ways and ran git commands nobody asked for (Kiro CLI gets the same change); on Kiro CLI a guard's refusal stops the tool call, as on Linux; aidlc config and doctor say once when the project folder is too deep for AI-DLC's records (75 characters or more), and the Units Generation gate when the Unit names make it so, naming a shorter folder and, for whichever is off, Windows long paths or git config --global core.longpaths true (with both on nothing is said; under Copilot CLI, which asks before reading any path over 260 characters, it is always said and names only a shorter folder); files the agent writes for AI-DLC with a byte order mark (as Windows PowerShell 5.1 does) are read as written; and the installer run right after an uninstall says to run it again in a minute.

Script compatibility

• a copied project's own config with no --from (for example bun .claude/tools/aidlc.ts config --force or --yes), in a project with no .aidlc-version pin, on a machine that also has a native aidlc and no AIDLC_RUNTIME_ROOT set, no longer refreshes from the native install's release; run without a terminal it now exits 4 with refreshing .claude needs the <version> release files, where 2.11.1 exited 0. Add --download to fetch the project's own release, or --from <install root>/versions/<version>/runtime to keep using the native install's files.
• a run that does not set AIDLC_UNATTENDED=1 and is not in autonomous Construction is treated as a person driving: when the agent stops, the turn ends instead of AI-DLC's Stop hook carrying the work on. A script or CI job that drives AI-DLC sets AIDLC_UNATTENDED=1, as the interaction modes guide already asks of automation.
• on Claude Code an Amazon Bedrock answer is written to the git-ignored .claude/settings.local.json, and .claude/tools/data/harness.json no longer holds the AWS profile. A project set up on 2.11.1 keeps its values in the shared .claude/settings.json through aidlc update and refreshes, and they leave it when the person who set them answers aidlc config providers again. A CI job that took Bedrock from the committed settings sets that environment in the shared settings.json itself and answers keep current; a script that read the profile from harness.json reads aidlc config providers --show --json.

Contributors

Thank you to everyone who contributed to this release: @vnlebaoduy, @Marukome0743, @wowzoo, @scottschreckengaust, @fsatsuki, @harmjeff, @mdanialqureshi, @szsunyuan, @alvarohare, @gpmattoo, @jimini55, @kumachan99, @vivibui, @YH1715.

New Contributors

• @kumachan99 made their first contribution in #2534
• @YH1715 made their first contribution in #2609
• @alvarohare made their first contribution in #2663

Promoted from v2.11.2-preview.20261027.2, source d67b4fcb8de7bfa9eadfd4c3707c4c8e391ee3c6.

Full Changelog: v2.11.1...v2.11.2