@rasensio/aidlc-content 1.55.0 → 1.56.0

package/docs/lifecycle.md

@@ -172,7 +172,11 @@ reviewer is handed one fixed `git diff` listing every test or spec file that exi
 and was modified, deleted or renamed — and fails each one the task did not ask to change. The listing
 is mechanical on purpose: the agent that wrote the code also used to be the one deciding the tests that
 define done were fine, and a loosened assertion looks like a pass from inside. It is asked once per
-instance and off by default, because it roughly doubles the agents. Tasks that may run at the same time
+instance and off by default, because it roughly doubles the agents. A repo can change the default:
+`aidlc init` asks "How should implementation tasks run?" when a configured platform has sub-agents,
+and saves the answer as `task_agents: per-task` (or `one-session`) in `.aidlc/config.yaml`. That
+answer becomes the recommendation every instance is offered — and the one an unattended autopilot
+run takes — while a prompt or a roadmap item asking for the other mode still wins for its instance. Tasks that may run at the same time
 carry `(wave: <n>)` in `tasks.md`; a wave must be a run of consecutive tasks, and a bad marker keeps
 the task and warns rather than dropping it from gate coverage. The whole loop is one rule file,
 `.aidlc/resources/rules/task-agents.md`, so a session that runs its tasks itself never reads it.

package/docs/roadmap.md

@@ -154,8 +154,9 @@ At most two items build at once, and never more than you asked for. Autopilot ne
 between `inbox/`, `backlog/` and `hold/` except to park what it is building, and never edits a rank or
 a dependency: deciding what is agreed work stays a person's job.
 
-**Setup** comes first, once per machine: `aidlc autopilot setup` (or `aidlc init --autopilot`). It
-asks four questions, each a list with one choice marked recommended:
+**Setup** comes first, once per machine. A plain `aidlc init` ends by asking "Set up autopilot now?"
+(default no); `aidlc init --autopilot` skips that question, and `aidlc autopilot setup` asks the same
+four questions on its own. Each is a list with one choice marked recommended:
 
 - **The agent, and what it may do.** Claude Code limited to editing files and running git, pnpm,
   node and read-only shell tools (recommended); Claude Code with full access; Codex in full-auto
@@ -170,8 +171,29 @@ asks four questions, each a list with one choice marked recommended:
   `scripts/release.sh` with the bump bookkeeping printed.
 
 Flags skip the questions: `--agent`, `--parallel`, `--cost-cap <usd|none>`, `--release
-<repo-script|merge-only>`. The answers go to `<git-common-dir>/aidlc/autopilot/config.json`, per
-machine and never committed, beside autopilot's `state.json`, `run.json`, `logs/`, `STOP` file and, while paused, `paused.json`.
+<repo-script|merge-only>`. `aidlc autopilot setup` writes all four answers to
+`<git-common-dir>/aidlc/autopilot/config.json`, per machine and never committed, beside autopilot's
+`state.json`, `run.json`, `logs/`, `STOP` file and, while paused, `paused.json`.
+
+**Team defaults.** The cost cap and the release step are the team's to decide, so `aidlc init` saves
+those two in the committed `.aidlc/config.yaml` and the agent and items-at-once on the machine:
+
+```yaml
+# .aidlc/config.yaml
+autopilot:
+  cost_cap_usd: 15        # or null for no cap
+  release: repo-script    # or merge-only — a preset name, never a command
+```
+
+A teammate's autopilot follows them without being asked. The machine's own `config.json` wins
+wherever it sets the same key, and when init saves a team answer it removes this machine's copy so the
+answer takes effect here too. The agent, its permissions and parallelism are read from the machine
+file only: the same keys in `.aidlc/config.yaml` are ignored, so cloning a repo can never grant an
+agent full access on your machine. A team value that is not valid — a cap that is not a positive number
+or `null`, a release step that is not one of the two names, `repo-script` with no script — is ignored.
+Re-running `aidlc init` pre-selects every answer in force, and an answer no choice matches is offered as
+"(current)" and left as it is. `--non-interactive --autopilot` asks nothing, keeps what is there and
+fills only what is missing with the recommended choice.
 
 **Watching and stopping.** `aidlc autopilot status` shows the active run and each item's step, pull
 request, CI failure count and last error. `aidlc autopilot stop` (or `/aidlc-autopilot-stop`) ends the
@@ -190,7 +212,7 @@ reads.
 Opt-in, and off until the config block exists. `aidlc roadmap sync` renders eligible items as
 GitHub issues; `aidlc roadmap import <issue-url>` seeds one `inbox/` item from an existing issue.
 
-`aidlc init` offers to write the block for you — it is the last question in the wizard, and it
+`aidlc init` offers to write the block for you — it is the last of the project questions, and it
 defaults to no. Say yes and it lists all five statuses with every one checked, so unchecking
 `inbox` and `hold` is a choice you make with the list in front of you rather than one made on your
 behalf. `done` cannot be turned off; without it the close path never runs and the projection never

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rasensio/aidlc-content",
-  "version": "1.55.0",
+  "version": "1.56.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/resources/rules/task-agents.md

@@ -2,11 +2,11 @@
 
 This file is the only statement of the rule. The implementation skill points here instead of restating it, so a session that runs its tasks itself carries none of this.
 
-**One agent per task** hands each task in `tasks.md` to a fresh agent, then has a second fresh agent review it. Task 8 gets the attention task 1 got, and the agent that wrote the code does not decide it is done. It costs at least twice the agents, so it is off unless chosen.
+**One agent per task** hands each task in `tasks.md` to a fresh agent, then has a second fresh agent review it. Task 8 gets the attention task 1 got, and the agent that wrote the code does not decide it is done. It doubles the agents, so it is off unless chosen.
 
 ## When it is offered
 
-Only for an instance with a task-bearing `tasks.md`, and only where the platform's entry for the skill says sub-agents are available — the line above the pointer in the skill file the platform loaded. Without it, every task runs in the session.
+Only for an instance with a task-bearing `tasks.md`, and only where the platform's entry for the skill says sub-agents are available — the line above the pointer in the loaded skill file. Without it, every task runs in the session.
 
 ## Choosing, once per instance
 
@@ -15,7 +15,7 @@ Ask through the **Question Protocol** (`.aidlc/resources/rules/question-protocol
 - **One session** — every task runs here. Cheapest; later tasks inherit earlier context.
 - **One agent per task** — each task in a fresh agent, checked by a reviewer that edits nothing. Roughly twice the tokens.
 
-Recommend **One session**, unless the prompt that started this session or the instance's `roadmap-item.md` asks for one agent per task — then recommend that. An `[Answer]:` already recorded is followed, never re-asked. Unattended, take the recommendation as the open-question default.
+Recommend per `task_agents` in `.aidlc/config.yaml`: **One agent per task** if `per-task`, else **One session**. The starting prompt or `roadmap-item.md` asking for the other wins. An `[Answer]:` already recorded is followed, never re-asked. Unattended, take the recommendation as the open-question default — so autopilot follows the repo.
 
 ## The loop, task by task