@felixdotgo/aidlc-kit 0.1.1 → 0.3.0

package/dist/services/aidlc-coordination/package.json

@@ -2,12 +2,16 @@
   "name": "@felixdotgo/aidlc-coordination",
   "private": true,
   "type": "module",
-  "bin": { "aidlc-fleet": "src/fleet-run.mjs" },
-  "engines": { "node": ">=20" },
+  "bin": {
+    "aidlc-fleet": "src/fleet-run.mjs"
+  },
+  "engines": {
+    "node": ">=20"
+  },
   "scripts": {
     "start": "node src/server.mjs",
     "test": "node --test test/*.test.mjs",
-    "lint": "node --check src/repository.mjs && node --check src/coordination.mjs && node --check src/fleet.mjs && node --check src/fleet-client.mjs && node --check src/fleet-run.mjs && node --check src/server.mjs"
+    "lint": "node -e \"const { readdirSync } = require('node:fs'); const { execFileSync } = require('node:child_process'); for (const file of readdirSync('src').filter((name) => name.endsWith('.mjs'))) execFileSync(process.execPath, ['--check', 'src/' + file], { stdio: 'inherit' });\""
   },
   "dependencies": {
     "@modelcontextprotocol/express": "^2.0.0",
@@ -17,5 +21,6 @@
     "express": "^5.2.1",
     "pg": "^8.23.0",
     "zod": "^4.4.3"
-  }
+  },
+  "version": "0.3.0"
 }

package/dist/services/aidlc-coordination/src/lifecycle-core.mjs

@@ -12,6 +12,8 @@ const phaseGate = (phase) => phase === "clarify" ? "G0_confirm" : phase === "pla
 const iso = (value) => typeof value === "string" && Number.isFinite(Date.parse(value)) && new Date(Date.parse(value)).toISOString() === value;
 const text = (value) => typeof value === "string" && Boolean(value.trim());
 const idPattern = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+const commitPattern = /^[0-9a-f]{7,64}$/;
+const commitFields = ["baseCommit", "finalCommit"];
 const digest = (content) => createHash("sha256").update(content).digest("hex");
 const archiveRecordPath = (id) => `.agents/data/state/archive/${id}.json`;
 const taskRecordContent = (task) => `${JSON.stringify(task, null, 2)}\n`;
@@ -74,6 +76,7 @@ const validateTask = (id, task) => {
   if (task.closure && (!text(task.closure.reason) || !text(task.closure.source) || !iso(task.closure.recordedAt))) throw new Error(`Invalid task closure: ${id}`);
   if ((task.status === "superseded") !== Boolean(task.successorTaskId) || (task.status === "closed" && task.successorTaskId)) throw new Error(`Invalid task successor: ${id}`);
   if (task.predecessorTaskId !== undefined && !text(task.predecessorTaskId)) throw new Error(`Invalid task predecessor: ${id}`);
+  for (const field of commitFields) if (task[field] !== undefined && !(typeof task[field] === "string" && commitPattern.test(task[field]))) throw new Error(`Invalid task ${field}: ${id}`);
   for (const path of Object.values(task.artifacts ?? {})) if (path) {
     const cleaned = normalize(path);
     if (isAbsolute(cleaned) || cleaned === ".." || cleaned.startsWith(`..${separator}`) || !cleaned.startsWith(`.agents${separator}data${separator}tasks${separator}`)) throw new Error(`Invalid artifact path for ${id}: ${path}`);
@@ -278,6 +281,14 @@ export const transitionTask = (state, id, target) => {
   task.phase = target; task.gate = phaseGate(target); task.status = target === "done" ? "done" : "active"; delete task.legacyG2Wait; task.updatedAt = new Date().toISOString(); return task;
 };
 
+/** Record a git SHA on a task. Wrappers resolve the SHA (lib/repo-head.mjs); the core never runs git. */
+export const recordTaskCommit = (task, field, sha) => {
+  if (!task || typeof task !== "object") throw new Error("recordTaskCommit requires a task");
+  if (!commitFields.includes(field)) throw new Error(`Unknown task commit field: ${field}`);
+  if (typeof sha !== "string" || !commitPattern.test(sha)) throw new Error(`Invalid ${field}: expected a lowercase hex git SHA (7-64 chars)`);
+  task[field] = sha; task.updatedAt = new Date().toISOString(); return task;
+};
+
 export const readyTaskItems = (task) => {
   const byId = new Map(task.tasks.map((item) => [item.id, item]));
   if (byId.size !== task.tasks.length) throw new Error(`Duplicate execution item: ${task.id}`);
@@ -307,6 +318,60 @@ export const readyTaskItems = (task) => {
   return { ready, blocked };
 };
 
+/* Parallel work partition: owned paths overlap by path segment (`a` overlaps `a/b`, not `ab`).
+ * Two open items can run concurrently unless one is a direct or transitive dependency of the other. */
+const ownedPathKey = (path) => String(path).replace(/\/+$/, "");
+export const pathOverlaps = (left, right) => { const a = ownedPathKey(left), b = ownedPathKey(right); return a === b || a.startsWith(`${b}/`) || b.startsWith(`${a}/`); };
+export const pathsOverlap = (left = [], right = []) => left.some((a) => right.some((b) => pathOverlaps(a, b)));
+const itemAncestors = (task) => {
+  const byId = new Map(task.tasks.map((item) => [item.id, item])); const memo = new Map();
+  const walk = (id, trail = new Set()) => { if (memo.has(id)) return memo.get(id); const found = new Set(); if (trail.has(id)) return found; trail.add(id); for (const dep of byId.get(id)?.dependsOn ?? []) { if (!byId.has(dep)) continue; found.add(dep); for (const deeper of walk(dep, trail)) found.add(deeper); } trail.delete(id); memo.set(id, found); return found; };
+  return (id) => walk(id);
+};
+export const concurrentItemPairs = (task) => {
+  const open = task.tasks.filter((item) => !["done", "deferred"].includes(item.status)); const ancestors = itemAncestors(task); const pairs = [];
+  for (let i = 0; i < open.length; i += 1) for (let j = i + 1; j < open.length; j += 1) { const a = open[i], b = open[j]; if (!ancestors(a.id).has(b.id) && !ancestors(b.id).has(a.id)) pairs.push([a, b]); }
+  return pairs;
+};
+/** Approve-plan partition check. `strict` (enabled loop) makes findings ERRORs; otherwise WARNs. */
+export const partitionDiagnostics = (task, { strict = true } = {}) => {
+  const level = strict ? "ERROR" : "WARN"; const diagnostics = [];
+  const unscoped = task.tasks.filter((item) => !["done", "deferred"].includes(item.status) && !(Array.isArray(item.ownedPaths) && item.ownedPaths.length));
+  if (unscoped.length) diagnostics.push({ level, code: "PARTITION_SCOPE", message: `Build items need owned paths (--owns) for parallel workers: ${unscoped.map((item) => item.id).join(", ")}` });
+  for (const [a, b] of concurrentItemPairs(task)) {
+    const shared = (a.ownedPaths ?? []).filter((path) => (b.ownedPaths ?? []).some((other) => pathOverlaps(path, other)));
+    if (shared.length) diagnostics.push({ level, code: "PARTITION_OVERLAP", message: `Items ${a.id} and ${b.id} can run concurrently but both own ${shared.join(", ")}; split the paths or add --depends-on` });
+  }
+  return diagnostics;
+};
+/** The partition check is strict when the loop is enabled: `loop.mode` local/fleet in the project config, or
+ * running inside a fleet-enabled coordination service. A missing config means the default `off`; an
+ * unreadable or corrupt config fails closed (strict). */
+export const loopPartitionStrict = (root) => {
+  if (process.env.MCP_FLEET_ENABLED === "1") return true;
+  if (root === undefined) return false;
+  const path = join(resolve(root), ".agents", "config.json");
+  if (!existsSync(path)) return false;
+  try { const mode = JSON.parse(readFileSync(path, "utf8"))?.loop?.mode; return mode === "local" || mode === "fleet"; }
+  catch { return true; }
+};
+/** Pick the next dispatchable batch: dependency-ready items in plan order, at most `capacity`,
+ * skipping items that overlap each other, `busyPaths`, or are listed in `exclude`. Never throws for overlap. */
+export const selectBuildBatch = (task, { capacity = Infinity, busyPaths = [], exclude = [] } = {}) => {
+  const byId = new Map(task.tasks.map((item) => [item.id, item])); const selected = []; const deferred = []; const taken = [];
+  for (const id of readyTaskItems(task).ready) {
+    const owned = byId.get(id)?.ownedPaths ?? [];
+    if (exclude.includes(id)) { deferred.push({ id, reason: "unresolved assignment" }); continue; }
+    if (!owned.length) { deferred.push({ id, reason: "no owned paths" }); continue; }
+    if (pathsOverlap(owned, busyPaths)) { deferred.push({ id, reason: "busy path held by an active assignment" }); continue; }
+    const clash = taken.find((entry) => pathsOverlap(owned, entry.owned));
+    if (clash) { deferred.push({ id, reason: `overlaps ${clash.id}` }); continue; }
+    if (selected.length >= capacity) { deferred.push({ id, reason: "capacity" }); continue; }
+    selected.push(id); taken.push({ id, owned });
+  }
+  return { selected, deferred };
+};
+
 export const nextAction = (task, root) => {
   const rootSuffix = root === undefined ? "" : ` --root ${JSON.stringify(resolve(root))}`;
   const script = (name) => root === undefined ? `node .agents/aidlc/scripts/${name}` : `node ${JSON.stringify(join(resolve(root), ".agents/aidlc/scripts", name))}`;
@@ -357,13 +422,14 @@ export const searchLessons = (root, state, query, areas = [], limit = 5) => { co
 
 export const listTaskSummaries = (state, options = {}) => { const active = Object.values(state.tasks).map((task) => ({ id: task.id, title: task.title, phase: task.phase, gate: task.gate, status: task.status, risk: task.risk, areas: task.areas, updatedAt: task.updatedAt, source: "active" })); const archived = options.includeArchive ? Object.values(state.archive ?? {}).map((task) => ({ id: task.id, title: task.title, phase: task.phase, gate: task.gate, status: task.status, risk: task.risk, areas: task.areas, updatedAt: task.updatedAt, source: "archive" })) : []; const queryTokens = tokens(options.query ?? ""); const statusSet = new Set(options.statuses ?? []); const filtered = [...active, ...archived].filter((item) => (!statusSet.size || statusSet.has(item.status)) && (!queryTokens.length || queryTokens.every((token) => tokens(`${item.id} ${item.title} ${item.areas.join(" ")}`).includes(token)))).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt) || a.id.localeCompare(b.id)); const cursor = Math.max(0, options.cursor ?? 0); const limit = Math.max(1, Math.min(options.limit ?? 20, 100)); const items = filtered.slice(cursor, cursor + limit); return { items, nextCursor: cursor + items.length < filtered.length ? String(cursor + items.length) : null, total: filtered.length }; };
 
-export const renderWorkplan = (task) => { const decisions = task.decisions.length ? task.decisions.map((item) => `- [${item.status === "approved" ? "x" : " "}] ${item.id} — ${item.label}${item.resolution ? ` — ${item.resolution}` : ""}`).join("\n") : "- None"; const tasks = task.tasks.length ? task.tasks.map((item) => `- [${item.status === "done" ? "x" : item.status === "in_progress" ? "~" : " "}] ${item.id} — ${item.label}`).join("\n") : "- None"; const lifecycle = [`- Status: \`${task.status}\``, task.handoff ? `- Handoff: \`${task.handoff.kind}\` — ${task.handoff.reason}` : "", task.closure ? `- Closure: ${task.closure.reason}` : "", task.predecessorTaskId ? `- Predecessor: \`${task.predecessorTaskId}\`` : "", task.successorTaskId ? `- Successor: \`${task.successorTaskId}\`` : "", task.lessonDisposition ? `- Lessons: \`${task.lessonDisposition.status}\`` : ""].filter(Boolean).join("\n"); return `# Workplan — ${task.title} (\`${task.id}\`)\n\n> Generated from canonical JSON state.\n\n## Lifecycle\n${lifecycle}\n\n## 🧩 Decisions (Approve plan — before implementation)\n${decisions}\n\n## 🧩 Tasks (Review implementation — work items)\n${tasks}\n`; };
+const workplanScope = (item) => { const parts = [item.ownedPaths?.length ? `owns: ${item.ownedPaths.join(", ")}` : "", item.dependsOn?.length ? `after: ${item.dependsOn.join(", ")}` : ""].filter(Boolean); return parts.length ? ` — ${parts.join(" · ")}` : ""; };
+export const renderWorkplan = (task) => { const decisions = task.decisions.length ? task.decisions.map((item) => `- [${item.status === "approved" ? "x" : " "}] ${item.id} — ${item.label}${item.resolution ? ` — ${item.resolution}` : ""}`).join("\n") : "- None"; const tasks = task.tasks.length ? task.tasks.map((item) => `- [${item.status === "done" ? "x" : item.status === "in_progress" ? "~" : " "}] ${item.id} — ${item.label}${workplanScope(item)}`).join("\n") : "- None"; const lifecycle = [`- Status: \`${task.status}\``, task.handoff ? `- Handoff: \`${task.handoff.kind}\` — ${task.handoff.reason}` : "", task.closure ? `- Closure: ${task.closure.reason}` : "", task.predecessorTaskId ? `- Predecessor: \`${task.predecessorTaskId}\`` : "", task.successorTaskId ? `- Successor: \`${task.successorTaskId}\`` : "", task.lessonDisposition ? `- Lessons: \`${task.lessonDisposition.status}\`` : ""].filter(Boolean).join("\n"); return `# Workplan — ${task.title} (\`${task.id}\`)\n\n> Generated from canonical JSON state.\n\n## Lifecycle\n${lifecycle}\n\n## 🧩 Decisions (Approve plan — before implementation)\n${decisions}\n\n## 🧩 Tasks (Review implementation — work items)\n${tasks}\n`; };
 export const renderViews = (root, state = loadState(root), selected = Object.values(state.tasks)) => { for (const task of selected) { if (!task.artifacts.workplan) continue; assertNoSymlinkPath(root, task.artifacts.workplan); writeAtomic(join(resolve(root), task.artifacts.workplan), renderWorkplan(task)); } };
 
 const safeArtifactTarget = (root, path) => { assertNoSymlinkPath(root, path); return join(resolve(root), path); };
 const artifactContent = (root, path) => { if (!path) return undefined; try { const target = safeArtifactTarget(root, path); return existsSync(target) ? readFileSync(target, "utf8") : undefined; } catch { return undefined; } /* intentional: unreadable/unsafe artifact is treated as absent */ };
 const artifactDiagnostics = (root, task, names) => names.flatMap((name) => { const path = task.artifacts[name]; if (!path) return [{ level: "ERROR", code: "ARTIFACT_REFERENCE", message: `${name} artifact is not referenced` }]; try { return existsSync(safeArtifactTarget(root, path)) ? [] : [{ level: "ERROR", code: "ARTIFACT_MISSING", message: `${path} does not exist` }]; } catch (error) { return [{ level: "ERROR", code: "ARTIFACT_UNSAFE", message: error instanceof Error ? error.message : String(error) }]; } });
-export const checkGate = (root, state, taskId, gate) => { const task = state.tasks[taskId]; if (!task) return [{ level: "ERROR", code: "TASK_UNKNOWN", message: `Unknown active task: ${taskId}` }]; const diagnostics = []; if (task.gate !== gate) diagnostics.push({ level: "ERROR", code: "GATE_STATE", message: `Task is at ${task.gate}, not ${gate}` }); if (["closed", "superseded"].includes(task.status)) diagnostics.push({ level: "ERROR", code: "TASK_TERMINAL", message: `Terminal task cannot approve ${gate}` }); if (task.handoff) diagnostics.push({ level: "ERROR", code: "TASK_HANDOFF", message: `Task has unresolved handoff: ${task.handoff.reason}` }); if (task.id !== taskId) diagnostics.push({ level: "ERROR", code: "TASK_ID", message: "Task key and id differ" }); if (!task.title.trim() || !task.areas.length) diagnostics.push({ level: "ERROR", code: "TASK_FIELDS", message: "Task title and affected areas are required" }); if (gate === "G0_confirm") { diagnostics.push(...artifactDiagnostics(root, task, ["intent"])); const content = artifactContent(root, task.artifacts.intent); if (content !== undefined) for (const heading of ["## 📋 Problem", "## 🗺️ Affected areas", "## 💭 Assumptions", "## ❓ Open questions", "## 🎯 Scope"]) if (!content.includes(heading)) diagnostics.push({ level: "ERROR", code: "INTENT_HEADING", message: `Intent is missing ${heading}` }); } if (gate === "G1_review") { diagnostics.push(...artifactDiagnostics(root, task, ["intent", "design", "workplan"])); diagnostics.push(...transitionDiagnostics(task, "build").filter((item) => item.code === "UNRESOLVED_DECISION")); const content = artifactContent(root, task.artifacts.design); if (content !== undefined) for (const heading of ["## 🧩 Solution per affected area", "## 📌 Spec traceability", "## 🔗 Cross-service contracts", "## ⚠️ Risks / edge cases"]) if (!content.includes(heading)) diagnostics.push({ level: "ERROR", code: "DESIGN_HEADING", message: `Design is missing ${heading}` }); } if (gate === "G2_codereview") { diagnostics.push(...artifactDiagnostics(root, task, ["intent", "design", "workplan"])); if (task.tasks.some((item) => !["done", "deferred"].includes(item.status))) diagnostics.push({ level: "ERROR", code: "TASKS_OPEN", message: "Build tasks remain open" }); for (const area of task.areas) if (!hasAreaVerification(task, area)) diagnostics.push({ level: "ERROR", code: "VERIFY_EVIDENCE", message: `Latest post-G1 verification evidence must pass for affected area: ${area}` }); if (!hasReview(task)) diagnostics.push({ level: "ERROR", code: "REVIEW_EVIDENCE", message: "Latest post-G1 code-review evidence must pass" }); const bounds = repairBounds(task); if (!isLegacyG2Wait(task) && (bounds.verifyExhausted || bounds.reviewExhausted)) diagnostics.push({ level: "ERROR", code: "REPAIR_BOUND", message: "Repair bound exhausted; record a durable handoff instead of presenting G2" }); } if (!diagnostics.length) diagnostics.push({ level: "INFO", code: "GATE_OK", message: `${gate} checks passed for ${taskId}` }); return diagnostics; };
+export const checkGate = (root, state, taskId, gate) => { const task = state.tasks[taskId]; if (!task) return [{ level: "ERROR", code: "TASK_UNKNOWN", message: `Unknown active task: ${taskId}` }]; const diagnostics = []; if (task.gate !== gate) diagnostics.push({ level: "ERROR", code: "GATE_STATE", message: `Task is at ${task.gate}, not ${gate}` }); if (["closed", "superseded"].includes(task.status)) diagnostics.push({ level: "ERROR", code: "TASK_TERMINAL", message: `Terminal task cannot approve ${gate}` }); if (task.handoff) diagnostics.push({ level: "ERROR", code: "TASK_HANDOFF", message: `Task has unresolved handoff: ${task.handoff.reason}` }); if (task.id !== taskId) diagnostics.push({ level: "ERROR", code: "TASK_ID", message: "Task key and id differ" }); if (!task.title.trim() || !task.areas.length) diagnostics.push({ level: "ERROR", code: "TASK_FIELDS", message: "Task title and affected areas are required" }); if (gate === "G0_confirm") { diagnostics.push(...artifactDiagnostics(root, task, ["intent"])); const content = artifactContent(root, task.artifacts.intent); if (content !== undefined) for (const heading of ["## 📋 Problem", "## 🗺️ Affected areas", "## 💭 Assumptions", "## ❓ Open questions", "## 🎯 Scope"]) if (!content.includes(heading)) diagnostics.push({ level: "ERROR", code: "INTENT_HEADING", message: `Intent is missing ${heading}` }); } if (gate === "G1_review") { diagnostics.push(...artifactDiagnostics(root, task, ["intent", "design", "workplan"])); diagnostics.push(...transitionDiagnostics(task, "build").filter((item) => item.code === "UNRESOLVED_DECISION")); const content = artifactContent(root, task.artifacts.design); if (content !== undefined) for (const heading of ["## 🧩 Solution per affected area", "## 📌 Spec traceability", "## 🔗 Cross-service contracts", "## ⚠️ Risks / edge cases"]) if (!content.includes(heading)) diagnostics.push({ level: "ERROR", code: "DESIGN_HEADING", message: `Design is missing ${heading}` }); diagnostics.push(...partitionDiagnostics(task, { strict: loopPartitionStrict(root) })); } if (gate === "G2_codereview") { diagnostics.push(...artifactDiagnostics(root, task, ["intent", "design", "workplan"])); if (task.tasks.some((item) => !["done", "deferred"].includes(item.status))) diagnostics.push({ level: "ERROR", code: "TASKS_OPEN", message: "Build tasks remain open" }); for (const area of task.areas) if (!hasAreaVerification(task, area)) diagnostics.push({ level: "ERROR", code: "VERIFY_EVIDENCE", message: `Latest post-G1 verification evidence must pass for affected area: ${area}` }); if (!hasReview(task)) diagnostics.push({ level: "ERROR", code: "REVIEW_EVIDENCE", message: "Latest post-G1 code-review evidence must pass" }); const bounds = repairBounds(task); if (!isLegacyG2Wait(task) && (bounds.verifyExhausted || bounds.reviewExhausted)) diagnostics.push({ level: "ERROR", code: "REPAIR_BOUND", message: "Repair bound exhausted; record a durable handoff instead of presenting G2" }); } if (!diagnostics.some((item) => item.level === "ERROR")) diagnostics.push({ level: "INFO", code: "GATE_OK", message: `${gate} checks passed for ${taskId}` }); return diagnostics; };
 const gateTarget = { G0_confirm: "plan", G1_review: "build", G2_codereview: "wrap" };
 export const approveAndAdvance = (root, state, taskId, gate, source, recordedAt = new Date().toISOString()) => { const task = state.tasks[taskId]; if (!task) throw new Error(`Unknown active task: ${taskId}`); if (["closed", "superseded"].includes(task.status) || task.handoff) throw new Error(`Terminal or handed-off task cannot approve ${gate}`); const target = gateTarget[gate]; if (!target) throw new Error(`Gate ${gate} cannot be approved`); if (task.phase === target) return { task, nextAction: nextAction(task, root), idempotent: true }; if (task.gate !== gate || task.status !== "blocked_on_user") throw new Error(`Task must be blocked_on_user at ${gate}`); const errors = checkGate(root, state, taskId, gate).filter((item) => item.level === "ERROR"); if (errors.length) throw new Error(errors.map((item) => item.message).join("; ")); task.evidence.push({ kind: "approval", gate, result: "pass", source, recordedAt }); transitionTask(state, taskId, target); return { task, nextAction: nextAction(task, root), idempotent: false }; };
 export const formatDiagnostics = (diagnostics) => diagnostics.map((item) => `${item.level} ${item.code}: ${item.message}`).join("\n");

package/dist/services/aidlc-coordination/src/repository.mjs

@@ -119,6 +119,19 @@ const approveSnapshot = (current, snapshot, taskId, source, integrationCommit) =
   transitionTask(state, taskId, target);
   return mutationResult(current.state, state, current.index, [taskId]);
 };
+const rejectSnapshot = (current, snapshot, taskId, feedback, snapshotId) => {
+  if (typeof feedback !== "string" || !feedback.trim() || feedback.length > 2000) throw new Error("bounded feedback text is required");
+  if (!snapshot || snapshot.task_id !== taskId || !current.state.tasks?.[taskId] || snapshot.task_digest !== taskDigest(current.state.tasks[taskId])) throw new Error("stale gate snapshot");
+  const task = current.state.tasks?.[taskId];
+  if (!task || task.gate !== snapshot.gate || task.status !== "blocked_on_user" || nextAction(task).classification !== "await_user") throw new Error("gate is no longer ready");
+  const state = structuredClone(current.state);
+  const recordedAt = new Date().toISOString();
+  state.tasks[taskId].evidence.push({ kind: "diagnostic", result: "pass", source: `Fleet reviewer: feedback (${snapshotId})`, detail: `Cancelled gate wait at ${snapshot.gate}: ${feedback}`, recordedAt });
+  delete state.tasks[taskId].legacyG2Wait;
+  state.tasks[taskId].status = "active";
+  state.tasks[taskId].updatedAt = recordedAt;
+  return mutationResult(current.state, state, current.index, [taskId]);
+};
 const verifyFence = (fleet, taskId, epoch, ownerToken, time = Date.now()) => {
   const lead = fleet?.leads?.[taskId];
   if (!lead || !Number.isInteger(epoch) || lead.epoch !== epoch || Date.parse(lead.expiresAt) <= time || (lead.ownerTokenHash && (typeof ownerToken !== "string" || createHash("sha256").update(ownerToken).digest("hex") !== lead.ownerTokenHash))) throw new Error("stale or expired lead epoch");
@@ -306,6 +319,32 @@ export class SqliteStateRepository {
     } catch(error){try{this.db.exec("ROLLBACK");}catch{} throw error;}
   }
 
+  async rejectGate(workspace,expectedRevision,idempotencyKey,taskId,gateSnapshotId,feedback,clientProjectRoot,principal) {
+    if(typeof idempotencyKey!=="string"||!idempotencyKey.trim()||typeof clientProjectRoot!=="string"||!isAbsolute(clientProjectRoot)) throw new Error("invalid rejection precondition");
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      this.#ensure(workspace);
+      sqliteRequest(this.db,workspace,idempotencyKey,principal,"gate_reject",{expectedRevision,taskId,gateSnapshotId,feedback,clientProjectRoot});
+      const cached=this.db.prepare("SELECT response FROM state_idempotency WHERE workspace=? AND idempotency_key=?").get(workspace,idempotencyKey);
+      if(cached){this.db.exec("COMMIT");return parse(cached.response);}
+      const current=snapshot(this.db.prepare("SELECT * FROM state_workspaces WHERE workspace=?").get(workspace));
+      if(current.revision!==expectedRevision) throw new RevisionConflict(current);
+      const gateSnapshot=this.db.prepare("SELECT * FROM state_gate_snapshots WHERE workspace=? AND id=?").get(workspace,gateSnapshotId);
+      const checkpointRow=this.db.prepare("SELECT * FROM state_gate_checkpoints WHERE workspace=? AND task_id=?").get(workspace,taskId);
+      const fleetRow=this.db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='fleet_workspaces'").get() ? this.db.prepare("SELECT fleet FROM fleet_workspaces WHERE workspace=?").get(workspace) : null;
+      const managed=fleetRow && parse(fleetRow.fleet)?.supervisors?.[taskId];
+      if (managed && (!checkpointRow || checkpointRow.status !== "pending" || checkpointRow.snapshot_id !== gateSnapshotId)) throw new Error("supervised rejection requires matching pending checkpoint");
+      if (checkpointRow?.status === "pending" && checkpointRow.snapshot_id !== gateSnapshotId) throw new Error("gate checkpoint does not match snapshot");
+      const next=rejectSnapshot(current,gateSnapshot,taskId,feedback,gateSnapshotId); const revision=current.revision+1; const updatedAt=new Date().toISOString(); next.index={...next.index,sourceRevision:revision,updatedAt};
+      const response={workspace,revision,state:next.state,index:next.index,nextActions:{[taskId]:nextAction(next.state.tasks[taskId],resolve(clientProjectRoot))},updatedAt};
+      this.db.prepare("UPDATE state_workspaces SET revision=?,state=?,task_index=?,updated_at=? WHERE workspace=?").run(revision,encode(next.state),encode(next.index),updatedAt,workspace);
+      this.db.prepare("UPDATE state_gate_checkpoints SET status='rejected' WHERE workspace=? AND task_id=? AND snapshot_id=? AND status='pending'").run(workspace,taskId,gateSnapshotId);
+      this.db.prepare("INSERT INTO state_events (workspace,revision,idempotency_key,command,recorded_at) VALUES (?,?,?,?,?)").run(workspace,revision,idempotencyKey,encode({type:"gate_reject",taskId,snapshotId:gateSnapshotId}),updatedAt);
+      this.db.prepare("INSERT INTO state_idempotency VALUES (?,?,?)").run(workspace,idempotencyKey,encode(response));
+      this.db.exec("COMMIT");return response;
+    } catch(error){try{this.db.exec("ROLLBACK");}catch{} throw error;}
+  }
+
   close() { this.db.close(); }
 }
 
@@ -360,6 +399,33 @@ export class PostgresStateRepository {
   async putGateSnapshot(workspace,expectedRevision,idempotencyKey,taskId,gate,reviewText,leadEpoch,integrationCommit,leadOwnerToken,checkpoint=false,principal) { if(typeof idempotencyKey!=="string"||!idempotencyKey.trim()) throw new Error("idempotencyKey is required"); const c=await this.pool.connect(); try { await this.#init(c); await c.query("BEGIN"); if(leadEpoch!==undefined){const fleetRow=(await c.query("SELECT fleet FROM fleet_workspaces WHERE workspace=$1 FOR UPDATE",[workspace])).rows[0];verifyFence(fleetRow?.fleet,taskId,leadEpoch,leadOwnerToken,Number((await c.query("SELECT extract(epoch from clock_timestamp()) * 1000 AS ms")).rows[0].ms));} await c.query("INSERT INTO state_workspaces VALUES ($1,0,$2,$3,$4) ON CONFLICT DO NOTHING",[workspace,emptyState(),emptyIndex(0),new Date().toISOString()]); const row=(await c.query("SELECT * FROM state_workspaces WHERE workspace=$1 FOR UPDATE",[workspace])).rows[0]; await postgresRequest(c,workspace,idempotencyKey,principal,"gate_snapshot_put",{expectedRevision,taskId,gate,reviewText,leadEpoch,integrationCommit,leadOwnerToken,checkpoint}); const cached=(await c.query("SELECT response FROM state_idempotency WHERE workspace=$1 AND idempotency_key=$2",[workspace,idempotencyKey])).rows[0]; if(cached){await c.query("COMMIT");return cached.response;} const current={workspace,revision:Number(row.revision),state:upgradeStoredState(row.state),index:row.task_index,updatedAt:row.updated_at}; if(current.revision!==expectedRevision) throw new RevisionConflict(current); if(checkpoint){const prior=(await c.query("SELECT status FROM state_gate_checkpoints WHERE workspace=$1 AND task_id=$2 FOR UPDATE",[workspace,taskId])).rows[0];if(prior?.status==="approved") throw new Error("approved checkpoint must be reconciled before replacement");} const boundReviewText=reviewWithCommit(gate,reviewText,integrationCommit); validateGateSnapshot(current,taskId,gate,boundReviewText,integrationCommit); const item={id:snapshotId(workspace,taskId,current.revision,gate,boundReviewText,integrationCommit),workspace,taskId,gate,stateRevision:current.revision,taskDigest:taskDigest(current.state.tasks[taskId]),integrationCommit:integrationCommit??null,reviewText:boundReviewText,createdAt:new Date().toISOString()}; await c.query("INSERT INTO state_gate_snapshots VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9) ON CONFLICT DO NOTHING",[item.id,workspace,taskId,gate,current.revision,item.taskDigest,item.integrationCommit,boundReviewText,item.createdAt]); item.createdAt=(await c.query("SELECT created_at FROM state_gate_snapshots WHERE id=$1",[item.id])).rows[0].created_at; if(checkpoint) await c.query("INSERT INTO state_gate_checkpoints (workspace,task_id,snapshot_id,gate,task_digest,state_revision,integration_commit,status,approval_revision,phase) VALUES ($1,$2,$3,$4,$5,$6,$7,'pending',NULL,$8) ON CONFLICT(workspace,task_id) DO UPDATE SET snapshot_id=excluded.snapshot_id,gate=excluded.gate,task_digest=excluded.task_digest,state_revision=excluded.state_revision,integration_commit=excluded.integration_commit,status='pending',approval_revision=NULL,phase=excluded.phase",[workspace,taskId,item.id,gate,item.taskDigest,current.revision,item.integrationCommit,current.state.tasks[taskId].phase]); await c.query("INSERT INTO state_idempotency VALUES ($1,$2,$3)",[workspace,idempotencyKey,item]); await c.query("COMMIT");return item; } catch(error){try{await c.query("ROLLBACK");}catch{} throw error;} finally{c.release();} }
   async gateCheckpoint(workspace,taskId) { const c=await this.pool.connect(); try { await this.#init(c); const row=(await c.query("SELECT snapshot_id AS \"snapshotId\",gate,phase,task_digest AS \"taskDigest\",state_revision AS \"stateRevision\",integration_commit AS \"integrationCommit\",status,approval_revision AS \"approvalRevision\" FROM state_gate_checkpoints WHERE workspace=$1 AND task_id=$2",[workspace,taskId])).rows[0]; return row ? {...row,stateRevision:Number(row.stateRevision),approvalRevision:row.approvalRevision===null?null:Number(row.approvalRevision)} : null; } finally { c.release(); } }
   async approveGate(workspace,expectedRevision,idempotencyKey,taskId,gateSnapshotId,source,clientProjectRoot,integrationCommit,principal) { if(typeof idempotencyKey!=="string"||!idempotencyKey.trim()||typeof clientProjectRoot!=="string"||!isAbsolute(clientProjectRoot)) throw new Error("invalid approval precondition"); const c=await this.pool.connect(); try { await this.#init(c); await c.query("BEGIN"); const fleetTable=(await c.query("SELECT to_regclass('fleet_workspaces') AS name")).rows[0].name; const fleetRow=fleetTable ? (await c.query("SELECT fleet FROM fleet_workspaces WHERE workspace=$1 FOR UPDATE",[workspace])).rows[0] : null; await c.query("INSERT INTO state_workspaces VALUES ($1,0,$2,$3,$4) ON CONFLICT DO NOTHING",[workspace,emptyState(),emptyIndex(0),new Date().toISOString()]); const row=(await c.query("SELECT * FROM state_workspaces WHERE workspace=$1 FOR UPDATE",[workspace])).rows[0]; await postgresRequest(c,workspace,idempotencyKey,principal,"gate_approve",{expectedRevision,taskId,gateSnapshotId,source,clientProjectRoot,integrationCommit}); const cached=(await c.query("SELECT response FROM state_idempotency WHERE workspace=$1 AND idempotency_key=$2",[workspace,idempotencyKey])).rows[0]; if(cached){await c.query("COMMIT");return cached.response;} const current={workspace,revision:Number(row.revision),state:upgradeStoredState(row.state),index:row.task_index,updatedAt:row.updated_at}; if(current.revision!==expectedRevision) throw new RevisionConflict(current); const gateSnapshot=(await c.query("SELECT * FROM state_gate_snapshots WHERE workspace=$1 AND id=$2",[workspace,gateSnapshotId])).rows[0]; const checkpointRow=(await c.query("SELECT * FROM state_gate_checkpoints WHERE workspace=$1 AND task_id=$2 FOR UPDATE",[workspace,taskId])).rows[0]; if(fleetRow?.fleet?.supervisors?.[taskId] && (!checkpointRow || checkpointRow.status!=="pending" || checkpointRow.snapshot_id!==gateSnapshotId)) throw new Error("supervised approval requires matching pending checkpoint"); if(checkpointRow?.status==="pending" && checkpointRow.snapshot_id!==gateSnapshotId) throw new Error("gate checkpoint does not match snapshot"); const next=approveSnapshot(current,gateSnapshot,taskId,source,integrationCommit); const revision=current.revision+1; const updatedAt=new Date().toISOString(); next.index={...next.index,sourceRevision:revision,updatedAt}; const response={workspace,revision,state:next.state,index:next.index,nextActions:{[taskId]:nextAction(next.state.tasks[taskId],resolve(clientProjectRoot))},updatedAt}; await c.query("UPDATE state_workspaces SET revision=$1,state=$2,task_index=$3,updated_at=$4 WHERE workspace=$5",[revision,next.state,next.index,updatedAt,workspace]); await c.query("UPDATE state_gate_checkpoints SET status='approved',approval_revision=$1 WHERE workspace=$2 AND task_id=$3 AND snapshot_id=$4 AND status='pending'",[revision,workspace,taskId,gateSnapshotId]); await c.query("INSERT INTO state_events (workspace,revision,idempotency_key,command,recorded_at) VALUES ($1,$2,$3,$4,$5)",[workspace,revision,idempotencyKey,{type:"gate_approve",taskId,snapshotId:gateSnapshotId,integrationCommit:integrationCommit??null},updatedAt]); await c.query("INSERT INTO state_idempotency VALUES ($1,$2,$3)",[workspace,idempotencyKey,response]); await c.query("COMMIT");return response; } catch(error){try{await c.query("ROLLBACK");}catch{} throw error;} finally{c.release();} }
+  async rejectGate(workspace,expectedRevision,idempotencyKey,taskId,gateSnapshotId,feedback,clientProjectRoot,principal) {
+    if(typeof idempotencyKey!=="string"||!idempotencyKey.trim()||typeof clientProjectRoot!=="string"||!isAbsolute(clientProjectRoot)) throw new Error("invalid rejection precondition");
+    const c=await this.pool.connect();
+    try {
+      await this.#init(c); await c.query("BEGIN");
+      const fleetTable=(await c.query("SELECT to_regclass('fleet_workspaces') AS name")).rows[0].name;
+      const fleetRow=fleetTable ? (await c.query("SELECT fleet FROM fleet_workspaces WHERE workspace=$1 FOR UPDATE",[workspace])).rows[0] : null;
+      await c.query("INSERT INTO state_workspaces VALUES ($1,0,$2,$3,$4) ON CONFLICT DO NOTHING",[workspace,emptyState(),emptyIndex(0),new Date().toISOString()]);
+      const row=(await c.query("SELECT * FROM state_workspaces WHERE workspace=$1 FOR UPDATE",[workspace])).rows[0];
+      await postgresRequest(c,workspace,idempotencyKey,principal,"gate_reject",{expectedRevision,taskId,gateSnapshotId,feedback,clientProjectRoot});
+      const cached=(await c.query("SELECT response FROM state_idempotency WHERE workspace=$1 AND idempotency_key=$2",[workspace,idempotencyKey])).rows[0];
+      if(cached){await c.query("COMMIT");return cached.response;}
+      const current={workspace,revision:Number(row.revision),state:upgradeStoredState(row.state),index:row.task_index,updatedAt:row.updated_at};
+      if(current.revision!==expectedRevision) throw new RevisionConflict(current);
+      const gateSnapshot=(await c.query("SELECT * FROM state_gate_snapshots WHERE workspace=$1 AND id=$2",[workspace,gateSnapshotId])).rows[0];
+      const checkpointRow=(await c.query("SELECT * FROM state_gate_checkpoints WHERE workspace=$1 AND task_id=$2 FOR UPDATE",[workspace,taskId])).rows[0];
+      if(fleetRow?.fleet?.supervisors?.[taskId] && (!checkpointRow || checkpointRow.status!=="pending" || checkpointRow.snapshot_id!==gateSnapshotId)) throw new Error("supervised rejection requires matching pending checkpoint");
+      if(checkpointRow?.status==="pending" && checkpointRow.snapshot_id!==gateSnapshotId) throw new Error("gate checkpoint does not match snapshot");
+      const next=rejectSnapshot(current,gateSnapshot,taskId,feedback,gateSnapshotId); const revision=current.revision+1; const updatedAt=new Date().toISOString(); next.index={...next.index,sourceRevision:revision,updatedAt};
+      const response={workspace,revision,state:next.state,index:next.index,nextActions:{[taskId]:nextAction(next.state.tasks[taskId],resolve(clientProjectRoot))},updatedAt};
+      await c.query("UPDATE state_workspaces SET revision=$1,state=$2,task_index=$3,updated_at=$4 WHERE workspace=$5",[revision,next.state,next.index,updatedAt,workspace]);
+      await c.query("UPDATE state_gate_checkpoints SET status='rejected' WHERE workspace=$1 AND task_id=$2 AND snapshot_id=$3 AND status='pending'",[workspace,taskId,gateSnapshotId]);
+      await c.query("INSERT INTO state_events (workspace,revision,idempotency_key,command,recorded_at) VALUES ($1,$2,$3,$4,$5)",[workspace,revision,idempotencyKey,{type:"gate_reject",taskId,snapshotId:gateSnapshotId},updatedAt]);
+      await c.query("INSERT INTO state_idempotency (workspace,idempotency_key,response) VALUES ($1,$2,$3)",[workspace,idempotencyKey,response]);
+      await c.query("COMMIT"); return response;
+    } catch(error) { try { await c.query("ROLLBACK"); } catch {} throw error; } finally { c.release(); }
+  }
   async close() { await this.pool.end(); }
 }
 

package/dist/services/aidlc-coordination/src/server.mjs

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { timingSafeEqual } from "node:crypto";
+import { readFileSync } from "node:fs";
 import { McpServer } from "@modelcontextprotocol/server";
 import { NodeStreamableHTTPServerTransport } from "@modelcontextprotocol/node";
 import { createMcpExpressApp } from "@modelcontextprotocol/express";
@@ -10,12 +11,14 @@ import { CoordinationConflict, SqliteCoordinationRepository, createCoordinationR
 import { FleetConflict, SqliteFleetRepository, createFleetRepository, featureReady, validateCanonicalFeature } from "./fleet.mjs";
 import { nextAction } from "./lifecycle-core.mjs";
 
+let serviceVersion = "0.0.0-dev";
+try { const parsed = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")); if (parsed?.version) serviceVersion = parsed.version; } catch {}
 const result = (value) => ({ content: [{ type: "text", text: JSON.stringify(value, null, 2) }] });
 const failure = (error) => ({ isError: true, content: [{ type: "text", text: JSON.stringify(error instanceof RevisionConflict ? { code: "REVISION_CONFLICT", current: error.current } : error instanceof CoordinationConflict ? { code: "COORDINATION_CONFLICT", current: error.current } : error instanceof FleetConflict ? { code: "FLEET_CONFLICT", current: error.current, message: error.message } : { code: "STATE_ERROR", message: error instanceof Error ? error.message : String(error) }) }] });
 const workspace = z.string().min(1).max(128);
 
 export const buildServer = (repository, coordination = new SqliteCoordinationRepository(), fleet = new SqliteFleetRepository(), identity = null) => {
-  const server = new McpServer({ name: "aidlc-coordination", version: "0.1.0" });
+  const server = new McpServer({ name: "aidlc-coordination", version: serviceVersion });
   const requireRole = (...allowed) => { if (identity && !allowed.includes(identity.role)) throw new Error("credential role is not authorized for this operation"); };
   const actorFor = (actor) => identity ? { id: identity.id, role: { lead: "admin", worker: "commenter", reviewer: "reader" }[identity.role] } : actor;
   server.registerTool("state_get", { description: "Pull the current workflow state and derived index for a workspace.", inputSchema: z.object({ workspace }) }, async ({ workspace: id }) => { try { return result(await repository.get(id)); } catch (error) { return failure(error); } });
@@ -55,6 +58,7 @@ export const buildServer = (repository, coordination = new SqliteCoordinationRep
     server.registerTool("gate_snapshot_put", { description: "Publish a review snapshot at the current canonical task revision, binding G2 to an integration commit.", inputSchema: z.object({...precondition,taskId:z.string(),leadEpoch:z.number().int(),leadOwnerToken:z.string().min(32).max(256).optional(),checkpoint:z.boolean().optional(),gate:z.enum(["G0_confirm","G1_review","G2_codereview"]),reviewText:z.string().min(1).max(20000),integrationCommit:z.string().regex(/^[a-f0-9]{40}$/).optional()}) }, async ({workspace:id,expectedRevision,idempotencyKey,taskId,leadEpoch,leadOwnerToken,checkpoint,gate,reviewText,integrationCommit}) => { try { requireRole("lead"); return result(await repository.putGateSnapshot(id,expectedRevision,idempotencyKey,taskId,gate,reviewText,leadEpoch,integrationCommit,leadOwnerToken,checkpoint,identity.id)); } catch(error){return failure(error);} });
     server.registerTool("gate_checkpoint_get", { description: "Read durable supervisor gate checkpoint.", inputSchema: z.object({workspace,taskId:z.string()}) }, async ({workspace:id,taskId}) => { try { requireRole("lead","reviewer"); return result(await repository.gateCheckpoint(id,taskId)); } catch(error){return failure(error);} });
     server.registerTool("gate_approve", { description: "Reviewer-only atomic approval against an unchanged task revision and reviewed integration commit.", inputSchema: z.object({...precondition,taskId:z.string(),snapshotId:z.string(),source:z.string().min(1).max(2000),clientProjectRoot:z.string(),integrationCommit:z.string().regex(/^[a-f0-9]{40}$/).optional()}) }, async ({workspace:id,expectedRevision,idempotencyKey,taskId,snapshotId,source,clientProjectRoot,integrationCommit}) => { try { requireRole("reviewer"); return result(await repository.approveGate(id,expectedRevision,idempotencyKey,taskId,snapshotId,source,clientProjectRoot,integrationCommit,identity.id)); } catch(error){return failure(error);} });
+    server.registerTool("gate_reject", { description: "Reviewer-only feedback against an unchanged task revision; returns the task to active so the loop can revise and re-present the gate.", inputSchema: z.object({...precondition,taskId:z.string(),snapshotId:z.string(),feedback:z.string().min(1).max(2000),clientProjectRoot:z.string()}) }, async ({workspace:id,expectedRevision,idempotencyKey,taskId,snapshotId,feedback,clientProjectRoot}) => { try { requireRole("reviewer"); return result(await repository.rejectGate(id,expectedRevision,idempotencyKey,taskId,snapshotId,feedback,clientProjectRoot,identity.id)); } catch(error){return failure(error);} });
   }
   return server;
 };
@@ -77,9 +81,11 @@ if (fleetEnabled && (fleetCredentials.length < 3 || fleetCredentials.some((entry
 const equalToken = (left,right) => { const a=Buffer.from(left); const b=Buffer.from(right); return a.length===b.length && timingSafeEqual(a,b); };
 const principalFor = (authorization) => fleetCredentials.find((entry) => equalToken(authorization,`Bearer ${entry.token}`));
 const app = createMcpExpressApp({ host });
+app.use((req, res, next) => { const started=Date.now(); res.on("finish", () => { const entry={ts:new Date().toISOString(),method:req.method,path:req.path,status:res.statusCode}; const principal=req.fleetPrincipal?.id; if (principal) entry.principal=principal; entry.ms=Date.now()-started; process.stderr.write(JSON.stringify(entry)+"\n"); }); next(); });
+app.get("/healthz", (req, res) => res.status(200).json({ ok: true }));
 app.use((req, res, next) => {
   if (fleetEnabled) { const principal=principalFor(req.headers.authorization ?? ""); if (!principal) return res.status(401).json({ error: "unauthorized" }); req.fleetPrincipal={id:principal.id,role:principal.role}; return next(); }
-  if (!token || req.headers.authorization === `Bearer ${token}`) return next();
+  if (!token || equalToken(req.headers.authorization ?? "", `Bearer ${token}`)) return next();
   res.status(401).json({ error: "unauthorized" });
 });
 app.post("/mcp", async (req, res) => {
@@ -88,6 +94,6 @@ app.post("/mcp", async (req, res) => {
   await server.connect(transport);
   await transport.handleRequest(req, res, req.body);
 });
-const listener = app.listen(port, host, () => console.error(`aidlc MCP state service listening at http://${host}:${port}/mcp`));
+const listener = app.listen(port, host, () => { const actual = (typeof listener.address === "function" && listener.address()) ? listener.address().port : port; console.error(`aidlc MCP state service listening at http://${host}:${actual}/mcp`); });
 const shutdown = async () => { listener.close(); await repository.close(); await coordination.close(); await fleet?.close(); };
 process.once("SIGINT", shutdown); process.once("SIGTERM", shutdown);

package/dist/services/aidlc-coordination/test/fleet.test.mjs

@@ -91,6 +91,27 @@ test("review snapshots require a ready wait and approval is atomic against its r
   } finally { repo.close(); }
 });
 
+test("reviewer rejection records feedback, returns the task to active, and marks the checkpoint rejected", async () => {
+  const repo = new SqliteStateRepository(":memory:");
+  try {
+    const first = await repo.apply("w", 0, "create", { type: "upsertTask", taskId: "T1", task }, "/workspace/project");
+    assert.equal(first.nextActions.T1.classification, "await_user");
+    const snapshot = await repo.putGateSnapshot("w", 1, "snapshot", "T1", "G0_confirm", "Review this intent", undefined, undefined, undefined, true);
+    assert.equal((await repo.gateCheckpoint("w", "T1")).status, "pending");
+    await assert.rejects(() => repo.rejectGate("w", 0, "stale", "T1", snapshot.id, "rewrite", "/workspace/project"), /revision conflict/);
+    const rejected = await repo.rejectGate("w", 1, "reject", "T1", snapshot.id, "Please rewrite the problem statement", "/workspace/project");
+    const after = rejected.state.tasks.T1;
+    assert.equal(after.status, "active");
+    assert.equal(after.phase, "clarify");
+    assert.equal(after.gate, "G0_confirm");
+    assert.equal(after.evidence.at(-1).kind, "diagnostic");
+    assert.match(after.evidence.at(-1).detail, /^Cancelled gate wait at G0_confirm: Please rewrite the problem statement$/);
+    assert.equal(rejected.nextActions.T1.classification, "run_phase");
+    assert.equal((await repo.gateCheckpoint("w", "T1")).status, "rejected");
+    await assert.rejects(() => repo.rejectGate("w", 2, "again", "T1", snapshot.id, "more feedback", "/workspace/project"), /stale gate snapshot/);
+  } finally { repo.close(); }
+});
+
 test("G2 snapshot binds the reviewed integration commit through approval", async () => {
   const repo=new SqliteStateRepository(":memory:");
   try {

package/dist/services/aidlc-coordination/test/server-health-auth.test.mjs

@@ -0,0 +1,67 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { spawn } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { randomBytes } from "node:crypto";
+
+const serviceRoot = join(fileURLToPath(new URL("..", import.meta.url)));
+
+test("health endpoint is public and non-fleet auth is timing-safe", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "aidlc-hz-"));
+  const db = join(dir, "state.db");
+  const token = randomBytes(16).toString("hex");
+  const env = {
+    ...process.env,
+    MCP_STATE_DATABASE: "sqlite",
+    MCP_STATE_SQLITE_PATH: db,
+    MCP_STATE_HOST: "127.0.0.1",
+    MCP_STATE_PORT: "0",
+    MCP_STATE_AUTH_TOKEN: token,
+  };
+  const child = spawn(process.execPath, [join(serviceRoot, "src", "server.mjs")], {
+    env,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  let stderr = "";
+  let port;
+  try {
+    port = await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error("timeout waiting for listening: " + stderr)), 10000);
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString();
+        const match = stderr.match(/listening at http:\/\/[^:]+:(\d+)\/mcp/);
+        if (match) {
+          clearTimeout(timeout);
+          resolve(Number(match[1]));
+        }
+      });
+      child.on("exit", (code) => {
+        clearTimeout(timeout);
+        reject(new Error("server exited " + code + ": " + stderr));
+      });
+    });
+
+    const health = await fetch(`http://127.0.0.1:${port}/healthz`);
+    assert.equal(health.status, 200);
+    assert.deepEqual(await health.json(), { ok: true });
+
+    const noAuth = await fetch(`http://127.0.0.1:${port}/mcp`, { method: "POST" });
+    assert.equal(noAuth.status, 401);
+
+    const wrong = await fetch(`http://127.0.0.1:${port}/mcp`, { method: "POST", headers: { Authorization: "Bearer wrong-token" } });
+    assert.equal(wrong.status, 401);
+
+    const correct = await fetch(`http://127.0.0.1:${port}/mcp`, { method: "POST", headers: { Authorization: `Bearer ${token}` } });
+    assert.notEqual(correct.status, 401);
+
+    assert.match(stderr, /listening at http:/);
+    assert.ok(!stderr.includes(token), "stderr must not contain the token");
+  } finally {
+    child.kill();
+    await new Promise((resolve) => child.on("exit", resolve));
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/dist/src/adapters.d.ts

@@ -1,7 +1,4 @@
 import type { Adapter, AgentId } from "./model.js";
 export declare const adapters: readonly Adapter[];
 export declare const resolvedAdapters: () => readonly Adapter[];
-export declare const resolvedAdaptersForUpgrade: () => readonly Adapter[];
-export declare const installableAdapters: () => readonly Adapter[];
 export declare const findAdapter: (id: AgentId) => Adapter | undefined;
-export declare const findAdapterForUpgrade: (id: AgentId) => Adapter | undefined;

package/dist/src/adapters.js

@@ -5,13 +5,14 @@
  */
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
+import { legacyManagedMarker, managedEndMarker, managedStartMarker } from "./managed-content.js";
 const hasManagedBlock = (root, path, owner) => {
     const target = join(root, path);
     if (!existsSync(target))
         return false;
     try {
         const content = readFileSync(target, "utf8");
-        return content.includes(`<!-- aidlc-installer:${owner}:start -->`) || content.includes(`<!-- aidlc-installer:${owner} -->`);
+        return content.includes(managedStartMarker(owner)) || content.includes(legacyManagedMarker(owner));
     }
     catch {
         return false;
@@ -21,7 +22,7 @@ const hasManagedBlock = (root, path, owner) => {
 const adapterFile = (owner, path, body) => ({
     path,
     owner,
-    content: `<!-- aidlc-installer:${owner}:start -->\n${body}<!-- aidlc-installer:${owner}:end -->\n`
+    content: `${managedStartMarker(owner)}\n${body}${managedEndMarker(owner)}\n`
 });
 /** Shared AI-DLC instruction text installed into each tool's primary prompt file. */
 const instruction = (agent, adapter) => [
@@ -107,7 +108,4 @@ export const adapters = [
     }
 ];
 export const resolvedAdapters = () => adapters;
-export const resolvedAdaptersForUpgrade = () => adapters;
-export const installableAdapters = () => adapters;
 export const findAdapter = (id) => adapters.find((adapter) => adapter.id === id);
-export const findAdapterForUpgrade = (id) => adapters.find((adapter) => adapter.id === id);

package/dist/src/cli/argv.d.ts

@@ -0,0 +1,12 @@
+export declare const usage: string;
+export declare const value: (args: string[], name: string) => string | undefined;
+export declare const flags: (args: string[]) => Set<string>;
+export declare const rootArg: (args: string[], fallback?: string) => string;
+export declare const INIT_FLAGS: Set<string>;
+export declare const UPGRADE_FLAGS: Set<string>;
+export declare const UNINSTALL_FLAGS: Set<string>;
+export declare const STATUS_FLAGS: Set<string>;
+export declare const DOCTOR_FLAGS: Set<string>;
+export declare const MCP_FLAGS: Set<string>;
+export declare const UI_FLAGS: Set<string>;
+export declare const assertKnownOptions: (args: string[], allowed: Set<string>) => void;

package/dist/src/cli/argv.js

@@ -0,0 +1,68 @@
+/**
+ * Pure argv layer: usage text, value/flag parsing, and per-command option
+ * allowlists. No prompting, no side effects.
+ */
+import { LOOP_PROVIDERS } from "../model.js";
+export const usage = `Usage:
+  npx @felixdotgo/aidlc-kit init [path] [--agent <name[,name]> | --all] [--loop-mode off|local|fleet] [--loop-lead ${LOOP_PROVIDERS.join("|")}] [--loop-workers <id=provider,...>] [--yes] [--dry-run] [--force]
+  npx @felixdotgo/aidlc-kit upgrade [path] [--loop-mode off|local|fleet] [--loop-lead ${LOOP_PROVIDERS.join("|")}] [--loop-workers <id=provider,...>] [--dry-run]
+  npx @felixdotgo/aidlc-kit uninstall [path] [--yes] [--dry-run]
+  npx @felixdotgo/aidlc-kit status [path] [--json]
+  npx @felixdotgo/aidlc-kit doctor [path] [--strict] [--json]
+  npx @felixdotgo/aidlc-kit profile validate [path]
+  npx @felixdotgo/aidlc-kit loop up [--root PATH] [--loop-env PATH] [--port 4173] [--host 127.0.0.1] [--open] [--no-ui]
+  npx @felixdotgo/aidlc-kit loop down|stop [--root PATH] [--now]
+  npx @felixdotgo/aidlc-kit loop env [--root PATH] [--loop-env PATH] [--json]
+  npx @felixdotgo/aidlc-kit loop status [--root PATH] [--json]          (daemon, dashboard, environment)
+  npx @felixdotgo/aidlc-kit loop start|status|intake [--task-id ID] [--title TITLE] [--root PATH] [--mode local|fleet] [--loop-env PATH]
+  npx @felixdotgo/aidlc-kit loop worker-image [--provider ${LOOP_PROVIDERS.join("|")}] [--tag TAG] [--root PATH]
+  npx @felixdotgo/aidlc-kit loop leases [--task-id ID] [--root PATH] [--json] [--clear-stale]
+  npx @felixdotgo/aidlc-kit loop migrate-data [--root PATH] [--json] [--dry-run]   (move pre-runtime per-task loop files under .agents/data/tasks/<id>/runtime/)
+  npx @felixdotgo/aidlc-kit ui [path] [--port 4173] [--host 127.0.0.1] [--open] [--reviewer-token-file PATH]
+  npx @felixdotgo/aidlc-kit mcp setup [path] [--dry-run] [--yes] [--storage sqlite|postgres] [--deployment docker|remote] [--bind localhost|network] [--workspace <id>] [--poll-ms <n>] [--token-env <name>] [--providers <p,...>] [--enable]
+  npx @felixdotgo/aidlc-kit version
+  Global options: --help, --version, -v`;
+export const value = (args, name) => {
+    const index = args.indexOf(name);
+    if (index < 0)
+        return undefined;
+    const next = args[index + 1];
+    if (next === undefined || next.startsWith("--"))
+        throw new Error(`${name} requires a value`);
+    return next;
+};
+export const flags = (args) => new Set(args.filter((item) => item.startsWith("--")));
+const valueFlags = new Set(["--agent", "--storage", "--deployment", "--bind", "--workspace", "--poll-ms", "--token-env", "--providers", "--loop-mode", "--loop-lead", "--loop-workers", "--port", "--host", "--reviewer-token-file"]);
+const COMMAND_KEYWORDS = ["init", "upgrade", "uninstall", "status", "doctor", "validate", "run", "list"];
+const positional = (args) => {
+    const result = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg !== undefined && valueFlags.has(arg)) {
+            index += 1;
+            continue;
+        }
+        if (arg !== undefined && !arg.startsWith("--"))
+            result.push(arg);
+    }
+    return result;
+};
+export const rootArg = (args, fallback = ".") => positional(args).find((item) => !COMMAND_KEYWORDS.includes(item)) ?? fallback;
+export const INIT_FLAGS = new Set(["--agent", "--all", "--loop-mode", "--loop-lead", "--loop-workers", "--yes", "--dry-run", "--force"]);
+export const UPGRADE_FLAGS = new Set(["--loop-mode", "--loop-lead", "--loop-workers", "--dry-run"]);
+export const UNINSTALL_FLAGS = new Set(["--yes", "--dry-run"]);
+export const STATUS_FLAGS = new Set(["--json"]);
+export const DOCTOR_FLAGS = new Set(["--strict", "--json"]);
+export const MCP_FLAGS = new Set(["--dry-run", "--yes", "--storage", "--deployment", "--bind", "--workspace", "--poll-ms", "--token-env", "--providers", "--enable"]);
+export const UI_FLAGS = new Set(["--port", "--host", "--open", "--reviewer-token-file"]);
+export const assertKnownOptions = (args, allowed) => {
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === undefined || !arg.startsWith("--"))
+            continue;
+        if (!allowed.has(arg))
+            throw new Error(`Unknown option: ${arg}`);
+        if (valueFlags.has(arg))
+            index += 1;
+    }
+};

package/dist/src/cli/commands.d.ts

@@ -0,0 +1,8 @@
+export declare const runLoopCommand: (args: string[]) => Promise<void>;
+export declare const runUi: (args: string[]) => Promise<void>;
+export declare const runMcpSetup: (args: string[]) => Promise<void>;
+export declare const runMcp: (args: string[]) => Promise<void>;
+export declare const runStatus: (args: string[]) => void;
+export declare const runDoctor: (args: string[]) => void;
+export declare const runProfileValidate: (args: string[]) => void;
+export declare const runProfile: (args: string[]) => void;