@rasensio/aidlc-content 1.56.0 → 1.58.0

package/docs/index.yaml

@@ -42,7 +42,7 @@ entries:
     title: The lifecycle
     file: lifecycle.md
     source: packages/cli/src/core
-    commands: [init, start, continue, status, transition, gate, menu, amend, templates, spec, cross-check]
+    commands: [init, start, continue, status, transition, gate, menu, amend, templates, spec, cross-check, revert]
 
   - id: state-and-concurrency
     kind: topic

package/docs/lifecycle.md

@@ -181,6 +181,23 @@ carry `(wave: <n>)` in `tasks.md`; a wave must be a run of consecutive tasks, an
 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.
 
+**Undoing a task.** Each commit made for a task ends with a `Task: <instance>/T<n>` git trailer. `aidlc revert <instance> --task T3` reads those trailers on the commits since the branch left `main`, prints
+the commits it would undo — newest first, marking any that also belong to another task as shared — and
+asks first:
+
+```
+Plan: undo T3 of add-export — 2 commits on feat/add-export since main, newest first:
+  4f1c2ab  feat: csv writer handles quotes  [T3, T4]  — shared: also T4
+  9e0d311  feat: csv writer  [T3]
+Tasks reset to open in tasks.md (if done): T3, T4
+```
+
+On a yes it adds one commit that undoes them, leaves `.aidlc/state/` as it was except those checkboxes,
+and abandons cleanly if the undo conflicts with later work. A clash inside `.aidlc/state/` alone — the
+next task's checkbox on the line below — is not such a conflict. `--phase implementation` undoes every task
+commit at once; `--dry-run` only prints the plan; without a terminal it needs `--yes`. It works only
+during implementation and never on `main`.
+
 ## Where the code lives
 
 - `packages/cli/src/core` — templates, scope resolution, and the gate engine.
@@ -197,6 +214,11 @@ the task and warns rather than dropping it from gate coverage. The whole loop is
   leave the corpus untouched.
 - `packages/cli/src/crosscheck` — `aidlc cross-check`, a pure comparison of one instance's three
   planning artifacts. Nothing but its own command imports it, and a test keeps it that way.
+- `packages/cli/src/revert` — `aidlc revert`: reads `Task:` trailers over `main..HEAD`, builds the plan
+  (pure), and applies it as one commit, returning to the recorded `HEAD` on any failure. It reads
+  `git log -z` with NUL between fields because NUL is the one byte a commit message cannot carry; git
+  keeps every other control character, and a body carrying the first separators chosen forged a
+  commit from `main` into the plan.
 - `packages/cli/src/menu` — the interactive picker. It reads no lifecycle state by design, because
   "what should I do next?" belongs to the skill, not the menu.
 - `packages/content/templates` — the five templates, as data.

package/docs/skills-and-platforms.md

@@ -37,6 +37,14 @@ project, so there is no second version to drift.
 `init` installs skills for the platforms listed in `.aidlc/config.yaml`. `update` refreshes them after
 the framework changes, and also rewrites the managed block in `CLAUDE.md`.
 
+**A version bump alone changes no generated file.** Each embedded skill body opens with
+`<!-- aidlc:generated version=… sha256=… -->`, and the version is the CLI version at which that body
+last changed, not the one that last wrote it: when the emitted body hashes to the recorded `sha256`,
+`update` keeps the line as it is. Stamping the running version instead restamped 42–44 identical files
+on every release, and every branch that ran `update` then conflicted with every other on files nobody
+edited. So an older version in a marker is normal. `aidlc doctor` reports a body only when it no longer
+matches its hash (a hand edit) or names a CLI newer than the one running (upgrade the CLI first).
+
 **Anything you write inside that managed block is lost on the next update.** Put project instructions
 above the start marker or below the end marker. This repo's own `CLAUDE.md` says so at the top, and the
 "Lessons That Keep Costing Us" section sits deliberately outside the block for exactly that reason.

package/package.json

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

package/skills/40-implementation.md

@@ -53,7 +53,7 @@ Then the source files that task touches. See **The context rule** (`.aidlc/resou
    - Infrastructure changes (provisioning, configuration)
    - Permission or access control modifications
    - Credential or secret handling
-7. **Commit incrementally.** Produce working code at each step; avoid large uncommittable diffs.
+7. **Commit incrementally, one task per commit where you can.** Produce working code at each step; avoid large uncommittable diffs. End every commit made for a task with a git trailer naming it — `Task: <instance>/T<n>` on its own line in the last paragraph of the message, one line per task when a commit spans two. The trailer is what lets `aidlc revert <instance> --task T<n>` find that task's commits later and undo them in one step, after showing the plan; a commit without it is invisible to the command.
 8. **Update the knowledge graph.** After modifying code, record what changed with `aidlc knowledge add` / `relate` / `update`: new or restructured modules, decisions taken, debt introduced or paid down. Keep the graph in sync with the code you just changed.
 9. **Update state.** As implementation artifacts are produced, mark them in `phase-implementation.yaml`.