amsd-pipeline-workflow 0.1.19 → 0.1.21

package/bin/cpu-bound

@@ -0,0 +1,22 @@
+#!/bin/bash
+# cpu-bound <command...> — the live session's tools may not size their pools from the whole machine.
+#
+# Run 11, 2026-10-20 23:07 UTC: the Writer agent ran the codeline's whole jest suite; jest sized 15 workers from the host's 16 cores
+# (~270 MB each) inside the session's 4096 MB memory scope, and the kernel OOM-killed the session. The Bash pipeline fixed exactly this in
+# run 9 (lib/bounded-exec.sh): the number of workers is DERIVED from the tightest cgroup memory limit (resolve_test_workers), and the
+# process's CPU affinity is restricted to that many CPUs (bound_self_affinity) — everything it starts, the agent's own tool commands
+# included, inherits it and sizes its pool from it; a preload (lib/node-cpu-bound.js) makes runners that count os.cpus() see the bound too.
+# Those are the PIPELINE's functions, sourced from the install (SCRIPT_DIR); nothing is copied here.
+#
+# Placed INSIDE the memory scope (bin/bounded), so the cgroup it reads is the one the session lives in:   bounded cpu-bound claude -p …
+# A bound that cannot be applied is SAID (stderr) and the command still runs — as the pipeline's own wrapper does.
+set -u
+[ $# -gt 0 ] || { echo "cpu-bound: no command" >&2; exit 64; }
+if [ -n "${SCRIPT_DIR:-}" ] && [ -f "$SCRIPT_DIR/lib/bounded-exec.sh" ]; then
+  # shellcheck source=/dev/null
+  . "$SCRIPT_DIR/lib/bounded-exec.sh"
+  bound_self_affinity "$(resolve_test_workers)"
+else
+  echo "[cpu-bound] WARNING: the pipeline's lib/bounded-exec.sh was not found (SCRIPT_DIR='${SCRIPT_DIR:-}') — this session's tools run UNBOUNDED" >&2
+fi
+exec "$@"

package/doctor/profile.json

@@ -61,12 +61,22 @@
       "never works a real codeline",
       "cannot resume run",
       "operator's yes",
-      "needs the operator"
+      "needs the operator",
+      "Missing required env vars",
+      "ingest reads Jira",
+      "UNHEALTHY",
+      "greenfield scaffolding is off",
+      "Brownfield worktree is not a git repository",
+      "the manifest could not be read",
+      ", not a copy"
     ],
     "faultMarks": [
       "\\(exit undefined\\)",
-      "\\(exit NaN\\)"
-    ]
+      "\\(exit NaN\\)",
+      "the same block \\d+ times in a row",
+      "the self-healing retry changed nothing"
+    ],
+    "policy": "all-but-refusals"
   },
   "settings": {
     "on": "EPAM_PIPELINE_DOCTOR",
@@ -89,7 +99,8 @@
     "evidence": [
       "driver.log"
     ],
-    "evidenceTailLines": 200
+    "evidenceTailLines": 200,
+    "legStart": "^\\[launch\\] replayed"
   },
   "branch": {
     "prefix": "doctor/"

package/driver/block-cap.js

@@ -3,7 +3,8 @@
 // retries"). A recorded difference from the pipeline (backlog B39): its lane loop retries an exit-2 phase while HEAD moves,
 // and every Writer run moves it, so a story a gate keeps blocking retries forever. Here a phase stops — failed, naming
 // the gate — when its last BLOCK_CAP runs ended in the same block of the same story.
-const BLOCK_CAP = 3;
+// RELAXED 3 → 5 (operator, 2026-10-20: "relax limits like self heal"): the pipeline's own retry gets more runs before the phase gives up, and giving up is a fault the doctor now takes (doctor/profile.json faultMarks).
+const BLOCK_CAP = 5;
 
 /** What blocked a Writer run: the story and the gate (the reason up to its detail), or null when nothing blocked. */
 function signature(story, res) {

package/driver/runtime.js

@@ -71,7 +71,8 @@ function liveCommand({ name, script, agentsJson, args, sessionDir, env, cwd }) {
   // the session itself waits for its workflow (CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS=0 below); the runner has no task-wait tool
   const prompt = `Run the workflow "${name}" with these args, exactly: ${JSON.stringify(args || {})}. When it has finished, reply with its result as JSON and nothing else.`;
   const claude = (env && env.CLAUDE_BIN) || 'claude';
-  const argv = [path.join(__dirname, '..', 'bin', 'bounded'), claude, '-p', prompt, '--output-format', 'json',
+  // memory scope (bin/bounded) → CPU bound derived from that scope (bin/cpu-bound, the pipeline's own bound_self_affinity) → the session: its tools (jest included) cannot out-size the scope (run 11 OOM)
+  const argv = [path.join(__dirname, '..', 'bin', 'bounded'), path.join(__dirname, '..', 'bin', 'cpu-bound'), claude, '-p', prompt, '--output-format', 'json',
     '--setting-sources', 'project', '--permission-mode', 'bypassPermissions'];
   return { cwd: home, argv, agents: Object.keys(defs).length, workflow: path.join(wfDir, `${name}.js`) };
 }

package/generator/agents-workflow.js

@@ -1,5 +1,6 @@
 'use strict';
 const gateway = require('./gateway.js');
+const { packPlan } = require('./pack-plan.js');
 // THE CODELINE, AGENTS WORKFLOW: plan (data) + emitted script (decisions 10, 15, 16, 25).
 //
 // The script holds the stage's ORDER — the pipeline's own: the launcher's reset (orchestrate.sh), the resume
@@ -16,6 +17,7 @@ const REPLY_SCHEMA = { type: 'object', required: ['reply'], properties: { reply:
 const RUN_SCHEMA = { type: 'object', properties: { done: { type: 'boolean' } } };
 
 function emit(plan) {
+  const packed = packPlan(plan);
   return `export const meta = {
   name: 'codeline-agents',
   description: 'Codeline, Agents stage: reset, resume, ingest (discovery, AC gate, PRD), agents (survey, mint, roster, roles, prompts), pause 1',
@@ -35,7 +37,7 @@ async function agentOrNull(prompt, opts) {
 }
 
 // GENERATED by amsd-pipeline-workflow/generator — do not edit. Source: ${plan.source}
-const PLAN = ${JSON.stringify(plan)}
+${packed.decls}const PLAN = ${packed.expr}
 const REPLY = ${JSON.stringify(REPLY_SCHEMA)}
 const RUN = ${JSON.stringify(RUN_SCHEMA)}
 

package/generator/pack-plan.js

@@ -0,0 +1,74 @@
+'use strict';
+// THE PLAN, AS SOURCE FOR THE EMITTED WORKFLOW (decision 12 continued): a workflow script embeds its `plan` as a literal
+// — the real Workflow tool's sandbox gives a script no `fs`, nothing else can reach generation-time data (test/layer1/
+// harness.js's vm context: no `fs`, no `require`) — but `plan.prompts` can hold several near-duplicate renders (the
+// Writer's first/retry/review variants, each the pipeline's FULL prompt with one small insertion). LIVE-AMSD-2974-11
+// died on "Workflow \"writer\" not found. Available: deep-research, spec": three ~105KB near-copies pushed the script
+// past the real Workflow tool's own script-size cap (524288 bytes — this repo's own Workflow tool documents the same
+// figure). Every `prompts` value that shares a long prefix and suffix with an earlier one is written as a slice of it,
+// not copied again; the runtime value is unchanged (packPlan's output round-trips to a deep-equal `plan`).
+const MIN_SHARE = 200; // below this, the slice expression costs more source than copying the text saves
+
+function sharedPrefixLen(a, b) {
+  const n = Math.min(a.length, b.length);
+  let i = 0;
+  while (i < n && a[i] === b[i]) i += 1;
+  return i;
+}
+function sharedSuffixLen(a, b, max) {
+  let i = 0;
+  while (i < max && a[a.length - 1 - i] === b[b.length - 1 - i]) i += 1;
+  return i;
+}
+
+/** `prompts` (string values), as a JS object-literal expression: a value sharing >= MIN_SHARE chars of prefix+suffix
+ *  with an earlier (unfactored) one is sliced from it; every other value is its own literal. */
+function packPrompts(prompts) {
+  const keys = Object.keys(prompts);
+  const bases = [];
+  let decls = '';
+  const entries = keys.map((k) => {
+    const text = prompts[k];
+    let best = null;
+    if (typeof text === 'string') {
+      for (const b of bases) {
+        const p = sharedPrefixLen(text, b.text);
+        const s = sharedSuffixLen(text, b.text, Math.min(text.length, b.text.length) - p);
+        const saved = p + s;
+        if (saved >= MIN_SHARE && (!best || saved > best.saved)) best = { b, p, s, saved };
+      }
+    }
+    let expr;
+    if (best) {
+      const { b, p, s } = best;
+      const mid = text.slice(p, text.length - s);
+      const parts = [];
+      if (p > 0) parts.push(`${b.name}.slice(0,${p})`);
+      if (mid) parts.push(JSON.stringify(mid));
+      if (s > 0) parts.push(`${b.name}.slice(${b.text.length - s})`);
+      expr = parts.join('+') || '""';
+    } else {
+      expr = JSON.stringify(text);
+      if (typeof text === 'string' && text.length >= MIN_SHARE) {
+        const name = `B${bases.length}`;
+        decls += `const ${name} = ${expr}\n`;
+        bases.push({ name, text });
+        expr = name;
+      }
+    }
+    return `${JSON.stringify(k)}: ${expr}`;
+  });
+  return { decls, expr: `{ ${entries.join(', ')} }` };
+}
+
+/** `plan`, as source for `const PLAN = <expr>`: every field by JSON.stringify, except `prompts` (packPrompts above). */
+function packPlan(plan) {
+  if (!plan || typeof plan !== 'object' || !plan.prompts || typeof plan.prompts !== 'object') {
+    return { decls: '', expr: JSON.stringify(plan) };
+  }
+  const { prompts, ...rest } = plan;
+  const packed = packPrompts(prompts);
+  return { decls: packed.decls, expr: `Object.assign(${JSON.stringify(rest)}, { prompts: ${packed.expr} })` };
+}
+
+module.exports = { packPlan, packPrompts, sharedPrefixLen, sharedSuffixLen };

package/generator/spec-workflow.js

@@ -1,5 +1,6 @@
 'use strict';
 const gateway = require('./gateway.js');
+const { packPlan } = require('./pack-plan.js');
 // THE SPEC WORKFLOW (Spec → pause 2): the order of spec-mode-runner.js run() and its callees, re-expressed as a script
 // (decisions 10, 15, 16). Every model call is an agent with its seam's definition; every judgement on an answer is the
 // pipeline's own code, run by the hook on that answer (hooks/spec-step.js) — the script only follows the result: which
@@ -9,6 +10,7 @@ const gateway = require('./gateway.js');
 
 /** The script. Plain JS, no clock, no randomness; the plan is embedded as a literal. */
 function emit(plan) {
+  const packed = packPlan(plan);
   return `export const meta = {
   name: 'spec',
   description: 'Spec stage for one lane: spec coordinator, ticket links, detective, openspec with its verification-criteria guard, change review, speckit, coordinator and model review, pause 2',
@@ -28,7 +30,7 @@ async function agentOrNull(prompt, opts) {
 }
 ${gateway.textFor(plan)}
 // GENERATED by amsd-pipeline-workflow/generator/generate-spec.js — do not edit. Source: ${plan.source}
-const PLAN = ${JSON.stringify(plan)}
+${packed.decls}const PLAN = ${packed.expr}
 const A = PLAN.agents, P = PLAN.prompts, M = PLAN.models, E = PLAN.efforts, L = PLAN.limits, SCH = PLAN.schemas
 const STEP = { type: 'object', properties: { done: { type: 'boolean' } } }
 

package/generator/writer-workflow.js

@@ -11,6 +11,7 @@ const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
 const tcs = require('./tc-slots.js');
+const { packPlan } = require('./pack-plan.js');
 
 const SLOT = /@@SLOT:([a-z_]+)@@/g;
 
@@ -66,6 +67,7 @@ const REVIEW_SCHEMA = { type: 'object', required: ['verdict'], properties: {
 
 /** The script. Plain JS, no clock, no randomness; the plan is embedded as a literal. */
 function emit(plan) {
+  const packed = packPlan(plan);
   return `export const meta = {
   name: 'writer',
   description: 'Writer stage for one story: writer, checks (hook-owned verdict), failure analyst, model ladder, review cycle',
@@ -86,7 +88,7 @@ async function agentOrNull(prompt, opts) {
 
 ${gateway.textFor(plan)}
 // GENERATED by amsd-pipeline-workflow/generator — do not edit. Source: ${plan.source}
-const PLAN = ${JSON.stringify(plan)}
+${packed.decls}const PLAN = ${packed.expr}
 
 // lib/handlers/ac-apply.py reads the remediator's answer for an object with "acs" (a list of criterion texts).
 const REMEDIATION_SCHEMA = { type: 'object', required: ['acs'], properties: { acs: { type: 'array', items: { type: 'string' } } } };

package/package.json

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