amsd-pipeline-workflow 0.1.13 → 0.1.15

package/driver/release-lines.js

@@ -43,7 +43,12 @@ 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'];
-      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'); })();
+      // 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 = lineIsDone(linePrd);
       if (bash(env, 'resume_preserves', ['completed-stories']).status === 0 && done
         && !handler(env, 'spec-predates-plan', [linePrd, canonical || clPrd]).stdout.trim()) {        // :96–106
         rerun = [];
@@ -89,4 +94,30 @@ 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 });
+  // THE PIPELINE'S FUNCTION SETS completed ONLY; the line's done test reads status (lib/release-lines.sh:96), so a line
+  // completed by its commit read as not done, took the --reset path and was rewritten (LIVE-AMSD-2974-11, 2026-10-20).
+  // A Writer-completed story carries both; this one does too.
+  const p = JSON.parse(fs.readFileSync(linePrd, 'utf8'));
+  let changed = false;
+  for (const s of p.stories || []) if (s.completed === true && s.status !== 'completed' && s.status !== 'deprecated') { s.status = 'completed'; changed = true; }
+  if (changed) fs.writeFileSync(linePrd, JSON.stringify(p, null, 2));
+}
+
+/** A line whose every story is completed — the pipeline's own test (lib/release-lines.sh:96). */
+function lineIsDone(linePrd) {
+  if (!fs.existsSync(linePrd)) return false;
+  const p = JSON.parse(fs.readFileSync(linePrd, 'utf8'));
+  return (p.stories || []).length > 0 && p.stories.every((s) => s.status === 'completed');
+}
+
+module.exports = { runReleaseLines, completeLineByCommit, lineIsDone };

package/driver/run.js

@@ -406,14 +406,15 @@ function provisionCodeline(ctx, cl, wt) {
 
 /** 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) {
+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` };
-  const base = path.join(ctx.runDir, 'workflows', lane.cl);
+  // 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 line of (fs.existsSync(base) ? fs.readdirSync(base) : [])) for (const tag of (fs.existsSync(path.join(base, line)) ? fs.readdirSync(path.join(base, line)) : [])) {
-    const f = path.join(base, line, tag, 'writer', id, 'checks', 'runs', 'review-feedback.json');
+  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;
@@ -448,7 +449,7 @@ async function phaseRunner(ctx, lane, laneEnv, { prd, phase, args, tag, lineSlug
     // 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);
+      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));
@@ -464,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)
@@ -471,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

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