amsd-pipeline-workflow 0.1.23 → 0.1.24

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/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.24",
   "description": "The AMSD pipeline as Claude workflows. Installed by the amsd-pipeline installer: install.sh --workflows",
   "license": "UNLICENSED",
   "bin": {