dsh-workflow-map 0.3.2 → 0.3.5

package/src/client/store.js

@@ -175,6 +175,22 @@ function wfPollUrl(sessionId) {
   return "/dsh-workflow/state?sessionId=" + encodeURIComponent(String(sessionId));
 }
 
+/**
+ * May the poll loop re-arm after this result?
+ *
+ * A tick aborts the request it replaces, and an aborted request resolves as status -1.
+ * That is the ORDINARY path whenever a poll outlives its interval, so -1 must not end
+ * the loop: it only defers to the replacement that is already in the air. Returning
+ * false there is what keeps two loops from running; returning false for anything else
+ * (a real error, a 4xx) would stop the panel from ever updating again.
+ *
+ * Extracted from the hook so the rule is testable without a renderer.
+ */
+function wfPollContinues(result, inflight) {
+  if (!result || result.status !== -1) return true;
+  return wfFinite(inflight) === null ? true : inflight <= 0;
+}
+
 /**
  * One conditional GET. Never throws: every outcome is a value, so the loop can
  * always decide what to render and how long to wait.
@@ -365,6 +381,9 @@ function wfPlanSummary(plan) {
     }
   }
   return {
+ // A finished plan must not decide a card's status any more; the summary carries
+ // the flag so the status policy can stand down without re-reading the phase.
+    terminal: plan.terminal === true,
     statuses: plan.statuses && typeof plan.statuses === "object" ? plan.statuses : {},
     anchorSeqs: plan.anchorSeqs && typeof plan.anchorSeqs === "object" ? plan.anchorSeqs : {},
     skipped: Array.isArray(plan.skipped) ? plan.skipped.slice() : [],
@@ -878,7 +897,10 @@ function wfBuildModel(view, prefs, nowMs) {
       errorText: typeof found.error === "string" ? found.error.slice(0, 200) : "",
       seq: wfFinite(found.seq),
       error: typeof found.error === "string" && found.error !== "",
-      result: typeof found.resultHead === "string" && found.resultHead !== "",
+      // The host's result boolean is the settled fact: a call that returned with an EMPTY body is
+      // settled. Falling back to resultHead alone marked such a call unsettled, so the panel kept
+      // it in the "calling right now" state and its dot pulsed after the call had already returned.
+      result: found.result === true || (typeof found.resultHead === "string" && found.resultHead !== ""),
       durationMs: wfFinite(found.durationMs),
       at: wfFinite(found.at),
     });

package/src/client/theme.js

@@ -169,7 +169,15 @@ var WF_CSS = [
  // the three branch hues live on the ROOT, so the dashed branches and their round
  // icons share one palette with the rest of the panel (and one place to change it).
     "--wf-chain-read:#5b8cff;--wf-chain-edit:#e0a13a;--wf-chain-tool:#8f7bea;" +
+  // `--dsw-alias-bg-layer-1` and `-2` carry the SAME value in the host's light theme (both
+  // neutral-bluish-00, i.e. #fff), so a card filled with layer-2 is invisible on the page. Every
+  // raised surface in the panel therefore paints one translucent lift over that fill. The lift goes
+  // towards ink on a light page and towards white on a dark one; the host marks dark by putting
+  // `data-ds-dark-theme` on <body>, so the light values are the defaults and the dark block below
+  // only wins when that attribute is present.
+    "--wf-lift:rgba(15,23,42,.045);--wf-lift-2:rgba(15,23,42,.085);" +
     "font-family:ui-sans-serif,system-ui,-apple-system,'Segoe UI','Microsoft YaHei',sans-serif;font-size:12px;line-height:1.5}",
+  "body[data-ds-dark-theme] .wf-root{--wf-lift:rgba(255,255,255,.035);--wf-lift-2:rgba(255,255,255,.07)}",
 
  /* card: fills the main area; the header and the settings card keep their own height,
      the two-column body takes the rest. No drag grips: the column has no free edges.
@@ -195,6 +203,10 @@ var WF_CSS = [
   ".wf-btn:hover{background:var(--dsw-alias-bg-layer-2,#2c3140);color:var(--dsw-alias-label-primary,#e9ecf3)}",
   ".wf-btn:focus-visible{outline:2px solid var(--dsw-alias-brand-primary,#5b8cff);outline-offset:1px}",
   ".wf-btn[data-active='true']{color:var(--dsw-alias-brand-primary,#5b8cff);border-color:var(--dsw-alias-brand-primary,#5b8cff)}",
+ // The refresh button's one-second acknowledgement. Width is pinned to the glyph's own
+ // box so swapping "↻" for "已刷新" cannot shift the header row underneath the pointer.
+  ".wf-btn-ok{color:var(--dsw-alias-state-success-primary,#3fb950);border-color:var(--dsw-alias-state-success-primary,#3fb950);" +
+    "width:auto;min-width:23px;padding:0 6px;font-size:11px}",
  // Hot injection is the one header action that injects text into the RUNNING turn, so it is the
  // one that must never be hunted for: a named, filled chip that keeps its name in Chinese.
  // User feedback: "too small, still have to open it first" - so it grows to 96x30 (the other two in the row stay
@@ -252,13 +264,14 @@ var WF_CSS = [
  // `grid-area:1/1` is what makes the triangle and the card share the cell: without it the
  // auto-placement cursor would drop the card into row 2, below the triangle.
   ".wf-step-card{grid-area:1/1;display:flex;gap:8px;align-items:flex-start;width:100%;padding:7px 8px;border-radius:8px;text-align:left;" +
-    "font:inherit;color:inherit;cursor:pointer;border:1px solid transparent;" +
-    "background:var(--dsw-alias-bg-layer-2,#282d3a);border-left:3px solid transparent}",
+    "font:inherit;color:inherit;cursor:pointer;border:1px solid var(--dsw-alias-border-l2,rgba(255,255,255,.22));" +
+    "background:var(--dsw-alias-bg-layer-2,#282d3a);background-image:linear-gradient(var(--wf-lift),var(--wf-lift));" +
+    "border-left:3px solid transparent}",
   ".wf-step-card:hover{border-color:var(--dsw-alias-border-l2,rgba(255,255,255,.22));" +
-    "background:var(--dsw-alias-bg-layer-1,#232733)}",
+    "background:var(--dsw-alias-bg-layer-1,#232733);background-image:linear-gradient(var(--wf-lift-2),var(--wf-lift-2))}",
   ".wf-step-card:focus-visible{outline:2px solid var(--dsw-alias-brand-primary,#5b8cff);outline-offset:1px}",
   ".wf-step-card[data-selected='true']{border-color:var(--dsw-alias-brand-primary,#5b8cff);" +
-    "background:var(--dsw-alias-bg-layer-1,#232733)}",
+    "background:var(--dsw-alias-bg-layer-1,#232733);background-image:linear-gradient(var(--wf-lift-2),var(--wf-lift-2))}",
   ".wf-step-card[data-active='true']{border-left-color:var(--dsw-alias-brand-primary,#5b8cff)}",
   ".wf-step-ring{flex:0 0 auto;width:18px;height:18px;margin-top:1px;border-radius:50%;" +
     "display:inline-flex;align-items:center;justify-content:center;font-size:11px;line-height:1;" +
@@ -412,7 +425,7 @@ var WF_CSS = [
   ".wf-branch-icon{flex:0 0 auto;width:" + WF_CHAIN_ICON + "px;height:" + WF_CHAIN_ICON + "px;padding:0;" +
     "border-radius:50%;display:inline-flex;align-items:center;justify-content:center;" +
     "font:inherit;font-size:11px;line-height:1;cursor:pointer;position:relative;" +
-    "background:var(--dsw-alias-bg-layer-2,#282d3a);color:var(--dsw-alias-label-secondary,#9aa3b2);" +
+    "background:var(--dsw-alias-bg-layer-2,#282d3a);background-image:linear-gradient(var(--wf-lift),var(--wf-lift));color:var(--dsw-alias-label-secondary,#9aa3b2);" +
     "border:1px solid var(--dsw-alias-border-l2,rgba(255,255,255,.28))}",
   ".wf-branch-icon:hover{color:var(--dsw-alias-label-primary,#e9ecf3)}",
   ".wf-branch-icon:focus-visible{outline:2px solid var(--dsw-alias-brand-primary,#5b8cff);outline-offset:2px}",
@@ -442,12 +455,14 @@ var WF_CSS = [
  /* node card: icon · title · meta · status dot */
   ".wf-node{display:flex;gap:7px;align-items:flex-start;width:100%;padding:6px 8px;border-radius:8px;" +
     "text-align:left;font:inherit;color:inherit;cursor:pointer;" +
-    "background:var(--dsw-alias-bg-layer-2,#282d3a);border:1px solid transparent;" +
+    "background:var(--dsw-alias-bg-layer-2,#282d3a);background-image:linear-gradient(var(--wf-lift),var(--wf-lift));" +
+    "border:1px solid var(--dsw-alias-border-l2,rgba(255,255,255,.22));" +
     "border-left:3px solid var(--dsw-alias-border-l2,rgba(255,255,255,.2))}",
-  ".wf-node:hover{border-color:var(--dsw-alias-border-l2,rgba(255,255,255,.24));background:var(--dsw-alias-bg-layer-1,#232733)}",
+  ".wf-node:hover{border-color:var(--dsw-alias-border-l2,rgba(255,255,255,.24));" +
+    "background:var(--dsw-alias-bg-layer-1,#232733);background-image:linear-gradient(var(--wf-lift-2),var(--wf-lift-2))}",
   ".wf-node:focus-visible{outline:2px solid var(--dsw-alias-brand-primary,#5b8cff);outline-offset:1px}",
   ".wf-node[data-selected='true']{border-color:var(--dsw-alias-brand-primary,#5b8cff);" +
-    "background:var(--dsw-alias-bg-layer-1,#232733)}",
+    "background:var(--dsw-alias-bg-layer-1,#232733);background-image:linear-gradient(var(--wf-lift-2),var(--wf-lift-2))}",
   ".wf-node[data-selected='true'] .wf-node-title{font-weight:600}",
   ".wf-node[data-kind='tool']{border-left-color:var(--dsw-alias-brand-primary,#5b8cff)}",
   ".wf-node[data-kind='report']{border-left-color:var(--dsw-alias-state-success-primary,#45c07a)}",
@@ -1024,11 +1039,12 @@ var WF_CSS_PAGE = [
 
  /* ---- the unit card ---- */
   ".wf-unit-card{display:grid;grid-template-columns:auto auto minmax(0,1fr);align-items:flex-start;gap:8px;" +
-    "width:100%;padding:10px 12px;border-radius:10px;text-align:left;border:1px solid transparent;" +
-    "background:var(--dsw-alias-bg-layer-2,#282d3a);color:inherit;font:inherit;cursor:pointer;" +
+    "width:100%;padding:10px 12px;border-radius:10px;text-align:left;border:1px solid var(--dsw-alias-border-l2,rgba(255,255,255,.22));" +
+    "background:var(--dsw-alias-bg-layer-2,#282d3a);background-image:linear-gradient(var(--wf-lift),var(--wf-lift));" +
+    "color:inherit;font:inherit;cursor:pointer;" +
     "border-left:3px solid transparent;box-sizing:border-box}",
   ".wf-unit-card:hover{border-color:var(--dsw-alias-border-l2,rgba(255,255,255,.22));" +
-    "background:var(--dsw-alias-bg-layer-1,#232733)}",
+    "background:var(--dsw-alias-bg-layer-1,#232733);background-image:linear-gradient(var(--wf-lift-2),var(--wf-lift-2))}",
   ".wf-unit-card:focus-visible{outline:2px solid var(--dsw-alias-brand-primary,#5b8cff);outline-offset:1px}",
   ".wf-unit-card[data-selected='true']{border-color:var(--dsw-alias-brand-primary,#5b8cff)}",
   ".wf-unit-card[data-active='true']{border-left-color:var(--dsw-alias-brand-primary,#5b8cff)}",

package/src/fold.mjs

@@ -63,7 +63,12 @@
 // own `inboxProjectionDefinition` replays. A checkpoint written before this bump has no ledger,
 // so the registry is told to drop it and rebuild from the log (the same contract as v1→v2: a
 // missing field must never be silently answered with a wrong index).
-export const STATE_VERSION = 3;
+//
+// STATE_VERSION 4 : the step ledger now follows the todo table's own statuses (a `pending` row
+// demotes a step that still carried `done`/`running`, and a step any table no longer names is
+// dropped). Checkpoints written before the bump hold ledgers from the older mapping — wrong
+// statuses and leftover rows — so the same contract applies: drop and rebuild from the log.
+export const STATE_VERSION = 5;
 
 export const SCHEMA_VERSION = 1;
 
@@ -515,6 +520,13 @@ function percentFor(state, step, now) {
     const pinned = step.percent === null ? 100 : step.percent;
     return { percent: clamp(pinned, 0, 100), source: step.percentSource === "none" ? "closed" : step.percentSource };
   }
+  // Only the step that is actually running can be partly done. A pending row is future work and a
+  // skipped one never will be done, so NEITHER carries a number. The old code let the todo table's
+  // completion ratio paint a bar on every waiting row as well, which is where the wall of bars
+  // below 100 % in an already finished session came from.
+  if (step.status !== STEP_STATUS.running) {
+    return { percent: null, source: "none" };
+  }
   // Priority 2 when a self-report exists: the todo table's completion ratio is a measurement (no
   // clock, no extrapolation), so it determines the number whenever it has rows to report on.
   // The self-report can only lower the result, never raise it above the measured ratio.
@@ -536,7 +548,11 @@ function percentFor(state, step, now) {
       const value = measured;
       return { percent: clamp(value, 0, 99), source: "todos" };
     }
-    return { percent: clamp(Math.max(reported.percent, step.maxPercent), 0, 100), source: "model" };
+    // The model's latest statement is the number, and an open step is 0..99: 100 % on a running
+    // row is a claim the log does not support. The high-water record is deliberately not applied
+    // here, as the comment above states; applying it freezes a row at the highest number it ever
+    // reached, so later reports cannot move the bar.
+    return { percent: clamp(reported.percent, 0, 99), source: "model" };
   }
   // The checklist's own completion ratio — a real measurement, so it sits above the time baseline.
   // It never claims 100 % for an OPEN step: the remaining row is still in progress.
@@ -608,6 +624,10 @@ function newNode(kind, tool, title, at, extra) {
     argsText: "",
     resultHead: "",
     error: "",
+    // Whether the call returned. Separate from the body text: a call that succeeds with
+    // no output has an empty resultHead and is still settled. The browser half colours by
+    // this flag, so deriving it from resultHead leaves every silent call "running".
+    settled: false,
     at,
     durationMs: null,
     // filled by appendNode when the caller did not pass one (see toolKey).
@@ -739,6 +759,25 @@ function argsDigest(args) {
 // fold
 // ---------------------------------------------------------------------------
 
+/**
+ * Reopen a closed row without letting its 100 % speak for the reopened one.
+ *
+ * A row taken back to in_progress used to keep the percent and the high-water record of its
+ * closed state, so the panel showed an in-progress step pinned at 100 %: a bar that can never
+ * move again, and a later self-report cannot lower it. A closed record's number belongs to
+ * that closure, not to the row that reopens it.
+ */
+function reopenStep(step, time) {
+  const reopened = step.status === STEP_STATUS.done || step.status === STEP_STATUS.failed;
+  const base = {
+    ...step,
+    status: STEP_STATUS.running,
+    endedAt: null,
+    startedAt: reopened || !step.startedAt ? time : step.startedAt,
+  };
+  return reopened ? { ...base, percent: null, percentSource: "none", maxPercent: 0 } : base;
+}
+
 function foldTodos(state, event, time) {
   const data = dataOf(event);
   const raw = data && Array.isArray(data.todos) ? data.todos : [];
@@ -752,12 +791,22 @@ function foldTodos(state, event, time) {
   // session (no PAE plan at all) still produces a step list.
   let steps = [...state.steps];
   let durations = state.durations;
+  // Every row that matched an existing step, and the status that row states. The table is the one
+  // authority on a step's lifecycle, so these are applied in a final pass instead of inline: a row
+  // can match a step that a LATER row also matches (slot reuse after the model rewrites the table),
+  // and an inline write could then be overwritten by a stale copy of the old status.
+  const authority = new Map();
+  // The ledger as it stood BEFORE this table. Slot binding has to read this snapshot: by the time a
+  // later row is examined, `steps` already holds the rows this very table created, so "the row in
+  // this position" would point at a row from the NEW table instead of the one being replaced.
+  const prior = state.steps;
 
   for (const item of todos) {
     if (item.content === "") continue;
     const planIndex = planIndexOf(item.content);
     let at = planIndex === null ? -1 : steps.findIndex((step) => step.planIndex === planIndex);
     if (at === -1) at = steps.findIndex((step) => normalizeTitle(step.title) === normalizeTitle(item.content));
+    const matchedByTitle = at !== -1;
     // REWORDED ROW at the source. The model often rewrites its own todo text between two
     // `todo/write` events (measured: "read-only inventory: read plugin sources..." -> "read-only inventory: sources/config..."). Matching on the
     // title alone then misses the row that already exists, a SECOND row is created for the new
@@ -765,8 +814,13 @@ function foldTodos(state, event, time) {
     // sync then drops. That was "only the running step shows tool types". The fix belongs HERE:
     // reword in place when the slot and lifecycle agree, so the row keeps its ledger.
     if (at === -1) {
-      const slotRow = steps[steps.length > todos.indexOf(item) ? todos.indexOf(item) : -1];
-      const sameSlot = slotRow && (slotRow.status === item.status || slotRow.status === STEP_STATUS.running);
+      const slotRow = prior[todos.indexOf(item)];
+      // A running step is never taken over by a row that is not running: that is how a pending row
+      // used to hijack the live step and leave the real one with no running row at all.
+      const sameSlot =
+        slotRow &&
+        (slotRow.status === item.status ||
+          (slotRow.status === STEP_STATUS.running && item.status === "in_progress"));
       if (sameSlot) at = steps.indexOf(slotRow);
     }
 
@@ -796,6 +850,12 @@ function foldTodos(state, event, time) {
     // its old key, so the nodes it already owns can follow the rename. Both the rename and the
     // lifecycle change are applied in one assignment, so neither can lose the other.
     let next = step;
+    // The row's ordinal follows the TABLE, not the row's history. A matched row that used to be
+    // unnumbered (or numbered differently) must take the ordinal this table now states, or the
+    // view keeps a stale planIndex and `applyPlanToView` patches the wrong plan step onto it.
+    // Measured 2026-10-29 on session 164e339f: leftover unnumbered rows kept planIndex 2 / 3 /
+    // 4... from an earlier PAE plan and the map rendered plan steps 3-7 twice.
+    if (planIndex !== null && next.planIndex !== planIndex) next = { ...next, planIndex };
     const shown = text(stripOrdinal(item.content) || item.content, TITLE_LIMIT);
     const shownKey = normalizeTitle(shown);
     if (shownKey !== "" && shownKey !== next.stepKey) {
@@ -811,12 +871,53 @@ function foldTodos(state, event, time) {
       if (next.startedAt > 0) durations = [...durations, time - next.startedAt].filter((value) => value > 0);
     } else if (item.status === "in_progress" && next.status !== STEP_STATUS.running) {
       // A step re-opened by a re-plan or a retry: keep its ledger row, restart the clock.
-      steps[at] = { ...next, status: STEP_STATUS.running, endedAt: null, startedAt: next.startedAt || time };
+      steps[at] = reopenStep(next, time);
     } else if (next !== step) {
       steps[at] = next;
     }
+    authority.set(at, { status: item.status, byTitle: matchedByTitle });
+  }
+
+  // The final pass: one status per step, exactly as the table now states it. `pending` is a real
+  // state — a row the model has not started — and a step that still carried `done` or `running`
+  // from the previous wording of the table has to be demoted, or the panel shows finished work the
+  // table does not claim (and a bar at 100 % next to an empty todo). Demotion is only safe when the
+  // row matched on its own title; a slot match after a reword could hit a different row's step.
+  for (const [at, claim] of authority) {
+    const step = steps[at];
+    if (!step) continue;
+    if (claim.status === "completed" && step.status !== STEP_STATUS.done) {
+      if (step.startedAt > 0) durations = [...durations, time - step.startedAt].filter((value) => value > 0);
+      steps[at] = closeStep(step, time);
+    } else if (claim.status === "in_progress" && step.status !== STEP_STATUS.running) {
+      steps[at] = reopenStep(step, time);
+    } else if (claim.status === "pending" && step.status !== STEP_STATUS.pending) {
+      // Same rule for a demotion: the row is not done, so it cannot keep a done row's number.
+      steps[at] = {
+        ...step,
+        status: STEP_STATUS.pending,
+        endedAt: null,
+        startedAt: 0,
+        percent: null,
+        percentSource: "none",
+        maxPercent: 0,
+      };
+    }
   }
 
+  // A row the table no longer names, that never started and owns no node, is the leftover of an
+  // earlier wording of the same list. Keeping it leaves a permanently empty card in the step
+  // column, which is how every rewritten table used to grow the panel by one or two rows.
+  const named = new Set(todos.map((item) => normalizeTitle(item.content)).filter((key) => key !== ""));
+  const nodeKeys = new Set(state.nodes.map((node) => node.stepKey));
+  const kept = steps.filter((step) => {
+    if (step.status !== STEP_STATUS.pending || step.startedAt > 0) return true;
+    const keys = [step.stepKey, ...(Array.isArray(step.aliasKeys) ? step.aliasKeys : [])].filter(Boolean);
+    if (keys.some((key) => nodeKeys.has(key))) return true;
+    return keys.some((key) => named.has(key));
+  });
+  if (kept.length !== steps.length) steps = kept;
+
 
   return { ...state, asOf: time, todos, steps: reindex(steps), durations };
 }
@@ -900,6 +1001,8 @@ function foldToolResult(state, event, time, seq) {
     ...previous,
     resultHead: isError ? "" : line(body),
     error: isError ? line(body) : "",
+    // Settled means "the call came back", whatever its body: empty output is not a pending call.
+    settled: true,
     durationMs: previous.at > 0 && time > previous.at ? time - previous.at : null,
   };
   const answered = { ...state, asOf: time, nodes };
@@ -914,7 +1017,14 @@ function foldToolResult(state, event, time, seq) {
           ),
         }
       : answered;
-  const next = withActive(settled, previous.id, time);
+  // A result is not an activity. Re-asserting the node that just finished as the active one
+  // makes the panel claim "calling right now" about a call that already returned. Keep the
+  // node a newer call opened, and otherwise hand the highlight back to the step.
+  const keepActive =
+    state.active && typeof state.active.nodeId === "string" && state.active.nodeId !== "" && state.active.nodeId !== previous.id
+      ? state.active.nodeId
+      : null;
+  const next = withActive(settled, keepActive, time);
   // A tool result is the moment two branch decisions become possible: a job that is STILL
   // open (background) is promoted to a lane, and a launcher's acknowledgement attaches its
   // run id. Both are no-ops for ordinary calls.
@@ -1134,7 +1244,14 @@ function parsePlanRows(blockText) {
   for (const raw of blockText.split("\n")) {
     const match = /^\s*(\d+)\.\s*(.+)$/.exec(raw);
     if (!match) continue;
-    rows.push({ planIndex: Number(match[1]), title: text(match[2], TITLE_LIMIT) });
+    // PAE appends each row's own step FILE to the title ("1. title（…）（step-01-x.md）"). That
+    // annotation is not title text: keeping it leaves `normalizeTitle` one parenthetical group short
+    // of the todo row the model writes ("1. title（…）"), so a plan step can carry a title that no
+    // row of the todo table has. Measured 2026-10-30 on session 1bb4baa0: the fold opened step 1 with
+    // the annotated title while its `stepKey` still held the table's wording, `foldTodos` therefore
+    // saw "no change" and the view kept a step the conversation does not list (audit-real ①).
+    const title = match[2].replace(/\s*[（(][^（()）]*\.(?:md|markdown|mjs|cjs|js|json|ya?ml|txt)[）)]\s*$/, "");
+    rows.push({ planIndex: Number(match[1]), title: text(title, TITLE_LIMIT) });
     if (rows.length >= 80) break;
   }
   return rows;
@@ -1195,10 +1312,26 @@ function openPlanStep(state, time, seq, planIndex, title, blockText) {
     steps.push(created);
   } else {
     const step = steps[targetAt];
+    // A plan title must not replace the row's identity key on its own: `stepKey` is what `foldTodos`
+    // compares the live table against and what node attribution follows. Adopting a title without its
+    // key left the pair inconsistent, so the next todo/write judged the row unchanged and a stale
+    // title survived into the view (measured 2026-10-30, session 1bb4baa0). The old key is parked in
+    // `aliasKeys` exactly as a rename does, so nodes already carrying it still migrate.
+    const adopted = title || step.title;
+    const adoptedKey = normalizeTitle(adopted);
+    const renamed = adoptedKey !== "" && adoptedKey !== step.stepKey;
+    const seenKeys = Array.isArray(step.aliasKeys) ? step.aliasKeys : [];
     steps[targetAt] = {
       ...step,
       planIndex,
-      title: title || step.title,
+      title: adopted,
+      ...(renamed
+        ? {
+            prevKey: step.stepKey,
+            stepKey: adoptedKey,
+            aliasKeys: [...new Set([...seenKeys, step.stepKey, adoptedKey])].filter((key) => key !== ""),
+          }
+        : {}),
       anchorSeq: step.anchorSeq === undefined ? anchorOf(state, planIndex, seq) : step.anchorSeq,
       status: STEP_STATUS.running,
       endedAt: null,
@@ -1261,7 +1394,20 @@ function foldTurnStart(state, _event, time) {
 }
 
 function foldTurnEnd(state, _event, time) {
-  return { ...state, asOf: time, turnActive: false };
+  const next = { ...state, asOf: time, turnActive: false };
+  // The turn is over, so the step it was running is over too. Leaving it `running` kept a live,
+  // forever-partial bar on the last step of every finished session.
+  // The one exception is a step the todo table still names as its `in_progress` row: that step
+  // really does continue into the next turn, and closing it here would make the next turn reopen
+  // a step that never stopped.
+  const running = runningStep(next);
+  if (!running) return next;
+  const inProgress = inProgressStepIndex(next);
+  if (isFiniteNumber(inProgress) && inProgress === running.index) return next;
+  const durations =
+    running.startedAt > 0 ? [...next.durations, time - running.startedAt].filter((value) => value > 0) : next.durations;
+  const steps = next.steps.map((step) => (step.index === running.index ? closeStep(step, time) : step));
+  return withPercents({ ...next, steps, durations }, time);
 }
 
 function foldReport(state, event, time) {
@@ -2225,6 +2371,8 @@ function nodeView(node) {
     files: node.files.map((file) => ({ path: file.path, action: file.action })),
     resultHead: node.resultHead,
     error: node.error,
+    // the boolean the browser half colours by; see newNode.settled
+    result: node.settled === true,
     at: node.at,
     durationMs: node.durationMs,
     // the detail's meta line names the event that produced the node. Null for the
@@ -2341,9 +2489,41 @@ function syncToTodos(state) {
     const key = normalizeTitle(item.content);
     if (key === "" || seen.has(key)) continue;
     seen.add(key);
-    wanted.push({ key, title, status: item.status });
+    // `planIndex` MUST be parsed from the RAW content, not from `title`: `stripOrdinal`
+    // already removed the "3." prefix, so `planIndexOf(title)` always returned null and every
+    // created row lost its ordinal. Measured 2026-10-29 on session 164e339f: a 14-row numbered
+    // table produced rows whose planIndex fell back to POSITION, so row 9 ("9. n8n 主工作流…")
+    // was stamped planIndex 2 and `applyPlanToView` then rewrote it with plan step 2's title and
+    // status — the map showed steps 3–7 twice and the wrong step as running.
+    wanted.push({ key, title, status: item.status, planIndex: planIndexOf(item.content) });
   }
   if (wanted.length === 0) return state;
+  // The row's status is the ONE statement of a step's lifecycle: `todo/write` replaces the whole
+  // table every time, so a matched row must not inherit the status of whatever record the matcher
+  // bound it to. Without this pass a row the model has not started kept the `done` of an old record
+  // (a card at 100 % next to an empty todo), while an `in_progress` row showed as `pending` because
+  // the record it landed on was still pending — both seen in one session on 2026-10-30.
+  const rowStatus = (step, row) => {
+    if (row.status === "completed") return step.status === STEP_STATUS.done ? step : closeStep(step, state.asOf || 0);
+    // A closed record cannot speak for an open row. When the table takes a row back to
+    // in_progress/pending, the record it is bound to may be a step this table already closed,
+    // or an older row a reworded title landed on. Keeping that percent and high-water renders
+    // a brand-new first row at 100 % the instant it appears.
+    const reopened = step.status === STEP_STATUS.done || step.status === STEP_STATUS.failed;
+    const carried = reopened
+      ? { percent: null, percentSource: "none", maxPercent: 0 }
+      : { percent: step.percent, percentSource: step.percentSource, maxPercent: step.maxPercent };
+    if (row.status === "in_progress") {
+      return {
+        ...step,
+        ...carried,
+        status: STEP_STATUS.running,
+        endedAt: null,
+        startedAt: reopened || !step.startedAt ? state.asOf || 0 : step.startedAt,
+      };
+    }
+    return { ...step, ...carried, status: STEP_STATUS.pending, endedAt: null, startedAt: 0, percent: null, percentSource: "none" };
+  };
 
   const byKey = new Map();
   for (const step of state.steps) {
@@ -2390,14 +2570,30 @@ function syncToTodos(state) {
     // (2) TEXT SHARE as the fallback for a re-numbered or re-ordered table.
     let candidate = null;
     const slot = wanted.indexOf(row);
-    const sameSlot = orphans.find((step) => !used.has(step.index) && step.index === slot);
+    // An explicit ordinal OUTRANKS position. A numbered table states which plan step each row
+    // IS; letting the slot win anyway pairs row 9 with whatever orphan happens to sit at
+    // position 8, and the row inherits that orphan's planIndex. Measured 2026-10-29 on session
+    // 164e339f: after a 7-row unnumbered table was replaced by a 14-row numbered one, row 9
+    // took the leftover row 2 and the map rendered plan steps 3-7 twice.
+    const ordinalConflict = (step) =>
+      row.planIndex !== null && Number.isInteger(step.planIndex) && step.planIndex !== row.planIndex;
+    const sameSlot = orphans.find(
+      (step) => !used.has(step.index) && step.index === slot && !ordinalConflict(step),
+    );
     if (sameSlot && (sameSlot.status === row.status || sameSlot.status === STEP_STATUS.running)) {
       candidate = sameSlot;
     }
+    if (candidate === null && row.planIndex !== null) {
+      const byOrdinal = orphans.find(
+        (step) => !used.has(step.index) && Number.isInteger(step.planIndex) && step.planIndex === row.planIndex,
+      );
+      if (byOrdinal) candidate = byOrdinal;
+    }
     if (candidate === null) {
       let bestShare = 0;
       for (const step of orphans) {
         if (used.has(step.index)) continue;
+        if (ordinalConflict(step)) continue;
         const other = normalizeTitle(step.title);
         const score = commonPrefix(other, row.key);
         if (score < REWORD_PREFIX_MIN) continue;
@@ -2417,7 +2613,7 @@ function syncToTodos(state) {
       // reworded title - the two did not match, so the nodes were dropped as orphans in the view.
       const oldKey = candidate.stepKey || normalizeTitle(candidate.title);
       const newKey = normalizeTitle(row.title);
-      const nextStep = { ...candidate, title: text(row.title, TITLE_LIMIT), stepKey: newKey };
+      const nextStep = rowStatus({ ...candidate, title: text(row.title, TITLE_LIMIT), stepKey: newKey }, row);
       reworded.set(oldKey, newKey);
       ordered.push(nextStep);
       origins.push(candidate.index);
@@ -2430,13 +2626,8 @@ function syncToTodos(state) {
     // node-remap nor the node attribution can ever find it.
     created.stepKey = row.key;
     created.startedAt = 0;
-    created.planIndex = planIndexOf(row.title) ?? undefined;
-    created.status = row.status === "completed" ? STEP_STATUS.done : STEP_STATUS.pending;
-    if (created.status === STEP_STATUS.done) {
-      created.percent = 100;
-      created.percentSource = "closed";
-      created.maxPercent = 100;
-    }
+    created.planIndex = row.planIndex ?? undefined;
+    Object.assign(created, rowStatus(created, row));
     ordered.push(created);
     origins.push(-1);
   }

package/src/orchestrator.mjs

@@ -37,6 +37,21 @@ export const PLAN_VERSION = 1;
 export const PLAN_ROOT = ".pae";
 export const PLAN_FILE = "orchestrator.json";
 
+/**
+ * Plan phases that are history rather than a live view.
+ *
+ * PAE's own vocabulary (dsh-plan-and-execute): none / planning / scheduled /
+ * executing / paused / completed / aborted. The last two never resume, and the
+ * file that carries them is never removed, so they must not speak for a row the
+ * session created after the plan ended.
+ */
+const TERMINAL_PHASES = new Set(["completed", "aborted"]);
+
+/** Is this normalized plan finished? True for completed and aborted. */
+export function planIsTerminal(plan) {
+  return isRecord(plan) && TERMINAL_PHASES.has(String(plan.phase ?? "").trim().toLowerCase());
+}
+
 /** Bounds. The plan is display data; a runaway file must not grow the session cache. */
 export const MAX_PLAN_STEPS = 200;
 export const MAX_STEP_REPORTS = 200;
@@ -197,9 +212,14 @@ export function normalizePlanDocument(raw, meta) {
   }
 
   const rawTask = typeof doc.task === "string" ? doc.task : "";
+  const phase = text(doc.phase, MAX_PHASE);
   const result = {
     ver: PLAN_VERSION,
-    phase: text(doc.phase, MAX_PHASE),
+    phase,
+ // Published as a boolean as well: the browser half decides card statuses from this
+ // section alone, and "is this plan finished" must not be re-derived from a string
+ // vocabulary in two places.
+    terminal: TERMINAL_PHASES.has(phase.trim().toLowerCase()),
     task: text(rawTask, MAX_TASK),
  // The first non-empty line, before flattening: it is the panel's header.
     taskTitle: line(rawTask, MAX_TASK_TITLE),
@@ -263,6 +283,10 @@ export function applyPlanToView(view, plan) {
   const normalized = isRecord(plan) ? plan : null;
   const result = { ...view, plan: normalized };
   if (normalized === null) return result;
+ // A finished plan is published for the detail page but patches nothing: its
+ // rows belong to a turn that is over, and the current todo table is the newer
+ // statement. See planIsTerminal.
+  if (planIsTerminal(normalized)) return result;
 
   if (normalized.taskTitle !== "") result.task = normalized.taskTitle;
 
@@ -300,6 +324,24 @@ export function applyPlanToView(view, plan) {
         }
       }
     }
+    // The plan's own `requiresConfirmation` is the OTHER half of the needs-confirmation flag:
+    // `buildView` derives the log half (an open approval, an unanswered question), and this
+    // adds the plan half. It belongs HERE because this is the only place that has both the
+    // normalised plan step and the view row it lands on. Measured 2026-10-29 on session
+    // 164e339f: plan steps 2 / 12 / 13 carry requiresConfirmation and the map showed none of
+    // them, while `pendingConfirmSteps` in fold.mjs only ever consulted the log.
+    //
+    // A finished step never carries the flag (the same rule `buildView` applies): a decision a
+    // done step was waiting on is history, not a request.
+    if (planStep.requiresConfirmation === true && step.status !== "done" && step.status !== "failed") {
+      const rows = Array.isArray(step.pendingConfirm) ? step.pendingConfirm : [];
+      if (!rows.some((row) => isRecord(row) && row.kind === "plan")) {
+        patch.pendingConfirm = [
+          ...rows,
+          { kind: "plan", label: planStep.title !== "" ? planStep.title : `第 ${planStep.index} 步`, at: 0 },
+        ];
+      }
+    }
     if (Object.keys(patch).length === 0) continue;
     steps[position] = { ...step, ...patch };
     changed = true;