@warnyin/sdlc 0.2.1 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## 0.3.0 (2026-08-21)
+
+- **`/sdlc:auto` resumes an open change** instead of always starting at `new`. It
+  resolves its entry stage from `sdlc status` first: an argument naming an active
+  change maps that change's status to the entry stage and the pipeline starts
+  there, keeping the tier, Delta and Assumptions it was already triaged with. Only
+  an argument matching no active change starts at `new`. The entry stage is stated
+  in the plan line, so a resume is never silent. The status → stage table stays in
+  `next.md` alone rather than being copied into a second place that can drift.
+- **Fix (ownership)**: `installFile` dropped a file's manifest entry whenever it
+  kept the file. The next run then saw a path it had never installed, which
+  permanently disarmed `update`'s refresh branch — the file froze at its old
+  payload version and every later run relabelled it user-modified. That affects
+  anyone who re-runs `init` to upgrade before `update`. A kept file now carries
+  its recorded hash forward; prune is unaffected (its guard compares the file on
+  disk against that same hash) and in fact strictly safer, since a kept file is no
+  longer even a prune candidate.
+- A file whose content still matches its recorded hash is reported as
+  `kept (ours, older version — run update to refresh)` instead of
+  `kept (user-modified)`, which sent people hunting for an edit they never made.
+
+## 0.2.2 (2026-08-20)
+
+- `init` (and `update`) now drop a `.gitkeep` in `sdlc/changes/archive/`, so the
+  directory survives a commit and is still there after a clone. 0.2.1 made
+  `archive` recover from the missing directory; this stops it going missing.
+  The marker is not payload-owned — prune never reclaims it and the installer
+  never warns about it.
+
 ## 0.2.1 (2026-08-20)
 
 - **Fix**: `archive` failed with `ENOENT` on the first change a repo ever ships.

package/README.md

@@ -30,6 +30,7 @@ Then in your coding agent:
 ```
 /sdlc:init                      # interview → constitution + harness (the one human gate)
 /sdlc:auto Add rate limiting    # AI runs new → contract → build → verify → ship
+/sdlc:auto add-rate-limiting    # already opened it with /sdlc:new? auto resumes from there
 ```
 
 ## How it works

package/bin/cli.mjs

@@ -101,7 +101,20 @@ export function installFile(projectRoot, destRel, content, ctx) {
     ctx.manifest.set(relPosix, nextHash);
     return tally(ctx, 'updated');
   }
-  ctx.warnings.push(`kept (user-modified): ${relPosix}`);
+  // Keeping the content must not forget the ownership. Dropping the entry made
+  // the next run see a file we had never installed, which permanently disarmed
+  // update's refresh branch (disk hash === old manifest hash) — the file froze
+  // at its old payload version and every later run relabelled it user-modified.
+  // The recorded hash stays the one we last wrote, so prune's "disk must match
+  // the manifest" guard still refuses to touch a file the user really did edit.
+  const owned = ctx.oldManifest?.get(relPosix);
+  if (owned) ctx.manifest.set(relPosix, owned);
+  // Matching the recorded hash proves nobody touched it — `install` simply does
+  // not refresh. Calling that "user-modified" sent people hunting for an edit
+  // they never made.
+  ctx.warnings.push(owned === currentHash
+    ? `kept (ours, older version — run \`npx @warnyin/sdlc update\` to refresh): ${relPosix}`
+    : `kept (user-modified): ${relPosix}`);
   return tally(ctx, 'kept');
 }
 
@@ -189,6 +202,12 @@ function scaffoldSdlc(projectRoot, tools, ctx) {
     fs.mkdirSync(path.join(sdlcRoot, dir), { recursive: true });
   }
 
+  // git does not track empty directories, so changes/archive/ vanishes for
+  // anyone who clones before the first change ships. Not manifested: an empty
+  // marker is nothing for prune to reclaim or for the installer to warn about.
+  const gitkeep = path.join(sdlcRoot, 'changes', 'archive', '.gitkeep');
+  if (!fs.existsSync(gitkeep)) fs.writeFileSync(gitkeep, '');
+
   // Seeds are user-owned from birth: created once, never manifested/overwritten.
   const seed = (rel, templateName, transform = (s) => s) => {
     const dest = path.join(sdlcRoot, rel);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@warnyin/sdlc",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Spec-driven, AI-driven SDLC framework — token-lean specs, contract-first changes, autonomous pipeline with managed hooks. Operationalizes the Day-1 'New SDLC with Vibe Coding' work process.",
   "type": "module",
   "bin": {

package/payload/adapters/claude/commands/sdlc/auto.md

@@ -1,5 +1,5 @@
----
-description: Run the whole pipeline autonomously: new → contract → build → verify → ship (pauses only on policy escalations)
-argument-hint: "<title>"
----
-Read `sdlc/.playbook/auto.md` and execute it now. Arguments: $ARGUMENTS
+---
+description: Run the whole pipeline autonomously — resumes an open change or opens a new one, then contract → build → verify → ship (pauses only on policy escalations)
+argument-hint: "<title|change-id>"
+---
+Read `sdlc/.playbook/auto.md` and execute it now. Arguments: $ARGUMENTS

package/payload/playbook/README.md

@@ -9,7 +9,7 @@ new → [design] → contract → build → verify → [review] → ship
 | Command | Day-1 phase | Reads | Writes | Gate (automatic unless noted) |
 |---|---|---|---|---|
 | /sdlc:init | Configure harness | interview | constitution, harness.md | human approves (once) |
-| /sdlc:auto | whole loop | — | everything below | escalation only |
+| /sdlc:auto | whole loop | status (resumes an open change) | everything below | escalation only |
 | /sdlc:new | Requirements | specs Purpose headers | change.md | validator: delta + assumptions |
 | /sdlc:design | Architecture | change + touched specs | change.md § Design | escalate irreversible only |
 | /sdlc:contract | Contract-first | change.md | contract/*, failing tests | adversarial panel + validator |

package/payload/playbook/auto.md

@@ -1,4 +1,4 @@
-# /sdlc:auto <title> — the whole pipeline, one command
+# /sdlc:auto <title|change-id> — the whole pipeline, one command
 
 Runs new → [design] → contract → build → verify → [review] → ship, each stage by
 its own playbook, WITHOUT pausing for the human except on the Autonomy-policy
@@ -10,8 +10,18 @@ escalation conditions:
 - token budget exceeded (if the user set one),
 - ship policy requires human approval (deep tier).
 
+Entry stage — resolve this first, never assume `new`:
+- Run `npx @warnyin/sdlc status`. If the argument names an active change (or one
+  is active and the argument describes it), RESUME: map its status to the entry
+  stage with `next.md` §2 and start the pipeline there.
+- Resume never rewrites an existing `change.md` — a change already triaged keeps
+  its tier, Delta and Assumptions. Re-run a stage only if its output is missing
+  or the validator rejects it.
+- Start at `new` only when the argument matches no active change.
+
 Rules:
-- Announce the plan in ≤3 lines after triage (id, tier, task count), then work.
+- Announce the plan in ≤3 lines after triage (id, tier, task count, entry stage),
+  so a resume is never silent. Then work.
 - Between stages run `npx @warnyin/sdlc validate <id>` — a red validator is a
   hard stop for that stage, not a suggestion.
 - On escalation: stop at the exact step, state what is needed in ≤5 lines, wait.