amsd-pipeline-workflow 0.1.11 → 0.1.13

package/driver/run.js

@@ -404,6 +404,24 @@ function provisionCodeline(ctx, cl, wt) {
   if (fs.existsSync(ap)) { fs.mkdirSync(epam, { recursive: true }); fs.copyFileSync(ap, path.join(epam, 'anti-patterns.json')); }
 }
 
+/** A story's newest review record: the lane log's review-verdict-<story>.json, else (a run from before that record) the
+ *  newest review-feedback.json any of this lane's Writers left; null when there is none. */
+function reviewRecord(ctx, lane, env, id) {
+  const read = (f) => { try { return JSON.parse(fs.readFileSync(f, 'utf8')); } catch { return null; } };
+  const v = env.LOG_DIR && read(path.join(env.LOG_DIR, `review-verdict-${id}.json`));
+  if (v) return { verdict: v.verdict, from: `review-verdict-${id}.json` };
+  const base = path.join(ctx.runDir, 'workflows', lane.cl);
+  const found = [];
+  for (const line of (fs.existsSync(base) ? fs.readdirSync(base) : [])) for (const tag of (fs.existsSync(path.join(base, line)) ? fs.readdirSync(path.join(base, line)) : [])) {
+    const f = path.join(base, line, tag, 'writer', id, 'checks', 'runs', 'review-feedback.json');
+    if (fs.existsSync(f)) found.push({ f, t: fs.statSync(f).mtimeMs });
+  }
+  if (!found.length) return null;
+  const newest = found.sort((a, b) => b.t - a.t)[0];
+  const fb = read(newest.f);
+  return fb ? { verdict: fb.verdict, from: path.relative(ctx.runDir, newest.f) } : null;
+}
+
 // ── ONE PHASE OF ONE LANE: what `bash run-agent-orchestration.sh` does for it, around the two workflows ─────────────
 // Returns the phase's exit code (lib/phase-exit.sh).
 async function phaseRunner(ctx, lane, laneEnv, { prd, phase, args, tag, lineSlug }) {
@@ -425,6 +443,14 @@ async function phaseRunner(ctx, lane, laneEnv, { prd, phase, args, tag, lineSlug
     const p = JSON.parse(fs.readFileSync(prd, 'utf8'));
     const rq = (s) => ((s.status === 'failed' || s.status === 'blocked') && !(s.completed) ? { ...s, status: 'pending' } : s);
     p.stories = (p.stories || []).map(rq);
+    // ONCE REVIEWED, LOCKED (operator, 2026-10-20): a completed story whose newest review record is an approval is neither
+    // rewritten nor re-reviewed; an "escalated" stamp an EARLIER attempt left is cleared as the pipeline clears it on
+    // approval (lib/review-cycle.sh ~:180–195) — the stale stamp would otherwise fail Step 5 on work already approved
+    for (const s of p.stories) {
+      if (!(s.completed === true && s.reviewStatus === 'escalated')) continue;
+      const rec = reviewRecord(ctx, lane, env, s.id);
+      if (rec && rec.verdict === 'approved') { s.reviewStatus = null; log(`[driver] ${s.id}: locked — reviewed and approved (${rec.from}); its earlier escalated stamp is cleared, nothing is rewritten or re-reviewed`); }
+    }
     fs.writeFileSync(prd, JSON.stringify(p, null, 2));
   }
   // RAO:1112–1123 — the spec pass, unless the lane resumed with its spec done
@@ -471,6 +497,13 @@ async function phaseRunner(ctx, lane, laneEnv, { prd, phase, args, tag, lineSlug
     }
     // what Steps 3.545 and 3.55 stamp on the story, so a retry inherits the finding (driver/writer-stamps.js)
     if (st) applyGateStamps(st, res);
+    // THE LOCK, RECORDED where a later Writer cannot wipe it (the lane's log; its out dir is rebuilt each leg, B64): a Writer
+    // that ends 'done' ended on an approved review
+    if (res.status === 'done') {
+      const head = spawnSync('git', ['-C', lane.wt, 'rev-parse', 'HEAD'], { encoding: 'utf8' });
+      fs.mkdirSync(env.LOG_DIR, { recursive: true });
+      fs.writeFileSync(path.join(env.LOG_DIR, `review-verdict-${s.id}.json`), `${JSON.stringify({ verdict: 'approved', head: head.status === 0 ? head.stdout.trim() : null, at: new Date().toISOString() })}\n`);
+    }
     fs.writeFileSync(prd, JSON.stringify(cur, null, 2));
     // lib/prd-state.sh update_story_status (the pipeline's), on the lane's PRD
     bash({ ...env, MAIN_PRD_FILE: prd, PRD_FILE: prd }, 'update_story_status', [s.id, res.exit === 0 ? 'completed' : 'failed'], { log });
@@ -492,7 +525,8 @@ async function phaseRunner(ctx, lane, laneEnv, { prd, phase, args, tag, lineSlug
   // RAO:4237–4311 — Step 5, THE PHASE GATE, by the pipeline's own check-phase-gate.sh as the orchestrator runs it
   // (SKIP_TESTS=true): review status, story completion, deliverables, cost variance. RETRY exits 1, ESCALATE exits 2; any
   // other code goes on (the pipeline's `case` has no default). The cost check reads the run's ledger (driver/session-cost.js).
-  if (!order.length) return 0;
+  // THE GATE RUNS EVEN WHEN NO STORY RAN THIS TIME (R1): RAO has no exit before Step 5 — a resumed lane whose stories are
+  // all completed is still judged (an escalated review, a missing deliverable)
   const g = phaseGate(env, phase, log);
   if (g !== 0) return g;
   // RAO:4318–4337 — Step 24, the final post-phase assessment (feature skill-assessment); non-critical

package/driver/runtime.js

@@ -120,8 +120,12 @@ function runLive(opts) {
   // (11 min) were cut there. The session's stderr is kept beside it as evidence.
   const r = spawnSync(cmd.argv[0], cmd.argv.slice(1), { cwd: cmd.cwd, env: { CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS: '0', ...process.env, ...(opts.env || {}) }, encoding: 'utf8', maxBuffer: 256 * 1024 * 1024 });
   try { fs.mkdirSync(opts.sessionDir, { recursive: true }); fs.writeFileSync(path.join(opts.sessionDir, `${opts.name}.stderr`), String(r.stderr || '')); } catch { /* evidence only */ }
-  if (r.status !== 0) throw new Error(`the live session for ${opts.name} exited ${r.status}: ${(r.stderr || '').slice(-2000)}`);
-  const out = JSON.parse(r.stdout);
+  // A FAILED SESSION STILL SPENT (R5): its cost record is read from its output when there is one, and run() records it
+  // BEFORE the failure is thrown — the stage fails as before, the spend is never lost
+  let out = null; try { out = JSON.parse(r.stdout); } catch { out = null; }
+  const spent = out && out.session_id ? { sessionId: out.session_id, modelUsage: out.modelUsage || {}, totalCostUsd: out.total_cost_usd } : null;
+  if (r.status !== 0) return { __throw: new Error(`the live session for ${opts.name} exited ${r.status}: ${(r.stderr || '').slice(-2000)}`), __session: spent };
+  if (!out) return { __throw: new Error(`the live session for ${opts.name} printed no JSON: ${String(r.stdout || '').slice(0, 500)}`), __session: null };
   // the session's own cost figure (decision 41a), taken BEFORE its answer is read: an answer that cannot be read must
   // never lose what the session spent (found by tools/cost-probe.js, 2026-10-18). driver/session-cost.js finds its
   // transcripts by this id.
@@ -203,11 +207,12 @@ async function run(o) {
   else throw new Error(`unknown runtime '${opts.runtime}' (standin | live)`);
   // THE COST RECORD of every session, by the pipeline's own ledger writer (driver/session-cost.js); a Writer session's rows
   // carry its story, as the story's attempts do in the pipeline
-  if (res && opts.env.SCRIPT_DIR && (opts.env.PHASE_COST_FILE || opts.env.LOG_DIR)) {
+  if (res && (res.__session || !res.__throw) && opts.env.SCRIPT_DIR && (opts.env.PHASE_COST_FILE || opts.env.LOG_DIR)) {
     res.__cost = recordSession(opts.env, res.__session, { stage: opts.name, storyId: opts.costStory || null, phase: opts.env.PHASE || null,
       projectsDir: res.__session && res.__session.projectsDir, log: opts.log });
     await Promise.all(res.__cost.traces || []);
   }
+  if (res && res.__throw) throw res.__throw;
   return res;
 }
 

package/generator/writer-workflow.js

@@ -450,7 +450,12 @@ async function tcWriter(attempt) {
   if (p.error) { log(\`attempt \${attempt + 1}: the tc-writer's question could not be built — \${p.reason}\`); return }
   if (!p.needed) { if (p.message) log(p.message); return }
   log(\`  [tc-writer] Generating TCs for phase '\${p.phase || '<unset>'}' (post-impl, pre-test)...\`)
-  await agentCall(relativize(p.prompt), { agentType: PLAN.agents.tcWriter, ...(p.model ? { model: p.model } : {}), schema: SCHEMAS.tc,
+  // THE ANSWER'S KEYS ARE THE STORIES THE QUESTION NAMES (R2: unnamed, the model answered {"output": …}, then a string)
+  const item = SCHEMAS.tc.additionalProperties
+  const ids = (p.stories || []).length ? p.stories : [story.id]
+  const schema = { type: 'object', required: ids, additionalProperties: false,
+    properties: Object.fromEntries(ids.map((id) => [id, { ...item, description: \`the test criteria for story \${id}, as an object (not a string)\` }])) }
+  await agentCall(relativize(p.prompt), { agentType: PLAN.agents.tcWriter, ...(p.model ? { model: p.model } : {}), schema,
     label: \`tc-writer after #\${attempt + 1}\`, phase: 'Writer' })
   const r = await stepResult(PLAN.agents.stepTcApply, \`tc-writer apply #\${attempt + 1}\`)
   if (r.ok && r.testCriteria) {

package/hooks/pipeline-step.js

@@ -32,7 +32,11 @@ if (require.main === module) {
       ...(() => { const c = (input.tool_input || {}).call || {}; return { CALL_AGENT: String(c.agent || ''), CALL_MODEL: String(c.model || ''),
         CALL_STORY: String(c.story || 'global'), CALL_REASON: String(c.reason || ''), CALL_ATTEMPT: String(c.attempt || 1) }; })() };
     const r = spawnSync('bash', [path.join(__dirname, script), a.pipeline, a.state], { encoding: 'utf8', env, maxBuffer: 64 * 1024 * 1024 });
-    try { result = JSON.parse(r.stdout); } catch { result = { ran: false, passed: false, reason: (r.stderr || `exit ${r.status}`).slice(-400) }; }
+    // THE STEP'S RESULT IS ITS LAST LINE (each step script ends with one `jq -c` line); anything the pipeline printed ahead of
+    // it is kept on stderr, never read as the result and never let onto this hook's stdout (R3, the B60 class)
+    const lines = String(r.stdout || '').split('\n').filter((l) => l.trim());
+    if (lines.length > 1) process.stderr.write(`${lines.slice(0, -1).join('\n')}\n`);
+    try { result = JSON.parse(lines[lines.length - 1]); } catch { result = { ran: false, passed: false, reason: (r.stderr || `exit ${r.status}`).slice(-400) }; }
   }
   process.stdout.write(`${JSON.stringify({ hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'allow',
     updatedInput: { ...(input.tool_input || {}), step: a.step, result } } })}\n`);

package/hooks/repro-checks.js

@@ -56,9 +56,13 @@ if (require.main === module) {
   let input = {};
   try { input = JSON.parse(fs.readFileSync(0, 'utf8') || '{}'); } catch { /* nothing to judge */ }
   if (input.tool_name !== 'StructuredOutput') process.exit(0);
+  // THE HOOK'S STDOUT IS ITS JSON ONLY (R4, the B60 class): the pipeline's plugin runs in this process; whatever it writes to
+  // stdout goes to stderr, and only the line below writes stdout
+  const stdout = process.stdout.write.bind(process.stdout);
+  process.stdout.write = (chunk, ...rest) => process.stderr.write(chunk, ...rest);
   let validation;
   try { validation = judge(a, input.tool_input || {}); } catch (e) { validation = { valid: false, committed: false, class: 'error', feedback: '', reason: e.message }; }
-  process.stdout.write(`${JSON.stringify({ hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'allow',
+  stdout(`${JSON.stringify({ hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'allow',
     updatedInput: { ...(input.tool_input || {}), validation } } })}\n`);
 }
 module.exports = { judge };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amsd-pipeline-workflow",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "The AMSD pipeline as Claude workflows. Installed by the amsd-pipeline installer: install.sh --workflows",
   "license": "UNLICENSED",
   "bin": {

package/test/layer1/harness.js

@@ -12,12 +12,35 @@ function fromSchema(schema, overrides) {
   const out = {};
   const props = (schema && schema.properties) || {};
   for (const k of (schema && schema.required) || Object.keys(props)) {
-    const t = (props[k] || {}).type;
-    out[k] = t === 'boolean' ? false : t === 'number' || t === 'integer' ? 0 : t === 'array' ? [] : t === 'object' ? fromSchema(props[k], {}) : `generated-${k}`;
+    const p = props[k] || {}; const t = p.type;
+    out[k] = Array.isArray(p.enum) ? p.enum[0] : t === 'boolean' ? false : t === 'number' || t === 'integer' ? 0 : t === 'array' ? [] : t === 'object' ? fromSchema(p, {}) : `generated-${k}`;
   }
   return { ...out, ...(overrides || {}) };
 }
 
+/**
+ * WHY A VALUE DOES NOT MATCH ITS SCHEMA, or '' — the subset of JSON Schema the workflows' answers use (type, required,
+ * properties, additionalProperties, items, enum). Claude Code refuses a StructuredOutput answer that does not match
+ * (deep review R7): the harness refuses it too.
+ */
+function schemaError(schema, v, at = '') {
+  if (!schema || typeof schema !== 'object') return '';
+  const t = schema.type;
+  const typeOf = (x) => (Array.isArray(x) ? 'array' : x === null ? 'null' : Number.isInteger(x) ? 'integer' : typeof x);
+  if (t && !(t === typeOf(v) || (t === 'number' && typeOf(v) === 'integer'))) return `${at || '/'}: ${typeOf(v)} where ${t} is required`;
+  if (Array.isArray(schema.enum) && !schema.enum.some((e) => JSON.stringify(e) === JSON.stringify(v))) return `${at || '/'}: ${JSON.stringify(v)} is not one of ${JSON.stringify(schema.enum)}`;
+  if (t === 'array' && schema.items) for (let i = 0; i < v.length; i += 1) { const e = schemaError(schema.items, v[i], `${at}/${i}`); if (e) return e; }
+  if (t === 'object' || (!t && v && typeof v === 'object' && !Array.isArray(v))) {
+    for (const k of schema.required || []) if (!(k in v)) return `${at || '/'}: required '${k}' is missing`;
+    const props = schema.properties || {};
+    for (const [k, x] of Object.entries(v)) {
+      if (props[k]) { const e = schemaError(props[k], x, `${at}/${k}`); if (e) return e; } else if (schema.additionalProperties === false) return `${at || '/'}: '${k}' is not allowed`;
+      else if (schema.additionalProperties && typeof schema.additionalProperties === 'object') { const e = schemaError(schema.additionalProperties, x, `${at}/${k}`); if (e) return e; }
+    }
+  }
+  return '';
+}
+
 /**
  * Run a workflow script.
  * @param {string} source  the script text (as emitted)
@@ -43,7 +66,14 @@ async function run(source, args, answer) {
     calls.push(call);
     const a = await answer(call);
     if (a === null || a === undefined) return null;
-    if (opts.schema) return fromSchema(opts.schema, typeof a === 'object' ? a : {});
+    if (opts.schema) {
+      // the hook harness has already judged the agent's own answer against its schema (before its hooks, as Claude Code)
+      if (call.judged) return a;
+      const full = fromSchema(opts.schema, typeof a === 'object' ? a : {});
+      const err = schemaError(opts.schema, full);
+      if (err) { call.refused = err; return null; }
+      return full;
+    }
     return typeof a === 'string' ? a : JSON.stringify(a);
   };
   const parallel = async (thunks) => Promise.all(thunks.map((t) => t().catch(() => null)));
@@ -61,4 +91,4 @@ async function run(source, args, answer) {
   return { meta, result, calls, phases, logs };
 }
 
-module.exports = { run, fromSchema };
+module.exports = { run, fromSchema, schemaError };

package/test/layer1/hook-harness.js

@@ -7,7 +7,7 @@
 // never answers, so its hook never runs. No AI.
 const fs = require('fs');
 const { spawnSync } = require('child_process');
-const { run } = require('./harness.js');
+const { run, fromSchema, schemaError } = require('./harness.js');
 
 /**
  * @param {string} source       the emitted script
@@ -23,16 +23,27 @@ async function runWithHooks(source, args, agentsFile, answer) {
     if (a === null || a === undefined) return null;
     const def = defs[call.opts.agentType];
     if (!def) throw new Error(`no generated definition for agent type '${call.opts.agentType}'`);
-    const pre = ((def.hooks || {}).PreToolUse || []).filter((h) => new RegExp(`^(${h.matcher})$`).test('StructuredOutput'));
+    // THE AGENT'S OWN ANSWER, judged against its schema before any hook (Claude Code refuses a StructuredOutput that does not
+    // match — the tc-writer's live refusals, deep review R7): refused, the agent has no answer and its hook never runs
     let input = a;
+    if (call.opts.schema) {
+      input = fromSchema(call.opts.schema, typeof a === 'object' ? a : {});
+      const err = schemaError(call.opts.schema, input);
+      if (err) { call.refused = err; return null; }
+      call.judged = true;
+    }
+    const pre = ((def.hooks || {}).PreToolUse || []).filter((h) => new RegExp(`^(${h.matcher})$`).test('StructuredOutput'));
     for (const h of pre) for (const c of h.hooks || []) {
       const res = spawnSync('bash', ['-c', c.command], { input: JSON.stringify({ hook_event_name: 'PreToolUse', tool_name: 'StructuredOutput', tool_input: input, agent_type: call.opts.agentType }),
         encoding: 'utf8', maxBuffer: 256 * 1024 * 1024 });
-      hookRuns.push({ agentType: call.opts.agentType, status: res.status, stderr: (res.stderr || '').slice(-2000) });
-      if (res.status !== 0) throw new Error(`hook of ${call.opts.agentType} exited ${res.status}: ${(res.stderr || '').slice(-1500)}`);
-      const outLine = String(res.stdout || '').trim().split('\n').pop();
-      const o = outLine ? JSON.parse(outLine) : {};
-      const upd = o.hookSpecificOutput && o.hookSpecificOutput.updatedInput;
+      hookRuns.push({ agentType: call.opts.agentType, status: res.status, stderr: (res.stderr || '').slice(-2000), stdout: String(res.stdout || '').slice(0, 2000) });
+      // AS CLAUDE CODE (deep review R6): exit 2 blocks the answer; any other non-zero exit is a non-blocking error and the
+      // answer goes on unchanged; on exit 0 the hook's JSON is read only when its WHOLE stdout is JSON — a log line ahead of
+      // it (B60) makes it plain text, and updatedInput is ignored
+      if (res.status === 2) { call.blocked = (res.stderr || '').slice(-500); return null; }
+      if (res.status !== 0) continue;
+      let o = null; try { o = JSON.parse(String(res.stdout || '').trim() || 'null'); } catch { o = null; }
+      const upd = o && o.hookSpecificOutput && o.hookSpecificOutput.updatedInput;
       if (upd) input = upd;
     }
     call.answered = input;