@tekyzinc/gsd-t 4.7.10 → 4.7.11

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [4.7.11] - 2026-06-22 (backlog #40 — deterministic domain archive+sweep — patch)
+
+### Fixed — complete-milestone now deterministically archives + sweeps a milestone's domains
+
+`complete-milestone` Step 7 was prose-only ("archive domains → clear `.gsd-t/domains/`") with no enforcement, so a Level-3 autonomous agent skipped or partial-did it for ~30 milestones — accumulating 77 stale domain dirs that polluted the file-disjointness oracle (surfaced + manually pruned during M90). Root-cause fix:
+
+- **`bin/gsd-t-archive-domains.cjs`** (new) + `gsd-t archive-domains` dispatch: copies an EXPLICIT set of the completing milestone's domain dirs → `<archive>/domains/<name>/`, then removes them from `.gsd-t/domains/`. Idempotent (re-running is a no-op), containment-guarded (refuses any name with path separators / dot-segments or resolving outside `.gsd-t/domains/` — [[feedback_destructive_path_ops_containment]]), fail-closed (a bad name aborts the whole batch, no partial sweep). Domains of other still-active milestones are left untouched (not a blanket wipe).
+- `commands/gsd-t-complete-milestone.md` Step 7: prose → the deterministic helper call.
+- Propagated via PROJECT_BIN_TOOLS + GLOBAL_BIN_TOOLS. 5 tests (sweep-exactly / idempotent / dry-run / containment / bad-input). Suite 2003 / 1999 pass / 0 fail.
+
 ## [4.7.10] - 2026-06-22 (M90 — The Unproven-Assumption Doctrine — minor)
 
 ### Added — a self-governing doctrine that stops the system building on unproven assumptions

package/README.md

@@ -1,6 +1,6 @@
 # GSD-T: Contract-Driven Development for Claude Code
 
-**v4.7.10** - A methodology for reliable, parallelizable development using Claude Code with optional Agent Teams support.
+**v4.7.11** - A methodology for reliable, parallelizable development using Claude Code with optional Agent Teams support.
 
 **Eliminates context rot** — task-level fresh dispatch (one subagent per task, ~10-20% context each) means compaction never triggers.
 **Compaction-proof debug loops** — `gsd-t headless --debug-loop` runs test-fix-retest cycles as separate `claude -p` sessions. A JSONL debug ledger persists all hypothesis/fix/learning history across fresh sessions. Anti-repetition preamble injection prevents retrying failed hypotheses. Escalation tiers (sonnet → opus → human) and a hard iteration ceiling enforced externally.

package/bin/gsd-t-archive-domains.cjs

@@ -0,0 +1,136 @@
+/**
+ * gsd-t-archive-domains.cjs
+ *
+ * Backlog #40 — Deterministic archive+sweep of a completed milestone's domain dirs.
+ *
+ * complete-milestone Step 7 was prose-only ("archive domains → clear .gsd-t/domains/") with no
+ * enforcement, so a Level-3 agent skipped/partial-did the clear for ~30 milestones and 77 stale
+ * domain dirs accumulated, polluting the file-disjointness oracle. This helper makes the sweep a
+ * deterministic, idempotent, containment-guarded operation.
+ *
+ * Behavior — for an EXPLICIT set of the completing milestone's domains (NOT a blanket wipe; a
+ * later still-active milestone may legitimately have live domains, e.g. M90 completing while
+ * M87/M88 are queued):
+ *   1. Copy each domain dir → <archiveDir>/domains/<name>/  (skip if already archived — idempotent)
+ *   2. Remove it from .gsd-t/domains/                        (skip if already gone — idempotent)
+ * Domains NOT in the set are left untouched.
+ *
+ * Containment guard ([[feedback_destructive_path_ops_containment]]): every removed path MUST resolve
+ * INSIDE .gsd-t/domains/ AND NOT equal it. Predicate: resolved.startsWith(domainsRoot + sep) &&
+ * resolved !== domainsRoot. Any violation aborts the whole run (fail-closed, no partial sweep).
+ *
+ * House style: { ok:true, ... } | { ok:false, error }; bad input → non-zero CLI exit; Node
+ * built-ins only; sync APIs; zero deps.
+ *
+ * Usage:
+ *   gsd-t archive-domains --domains d-a,d-b,d-c --archive .gsd-t/milestones/mNN-name-DATE [--projectDir .] [--dry-run] [--json]
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DOMAINS_SUBPATH = path.join('.gsd-t', 'domains');
+
+/**
+ * Archive + sweep the named domains.
+ *
+ * @param {object} opts
+ * @param {string[]} opts.domains   — explicit domain dir names (the completing milestone's set)
+ * @param {string}   opts.archiveDir — milestone archive dir (domains land under <archiveDir>/domains/)
+ * @param {string}   [opts.projectDir] — project root (default cwd)
+ * @param {boolean}  [opts.dryRun]   — compute the plan, write nothing
+ * @returns {{ok:true, archived:string[], removed:string[], skipped:string[], dryRun:boolean}
+ *          | {ok:false, error:string}}
+ */
+function archiveDomains({ domains, archiveDir, projectDir, dryRun = false } = {}) {
+  if (!Array.isArray(domains) || domains.length === 0) {
+    return { ok: false, error: 'archive-domains requires a non-empty --domains list (the completing milestone\'s domain set)' };
+  }
+  if (!archiveDir || typeof archiveDir !== 'string' || !archiveDir.trim()) {
+    return { ok: false, error: 'archive-domains requires --archive <milestone archive dir>' };
+  }
+
+  const root = path.resolve(projectDir || process.cwd());
+  const domainsRoot = path.resolve(root, DOMAINS_SUBPATH);
+  const archiveRootAbs = path.isAbsolute(archiveDir) ? archiveDir : path.resolve(root, archiveDir);
+  const archiveDomainsDir = path.join(archiveRootAbs, 'domains');
+
+  // Validate every target up front (fail-closed: no partial sweep on a bad name).
+  const plan = [];
+  for (const name of domains) {
+    if (!name || typeof name !== 'string' || name.includes('/') || name.includes('\\') || name === '.' || name === '..') {
+      return { ok: false, error: `invalid domain name (no path separators / dot-segments allowed): ${JSON.stringify(name)}` };
+    }
+    const srcAbs = path.resolve(domainsRoot, name);
+    // CONTAINMENT GUARD: must resolve strictly INSIDE .gsd-t/domains/ (not outside, not equal).
+    if (!(srcAbs.startsWith(domainsRoot + path.sep) && srcAbs !== domainsRoot)) {
+      return { ok: false, error: `containment violation: ${name} resolves to ${srcAbs}, outside or equal to ${domainsRoot} — refusing` };
+    }
+    plan.push({ name, srcAbs, destAbs: path.join(archiveDomainsDir, name) });
+  }
+
+  const archived = [];
+  const removed = [];
+  const skipped = [];
+
+  for (const { name, srcAbs, destAbs } of plan) {
+    const srcExists = fs.existsSync(srcAbs);
+    const destExists = fs.existsSync(destAbs);
+
+    // IDEMPOTENT: nothing live and already archived → skip silently.
+    if (!srcExists && destExists) { skipped.push(name); continue; }
+    // Nothing live and not archived → the domain doesn't exist at all → skip (not an error;
+    // re-running after a manual prune is valid).
+    if (!srcExists && !destExists) { skipped.push(name); continue; }
+
+    if (dryRun) {
+      if (!destExists) archived.push(name);
+      removed.push(name);
+      continue;
+    }
+
+    // 1. Archive (copy) unless already archived.
+    if (!destExists) {
+      fs.mkdirSync(archiveDomainsDir, { recursive: true });
+      fs.cpSync(srcAbs, destAbs, { recursive: true });
+      archived.push(name);
+    }
+    // 2. Remove from live domains (containment re-checked at delete time).
+    if (!(srcAbs.startsWith(domainsRoot + path.sep) && srcAbs !== domainsRoot)) {
+      return { ok: false, error: `containment re-check failed at delete: ${srcAbs}` };
+    }
+    fs.rmSync(srcAbs, { recursive: true, force: true });
+    removed.push(name);
+  }
+
+  return { ok: true, archived, removed, skipped, dryRun };
+}
+
+module.exports = { archiveDomains };
+
+// ---------------------------------------------------------------------------
+// CLI
+// ---------------------------------------------------------------------------
+if (require.main === module) {
+  const argv = process.argv.slice(2);
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--dry-run') flags.dryRun = true;
+    else if (a === '--json') flags.json = true;
+    else if (a.startsWith('--') && i + 1 < argv.length) flags[a.slice(2)] = argv[++i];
+  }
+
+  const domains = (flags.domains || '').split(',').map((s) => s.trim()).filter(Boolean);
+  const result = archiveDomains({
+    domains,
+    archiveDir: flags.archive,
+    projectDir: flags.projectDir || process.cwd(),
+    dryRun: !!flags.dryRun,
+  });
+
+  process.stdout.write(JSON.stringify(result) + '\n');
+  process.exit(result.ok ? 0 : 1);
+}

package/bin/gsd-t.js

@@ -1268,6 +1268,8 @@ const GLOBAL_BIN_TOOLS = [
   "gsd-t-architectural-trigger.cjs",
   // M90 D2 — Loop ledger (non-convergence detection + halt directive; §3).
   "gsd-t-loop-ledger.cjs",
+  // Backlog #40 — deterministic archive+sweep of a completed milestone's domain dirs.
+  "gsd-t-archive-domains.cjs",
 ];
 
 function installGlobalBinTools() {
@@ -2579,6 +2581,9 @@ const PROJECT_BIN_TOOLS = [
   // M90 D2 — Loop ledger (non-convergence detection + halt directive; §3).
   // Propagated so project-local runCli helpers (gsd-t-debug.workflow.js) can invoke it.
   "gsd-t-loop-ledger.cjs",
+  // Backlog #40 — deterministic archive+sweep of a completed milestone's domain dirs
+  // (complete-milestone Step 7). Propagated so complete-milestone can invoke it project-local.
+  "gsd-t-archive-domains.cjs",
 ];
 
 // Files that older versions of this installer copied into project bin/ but
@@ -4754,6 +4759,20 @@ if (require.main === module) {
       });
       process.exit(res.status == null ? 1 : res.status);
     }
+    case "archive-domains": {
+      // Backlog #40 — `gsd-t archive-domains --domains a,b --archive <dir>` deterministic
+      // archive+sweep of a completed milestone's domain dirs (complete-milestone Step 7).
+      const { spawnSync } = require("child_process");
+      const js = path.join(__dirname, "gsd-t-archive-domains.cjs");
+      if (!require("node:fs").existsSync(js)) {
+        error(`gsd-t-archive-domains.cjs not found at ${js} — install or build backlog #40 first`);
+        process.exit(1);
+      }
+      const res = spawnSync(process.execPath, [js, ...args.slice(1)], {
+        stdio: "inherit",
+      });
+      process.exit(res.status == null ? 1 : res.status);
+    }
     case "metrics":
       doMetrics(args.slice(1));
       break;

package/commands/gsd-t-complete-milestone.md

@@ -401,8 +401,21 @@ node scripts/gsd-t-watch-state.js advance --agent-id "$GSD_T_AGENT_ID" --parent-
 
 Reset `.gsd-t/` for next milestone:
 
-1. Archive current domains → `.gsd-t/milestones/{name}/domains/`
-2. Clear `.gsd-t/domains/` (empty, ready for next partition)
+1. **Archive + sweep the completed milestone's domains — DETERMINISTICALLY (backlog #40, NOT prose).**
+   This step was prose-only for ~30 milestones and got skipped, accumulating 77 stale domain dirs
+   that polluted the file-disjointness oracle. Run the helper with the EXPLICIT set of THIS
+   milestone's domain dirs (the partition's domain set — NOT a blanket wipe; a later still-active
+   milestone may legitimately have live domains):
+   ```bash
+   gsd-t archive-domains --domains "{comma-separated domain dir names for THIS milestone}" \
+     --archive ".gsd-t/milestones/{name}-{date}" --projectDir .
+   ```
+   (prefer the project-local `bin/gsd-t-archive-domains.cjs` when present). It (a) copies each named
+   domain → `<archive>/domains/<name>/`, then (b) removes it from `.gsd-t/domains/`. Idempotent
+   (re-running is a no-op), containment-guarded (refuses any name with path separators / dot-segments
+   or resolving outside `.gsd-t/domains/`), and fail-closed (a bad name aborts the whole batch — no
+   partial sweep). Domains belonging to other (still-active) milestones are left untouched.
+2. (Step 1 already cleared this milestone's domains from `.gsd-t/domains/` — do NOT blanket-wipe the dir.)
 3. Archive current reports → milestone folder
 4. Clear `.gsd-t/impact-report.md`, `.gsd-t/test-coverage.md`
 5. Update `.gsd-t/progress.md`:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "4.7.10",
+  "version": "4.7.11",
   "description": "GSD-T: Contract-Driven Development for Claude Code — 54 slash commands with headless-by-default workflow spawning, unattended supervisor relay with event stream, graph-powered code analysis, real-time agent dashboard, task telemetry, doc-ripple enforcement, backlog management, impact analysis, test sync, milestone archival, and PRD generation",
   "author": "Tekyz, Inc.",
   "license": "MIT",