amsd-pipeline-workflow 0.1.23 → 0.1.25

package/driver/sibling-prebuild.js

@@ -0,0 +1,32 @@
+'use strict';
+// THE SIBLING PROVIDER IS BUILT BEFORE THE WRITER, OUTSIDE ITS MEMORY SCOPE (run 11, 2026-10-21): a consumer's Step 19 type-checks it against the provider's own build, and the pipeline builds that provider as a hook INSIDE the
+// Writer session — cx-shared's build is 3.2 GB (anon) and 67 s, and the session's scope is 4096 MB: the kernel killed it twice. The pipeline's own provisioning (provision_lane_worktree → link_sibling_builds) builds once per
+// provider checkout and stamps it in LOG_DIR; this runs that same provisioning from the driver — in the leg's scope — on a throwaway worktree of the consumer, with LOG_DIR = the lane's persistent log, so the stamp survives
+// and the generator seeds it into the Writer's state (generator/sibling-stamps.js). Nothing is re-implemented: the handler that finds the providers and the function that builds them are the pipeline's.
+//   prebuildSiblings(env, { root, laneLog, prd, log? }) → { providers: n }      a build that fails is reported by the pipeline's function and left unstamped (tried again next time); nothing here throws
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { bash, handler } = require('./pipeline.js');
+
+const git = (repo, ...a) => spawnSync('git', ['-C', repo, ...a], { encoding: 'utf8' });
+
+function prebuildSiblings(env, { root, laneLog, prd, log }) {
+  const out = handler(env, 'sibling-providers', [prd, root]);
+  const providers = out.stdout.split('\n').filter(Boolean);
+  if (!providers.length) return { providers: 0 };
+  fs.mkdirSync(laneLog, { recursive: true });
+  const tmp = fs.mkdtempSync(path.join(env.TMPDIR || os.tmpdir(), 'receiving-')); const wt = path.join(tmp, path.basename(root));
+  try {
+    const add = git(root, 'worktree', 'add', '-q', '--detach', wt, 'HEAD');
+    if (add.status !== 0) { if (log) log(`[sibling] prebuild: could not make a worktree of ${root}: ${(add.stderr || '').trim()}`); return { providers: providers.length, error: 'worktree' }; }
+    if (log) log(`[sibling] prebuild: ${providers.map((l) => l.split('\t')[0]).join(', ')} for ${path.basename(root)} — built here, before the Writer, so the Writer's session never builds it`);
+    bash({ ...env, LOG_DIR: laneLog, PRD_FILE: prd, MAIN_PRD_FILE: prd }, 'provision_lane_worktree', [root, wt], { log });
+  } finally {
+    git(root, 'worktree', 'remove', '--force', wt); fs.rmSync(tmp, { recursive: true, force: true }); git(root, 'worktree', 'prune');
+  }
+  return { providers: providers.length };
+}
+
+module.exports = { prebuildSiblings };

package/driver/stages.js

@@ -7,6 +7,7 @@ const path = require('path');
 const { spawnSync } = require('child_process');
 const runtime = require('./runtime.js');
 const { bash } = require('./pipeline.js');
+const { prebuildSiblings } = require('./sibling-prebuild.js');
 
 // THE NAME EACH WORKFLOW IS RUN BY (and so the file it is placed in, <codeline>/.claude/workflows/<name>.js). No name may match a test runner's default pattern: the Spec workflow was "spec", the client's jest ran
 // spec.js as a test, and every whole-suite run in a codeline reported the pipeline's own file as a failing suite (run 11, 2026-10-20; test/integration/workflow-placement.test.js).
@@ -213,6 +214,9 @@ function overlay(ctx, lane, lineSlug) {
 
 async function runWriter(ctx, lane, env, { story, out, lineSlug, reviewCommitted }) {
   fs.rmSync(out, { recursive: true, force: true });
+  // A CODELINE THAT RECEIVES ANOTHER'S CHANGE has the provider built BEFORE the Writer, here, outside the session's memory scope (driver/sibling-prebuild.js; run 11's two OOM kills). Never blocks the Writer: said, and the
+  // session's own Step 19 would then try the build itself, as before.
+  try { prebuildSiblings(env, { root: lane.wt, laneLog: env.LOG_DIR, prd: env.PRD_FILE || env.MAIN_PRD_FILE, log: ctx.log }); } catch (e) { ctx.log(`[sibling] prebuild failed — ${e.message}`); }
   const inst = overlay(ctx, lane, lineSlug);
   // the run's recorded launch settings (driver/launch-env.js) go to the generator as its --launch-env file (NAME=value
   // lines), so plan.launchEnv records them and every Writer hook replays them (decision: record and replay)
@@ -243,6 +247,8 @@ async function runWriter(ctx, lane, env, { story, out, lineSlug, reviewCommitted
  *  keeps it (story-attempt.sh:2666–2688) and the next generation reads it (generator/ladder.sh). */
 function persistFailures(out, laneLog) {
   const f = path.join(out, 'checks', 'runs', 'pipeline-env', 'logs', 'story-failures.jsonl');
+  // a provider build the session itself made is stamped in the lane's log too (generator/sibling-stamps.js)
+  if (laneLog) require('../generator/sibling-stamps.js').persist(path.join(out, 'checks', 'runs', 'pipeline-env', 'logs'), laneLog);
   if (!laneLog || !fs.existsSync(f)) return;
   fs.mkdirSync(laneLog, { recursive: true });
   fs.copyFileSync(f, path.join(laneLog, 'story-failures.jsonl'));

package/generator/generate.js

@@ -149,6 +149,9 @@ function main(a) {
     fs.mkdirSync(path.join(checksState, 'pipeline-env', 'logs'), { recursive: true });
     fs.copyFileSync(path.join(process.env.LOG_DIR, 'story-failures.jsonl'), path.join(checksState, 'pipeline-env', 'logs', 'story-failures.jsonl'));
   }
+  // THE "PROVIDER BUILT" STAMPS (generator/sibling-stamps.js): the driver builds a sibling provider before the Writer (driver/sibling-prebuild.js) and stamps it in the lane's log; Step 19's hook inside the session finds the
+  // stamp here and does not build it again (run 11: that build, 3.2 GB, is what the session's 4096 MB scope could not hold)
+  if (process.env.LOG_DIR) require('./sibling-stamps.js').seed(process.env.LOG_DIR, path.join(checksState, 'pipeline-env', 'logs'));
   // the plan the run works from, published as the pipeline publishes it after the spec pass (hooks/publish-agent-outputs.sh),
   // in the hooks' state before any hook renders from it
   const pub = spawnSync('bash', [path.join(__dirname, '..', 'hooks', 'publish-agent-outputs.sh'), pipelineJson, checksState], { encoding: 'utf8' });

package/generator/plan-no-change-structured.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+'use strict';
+// DOES THE DETECTIVE'S STRUCTURED ANALYSIS GIVE THIS CODELINE NO CHANGE? (run 11, 2026-10-21.) The pipeline's plan-gives-no-change.js reads prose (the consumer's `change` line must be exactly "none"); the same story carries the
+// detective's structured findings — every fix site has `changeRequired` — and a codeline whose sites ALL say false needs no edit: its files are "NO EDIT REQUIRED", verified, not changed. Exit 0 = no change (and the reason on
+// stdout as JSON); exit 1 = otherwise: no analysis for the lane, no sites, or ANY site that is true or does not say (no evidence is not "no change").
+//   plan-no-change-structured.js <prd> <story-id> <lane codeline>
+const fs = require('fs');
+
+try {
+  const [prdFile, storyId, lane] = process.argv.slice(2);
+  const prd = JSON.parse(fs.readFileSync(prdFile, 'utf8'));
+  const s = (prd.stories || []).find((x) => x && x.id === storyId);
+  if (!s) process.exit(1);
+  // ONLY A LANE THE PLAN SAYS MERELY RECEIVES THE CHANGE: a consumer in the story's overall plan and the provider of none of its packages. The provider is where the change is made — and run 9's detective marked the two
+  // sites cxshared edited changeRequired:false — so for it the field is not evidence of anything.
+  const pkgs = (s.overallPlan && Array.isArray(s.overallPlan.packages)) ? s.overallPlan.packages : [];
+  const isConsumer = pkgs.some((p) => p && (p.consumers || []).some((c) => c && c.codeline === lane));
+  const isProvider = pkgs.some((p) => p && p.providedBy === lane);
+  if (!isConsumer || isProvider) process.exit(1);
+  const per = s.fixSiteAnalysisPerCodeline && typeof s.fixSiteAnalysisPerCodeline === 'object' ? s.fixSiteAnalysisPerCodeline : {};
+  const sites = Array.isArray(per[lane]) ? per[lane] : (s.codeline === lane && Array.isArray(s.fixSiteAnalysis) ? s.fixSiteAnalysis : null);
+  if (!sites || !sites.length || !sites.every((x) => x && x.changeRequired === false)) process.exit(1);
+  process.stdout.write(`${JSON.stringify({ sites: sites.length, reason: `none of its ${sites.length} fix sites has changeRequired (the detective's structured analysis)` })}\n`);
+  process.exit(0);
+} catch { process.exit(1); }

package/generator/plan-no-change.sh

@@ -14,7 +14,13 @@ LANE_LOG="${LOG_DIR:-}"
 set +e
 for _np in "${PRD_FILE:-}" "${MAIN_PRD_FILE:-}"; do
     [ -n "$_np" ] && [ -f "$_np" ] || continue
-    "$NODE_BIN" "$SCRIPT_DIR/lib/handlers/plan-gives-no-change.js" "$_np" "$STORY" "$LANE" 2>/dev/null || continue
+    # THE PIPELINE'S ROUTE (the consumer's change line is exactly "none"), else THE STRUCTURED ONE (generator/plan-no-change-structured.js: every fix site of this lane's analysis says changeRequired false) — run 11:
+    # the plan's prose was "Verify … no manifest change." and a Writer was sent into 8 failing attempts over files the detective had already marked NO EDIT REQUIRED
+    _why=""
+    if ! "$NODE_BIN" "$SCRIPT_DIR/lib/handlers/plan-gives-no-change.js" "$_np" "$STORY" "$LANE" 2>/dev/null; then
+        _sj=$("$NODE_BIN" "$(dirname "${BASH_SOURCE[0]}")/plan-no-change-structured.js" "$_np" "$STORY" "$LANE" 2>/dev/null) || continue
+        _why=" ($(printf '%s' "$_sj" | jq -r '.reason // empty' 2>/dev/null))"
+    fi
     _ref=""
     if [ -e "$PROJECT_ROOT/.git" ]; then
         [ -n "$LANE_LOG" ] && [ -f "$LANE_LOG/phase-baseline-sha.txt" ] && _ref=$(tr -d '[:space:]' < "$LANE_LOG/phase-baseline-sha.txt" 2>/dev/null)
@@ -26,7 +32,7 @@ for _np in "${PRD_FILE:-}" "${MAIN_PRD_FILE:-}"; do
             '{noChange:false, message:$m}'
         exit 0
     fi
-    jq -cn --arg m "Story $STORY: the story's plan gives $LANE no change — no writer is run; the lane's gates prove it against the release it receives" \
+    jq -cn --arg m "Story $STORY: the story's plan gives $LANE no change${_why} — no writer is run; the lane's gates prove it against the release it receives" \
         '{noChange:true, message:$m}'
     exit 0
 done

package/generator/sibling-stamps.js

@@ -0,0 +1,26 @@
+'use strict';
+// THE "BUILT ONCE" STAMPS OF SIBLING PROVIDERS (lib/codeline-lanes.sh link_sibling_builds: `sibling-build-<hash of the provider's path>-<its HEAD>` in LOG_DIR, written when the provider's build succeeded). The Bash pipeline's LOG_DIR
+// is the lane's persistent log; the Writer's hooks run with a per-invocation state folder, so a stamp made in the lane's log (by driver/sibling-prebuild.js, outside the session) is COPIED into the state before the session
+// (seed), and one a session made is copied back (persist). Only stamp files move — never the build logs or anything else. No AI.
+const fs = require('fs');
+const path = require('path');
+
+const STAMP = /^sibling-build-[0-9a-f]{12}-[0-9a-z]+$/;
+
+function copyStamps(from, to) {
+  let names = [];
+  try { names = fs.readdirSync(from).filter((n) => STAMP.test(n)); } catch { return []; }
+  const moved = [];
+  for (const n of names) {
+    if (fs.existsSync(path.join(to, n))) continue;
+    fs.mkdirSync(to, { recursive: true }); fs.copyFileSync(path.join(from, n), path.join(to, n)); moved.push(n);
+  }
+  return moved;
+}
+
+/** The lane's stamps into the Writer's state logs; returns the names copied. */
+const seed = (laneLog, stateLogs) => copyStamps(laneLog, stateLogs);
+/** The stamps a session made, back into the lane's log; returns the names copied. */
+const persist = (stateLogs, laneLog) => copyStamps(stateLogs, laneLog);
+
+module.exports = { seed, persist, STAMP };

package/package.json

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