amsd-pipeline-workflow 0.1.12 → 0.1.14

package/driver/release-lines.js

@@ -43,6 +43,11 @@ async function runReleaseLines(ctx, lane, clPrd, laneLog, laneEnv, canonical, ph
       const lineLog = path.join(laneLog, 'lines', slug); fs.mkdirSync(lineLog, { recursive: true });
       const linePrd = path.join(lineLog, 'prd.json');
       let rerun = ['--reset'];
+      // A RESUMED LINE'S COMMITTED WORK IS NOT REWRITTEN (operator, 2026-10-20): its story completed by its commit, as a lane's is
+      if (env.EPAM_RESUME_RUN && fs.existsSync(linePrd)) {
+        const id = (JSON.parse(fs.readFileSync(linePrd, 'utf8')).stories[0] || {}).id;
+        if (id) completeLineByCommit(env, wt, lineLog, linePrd, `${env.EPAM_BRANCH_PREFIX || ''}AI-${id}-${slug}`, log);
+      }
       const done = fs.existsSync(linePrd) && (() => { const p = JSON.parse(fs.readFileSync(linePrd, 'utf8')); return p.stories.length > 0 && p.stories.every((s) => s.status === 'completed'); })();
       if (bash(env, 'resume_preserves', ['completed-stories']).status === 0 && done
         && !handler(env, 'spec-predates-plan', [linePrd, canonical || clPrd]).stdout.trim()) {        // :96–106
@@ -89,4 +94,16 @@ async function runReleaseLines(ctx, lane, clPrd, laneLog, laneEnv, canonical, ph
   }
 }
 
-module.exports = { runReleaseLines };
+/**
+ * A RESUMED RELEASE LINE (LIVE-AMSD-2974-11): the line's branch checked out and the pipeline's own
+ * story_resume_completed_by_commit run on the line's log and PRD. The pipeline applies it to lanes only, so a line whose
+ * work was committed before its session died was reset and rewritten. A story committed on the line branch since the
+ * line's baseline is completed; the line's "completed" path then has its reviewer judge it (locked once approved).
+ */
+function completeLineByCommit(env, wt, lineLog, linePrd, branch, log) {
+  if (git(wt, 'rev-parse', '--verify', '--quiet', branch).status !== 0) return;
+  if (git(wt, 'checkout', '-q', branch).status !== 0) { log(`[orch] could not check out ${branch} to read its committed work`); return; }
+  bash({ ...env, PROJECT_ROOT: wt }, 'story_resume_completed_by_commit', [wt, lineLog, linePrd], { log });
+}
+
+module.exports = { runReleaseLines, completeLineByCommit };

package/driver/run.js

@@ -404,6 +404,25 @@ function provisionCodeline(ctx, cl, wt) {
   if (fs.existsSync(ap)) { fs.mkdirSync(epam, { recursive: true }); fs.copyFileSync(ap, path.join(epam, 'anti-patterns.json')); }
 }
 
+/** A story's newest review record: the lane log's review-verdict-<story>.json, else (a run from before that record) the
+ *  newest review-feedback.json any of this lane's Writers left; null when there is none. */
+function reviewRecord(ctx, lane, env, id, lineSlug) {
+  const read = (f) => { try { return JSON.parse(fs.readFileSync(f, 'utf8')); } catch { return null; } };
+  const v = env.LOG_DIR && read(path.join(env.LOG_DIR, `review-verdict-${id}.json`));
+  if (v) return { verdict: v.verdict, from: `review-verdict-${id}.json` };
+  // THIS LINE'S Writers only: a release line is never locked by another line's approval
+  const base = path.join(ctx.runDir, 'workflows', lane.cl, lineSlug ? `line-${lineSlug}` : 'main');
+  const found = [];
+  for (const tag of (fs.existsSync(base) ? fs.readdirSync(base) : [])) {
+    const f = path.join(base, tag, 'writer', id, 'checks', 'runs', 'review-feedback.json');
+    if (fs.existsSync(f)) found.push({ f, t: fs.statSync(f).mtimeMs });
+  }
+  if (!found.length) return null;
+  const newest = found.sort((a, b) => b.t - a.t)[0];
+  const fb = read(newest.f);
+  return fb ? { verdict: fb.verdict, from: path.relative(ctx.runDir, newest.f) } : null;
+}
+
 // ── ONE PHASE OF ONE LANE: what `bash run-agent-orchestration.sh` does for it, around the two workflows ─────────────
 // Returns the phase's exit code (lib/phase-exit.sh).
 async function phaseRunner(ctx, lane, laneEnv, { prd, phase, args, tag, lineSlug }) {
@@ -425,6 +444,14 @@ async function phaseRunner(ctx, lane, laneEnv, { prd, phase, args, tag, lineSlug
     const p = JSON.parse(fs.readFileSync(prd, 'utf8'));
     const rq = (s) => ((s.status === 'failed' || s.status === 'blocked') && !(s.completed) ? { ...s, status: 'pending' } : s);
     p.stories = (p.stories || []).map(rq);
+    // ONCE REVIEWED, LOCKED (operator, 2026-10-20): a completed story whose newest review record is an approval is neither
+    // rewritten nor re-reviewed; an "escalated" stamp an EARLIER attempt left is cleared as the pipeline clears it on
+    // approval (lib/review-cycle.sh ~:180–195) — the stale stamp would otherwise fail Step 5 on work already approved
+    for (const s of p.stories) {
+      if (!(s.completed === true && s.reviewStatus === 'escalated')) continue;
+      const rec = reviewRecord(ctx, lane, env, s.id, lineSlug);
+      if (rec && rec.verdict === 'approved') { s.reviewStatus = null; log(`[driver] ${s.id}: locked — reviewed and approved (${rec.from}); its earlier escalated stamp is cleared, nothing is rewritten or re-reviewed`); }
+    }
     fs.writeFileSync(prd, JSON.stringify(p, null, 2));
   }
   // RAO:1112–1123 — the spec pass, unless the lane resumed with its spec done
@@ -438,6 +465,12 @@ async function phaseRunner(ctx, lane, laneEnv, { prd, phase, args, tag, lineSlug
   const p = JSON.parse(fs.readFileSync(prd, 'utf8'));
   const order = ((p.implementationOrder || {})[phase] || []).map((id) => p.stories.find((s) => s.id === id))
     .filter((s) => s && s.status !== 'deprecated' && !s.completed && s.agentRole !== 'review-agent');
+  // COMMITTED BUT NEVER REVIEWED (a resume: the pipeline completed it by its commit): reviewed, not rewritten — once
+  // reviewed, locked (operator, 2026-10-20); an approved one is locked and not touched
+  const toReview = env.EPAM_RESUME_RUN ? ((p.implementationOrder || {})[phase] || []).map((id) => p.stories.find((s) => s.id === id))
+    .filter((s) => s && s.completed === true && s.status !== 'deprecated' && s.agentRole !== 'review-agent')
+    .filter((s) => { const rec = reviewRecord(ctx, lane, env, s.id, lineSlug); return !(rec && rec.verdict === 'approved'); }) : [];
+  for (const s of toReview) log(`[driver] ${s.id}: committed but never reviewed — its review judges the committed change; nothing is rewritten`);
   if (order.length && env.EPAM_BROWNFIELD === '1') bash(env, 'ensure_story_branch', [lane.wt, order[0].id, env.JIRA_BASELINE_BRANCH || ''], { log });
   // RAO:2653–2654 — THE LANE'S PHASE BASELINE (lib/qa-gate-evidence.sh qa_record_phase_baseline: the fork point from the
   // base branch) in the lane's log, where the release lines read the main line's change from (lib/release-lines.sh:69–74)
@@ -445,11 +478,12 @@ async function phaseRunner(ctx, lane, laneEnv, { prd, phase, args, tag, lineSlug
   // RAO:3094–3323 — Steps 11 and 12, once per phase before its stories (driver/phase-audits.js)
   if (order.length) runPhaseAudits(env, { wt: lane.wt, phase }, log);
   // the Writer, per story in the phase's order (docs/DRIVER.md: Steps 3.54–3.6, 19 and 20 run once per story)
-  for (const s of order) {
+  for (const s of [...order, ...toReview]) {
+    const reviewCommitted = toReview.includes(s);
     // lib/cli-commands.sh:501–504 — the per-story guards: cost budget, pause, redirect (driver/story-guards.js)
     storyGuards(env, { prd, story: s.id, checkpointPrd: path.join(ctx.env.EPAM_PROJECT_CONFIG_DIR, 'runs', ctx.run, 'lanes', lane.cl,
       ...(lineSlug ? ['lines', lineSlug] : []), 'checkpoint', 'prd.json') }, log);
-    const res = await stages.runWriter(ctx, lane, env, { story: s.id, out: path.join(dir, 'writer', s.id), lineSlug });
+    const res = await stages.runWriter(ctx, lane, env, { story: s.id, out: path.join(dir, 'writer', s.id), lineSlug, reviewCommitted });
     log(`[driver] ${lane.cl} ${s.id}: writer → ${res.status} (exit ${res.exit})${res.reason ? ` — ${res.reason}` : ''}`);
     if (blockCap.signature(s.id, res)) ctx.lastBlock = blockCap.signature(s.id, res);
     // story-attempt.sh:2561–2578, :2865 — the ladder position the next invocation resumes at, in the lane's log, by the
@@ -471,6 +505,13 @@ async function phaseRunner(ctx, lane, laneEnv, { prd, phase, args, tag, lineSlug
     }
     // what Steps 3.545 and 3.55 stamp on the story, so a retry inherits the finding (driver/writer-stamps.js)
     if (st) applyGateStamps(st, res);
+    // THE LOCK, RECORDED where a later Writer cannot wipe it (the lane's log; its out dir is rebuilt each leg, B64): a Writer
+    // that ends 'done' ended on an approved review
+    if (res.status === 'done') {
+      const head = spawnSync('git', ['-C', lane.wt, 'rev-parse', 'HEAD'], { encoding: 'utf8' });
+      fs.mkdirSync(env.LOG_DIR, { recursive: true });
+      fs.writeFileSync(path.join(env.LOG_DIR, `review-verdict-${s.id}.json`), `${JSON.stringify({ verdict: 'approved', head: head.status === 0 ? head.stdout.trim() : null, at: new Date().toISOString() })}\n`);
+    }
     fs.writeFileSync(prd, JSON.stringify(cur, null, 2));
     // lib/prd-state.sh update_story_status (the pipeline's), on the lane's PRD
     bash({ ...env, MAIN_PRD_FILE: prd, PRD_FILE: prd }, 'update_story_status', [s.id, res.exit === 0 ? 'completed' : 'failed'], { log });

package/driver/stages.js

@@ -207,7 +207,7 @@ function overlay(ctx, lane, lineSlug) {
   return dest;
 }
 
-async function runWriter(ctx, lane, env, { story, out, lineSlug }) {
+async function runWriter(ctx, lane, env, { story, out, lineSlug, reviewCommitted }) {
   fs.rmSync(out, { recursive: true, force: true });
   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
@@ -216,7 +216,8 @@ async function runWriter(ctx, lane, env, { story, out, lineSlug }) {
   fs.mkdirSync(path.dirname(lf), { recursive: true });
   fs.writeFileSync(lf, Object.entries(ctx.launchEnv || {}).map(([k, v]) => `${k}=${v}`).join('\n') + '\n');
   gen('generate.js', ['--install', inst, '--project', ctx.project, '--run', ctx.run, '--lane', lane.cl, '--story', story,
-    '--codeline', lane.wt, '--out', out, '--set', ctx.set, ...(Object.keys(ctx.launchEnv || {}).length ? ['--launch-env', lf] : [])], env);
+    '--codeline', lane.wt, '--out', out, '--set', ctx.set, ...(Object.keys(ctx.launchEnv || {}).length ? ['--launch-env', lf] : []),
+    ...(reviewCommitted ? ['--review-committed', 'yes'] : [])], env);
   const plan = JSON.parse(fs.readFileSync(path.join(out, 'plan.json'), 'utf8'));
   // THE RUN'S LAUNCH SETTINGS, AS THE GENERATOR RECORDED THEM (plan.launchEnv, the Writer port's field): they must be the
   // settings this run was launched with — read, never re-derived here

package/generator/generate.js

@@ -481,6 +481,9 @@ function main(a) {
     roleRefused,
     noChange,
     planNote,
+    // COMMITTED BUT NOT REVIEWED (a resumed story the pipeline completed by its commit with no approved review): the Writer
+    // reviews the change as it is, no writer attempt (once reviewed, locked — operator, 2026-10-20)
+    reviewCommitted: a['review-committed'] === 'yes' ? { message: `Story ${a.story}: its work is committed in this run and was never reviewed — the review judges the committed change; nothing is rewritten` } : null,
     resume: (resume.attempt > 0 || resume.model) ? resume : null,
     story: { id: story.id, title: story.title || '', description: story.description || '', acs },
     // Run state at pause 2; the workflow carries the current value forward as hooks report changes (D5).

package/generator/writer-workflow.js

@@ -646,6 +646,14 @@ if (PLAN.noChange) {
   }
   reReview = checks
 }
+// COMMITTED BUT NOT REVIEWED (PLAN.reviewCommitted; story_resume_completed_by_commit's "the review judges the committed
+// change"): the review inputs from the codeline as it is, and the loop's first pass reviews them — no writer attempt; the
+// committed reproducing test stands (Step 3.54 is not run again). Approved, the story is done and locked.
+if (PLAN.reviewCommitted && !reReview) {
+  log(PLAN.reviewCommitted.message)
+  reproDone = true
+  reReview = await refreshed({ passed: true, problems: [], changes: '' }, 'review inputs: the committed change')
+}
 // PLAN MODE AND THE PLANNING PHASE (feature plan-mode; story-attempt.sh:980–984, :1103, :1207–1216, hooks/plan-round.sh):
 // the pipeline's own functions decide whether either runs and build every question; the planning agents answer one at a
 // time; a reviewed plan wraps every attempt's prompt (:1617–1625). A call whose agent ended without an answer fails, as

package/package.json

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