amsd-pipeline-workflow 0.1.10 → 0.1.12

package/driver/run.js

@@ -492,7 +492,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/driver/writer-stamps.js

@@ -17,6 +17,9 @@ function applyGateStamps(story, res) {
   else if (uit && uit.passed === true) { del('suiteState'); del('suiteStateStep'); }
   const gate = res && res.gate;
   if (gate && gate.ran !== false && gate.passed === false) { set('reviewStatus', 'escalated'); set('reproGate', 'failed'); }
+  // A REAL APPROVAL CLEARS AN EARLIER ATTEMPT'S ESCALATION (lib/review-cycle.sh ~:180–195, the pipeline's own: reviewStatus
+  // "escalated" → null). A Writer result of 'done' comes only after the review approved. B65: the stale stamp blocked the gate.
+  else if (res && res.status === 'done' && story.reviewStatus === 'escalated') set('reviewStatus', null);
   return changed;
 }
 

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.10",
+  "version": "0.1.12",
   "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;