amsd-pipeline-workflow 0.1.6 → 0.1.8

package/README.md

@@ -10,7 +10,7 @@ Three steps, in this order, into one install:
 
 ```bash
 npx amsd-pipeline@2.0.80 --dest <dir> --ref v2.0.80 --no-docker        # 1. the pipeline, as always
-npx amsd-pipeline-shared@<version> install --into <dir>                # 2. the shared gateway, reviewer, messages
+npx amsd-pipeline-shared@<version> install --into <dir>                # 2. the shared gateway, reviewer, messages, pre-launch
 npx amsd-pipeline-workflow@<version> install --into <dir> [--codeline-cache <cache>]   # 3. the workflows
 ```
 
@@ -20,7 +20,20 @@ into the same project, so the pipeline reuses them instead of minting and genera
 launch whether each is current. Reinstalling replaces `claude-workflows/`. Without step 2 the workflows still run, but
 messaging is off (said at generation) and the gateway's hub keeps 2.0.80's defect B56 (a failed call reads as success).
 
+Then seed the codeline the ticket's work belongs to with the pipeline's own restore, so the launch starts from its
+recorded agents and reviewed prompts (a fresh install's project prompts are not the ticket's):
+
+```bash
+EPAM_PROJECT_CONFIG_DIR=<dir>/orchestrations/projects/<project> \
+  bash -c '. <dir>/orchestrations/scripts/lib/prompt-variant.sh; codeline_minted_restore <codeline>'
+```
+
+A codeline cache built with `tools/cache-from-checkpoint.js` carries both of the builder's layers: the prompt set and, with
+`--entries`, the source run's per-prompt entries (only where the entry is the cached prompt), plus `--marker`, the source
+run's own completion marker. A template change then rebuilds only that template's prompt.
+
 Needs: Node 20+, the `claude` CLI, `unshare` (util-linux) and `systemd-run --user` (the memory bound, `bin/bounded`).
+ClickHouse is not used: Langfuse runs on postgres and redis only.
 
 ## What every agent call gets
 
@@ -44,6 +57,19 @@ sent as one generation through the pipeline's own emitter.
 
 ## Live runs: the run note and the abort
 
+Before any leg, the launch runs the **shared pre-launch** (amsd-pipeline-shared `lib/prelaunch.js`, the same one every bash
+launcher runs): the pipeline's pre-flight, Langfuse, seed, cache, cost, alone, memory, no-timeout and the 12-item checklist.
+Any red refuses the launch before a model call (`<run>/prelaunch-leg-<n>/prelaunch.json`). A live launch states the seeded
+codeline and, if it accepts some prompts being rebuilt, how many:
+
+```bash
+node tools/rehearse.js --install <install> --out <run dir> --live yes --tag <n> --start live --stop-at pause-1 \
+  --seed-codeline <codeline> --expect-scope <codeline> [--max-rebuild <n>]
+```
+
+`--expect-scope` stops the leg the moment ingest scopes the story to any other set of codelines (`tools/scope-watch.js`). A
+leg has no time limit. Right before launching, check that no other memory-heavy job is running on the machine.
+
 `tools/rehearse.js --live yes` (and `--start live`, `--leg 2|3`, `--tag`) keeps one note per run in the operator's vault
 (`pipeline/live/<run>.md`, `tools/live-tracker.js`), refreshed every 2 minutes while a leg runs: legs, cost by stage,
 the Langfuse session id (proven by a launch trace read back before each leg), the lanes, the messages, and the six
@@ -54,3 +80,18 @@ At £0, `--plant writer,reviewer` makes those agents give no answer once per lan
 ## Version
 
 `amsd-pipeline-workflow version`. `package.json` `amsdPipeline.tested` names the pipeline release it was tested against.
+
+## The critical agent transitions as `claude plugin eval` cases
+
+`evals/` holds the critical agent transitions of the pipeline as a [`claude plugin eval`](https://code.claude.com/docs/en/plugin-evals)
+suite: discovery's repository descriptions, the classifier's scope, role assignment for every story/codeline pair, the
+self-heal analyst's corrective, and the Writer's reviewer (approves run 9's real fix; rejects the same change with a planted
+accessibility defect — prompts rendered by `team-lead-review.sh` itself, `tools/capture-review-prompt.sh`). Each case is the transition's real rendered prompt recorded from a run (`evals/source/`, exported
+from Langfuse), handed verbatim to that seam's own agent definition, with graders on its answer. Build the plugin from a run's
+generated agents, then run it (every run is a real model call):
+
+```bash
+node tools/build-eval-plugin.js --agents <run>/w1/gen/agents     # writes evals/plugin/
+claude plugin validate evals/plugin                              # free: structure only
+claude plugin eval evals/plugin --ablation none                  # paid: 6 cases x 3 runs
+```

package/driver/session-cost.js

@@ -96,13 +96,34 @@ const sum = (t) => TYPES.reduce((a, k) => a + (t[k] || 0), 0);
 /** modelUsage's entry for a transcript's model: the same name, or one a prefix of the other (a dated id). */
 const usageFor = (modelUsage, model) => modelUsage[model] || Object.entries(modelUsage).find(([k]) => model.startsWith(k) || k.startsWith(model))?.[1] || null;
 
-/** Each entry's share of its model's session cost, by its tokens. */
-function allocate(entries, modelUsage) {
+/**
+ * A call's cost from its own tokens and the pipeline's price table (config/model-pricing.json, or MODEL_PRICING_FILE), for
+ * a call its session reported no cost for — a leg killed before its session answered (LIVE-AMSD-2974-8/9, 2026-10-19:
+ * every call booked $0). null when the table does not price the model: unknown stays unknown, never a guessed figure.
+ * Cache writes and reads at the table's own rates, else the vendor's standard multiples of the input price (1.25x, 0.1x).
+ */
+function priceFromTable(prices, model, t) {
+  const p = prices[model] || Object.entries(prices).find(([k]) => model.startsWith(k) || k.startsWith(model))?.[1];
+  if (!p || p.inputPerMillion == null || p.outputPerMillion == null) return null;
+  const write = p.cacheWrite5mPerMillion != null ? p.cacheWrite5mPerMillion : p.inputPerMillion * 1.25;
+  const read = p.cacheReadPerMillion != null ? p.cacheReadPerMillion : p.inputPerMillion * 0.1;
+  return ((t.in || 0) * p.inputPerMillion + (t.cacheCreate || 0) * write + (t.cacheRead || 0) * read + (t.out || 0) * p.outputPerMillion) / 1e6;
+}
+function priceTable(env) {
+  const f = (env && env.MODEL_PRICING_FILE) || (env && env.SCRIPT_DIR ? path.join(env.SCRIPT_DIR, '..', 'config', 'model-pricing.json') : '');
+  try { return (JSON.parse(fs.readFileSync(f, 'utf8')) || {}).models || {}; } catch { return {}; }
+}
+
+/** Each entry's share of its model's session cost, by its tokens; a model the session did not report, priced from the table. */
+function allocate(entries, modelUsage, prices = {}) {
   const totals = {};
   for (const e of entries) { const key = usageFor(modelUsage, e.model) ? e.model : null; if (key) totals[key] = (totals[key] || 0) + sum(e.tokens); }
   return entries.map((e) => {
     const mu = usageFor(modelUsage, e.model);
-    if (!mu) return { ...e, costUsd: 0, costUnknown: true };
+    if (!mu) {
+      const est = priceFromTable(prices, e.model, e.tokens);
+      return est == null ? { ...e, costUsd: 0, costUnknown: true } : { ...e, costUsd: est, costUnknown: false, pricedFromTable: true };
+    }
     const w = totals[e.model] ? sum(e.tokens) / totals[e.model] : 0;
     return { ...e, costUsd: (mu.costUSD || 0) * w, costUnknown: false };
   });
@@ -128,7 +149,7 @@ function recordSession(env, session, { stage, storyId, phase, projectsDir, log }
   const rows = [];
   try {
     if (entries && entries.length) {
-      for (const e of allocate(entries, modelUsage)) {
+      for (const e of allocate(entries, modelUsage, priceTable(env))) {
         rows.push(appendLedgerRecord({ ledgerFile: ledger, agent: e.agent, storyId, phase, model: e.model,
           cost: { costUsd: e.costUsd, tokensIn: e.tokens.in, tokensOut: e.tokens.out, tokensCached: e.tokens.cacheRead, tokensCacheCreate: e.tokens.cacheCreate,
             costIsEstimate: true, costUnknown: e.costUnknown } }));
@@ -156,4 +177,4 @@ function recordSession(env, session, { stage, storyId, phase, projectsDir, log }
   }
 }
 
-module.exports = { recordSession, sessionEntries, allocate, transcriptTokens, callContent };
+module.exports = { recordSession, sessionEntries, allocate, transcriptTokens, callContent, priceFromTable };

package/generator/generate-agents.js

@@ -55,8 +55,14 @@ const STAGE_PHASES = [
   { title: 'Role assignment', step: 'agents', seams: ['role-assigner'] },                                        // :1080–1087
   { title: 'Project prompts', step: 'agents', seams: ['prompt-builder', 'prompt-review', 'prompt-claim-adjudicator'] }, // :1159–1406
 ];
-// asked from inside any seam's call, never a phase of its own: the hub's self-heal analyst (lib/self-heal.js)
-const ANY_PHASE_SEAMS = ['agent-failure-analyst'];
+// ASKED FROM INSIDE ANY SEAM'S CALL, never a phase of its own: the pipeline's self-heal — the analyst that diagnoses a
+// failed attempt and the synthesiser that turns its episodes into KB constraints (content-retry.js, self-heal.js,
+// agent-attempt-analyst.sh, kb-synthesizer.js). Read from the registry by what those seams produce, not listed by name:
+// the list named only the analyst, so the synthesiser was "out of the pipeline's order" and self-heal could not finish
+// inside the stage (LIVE-AMSD-2974-7, 2026-10-19).
+const SELF_HEAL_PRODUCES = ['diagnosis', 'kb-constraint'];
+const anyPhaseSeams = (registry, agentMap) => Object.keys(registry.profiles || {})
+  .filter((s) => SELF_HEAL_PRODUCES.includes((registry.profiles[s] || {}).produces) && agentMap[s]).sort();
 const PAUSE_STEP = 'pause-1';
 const HOOK = path.resolve(__dirname, '..', 'hooks', 'agents-step.js');
 const q = (x) => `'${String(x).replace(/'/g, "'\\''")}'`;
@@ -219,7 +225,7 @@ function main(a) {
   const features = JSON.parse(fs.readFileSync(path.join(__dirname, 'features.json'), 'utf8')).features;
   const plan = {
     source: `${a.project} run ${a.run} (Codeline, Agents; issues ${issuesFrom.file || `rebuilt from run ${issuesFrom.recordedRun}`})`,
-    steps: STEPS, pauseStep: PAUSE_STEP, agents: agentMap, runners, si, stagePhases: STAGE_PHASES, anyPhaseSeams: ANY_PHASE_SEAMS,
+    steps: STEPS, pauseStep: PAUSE_STEP, agents: agentMap, runners, si, stagePhases: STAGE_PHASES, anyPhaseSeams: anyPhaseSeams(registry, agentMap),
     // The 1,000-agent limit of one workflow run (decision 15), less the step runners.
     maxCalls: 900,
     features,
@@ -238,7 +244,7 @@ function main(a) {
   return manifest;
 }
 
-module.exports = { main, STEPS, STAGE_PHASES, ANY_PHASE_SEAMS };
+module.exports = { main, STEPS, STAGE_PHASES, SELF_HEAL_PRODUCES, anyPhaseSeams };
 if (require.main === module) {
   try { const m = main(args(process.argv.slice(2))); process.stdout.write(`${JSON.stringify({ agents: m.agents.length })}\n`); } catch (e) { process.stderr.write(`${e.message}\n`); process.exit(1); }
 }

package/package.json

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