diff --git a/packages/core/src/__tests__/task-fields.test.ts b/packages/core/src/__tests__/task-fields.test.ts
index a35e0c855d..5306ad9547 100644
--- a/packages/core/src/__tests__/task-fields.test.ts
+++ b/packages/core/src/__tests__/task-fields.test.ts
@@ -432,6 +432,81 @@ describe("store: updateWorkflowDefinition field-type change coercion (U11)", ()
     // y orphaned but retained.
     expect(got?.customFields).toEqual({ x: "a", y: "b" });
   });
+
+  // T1 (store.ts:12410): a field-schema edit that adds a new required+default
+  // field must backfill the default onto EVERY occupant, including occupants
+  // that currently hold no custom field values — not only ones already populated.
+  it("backfills a new required+default field onto occupants with no existing values", async () => {
+    const { taskId, workflowId } = await fieldedTaskAndWf([F({ id: "x", type: "string" })]);
+    // Occupant deliberately has NO custom field values stored.
+    const before = await store.getTask(taskId);
+    expect(before?.customFields ?? {}).toEqual({});
+
+    await store.updateWorkflowDefinition(workflowId, {
+      ir: irWith([
+        F({ id: "x", type: "string" }),
+        F({ id: "tier", type: "string", required: true, default: "bronze" }),
+      ]),
+    });
+
+    const got = await store.getTask(taskId);
+    expect(got?.customFields).toEqual({ tier: "bronze" });
+  });
+});
+
+// ── Archive → unarchive customFields round-trip ──────────────────────────────
+
+describe("store: archive → unarchive preserves customFields (T0)", () => {
+  const harness = createTaskStoreTestHarness();
+  let store: ReturnType<typeof harness.store>;
+
+  const irWith = (fields: WorkflowFieldDefinition[], name = "WF"): WorkflowIr =>
+    ({
+      version: "v2",
+      name,
+      columns: [
+        { id: "todo", name: "todo", traits: [] },
+        { id: "in-progress", name: "in-progress", traits: [] },
+        { id: "done", name: "done", traits: [] },
+      ],
+      nodes: [
+        { id: "start", kind: "start", column: "todo" },
+        { id: "end", kind: "end", column: "todo" },
+      ],
+      edges: [{ from: "start", to: "end" }],
+      fields,
+    }) as unknown as WorkflowIr;
+
+  beforeEach(async () => {
+    await harness.beforeEach();
+    store = harness.store();
+  });
+  afterEach(async () => {
+    await harness.afterEach();
+  });
+
+  it("restores customFields after an archive → unarchive round-trip", async () => {
+    const def = await (store as any).createWorkflowDefinition({
+      name: "WF",
+      ir: irWith([F({ id: "sev", type: "enum", options: enumOpts }), F({ id: "pts", type: "number" })]),
+    });
+    const t = await store.createTask({ description: "round-trip" });
+    await (store as any).selectTaskWorkflow(t.id, def.id);
+    await (store as any).updateTaskCustomFields(t.id, { sev: "high", pts: 5 });
+
+    // Move through the legacy transition chain to reach 'done', then archive.
+    await store.moveTask(t.id, "todo");
+    await store.moveTask(t.id, "in-progress");
+    await store.moveTask(t.id, "in-review");
+    await store.moveTask(t.id, "done");
+    const archived = await store.archiveTask(t.id);
+    expect(archived.column).toBe("archived");
+
+    const restored = await store.unarchiveTask(t.id);
+    expect(restored.customFields).toEqual({ sev: "high", pts: 5 });
+    const got = await store.getTask(t.id);
+    expect(got?.customFields).toEqual({ sev: "high", pts: 5 });
+  });
 });
 
 // ── JSON round-trip stability ────────────────────────────────────────────────
diff --git a/packages/core/src/store.ts b/packages/core/src/store.ts
index 85d706e40d..352b281004 100644
--- a/packages/core/src/store.ts
+++ b/packages/core/src/store.ts
@@ -11703,6 +11703,7 @@ export class TaskStore extends EventEmitter<TaskStoreEvents> {
       dependencies: entry.dependencies,
       steps: entry.steps,
       currentStep: entry.currentStep,
+      customFields: entry.customFields ?? undefined,
       size: entry.size,
       reviewLevel: entry.reviewLevel,
       prInfo: entry.prInfo,
@@ -12381,7 +12382,6 @@ ${stepsSection}`;
       if (fieldsChanged) {
         const occupantTaskIds = this.listWorkflowOccupantTaskIds(id, false);
         const occupantsByField = new Map<string, number>();
-        const occupantsWithFields: string[] = [];
         for (const taskId of occupantTaskIds) {
           const row = this.db.prepare("SELECT customFields FROM tasks WHERE id = ?").get(taskId) as
             | { customFields: string | null }
@@ -12389,8 +12389,11 @@ ${stepsSection}`;
           const values = row?.customFields
             ? (fromJson<Record<string, unknown>>(row.customFields) ?? {})
             : {};
+          // Incompatible-change detection only blocks on occupants that already
+          // HOLD a value for a field, so count only those. Reconciliation itself
+          // must still touch every occupant so new required+default fields get
+          // backfilled onto tasks that currently have no custom field values.
           if (Object.keys(values).length === 0) continue;
-          occupantsWithFields.push(taskId);
           for (const key of Object.keys(values)) {
             occupantsByField.set(key, (occupantsByField.get(key) ?? 0) + 1);
           }
@@ -12406,7 +12409,7 @@ ${stepsSection}`;
         pendingFieldReconcile = {
           oldFields,
           newFields,
-          occupantTaskIds: occupantsWithFields,
+          occupantTaskIds,
           coerce: updates.coerce,
         };
       }
diff --git a/packages/dashboard/app/api/legacy.ts b/packages/dashboard/app/api/legacy.ts
index 81e06dc866..8c4b40e8a6 100644
--- a/packages/dashboard/app/api/legacy.ts
+++ b/packages/dashboard/app/api/legacy.ts
@@ -5058,6 +5058,16 @@ export function fetchTraits(projectId?: string): Promise<TraitCatalogEntry[]> {
   );
 }
 
+/** Fetch the step-parser id catalog (built-ins + registered plugin parsers) for
+ *  the parse-steps node inspector (KTD-12). Registry-backed, read-only,
+ *  session-scoped. Mirrors fetchTraits. */
+export function fetchStepParsers(projectId?: string): Promise<string[]> {
+  const path = withProjectId("/step-parsers", projectId);
+  return dedupe(path, () =>
+    api<{ parsers: Array<{ id: string }> }>(path).then((res) => res.parsers.map((p) => p.id)),
+  );
+}
+
 /** Fetch a single workflow definition. */
 export function fetchWorkflow(id: string, projectId?: string): Promise<import("@fusion/core").WorkflowDefinition> {
   return api<import("@fusion/core").WorkflowDefinition>(withProjectId(`/workflows/${encodeURIComponent(id)}`, projectId));
diff --git a/packages/dashboard/app/components/TaskFieldsSection.tsx b/packages/dashboard/app/components/TaskFieldsSection.tsx
index 67d7cfb76e..db5eaa730c 100644
--- a/packages/dashboard/app/components/TaskFieldsSection.tsx
+++ b/packages/dashboard/app/components/TaskFieldsSection.tsx
@@ -30,7 +30,7 @@
  * nothing (null), so a task on a field-less workflow is byte-identical to
  * today's UI (snapshot-guarded by the test suite).
  */
-import { useCallback, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { useTranslation } from "react-i18next";
 import { ChevronRight, ChevronDown } from "lucide-react";
 import type {
@@ -92,10 +92,22 @@ function FieldRow({ field, value, onSave, error, readOnly }: FieldRowProps) {
   const fieldError = error && error.fieldId === field.id ? error : null;
   const disabled = readOnly || !onSave;
 
+  // Serialize per-field saves: rapid chip/toggle/blur edits to the same field
+  // would otherwise fire overlapping PATCHes whose responses can resolve out of
+  // order, letting an older request clobber a newer selection. We chain each
+  // save onto the previous one for this field so they apply in click order.
+  const saveTailRef = useRef<Promise<void>>(Promise.resolve());
   const commit = useCallback(
     (next: unknown) => {
       if (!onSave) return;
-      void onSave({ [field.id]: next });
+      const run = () => onSave({ [field.id]: next });
+      // Run after any in-flight save for this field, regardless of its outcome,
+      // so a rejected save doesn't permanently break the chain. The tail is kept
+      // settled-always (.catch) so its own rejection never floats unhandled and
+      // never blocks the next queued save — the caller surfaces failures via
+      // `error`, so we intentionally swallow here for ordering purposes only.
+      const prev = saveTailRef.current;
+      saveTailRef.current = prev.then(run, run).catch(() => {});
     },
     [onSave, field.id],
   );
@@ -103,6 +115,29 @@ function FieldRow({ field, value, onSave, error, readOnly }: FieldRowProps) {
   const labelId = `task-field-label-${field.id}`;
   const controlId = `task-field-${field.id}`;
 
+  // Prop-derived string value for the uncontrolled-style inputs (date / text /
+  // string / number / url). These were previously rendered with `defaultValue`,
+  // which only seeds on mount — so an external refresh of `customFields` (SSE or
+  // a save round-trip) left the DOM showing a stale value, and a later blur would
+  // commit that stale value back over the refreshed one. We make them controlled
+  // and re-sync to the latest prop whenever it changes.
+  const propTextValue =
+    field.type === "date"
+      ? typeof value === "string"
+        ? value.slice(0, 10)
+        : ""
+      : field.type === "number"
+        ? typeof value === "number"
+          ? String(value)
+          : ""
+        : typeof value === "string"
+          ? value
+          : "";
+  const [localValue, setLocalValue] = useState(propTextValue);
+  useEffect(() => {
+    setLocalValue(propTextValue);
+  }, [propTextValue]);
+
   const renderControl = () => {
     // enum → select / radio / chips (single)
     if (field.type === "enum") {
@@ -218,18 +253,18 @@ function FieldRow({ field, value, onSave, error, readOnly }: FieldRowProps) {
 
     // date → date input
     if (field.type === "date") {
-      const current = typeof value === "string" ? value.slice(0, 10) : "";
       return (
         <input
           id={controlId}
           type="date"
           className="task-field-input"
-          defaultValue={current}
+          value={localValue}
           disabled={disabled}
           aria-labelledby={labelId}
+          onChange={(e) => setLocalValue(e.target.value)}
           onBlur={(e) => {
             const next = e.target.value;
-            if (next === current) return;
+            if (next === propTextValue) return;
             commit(next === "" ? null : next);
           }}
         />
@@ -238,17 +273,17 @@ function FieldRow({ field, value, onSave, error, readOnly }: FieldRowProps) {
 
     // text → textarea
     if (field.type === "text") {
-      const current = typeof value === "string" ? value : "";
       return (
         <textarea
           id={controlId}
           className="task-field-textarea"
-          defaultValue={current}
+          value={localValue}
           disabled={disabled}
           aria-labelledby={labelId}
           rows={3}
+          onChange={(e) => setLocalValue(e.target.value)}
           onBlur={(e) => {
-            if (e.target.value === current) return;
+            if (e.target.value === propTextValue) return;
             commit(e.target.value === "" ? null : e.target.value);
           }}
         />
@@ -256,21 +291,18 @@ function FieldRow({ field, value, onSave, error, readOnly }: FieldRowProps) {
     }
 
     // number / url / string → validated input
-    const current =
-      field.type === "number"
-        ? (typeof value === "number" ? String(value) : "")
-        : (typeof value === "string" ? value : "");
     return (
       <input
         id={controlId}
         type={field.type === "number" ? "number" : field.type === "url" ? "url" : "text"}
         className="task-field-input"
-        defaultValue={current}
+        value={localValue}
         disabled={disabled}
         aria-labelledby={labelId}
+        onChange={(e) => setLocalValue(e.target.value)}
         onBlur={(e) => {
           const raw = e.target.value;
-          if (raw === current) return;
+          if (raw === propTextValue) return;
           if (raw === "") {
             commit(null);
             return;
diff --git a/packages/dashboard/app/components/WorkflowNodeEditor.tsx b/packages/dashboard/app/components/WorkflowNodeEditor.tsx
index 1afbb8eb00..2f97816815 100644
--- a/packages/dashboard/app/components/WorkflowNodeEditor.tsx
+++ b/packages/dashboard/app/components/WorkflowNodeEditor.tsx
@@ -54,7 +54,7 @@ import {
   FOREACH_CHILD_X,
   FOREACH_CHILD_Y,
 } from "./workflow-flow-mapping";
-import { fetchTraits, type TraitCatalogEntry } from "../api";
+import { fetchTraits, fetchStepParsers, type TraitCatalogEntry } from "../api";
 import { WorkflowColumnPanel } from "./WorkflowColumnPanel";
 import { WorkflowFieldsPanel } from "./WorkflowFieldsPanel";
 import type { WorkflowFieldDefinition } from "../api";
@@ -93,8 +93,9 @@ function newNodeId(): string {
   return `n-${Date.now().toString(36)}-${nodeSeq}`;
 }
 
-/** Built-in step parsers (KTD-12). Hardcoded for now; TODO: source from the live
- *  parser registry once a catalog endpoint exists (incl. plugin parsers). */
+/** Built-in step parsers (KTD-12). Fallback list when the live catalog endpoint
+ *  (GET /api/step-parsers) is unreachable; the editor otherwise merges in any
+ *  registered plugin parsers fetched from the registry. */
 const BUILTIN_STEP_PARSERS = ["step-headings", "json-steps"] as const;
 
 /** Step-review verdict outcomes (KTD-4), authored as `outcome:<verdict>` edge
@@ -138,6 +139,10 @@ function InnerEditor({
   // v2 custom field definitions the editor is authoring (KTD-13/14, U13).
   const [fields, setFields] = useState<WorkflowFieldDefinition[]>([]);
   const [traitCatalog, setTraitCatalog] = useState<TraitCatalogEntry[]>([]);
+  // Step-parser ids for the parse-steps inspector (KTD-12). Seeded with the
+  // built-in pair so the select is never empty; replaced by the live catalog
+  // (built-ins + plugin parsers) once GET /api/step-parsers resolves.
+  const [stepParsers, setStepParsers] = useState<string[]>([...BUILTIN_STEP_PARSERS]);
 
   const activeWorkflow = useMemo(() => workflows.find((w) => w.id === activeId), [workflows, activeId]);
   const isBuiltin = !!activeWorkflow && isBuiltinWorkflowId(activeWorkflow.id);
@@ -158,6 +163,23 @@ function InnerEditor({
     };
   }, [projectId]);
 
+  // Step-parser catalog (KTD-12) for the parse-steps inspector's parser select.
+  // Merges built-ins with any registered plugin parsers; falls back to the
+  // built-in pair if the fetch fails so the select always has options.
+  useEffect(() => {
+    let cancelled = false;
+    fetchStepParsers(projectId)
+      .then((ids) => {
+        if (!cancelled && ids.length > 0) setStepParsers(ids);
+      })
+      .catch(() => {
+        // Non-fatal: keep the built-in fallback already in state.
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [projectId]);
+
   // Composition violations (client mirror of validateColumnTraits).
   const columnViolations: TraitViolation[] = useMemo(
     () => (columns.length ? validateColumnsClient(columns, traitCatalog) : []),
@@ -1181,12 +1203,17 @@ function InnerEditor({
                   )}
                   <label className="wf-field">
                     <span>{t("workflowNodes.parseParser", "Parser")}</span>
-                    {/* TODO: source from the live parser registry (incl. plugin parsers). */}
+                    {/* Sourced from the live parser registry via GET /api/step-parsers
+                        (built-ins + plugin parsers), with a built-in fallback. The
+                        node's current parser is always included so a plugin parser
+                        the catalog missed never silently drops out of the select. */}
                     <select
                       value={String(selectedNode.data.config?.parser ?? "step-headings")}
                       onChange={(e) => updateSelectedData({ config: { parser: e.target.value } })}
                     >
-                      {BUILTIN_STEP_PARSERS.map((p) => (
+                      {Array.from(
+                        new Set([String(selectedNode.data.config?.parser ?? "step-headings"), ...stepParsers]),
+                      ).map((p) => (
                         <option key={p} value={p}>
                           {p}
                         </option>
diff --git a/packages/dashboard/app/components/__tests__/TaskFieldsSection.test.tsx b/packages/dashboard/app/components/__tests__/TaskFieldsSection.test.tsx
index 30b927ef49..9ff0b2e405 100644
--- a/packages/dashboard/app/components/__tests__/TaskFieldsSection.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskFieldsSection.test.tsx
@@ -171,6 +171,96 @@ describe("TaskFieldsSection", () => {
     expect(body.textContent).toContain("stale");
   });
 
+  it("serializes per-field saves so a stale response can't clobber a newer one (T2)", async () => {
+    // Two overlapping chip clicks: the FIRST save resolves slowly, the second
+    // quickly. With serialization the second onSave must not start until the
+    // first settles, guaranteeing the newer selection is applied last.
+    const resolvers: Array<() => void> = [];
+    const onSave = vi.fn().mockImplementation(
+      () =>
+        new Promise<void>((resolve) => {
+          resolvers.push(resolve);
+        }),
+    );
+    const field: WorkflowFieldDefinition = { ...enumField, render: { placement: "detail", widget: "chips" } };
+    render(<TaskFieldsSection fieldDefs={[field]} customFields={{}} onSave={onSave} />);
+    const low = screen.getByRole("button", { name: "Low" });
+    const high = screen.getByRole("button", { name: "High" });
+
+    fireEvent.click(low);
+    fireEvent.click(high);
+
+    // Only the first save has started; the second is queued behind it.
+    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
+    expect(onSave).toHaveBeenNthCalledWith(1, { severity: "low" });
+    expect(resolvers).toHaveLength(1);
+
+    // Resolve the first; the second now runs.
+    resolvers[0]();
+    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(2));
+    expect(onSave).toHaveBeenNthCalledWith(2, { severity: "high" });
+  });
+
+  it("keeps the chain alive after a rejected save (T2)", async () => {
+    // First save rejects; the chain must recover so a later edit still saves.
+    const onSave = vi
+      .fn()
+      .mockRejectedValueOnce(new Error("boom"))
+      .mockResolvedValue(undefined);
+    const field: WorkflowFieldDefinition = { id: "owner", name: "Owner", type: "string", render: { placement: "detail" } };
+    render(<TaskFieldsSection fieldDefs={[field]} customFields={{}} onSave={onSave} />);
+    const input = screen.getByLabelText("Owner") as HTMLInputElement;
+
+    fireEvent.change(input, { target: { value: "a" } });
+    fireEvent.blur(input);
+    await waitFor(() => expect(onSave).toHaveBeenNthCalledWith(1, { owner: "a" }));
+
+    fireEvent.change(input, { target: { value: "ab" } });
+    fireEvent.blur(input);
+    await waitFor(() => expect(onSave).toHaveBeenNthCalledWith(2, { owner: "ab" }));
+  });
+
+  it("text input re-syncs to refreshed customFields after mount (T3)", () => {
+    const onSave = vi.fn().mockResolvedValue(undefined);
+    const field: WorkflowFieldDefinition = { id: "owner", name: "Owner", type: "string", render: { placement: "detail" } };
+    const { rerender } = render(
+      <TaskFieldsSection fieldDefs={[field]} customFields={{ owner: "alice" }} onSave={onSave} />,
+    );
+    const input = screen.getByLabelText("Owner") as HTMLInputElement;
+    expect(input.value).toBe("alice");
+    // External refresh (SSE / save round-trip) — uncontrolled inputs would keep
+    // showing "alice"; controlled inputs must reflect the new prop value.
+    rerender(<TaskFieldsSection fieldDefs={[field]} customFields={{ owner: "bob" }} onSave={onSave} />);
+    expect((screen.getByLabelText("Owner") as HTMLInputElement).value).toBe("bob");
+  });
+
+  it("a stale blur does not overwrite a refreshed value (T3)", () => {
+    const onSave = vi.fn().mockResolvedValue(undefined);
+    const field: WorkflowFieldDefinition = { id: "owner", name: "Owner", type: "string", render: { placement: "detail" } };
+    const { rerender } = render(
+      <TaskFieldsSection fieldDefs={[field]} customFields={{ owner: "alice" }} onSave={onSave} />,
+    );
+    // External refresh to "bob" while the field still holds the old DOM value.
+    rerender(<TaskFieldsSection fieldDefs={[field]} customFields={{ owner: "bob" }} onSave={onSave} />);
+    const input = screen.getByLabelText("Owner") as HTMLInputElement;
+    // Blur with the refreshed value present → no spurious commit of the stale value.
+    fireEvent.blur(input);
+    expect(onSave).not.toHaveBeenCalled();
+  });
+
+  it("date input re-syncs to refreshed customFields after mount (T3)", () => {
+    const onSave = vi.fn().mockResolvedValue(undefined);
+    const field: WorkflowFieldDefinition = { id: "due", name: "Due", type: "date", render: { placement: "detail" } };
+    const { rerender } = render(
+      <TaskFieldsSection fieldDefs={[field]} customFields={{ due: "2026-06-04T00:00:00.000Z" }} onSave={onSave} />,
+    );
+    expect((screen.getByLabelText("Due") as HTMLInputElement).value).toBe("2026-06-04");
+    rerender(
+      <TaskFieldsSection fieldDefs={[field]} customFields={{ due: "2026-07-01T00:00:00.000Z" }} onSave={onSave} />,
+    );
+    expect((screen.getByLabelText("Due") as HTMLInputElement).value).toBe("2026-07-01");
+  });
+
   it("does not call onSave when readOnly", () => {
     const onSave = vi.fn();
     render(<TaskFieldsSection fieldDefs={[enumField]} customFields={{ severity: "low" }} onSave={onSave} readOnly />);
diff --git a/packages/dashboard/app/components/__tests__/WorkflowNodeEditor.test.tsx b/packages/dashboard/app/components/__tests__/WorkflowNodeEditor.test.tsx
index 81f36a4b79..f220ce674c 100644
--- a/packages/dashboard/app/components/__tests__/WorkflowNodeEditor.test.tsx
+++ b/packages/dashboard/app/components/__tests__/WorkflowNodeEditor.test.tsx
@@ -11,13 +11,14 @@ vi.mock("../../api", () => ({
   deleteWorkflow: vi.fn(),
   compileWorkflow: vi.fn(),
   fetchTraits: vi.fn(),
+  fetchStepParsers: vi.fn(),
   fetchModels: vi.fn(),
   fetchAgents: vi.fn(),
   fetchDiscoveredSkills: vi.fn(),
 }));
 
 import { fireEvent } from "@testing-library/react";
-import { fetchWorkflows, fetchTraits, updateWorkflow, compileWorkflow, createWorkflow, fetchModels } from "../../api";
+import { fetchWorkflows, fetchTraits, fetchStepParsers, updateWorkflow, compileWorkflow, createWorkflow, fetchModels } from "../../api";
 import type { TraitCatalogEntry } from "../../api";
 import { WorkflowNodeEditor } from "../WorkflowNodeEditor";
 
@@ -122,6 +123,7 @@ describe("WorkflowNodeEditor", () => {
   beforeEach(() => {
     vi.mocked(fetchWorkflows).mockResolvedValue([]);
     vi.mocked(fetchTraits).mockResolvedValue(TRAIT_CATALOG);
+    vi.mocked(fetchStepParsers).mockResolvedValue(["step-headings", "json-steps"]);
   });
 
   afterEach(() => {
@@ -145,6 +147,7 @@ describe("WorkflowNodeEditor", () => {
 describe("WorkflowNodeEditor — U10 columns/traits/holds", () => {
   beforeEach(() => {
     vi.mocked(fetchTraits).mockResolvedValue(TRAIT_CATALOG);
+    vi.mocked(fetchStepParsers).mockResolvedValue(["step-headings", "json-steps"]);
   });
   afterEach(() => {
     cleanup();
@@ -321,6 +324,7 @@ function stepwiseDef(): WorkflowDefinition {
 describe("WorkflowNodeEditor — U8 step-inversion authoring", () => {
   beforeEach(() => {
     vi.mocked(fetchTraits).mockResolvedValue(TRAIT_CATALOG);
+    vi.mocked(fetchStepParsers).mockResolvedValue(["step-headings", "json-steps"]);
   });
   afterEach(() => {
     cleanup();
@@ -466,6 +470,40 @@ describe("WorkflowNodeEditor — U8 step-inversion authoring", () => {
     expect(parserSel.value).toBe("json-steps");
   });
 
+  it("offers plugin step parsers from the live catalog (KTD-12)", async () => {
+    vi.mocked(fetchStepParsers).mockResolvedValue([
+      "step-headings",
+      "json-steps",
+      "plugin:acme:yaml-steps",
+    ]);
+    vi.mocked(fetchWorkflows).mockResolvedValue([stepwiseDef()]);
+    render(<WorkflowNodeEditor isOpen onClose={() => {}} addToast={() => {}} />);
+    const parseNode = await screen.findByTestId("wf-node-parse-steps");
+    fireEvent.click(parseNode);
+    const parserSel = (await screen.findByText("Parser")).parentElement!.querySelector("select")! as HTMLSelectElement;
+    // The plugin parser option becomes available once the catalog resolves...
+    await waitFor(() =>
+      expect(
+        Array.from(parserSel.options).some((o) => o.value === "plugin:acme:yaml-steps"),
+      ).toBe(true),
+    );
+    // ...and is selectable.
+    fireEvent.change(parserSel, { target: { value: "plugin:acme:yaml-steps" } });
+    expect(parserSel.value).toBe("plugin:acme:yaml-steps");
+  });
+
+  it("falls back to the built-in parser pair when the catalog fetch fails", async () => {
+    vi.mocked(fetchStepParsers).mockRejectedValue(new Error("offline"));
+    vi.mocked(fetchWorkflows).mockResolvedValue([stepwiseDef()]);
+    render(<WorkflowNodeEditor isOpen onClose={() => {}} addToast={() => {}} />);
+    const parseNode = await screen.findByTestId("wf-node-parse-steps");
+    fireEvent.click(parseNode);
+    const parserSel = (await screen.findByText("Parser")).parentElement!.querySelector("select")! as HTMLSelectElement;
+    const values = Array.from(parserSel.options).map((o) => o.value);
+    expect(values).toContain("step-headings");
+    expect(values).toContain("json-steps");
+  });
+
   it("edits a code node source and timeout", async () => {
     vi.mocked(fetchWorkflows).mockResolvedValue([v2Def()]);
     render(<WorkflowNodeEditor isOpen onClose={() => {}} addToast={() => {}} />);
@@ -501,6 +539,7 @@ function builtinStepwiseDef(): WorkflowDefinition {
 describe("WorkflowNodeEditor — built-in stepwise selection render path", () => {
   beforeEach(() => {
     vi.mocked(fetchTraits).mockResolvedValue(TRAIT_CATALOG);
+    vi.mocked(fetchStepParsers).mockResolvedValue(["step-headings", "json-steps"]);
   });
   afterEach(() => {
     cleanup();
diff --git a/packages/dashboard/src/routes/__tests__/step-parsers-route.test.ts b/packages/dashboard/src/routes/__tests__/step-parsers-route.test.ts
new file mode 100644
index 0000000000..ee7ba9ef18
--- /dev/null
+++ b/packages/dashboard/src/routes/__tests__/step-parsers-route.test.ts
@@ -0,0 +1,65 @@
+// @vitest-environment node
+//
+// KTD-12: HTTP coverage for GET /api/step-parsers — the parse-steps node
+// inspector's parser catalog. Mirrors GET /api/traits: registry-backed,
+// read-only, session-scoped. Exercises the route end-to-end against a REAL
+// TaskStore via createApiRoutes:
+//   - built-ins (step-headings, json-steps) are always present
+//   - a registered plugin parser (plugin:<id>:<parser>) surfaces in the list
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import express from "express";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { TaskStore, registerStepParser, unregisterStepParser } from "@fusion/core";
+import { createApiRoutes } from "../../routes.js";
+import { request as REQUEST } from "../../test-request.js";
+
+const PLUGIN_PARSER_ID = "plugin:acme:yaml-steps";
+
+describe("GET /api/step-parsers", () => {
+  let store: TaskStore;
+  let rootDir: string;
+  let globalDir: string;
+  let app: express.Express;
+
+  beforeEach(async () => {
+    rootDir = mkdtempSync(join(tmpdir(), "sp-route-root-"));
+    globalDir = mkdtempSync(join(tmpdir(), "sp-route-global-"));
+    store = new TaskStore(rootDir, globalDir, { inMemoryDb: true });
+    await store.init();
+
+    app = express();
+    app.use(express.json());
+    app.use("/api", createApiRoutes(store));
+  });
+
+  afterEach(() => {
+    // Tear down the plugin parser registered in the relevant test (idempotent).
+    unregisterStepParser(PLUGIN_PARSER_ID);
+    store.close();
+    rmSync(rootDir, { recursive: true, force: true });
+    rmSync(globalDir, { recursive: true, force: true });
+  });
+
+  const get = (path: string) => REQUEST(app, "GET", path);
+
+  it("returns the built-in parsers", async () => {
+    const res = await get("/api/step-parsers");
+    expect(res.status).toBe(200);
+    const body = res.body as { parsers: Array<{ id: string }> };
+    const ids = body.parsers.map((p) => p.id);
+    expect(ids).toContain("step-headings");
+    expect(ids).toContain("json-steps");
+  });
+
+  it("includes a registered plugin parser", async () => {
+    registerStepParser({ id: PLUGIN_PARSER_ID, parse: () => ({ steps: [] }) });
+    const res = await get("/api/step-parsers");
+    expect(res.status).toBe(200);
+    const ids = (res.body as { parsers: Array<{ id: string }> }).parsers.map((p) => p.id);
+    expect(ids).toContain(PLUGIN_PARSER_ID);
+    expect(ids).toContain("step-headings");
+  });
+});
diff --git a/packages/dashboard/src/routes/register-workflow-routes.ts b/packages/dashboard/src/routes/register-workflow-routes.ts
index fcca66624b..d8b8ed2556 100644
--- a/packages/dashboard/src/routes/register-workflow-routes.ts
+++ b/packages/dashboard/src/routes/register-workflow-routes.ts
@@ -1,5 +1,5 @@
 import type { WorkflowIr, WorkflowIrNode } from "@fusion/core";
-import { ColumnTraitValidationError, OccupiedColumnsError, InvalidRehomeTargetError, WorkflowCompileError, WorkflowIrError, compileWorkflowToSteps, listTraits } from "@fusion/core";
+import { ColumnTraitValidationError, OccupiedColumnsError, InvalidRehomeTargetError, WorkflowCompileError, WorkflowIrError, compileWorkflowToSteps, listTraits, listStepParsers } from "@fusion/core";
 import { validateCodeNodeSources } from "@fusion/engine";
 import { ApiError, badRequest, conflict, notFound } from "../api-error.js";
 import { emitWorkflowSseEvent } from "../sse.js";
@@ -67,6 +67,24 @@ export function registerWorkflowRoutes(ctx: ApiRoutesContext): void {
     }
   });
 
+  // GET /api/step-parsers — step-parser catalog for the parse-steps node
+  // inspector (KTD-12). Returns the registry's listStepParsers() ids (built-ins
+  // plus any registered plugin parsers), mirroring GET /api/traits: registry-
+  // backed, read-only, and session-scoped via getProjectContext. The editor
+  // falls back to the built-in pair if this fetch fails, so it adds no hard
+  // dependency on the project store beyond confirming the session.
+  router.get("/step-parsers", async (req, res) => {
+    try {
+      await getProjectContext(req);
+      res.json({
+        parsers: listStepParsers().map((p) => ({ id: p.id })),
+      });
+    } catch (err: unknown) {
+      if (err instanceof ApiError) throw err;
+      rethrowAsApiError(err);
+    }
+  });
+
   // GET /api/workflows — list all workflow definitions for the project.
   router.get("/workflows", async (req, res) => {
     try {
diff --git a/packages/engine/src/__tests__/agent-tools.test.ts b/packages/engine/src/__tests__/agent-tools.test.ts
index 8f48082085..a8155542f5 100644
--- a/packages/engine/src/__tests__/agent-tools.test.ts
+++ b/packages/engine/src/__tests__/agent-tools.test.ts
@@ -433,6 +433,40 @@ describe("createWorkflowGetTool", () => {
     expect(result.details).toMatchObject({ builtin: true });
   });
 
+  it("includes layout when the definition carries editor positions", async () => {
+    const layout = { n1: { x: 10, y: 20 } };
+    const store = {
+      getWorkflowDefinition: vi.fn().mockResolvedValue({
+        id: "WF-005",
+        name: "Laid out",
+        description: "",
+        ir: { version: "v2", name: "Laid out", columns: [], nodes: [{ id: "n1", kind: "step-execute" }], edges: [] },
+        layout,
+      }),
+    };
+    const tool = createWorkflowGetTool(store as any);
+    const result = await tool.execute("call-1", { workflow_id: "WF-005" } as any, undefined, undefined, {} as any);
+    const text = result.content[0]?.type === "text" ? result.content[0].text : "";
+    expect(JSON.parse(text).layout).toEqual(layout);
+    expect(result.details).toMatchObject({ workflowId: "WF-005", layout });
+  });
+
+  it("omits layout when the definition has none", async () => {
+    const store = {
+      getWorkflowDefinition: vi.fn().mockResolvedValue({
+        id: "WF-006",
+        name: "No layout",
+        description: "",
+        ir: { version: "v2", name: "No layout", columns: [], nodes: [], edges: [] },
+      }),
+    };
+    const tool = createWorkflowGetTool(store as any);
+    const result = await tool.execute("call-1", { workflow_id: "WF-006" } as any, undefined, undefined, {} as any);
+    const text = result.content[0]?.type === "text" ? result.content[0].text : "";
+    expect(JSON.parse(text)).not.toHaveProperty("layout");
+    expect(result.details).not.toHaveProperty("layout");
+  });
+
   it("returns an error result for an unknown id", async () => {
     const store = { getWorkflowDefinition: vi.fn().mockResolvedValue(undefined) };
     const tool = createWorkflowGetTool(store as any);
diff --git a/packages/engine/src/__tests__/code-node.test.ts b/packages/engine/src/__tests__/code-node.test.ts
index 31820c35fe..944b89f2c5 100644
--- a/packages/engine/src/__tests__/code-node.test.ts
+++ b/packages/engine/src/__tests__/code-node.test.ts
@@ -113,6 +113,24 @@ describe("validateCodeNodeSources (U14, save-time helper)", () => {
     const ir = { nodes: [codeNode("export default async () => ({ outcome: 'ok' });")] };
     expect(await validateCodeNodeSources(ir)).toEqual([]);
   });
+
+  it("does not crash on a malformed foreach template.nodes (non-array)", async () => {
+    const ir = {
+      nodes: [
+        // `nodes` is an object, not an array — a truthy-but-malformed config.
+        { id: "fe", kind: "foreach", config: { template: { nodes: { bogus: true } } } } as unknown as WorkflowIrNode,
+      ],
+    };
+    const failures = await validateCodeNodeSources(ir);
+    expect(failures).toEqual([{ nodeId: "fe", error: "foreach template.nodes must be an array" }]);
+  });
+
+  it("ignores a foreach with no template nodes", async () => {
+    const ir = {
+      nodes: [{ id: "fe", kind: "foreach", config: { template: {} } } as unknown as WorkflowIrNode],
+    };
+    expect(await validateCodeNodeSources(ir)).toEqual([]);
+  });
 });
 
 describe("createCodeNodeRunner result mapping (U14, seam-injected)", () => {
diff --git a/packages/engine/src/__tests__/workflow-graph-step-rerun.test.ts b/packages/engine/src/__tests__/workflow-graph-step-rerun.test.ts
index 68436922fe..376e5bb48e 100644
--- a/packages/engine/src/__tests__/workflow-graph-step-rerun.test.ts
+++ b/packages/engine/src/__tests__/workflow-graph-step-rerun.test.ts
@@ -27,8 +27,14 @@ describe("runGraphTaskStep (FIX 3)", () => {
       steps: stepStatus ? [{ name: "S1", status: stepStatus }] : [{ name: "S1", status: "pending" }],
     });
     const executor: any = new TaskExecutor(store, "/tmp/test", {});
-    // Stamp the active foreach context the seam would normally stamp.
-    if (active) executor.graphStepActiveContext.set("FN-001", { stepIndex: 0, ...active });
+    // Stamp the active foreach context the seam would normally stamp, keyed by
+    // the composite per-instance key (T7).
+    if (active) {
+      executor.graphStepActiveContext.set(
+        executor.graphActiveContextKey("FN-001", "inst-0"),
+        { stepIndex: 0, instanceId: "inst-0", ...active },
+      );
+    }
     return { executor, store };
   }
 
@@ -93,4 +99,55 @@ describe("runGraphTaskStep (FIX 3)", () => {
     const result = await executor.runGraphTaskStep(task, 0);
     expect(result.success).toBe(true);
   });
+
+  // T9: a RETHINK after a SUCCESSFUL pass must clear the memoized implementation
+  // so the rework re-runs implementation rather than re-awaiting the resolved memo.
+  it("clears the memo on rethink reset so implementation re-runs after a successful pass", async () => {
+    const { executor, store } = makeExecutor("done", { deferDoneToReview: true });
+    // No-op the git/step reset machinery — only the memo-clearing path matters here.
+    store.getTask = vi.fn().mockResolvedValue({ id: "FN-001", steps: [{ name: "S1", status: "done" }] });
+    let calls = 0;
+    executor.runImplementationPhase = vi.fn().mockImplementation(async () => {
+      calls += 1;
+      return { taskDone: true, modifiedFiles: [] };
+    });
+
+    // First pass: succeeds and the memo is now resolved.
+    const first = await executor.runGraphTaskStep(task, 0, "inst-0");
+    expect(first.success).toBe(true);
+    expect(calls).toBe(1);
+    expect(executor.graphStepRunOnce.has("FN-001")).toBe(true);
+
+    // RETHINK reset clears the SETTLED memo (guarded against in-flight clobber).
+    await executor.applyGraphRethinkReset("FN-001", { stepIndex: 0, instanceId: "inst-0" });
+    expect(executor.graphStepRunOnce.has("FN-001")).toBe(false);
+
+    // Rework re-run: implementation is invoked AGAIN (the bug re-awaited the memo).
+    const second = await executor.runGraphTaskStep(task, 0, "inst-0");
+    expect(second.success).toBe(true);
+    expect(calls).toBe(2);
+  });
+
+  // T7: parallel instances of the same task keep independent active contexts.
+  it("keys active context per-instance so parallel foreach instances do not clobber", async () => {
+    const store = createMockStore();
+    store.getTask = vi.fn().mockResolvedValue({ id: "FN-001", steps: [{ name: "S1", status: "in-progress" }] });
+    const executor: any = new TaskExecutor(store, "/tmp/test", {});
+    // Instance A defers done to review (non-terminal → success); instance B does not
+    // (non-terminal → failure). A per-task key would let one overwrite the other.
+    executor.graphStepActiveContext.set(
+      executor.graphActiveContextKey("FN-001", "inst-A"),
+      { stepIndex: 0, instanceId: "inst-A", deferDoneToReview: true },
+    );
+    executor.graphStepActiveContext.set(
+      executor.graphActiveContextKey("FN-001", "inst-B"),
+      { stepIndex: 0, instanceId: "inst-B", deferDoneToReview: false },
+    );
+    executor.runImplementationPhase = vi.fn().mockResolvedValue({ taskDone: false, modifiedFiles: [] });
+
+    const a = await executor.runGraphTaskStep(task, 0, "inst-A");
+    const b = await executor.runGraphTaskStep(task, 0, "inst-B");
+    expect(a.success).toBe(true); // review authors done
+    expect(b.success).toBe(false); // implementation left it incomplete
+  });
 });
diff --git a/packages/engine/src/__tests__/workflow-step-integration-cwd.test.ts b/packages/engine/src/__tests__/workflow-step-integration-cwd.test.ts
new file mode 100644
index 0000000000..d15a18f4b7
--- /dev/null
+++ b/packages/engine/src/__tests__/workflow-step-integration-cwd.test.ts
@@ -0,0 +1,77 @@
+// -nocheck
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import "./executor-test-helpers.js";
+import { TaskExecutor } from "../executor.js";
+import { createMockStore, resetExecutorMocks, mockedExecSync } from "./executor-test-helpers.js";
+
+/**
+ * T8: the integration rebase (and rebase --abort) must run in the INSTANCE
+ * worktree — the instance branch is checked out there, so running the rebase
+ * from the task's MAIN worktree fails with "branch is already checked out in
+ * another worktree". The final fast-forward merge still runs from the main
+ * worktree (it advances the target branch checked out there).
+ *
+ * The shared executor harness routes the promisified `exec` through the
+ * `execSync` mock (see executor-test-helpers), so we drive behavior + capture
+ * cwds via `mockedExecSync`.
+ */
+describe("buildForeachWorktreeDeps integrate() cwd (T8)", () => {
+  beforeEach(() => {
+    resetExecutorMocks();
+    mockedExecSync.mockReset();
+  });
+  afterEach(() => vi.restoreAllMocks());
+
+  function makeDeps() {
+    const store = createMockStore();
+    store.getTask = vi.fn().mockResolvedValue({
+      id: "FN-PAR",
+      worktree: "/main/wt",
+      branch: "fusion/FN-PAR",
+    });
+    const executor: any = new TaskExecutor(store, "/root", {});
+    // Stub createWorktree so allocateInstanceWorktree records the instance path
+    // without touching the filesystem.
+    executor.createWorktree = vi.fn(async (branch: string, _path: string) => ({
+      path: `/inst/step-${branch}`,
+      branch,
+    }));
+    const deps = executor.buildForeachWorktreeDeps({ id: "FN-PAR", branch: "fusion/FN-PAR" });
+    return { executor, deps };
+  }
+
+  it("runs rebase in the instance worktree and ff-merge in the main worktree", async () => {
+    const { deps } = makeDeps();
+    const alloc = await deps.allocateInstanceWorktree(2, "base-sha");
+    const calls: Array<{ cmd: string; cwd: string }> = [];
+    mockedExecSync.mockImplementation((cmd: string, opts: any) => {
+      calls.push({ cmd, cwd: String(opts?.cwd ?? "") });
+      return "deadbeef";
+    });
+
+    const result = await deps.integrationGitOps.integrate(alloc.branchName, 2);
+    expect(result.kind).toBe("integrated");
+
+    const rebase = calls.find((c) => c.cmd.startsWith("git rebase ") && !c.cmd.includes("--abort"));
+    const merge = calls.find((c) => c.cmd.startsWith("git merge --ff-only"));
+    expect(rebase?.cwd).toBe(`/inst/step-${alloc.branchName}`); // instance worktree
+    expect(merge?.cwd).toBe("/main/wt"); // main worktree
+  });
+
+  it("falls back to the main worktree cwd when no instance path is recorded", async () => {
+    // Defensive: an integrate() for a stepIndex with no allocated instance path
+    // (e.g. shared isolation) must not pass an undefined cwd to the rebase.
+    const { deps } = makeDeps();
+    const calls: Array<{ cmd: string; cwd: string }> = [];
+    mockedExecSync.mockImplementation((cmd: string, opts: any) => {
+      calls.push({ cmd, cwd: String(opts?.cwd ?? "") });
+      return "deadbeef";
+    });
+
+    const result = await deps.integrationGitOps.integrate("fusion/FN-PAR-step-9", 9);
+    expect(result.kind).toBe("integrated");
+    const rebase = calls.find((c) => c.cmd.startsWith("git rebase ") && !c.cmd.includes("--abort"));
+    expect(rebase?.cwd).toBe("/main/wt"); // fallback to main worktree, never undefined
+  });
+});
diff --git a/packages/engine/src/agent-tools.ts b/packages/engine/src/agent-tools.ts
index 602d5ef505..e680955baa 100644
--- a/packages/engine/src/agent-tools.ts
+++ b/packages/engine/src/agent-tools.ts
@@ -1080,10 +1080,14 @@ export function createWorkflowGetTool(store: TaskStore): ToolDefinition {
           description: def.description,
           builtin,
           ir: def.ir,
+          // Preserve editor node positions so a read→modify→write cycle does not
+          // strip the layout. May be absent for older/built-in defs; only include
+          // when present to keep the payload tidy.
+          ...(def.layout ? { layout: def.layout } : {}),
         };
         return {
           content: [{ type: "text" as const, text: JSON.stringify(payload, null, 2) }],
-          details: { workflowId: def.id, builtin },
+          details: { workflowId: def.id, builtin, ...(def.layout ? { layout: def.layout } : {}) },
         };
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       } catch (err: any) {
diff --git a/packages/engine/src/code-node-runner.ts b/packages/engine/src/code-node-runner.ts
index ad13ceeaee..a2ae287429 100644
--- a/packages/engine/src/code-node-runner.ts
+++ b/packages/engine/src/code-node-runner.ts
@@ -401,9 +401,15 @@ export async function validateCodeNodeSources(
   // Recurse into any foreach templates (code nodes are legal inside them, KTD-15).
   for (const node of ir.nodes) {
     if (node.kind !== "foreach") continue;
-    const template = (node.config as { template?: { nodes?: WorkflowIrNode[] } } | undefined)?.template;
-    if (template?.nodes) {
-      failures.push(...(await validateCodeNodeSources({ nodes: template.nodes })));
+    const template = (node.config as { template?: { nodes?: unknown } } | undefined)?.template;
+    // Guard with an explicit array check: a malformed config where `nodes` is a
+    // non-array truthy value would otherwise break the `for...of` inside the
+    // recursive validateCodeNodeSources call and bubble as a 500 rather than a
+    // clean validation failure.
+    if (Array.isArray(template?.nodes)) {
+      failures.push(...(await validateCodeNodeSources({ nodes: template.nodes as WorkflowIrNode[] })));
+    } else if (template?.nodes != null) {
+      failures.push({ nodeId: node.id, error: "foreach template.nodes must be an array" });
     }
   }
   return failures;
diff --git a/packages/engine/src/executor.ts b/packages/engine/src/executor.ts
index 628c3ad123..3a29414187 100644
--- a/packages/engine/src/executor.ts
+++ b/packages/engine/src/executor.ts
@@ -3249,9 +3249,16 @@ export class TaskExecutor {
    *  `deferDoneToReview` when deciding whether a non-terminal step is a success
    *  (review will author done) or a failure (implementation left it incomplete).
    *  Stamped by the stepExecute seam around the runTaskStep call; cleared with the
-   *  per-run pins. */
+   *  per-run pins. Keyed by `${task.id}:${instanceId}` so parallel foreach
+   *  instances of the same task cannot clobber each other's active context
+   *  (the read path threads the same instanceId through `runGraphTaskStep`). */
   private graphStepActiveContext = new Map<string, ForeachActiveContext>();
 
+  /** Composite key for {@link graphStepActiveContext}: per-instance, not per-task. */
+  private graphActiveContextKey(taskId: string, instanceId: string): string {
+    return `${taskId}:${instanceId}`;
+  }
+
   /** Tasks currently being orchestrated by the graph runner. Process-wide for
    *  the same reason as executingTaskLock (FN-4811): duplicate execute()
    *  invocations can arrive from different TaskExecutor instances in one
@@ -3378,7 +3385,11 @@ export class TaskExecutor {
       // Clear per-run step-inversion pins (KTD-8: pinned only for the run's life).
       this.graphStepSessionPinned.delete(task.id);
       this.graphStepRunOnce.delete(task.id);
-      this.graphStepActiveContext.delete(task.id);
+      // Per-instance keys: clear every instance slot owned by this task.
+      const ctxPrefix = `${task.id}:`;
+      for (const key of this.graphStepActiveContext.keys()) {
+        if (key.startsWith(ctxPrefix)) this.graphStepActiveContext.delete(key);
+      }
     }
   }
 
@@ -3656,17 +3667,26 @@ export class TaskExecutor {
         integrate: async (branchName, stepIndex): Promise<import("./step-integration.js").IntegrationAttemptResult> => {
           const cwd = await mainWorktree();
           const target = await mainBranch();
+          // The instance branch is checked out in its OWN worktree, so the rebase
+          // (which checks out `branchName`) must run THERE — running it from the
+          // main worktree fails with "branch is already checked out in another
+          // worktree". The final fast-forward merge still runs from the main
+          // worktree (it only advances `target`, which is checked out there).
+          const instanceCwd = instancePaths.get(stepIndex) ?? cwd;
           try {
-            // Rebase the instance branch onto the current main tip, then ff main.
-            await execAsync(`git rebase ${target} ${branchName}`, { cwd });
+            // Rebase the instance branch onto the current main tip (in its own
+            // worktree), then ff main from the main worktree.
+            await execAsync(`git rebase ${target} ${branchName}`, { cwd: instanceCwd });
             await execAsync(`git checkout ${target}`, { cwd });
             await execAsync(`git merge --ff-only ${branchName}`, { cwd });
             return { kind: "integrated", integratedAt: new Date().toISOString() };
           } catch (err) {
             // Conflict (or other rebase failure): classify via merger helper, abort.
-            const conflictedFiles = await getConflictedFiles(cwd);
+            // The rebase ran in the instance worktree, so conflicts live there and
+            // the abort must target that same cwd.
+            const conflictedFiles = await getConflictedFiles(instanceCwd);
             try {
-              await execAsync("git rebase --abort", { cwd });
+              await execAsync("git rebase --abort", { cwd: instanceCwd });
             } catch {
               // best-effort; leave the worktree recoverable.
             }
@@ -3808,6 +3828,28 @@ export class TaskExecutor {
    * the documented KTD-2 semantics; the git reset + step→pending are authoritative.
    */
   private async applyGraphRethinkReset(taskId: string, active: ForeachActiveContext): Promise<void> {
+    // Clear the memoized implementation pass so the next `runGraphTaskStep`
+    // re-executes (T9): the per-run pass is memoized in `graphStepRunOnce` keyed
+    // by task id and is normally only cleared on REJECTION. A RETHINK fires AFTER
+    // a SUCCESSFUL pass (a review verdict resets git/step state via this reset),
+    // so without clearing the memo the rework re-awaits the already-resolved
+    // promise and implementation never re-runs — leaving the instance permanently
+    // pending or falsely successful under `deferDoneToReview`. Mirrors the
+    // rejection-clear guard: only delete the memo when the stored promise is the
+    // SETTLED pass (a fresh in-flight attempt another caller installed is left
+    // untouched). At rethink time the pass under review has already resolved, so
+    // checking settled-ness avoids clobbering a concurrent re-dispatch.
+    const memo = this.graphStepRunOnce.get(taskId);
+    if (memo) {
+      let settled = false;
+      await Promise.race([memo.then(
+        () => { settled = true; },
+        () => { settled = true; },
+      ), Promise.resolve()]);
+      if (settled && this.graphStepRunOnce.get(taskId) === memo) {
+        this.graphStepRunOnce.delete(taskId);
+      }
+    }
     // Worktree isolation (KTD-11): reset the instance's OWN branch/worktree only —
     // sibling instances and the integration base are untouched, so the blast-radius
     // guard is STRUCTURAL (skipped) in this mode. Shared isolation resets the task's
@@ -4015,7 +4057,11 @@ export class TaskExecutor {
    *
    * Returns whether the targeted step ended up `done`/`skipped` in the projection.
    */
-  private async runGraphTaskStep(task: Task, stepIndex: number): Promise<{ success: boolean; error?: string }> {
+  private async runGraphTaskStep(
+    task: Task,
+    stepIndex: number,
+    instanceId?: string,
+  ): Promise<{ success: boolean; error?: string }> {
     // Pin step-session physics for the run before the implementation pass.
     this.graphStepSessionPinned.add(task.id);
 
@@ -4049,7 +4095,7 @@ export class TaskExecutor {
     // completes; a step-review node (when present) decides done-ness instead.
     try {
       const live = await this.store.getTask(task.id);
-      const active = this.foreachActiveForTask(task.id);
+      const active = this.foreachActiveForTask(task.id, instanceId);
       const status = live.steps[stepIndex]?.status;
       if (status === "done" || status === "skipped") return { success: true };
       // Step not terminal after the pass: when a review will author done-ness
@@ -4071,8 +4117,21 @@ export class TaskExecutor {
    *  the step driver can honor `deferDoneToReview`. The active context is threaded
    *  through the foreach sub-walk; we surface it via a per-task slot the
    *  step-execute seam stamps. Returns undefined outside a foreach instance. */
-  private foreachActiveForTask(taskId: string): ForeachActiveContext | undefined {
-    return this.graphStepActiveContext.get(taskId);
+  private foreachActiveForTask(taskId: string, instanceId?: string): ForeachActiveContext | undefined {
+    if (typeof instanceId === "string") {
+      const byInstance = this.graphStepActiveContext.get(this.graphActiveContextKey(taskId, instanceId));
+      if (byInstance) return byInstance;
+    }
+    // Fallback (single-instance / no instanceId threaded): return the sole slot
+    // owned by this task if exactly one exists.
+    const prefix = `${taskId}:`;
+    let only: ForeachActiveContext | undefined;
+    for (const [key, value] of this.graphStepActiveContext) {
+      if (!key.startsWith(prefix)) continue;
+      if (only) return undefined; // ambiguous: more than one instance active
+      only = value;
+    }
+    return only;
   }
 
   /** Seam implementations delegating to the legacy engine (KTD-1: delegate, never reimplement). */
@@ -4160,7 +4219,7 @@ export class TaskExecutor {
         const worktreePath = active.worktreePath || live.worktree || this.rootDir;
         // Stamp the active instance so `runGraphTaskStep` can honor
         // `deferDoneToReview` when judging a non-terminal step (FIX 3).
-        this.graphStepActiveContext.set(seamTask.id, active);
+        this.graphStepActiveContext.set(this.graphActiveContextKey(seamTask.id, active.instanceId), active);
         const result = await runTaskStep(
           {
             store: this.store,
@@ -4168,8 +4227,9 @@ export class TaskExecutor {
             // U6/U8: per-step session physics — graph-owned runs force
             // step-session mode for the run (KTD-2/KTD-8) regardless of the
             // runStepsInNewSessions setting. The agent authors the step's commit;
-            // this driver only observes (KTD-2).
-            runStep: (stepIndex) => this.runGraphTaskStep(seamTask, stepIndex),
+            // this driver only observes (KTD-2). Thread the instanceId so the
+            // active-context read is per-instance (parallel-foreach safe).
+            runStep: (stepIndex) => this.runGraphTaskStep(seamTask, stepIndex, active.instanceId),
           },
           { id: seamTask.id, steps: live.steps },
           active.stepIndex,
diff --git a/packages/i18n/locales/es/app.json b/packages/i18n/locales/es/app.json
index 3a844d6155..a23a920f09 100644
--- a/packages/i18n/locales/es/app.json
+++ b/packages/i18n/locales/es/app.json
@@ -6717,50 +6717,50 @@
   },
   "workflowNodes": {
     "advisory": "",
-    "codeNote": "Runs sandboxed TypeScript. Syntax is validated at save.",
-    "codeSource": "Source (TypeScript)",
-    "codeTimeout": "Timeout (ms)",
-    "edgeConditionLabel": "Condition: {{condition}}",
-    "edgeInspector": "Edge",
-    "edgeNoVerdict": "— success (no verdict) —",
-    "edgeRework": "Rework edge (loop back, bounded)",
-    "edgeReworkNote": "Rework edges are the only legal cycles — they loop back within the for-each step instance, bounded by Max rework cycles.",
-    "edgeVerdict": "Review verdict",
-    "failureCollect": "",
-    "failureFailFast": "",
-    "failurePolicy": "",
-    "foreachConcurrency": "Concurrency",
-    "foreachEmptyHint": "Drag a step-execute node here",
-    "foreachIsolation": "Isolation",
-    "foreachMaxRework": "Max rework cycles",
-    "foreachMode": "Mode",
-    "foreachNote": "Expands once per planned step. Drop a step-execute node (and optional step-review) into the region.",
-    "foreachParallel": "Parallel",
-    "foreachSequential": "Sequential",
-    "foreachShared": "Shared worktree",
-    "foreachWorktree": "Per-step worktree",
-    "gateBlocks": "",
-    "gateMode": "",
-    "joinAll": "",
-    "joinAny": "",
-    "joinMode": "",
-    "joinQuorum": "",
-    "mergeBoundaryNote": "",
+    "codeNote": "Ejecuta TypeScript en un entorno aislado. La sintaxis se valida al guardar.",
+    "codeSource": "Origen (TypeScript)",
+    "codeTimeout": "Tiempo de espera (ms)",
+    "edgeConditionLabel": "Condición: {{condition}}",
+    "edgeInspector": "Conexión",
+    "edgeNoVerdict": "— éxito (sin veredicto) —",
+    "edgeRework": "Conexión de revisión (bucle de retorno, acotado)",
+    "edgeReworkNote": "Las conexiones de revisión son los únicos ciclos permitidos: regresan dentro de la instancia del paso for-each, acotadas por los ciclos máximos de revisión.",
+    "edgeVerdict": "Veredicto de revisión",
+    "failureCollect": "Recopilar (esperar a todas)",
+    "failureFailFast": "Falla rápida (cancelar hermanas)",
+    "failurePolicy": "Al fallar una rama",
+    "foreachConcurrency": "Concurrencia",
+    "foreachEmptyHint": "Arrastra aquí un nodo de ejecución de paso",
+    "foreachIsolation": "Aislamiento",
+    "foreachMaxRework": "Ciclos máximos de revisión",
+    "foreachMode": "Modo",
+    "foreachNote": "Se expande una vez por cada paso planificado. Coloca un nodo de ejecución de paso (y opcionalmente de revisión de paso) en la región.",
+    "foreachParallel": "Paralelo",
+    "foreachSequential": "Secuencial",
+    "foreachShared": "Árbol de trabajo compartido",
+    "foreachWorktree": "Árbol de trabajo por paso",
+    "gateBlocks": "Compuerta (bloquea)",
+    "gateMode": "Modo de compuerta",
+    "joinAll": "Todas las ramas",
+    "joinAny": "Cualquier rama",
+    "joinMode": "Modo de unión",
+    "joinQuorum": "Quórum (n)",
+    "mergeBoundaryNote": "Los pasos antes de este marcador se ejecutan antes de la fusión; los posteriores, después de la fusión.",
     "parseArtifact": "Artifact",
     "parseParser": "Parser",
-    "quorumN": "",
-    "releaseCapacity": "",
-    "releaseCondition": "",
-    "releaseDependency": "",
-    "releaseExternal": "",
-    "releaseManual": "",
-    "releaseTimer": "",
+    "quorumN": "Recuento de quórum (n)",
+    "releaseCapacity": "Capacidad posterior",
+    "releaseCondition": "Condición de liberación",
+    "releaseDependency": "Dependencia completada",
+    "releaseExternal": "Evento externo",
+    "releaseManual": "Promoción manual",
+    "releaseTimer": "Temporizador",
     "reviewCode": "Code review",
     "reviewModel": "Review model (optional)",
     "reviewNote": "Verdicts route as outcome edges. Click an outgoing edge to set its verdict and rework behavior.",
     "reviewPlan": "Plan review",
     "reviewType": "Review type",
-    "splitNote": "",
+    "splitNote": "Las ramas se ejecutan de forma concurrente desde este nodo. No se permiten uniones de ejecución y fusión dentro de una rama.",
     "stepExecuteLabel": "Step execute"
   },
   "workflows": {
@@ -6800,37 +6800,37 @@
     "saveFailed": "No se pudo guardar el campo"
   },
   "workflowFields": {
-    "add": "Add field",
-    "addOption": "Add option",
-    "badge": "Render as badge",
-    "default": "Default",
-    "defaultLabel": "Default value",
-    "defaultTrue": "Default on",
-    "duplicateId": "A field with that id already exists",
-    "editId": "Edit id",
-    "empty": "No custom fields yet. Add a field to extend the task form and cards.",
-    "idLabel": "Field id",
-    "idWarn": "Changing the id discards values stored under the old id (remove + add).",
-    "nameLabel": "Field name",
-    "newFieldName": "New field",
-    "newOptionLabel": "Option 1",
-    "noDefault": "— none —",
-    "optionColor": "Option color",
-    "optionLabel": "Option label",
-    "optionN": "Option {{n}}",
-    "optionValue": "Option value",
-    "options": "Options",
-    "placement": "Placement",
-    "placementCard": "Card badge",
-    "placementDetail": "Detail (inline)",
-    "placementSection": "Detail section",
-    "readOnlyHint": "Built-in workflows are read-only — duplicate to edit",
-    "remove": "Remove field",
-    "removeOption": "Remove option",
-    "required": "Required",
-    "title": "Fields",
-    "typeLabel": "Type",
-    "widget": "Widget",
-    "widgetDefault": "Default"
+    "add": "Agregar campo",
+    "addOption": "Agregar opción",
+    "badge": "Mostrar como insignia",
+    "default": "Predeterminado",
+    "defaultLabel": "Valor predeterminado",
+    "defaultTrue": "Activado por defecto",
+    "duplicateId": "Ya existe un campo con ese id",
+    "editId": "Editar id",
+    "empty": "Aún no hay campos personalizados. Agrega un campo para ampliar el formulario y las tarjetas de la tarea.",
+    "idLabel": "Id del campo",
+    "idWarn": "Cambiar el id descarta los valores almacenados con el id anterior (quitar + agregar).",
+    "nameLabel": "Nombre del campo",
+    "newFieldName": "Nuevo campo",
+    "newOptionLabel": "Opción 1",
+    "noDefault": "— ninguno —",
+    "optionColor": "Color de la opción",
+    "optionLabel": "Etiqueta de la opción",
+    "optionN": "Opción {{n}}",
+    "optionValue": "Valor de la opción",
+    "options": "Opciones",
+    "placement": "Ubicación",
+    "placementCard": "Insignia de tarjeta",
+    "placementDetail": "Detalle (en línea)",
+    "placementSection": "Sección de detalle",
+    "readOnlyHint": "Los flujos de trabajo integrados son de solo lectura: duplica para editar",
+    "remove": "Quitar campo",
+    "removeOption": "Quitar opción",
+    "required": "Obligatorio",
+    "title": "Campos",
+    "typeLabel": "Tipo",
+    "widget": "Control",
+    "widgetDefault": "Predeterminado"
   }
 }
diff --git a/packages/i18n/locales/fr/app.json b/packages/i18n/locales/fr/app.json
index 4e2ea2dde6..c9a98a1bfd 100644
--- a/packages/i18n/locales/fr/app.json
+++ b/packages/i18n/locales/fr/app.json
@@ -6717,50 +6717,50 @@
   },
   "workflowNodes": {
     "advisory": "",
-    "codeNote": "Runs sandboxed TypeScript. Syntax is validated at save.",
+    "codeNote": "Exécute du TypeScript en bac à sable. La syntaxe est validée à l’enregistrement.",
     "codeSource": "Source (TypeScript)",
-    "codeTimeout": "Timeout (ms)",
-    "edgeConditionLabel": "Condition: {{condition}}",
-    "edgeInspector": "Edge",
-    "edgeNoVerdict": "— success (no verdict) —",
-    "edgeRework": "Rework edge (loop back, bounded)",
-    "edgeReworkNote": "Rework edges are the only legal cycles — they loop back within the for-each step instance, bounded by Max rework cycles.",
-    "edgeVerdict": "Review verdict",
-    "failureCollect": "",
-    "failureFailFast": "",
-    "failurePolicy": "",
-    "foreachConcurrency": "Concurrency",
-    "foreachEmptyHint": "Drag a step-execute node here",
+    "codeTimeout": "Délai d’expiration (ms)",
+    "edgeConditionLabel": "Condition : {{condition}}",
+    "edgeInspector": "Lien",
+    "edgeNoVerdict": "— succès (aucun verdict) —",
+    "edgeRework": "Lien de reprise (boucle de retour, borné)",
+    "edgeReworkNote": "Les liens de reprise sont les seuls cycles autorisés — ils bouclent au sein de l’instance de l’étape for-each, bornés par le nombre maximal de cycles de reprise.",
+    "edgeVerdict": "Verdict de révision",
+    "failureCollect": "Collecter (attendre toutes)",
+    "failureFailFast": "Échec rapide (annuler les voisines)",
+    "failurePolicy": "En cas d’échec de branche",
+    "foreachConcurrency": "Concurrence",
+    "foreachEmptyHint": "Glissez ici un nœud d’exécution d’étape",
     "foreachIsolation": "Isolation",
-    "foreachMaxRework": "Max rework cycles",
+    "foreachMaxRework": "Cycles de reprise max",
     "foreachMode": "Mode",
-    "foreachNote": "Expands once per planned step. Drop a step-execute node (and optional step-review) into the region.",
-    "foreachParallel": "Parallel",
-    "foreachSequential": "Sequential",
-    "foreachShared": "Shared worktree",
-    "foreachWorktree": "Per-step worktree",
-    "gateBlocks": "",
-    "gateMode": "",
-    "joinAll": "",
-    "joinAny": "",
-    "joinMode": "",
-    "joinQuorum": "",
-    "mergeBoundaryNote": "",
+    "foreachNote": "Se développe une fois par étape planifiée. Déposez un nœud d’exécution d’étape (et éventuellement de révision d’étape) dans la région.",
+    "foreachParallel": "Parallèle",
+    "foreachSequential": "Séquentiel",
+    "foreachShared": "Arbre de travail partagé",
+    "foreachWorktree": "Arbre de travail par étape",
+    "gateBlocks": "Barrière (bloque)",
+    "gateMode": "Mode de barrière",
+    "joinAll": "Toutes les branches",
+    "joinAny": "N’importe quelle branche",
+    "joinMode": "Mode de jointure",
+    "joinQuorum": "Quorum (n)",
+    "mergeBoundaryNote": "Les étapes avant ce marqueur s’exécutent avant la fusion ; celles après, après la fusion.",
     "parseArtifact": "Artifact",
     "parseParser": "Parser",
-    "quorumN": "",
-    "releaseCapacity": "",
-    "releaseCondition": "",
-    "releaseDependency": "",
-    "releaseExternal": "",
-    "releaseManual": "",
-    "releaseTimer": "",
+    "quorumN": "Nombre de quorum (n)",
+    "releaseCapacity": "Capacité en aval",
+    "releaseCondition": "Condition de libération",
+    "releaseDependency": "Dépendance terminée",
+    "releaseExternal": "Événement externe",
+    "releaseManual": "Promotion manuelle",
+    "releaseTimer": "Minuteur",
     "reviewCode": "Code review",
     "reviewModel": "Review model (optional)",
     "reviewNote": "Verdicts route as outcome edges. Click an outgoing edge to set its verdict and rework behavior.",
     "reviewPlan": "Plan review",
     "reviewType": "Review type",
-    "splitNote": "",
+    "splitNote": "Les branches s’exécutent simultanément depuis ce nœud. Les jointures d’exécution et de fusion ne sont pas autorisées dans une branche.",
     "stepExecuteLabel": "Step execute"
   },
   "workflows": {
@@ -6800,37 +6800,37 @@
     "saveFailed": "Échec de l'enregistrement du champ"
   },
   "workflowFields": {
-    "add": "Add field",
-    "addOption": "Add option",
-    "badge": "Render as badge",
-    "default": "Default",
-    "defaultLabel": "Default value",
-    "defaultTrue": "Default on",
-    "duplicateId": "A field with that id already exists",
-    "editId": "Edit id",
-    "empty": "No custom fields yet. Add a field to extend the task form and cards.",
-    "idLabel": "Field id",
-    "idWarn": "Changing the id discards values stored under the old id (remove + add).",
-    "nameLabel": "Field name",
-    "newFieldName": "New field",
+    "add": "Ajouter un champ",
+    "addOption": "Ajouter une option",
+    "badge": "Afficher comme badge",
+    "default": "Par défaut",
+    "defaultLabel": "Valeur par défaut",
+    "defaultTrue": "Activé par défaut",
+    "duplicateId": "Un champ avec cet id existe déjà",
+    "editId": "Modifier l'id",
+    "empty": "Aucun champ personnalisé pour l'instant. Ajoutez un champ pour étendre le formulaire et les cartes de la tâche.",
+    "idLabel": "Id du champ",
+    "idWarn": "Modifier l'id supprime les valeurs stockées sous l'ancien id (retirer + ajouter).",
+    "nameLabel": "Nom du champ",
+    "newFieldName": "Nouveau champ",
     "newOptionLabel": "Option 1",
-    "noDefault": "— none —",
-    "optionColor": "Option color",
-    "optionLabel": "Option label",
+    "noDefault": "— aucun —",
+    "optionColor": "Couleur de l'option",
+    "optionLabel": "Libellé de l'option",
     "optionN": "Option {{n}}",
-    "optionValue": "Option value",
+    "optionValue": "Valeur de l'option",
     "options": "Options",
-    "placement": "Placement",
-    "placementCard": "Card badge",
-    "placementDetail": "Detail (inline)",
-    "placementSection": "Detail section",
-    "readOnlyHint": "Built-in workflows are read-only — duplicate to edit",
-    "remove": "Remove field",
-    "removeOption": "Remove option",
-    "required": "Required",
-    "title": "Fields",
+    "placement": "Emplacement",
+    "placementCard": "Badge de carte",
+    "placementDetail": "Détail (en ligne)",
+    "placementSection": "Section de détail",
+    "readOnlyHint": "Les flux de travail intégrés sont en lecture seule — dupliquez pour modifier",
+    "remove": "Retirer le champ",
+    "removeOption": "Retirer l'option",
+    "required": "Obligatoire",
+    "title": "Champs",
     "typeLabel": "Type",
-    "widget": "Widget",
-    "widgetDefault": "Default"
+    "widget": "Composant",
+    "widgetDefault": "Par défaut"
   }
 }
diff --git a/packages/i18n/locales/ko/app.json b/packages/i18n/locales/ko/app.json
index c9b8cfb5ae..f6c3954e22 100644
--- a/packages/i18n/locales/ko/app.json
+++ b/packages/i18n/locales/ko/app.json
@@ -6717,50 +6717,50 @@
   },
   "workflowNodes": {
     "advisory": "",
-    "codeNote": "Runs sandboxed TypeScript. Syntax is validated at save.",
-    "codeSource": "Source (TypeScript)",
-    "codeTimeout": "Timeout (ms)",
-    "edgeConditionLabel": "Condition: {{condition}}",
-    "edgeInspector": "Edge",
-    "edgeNoVerdict": "— success (no verdict) —",
-    "edgeRework": "Rework edge (loop back, bounded)",
-    "edgeReworkNote": "Rework edges are the only legal cycles — they loop back within the for-each step instance, bounded by Max rework cycles.",
-    "edgeVerdict": "Review verdict",
-    "failureCollect": "",
-    "failureFailFast": "",
-    "failurePolicy": "",
-    "foreachConcurrency": "Concurrency",
-    "foreachEmptyHint": "Drag a step-execute node here",
-    "foreachIsolation": "Isolation",
-    "foreachMaxRework": "Max rework cycles",
-    "foreachMode": "Mode",
-    "foreachNote": "Expands once per planned step. Drop a step-execute node (and optional step-review) into the region.",
-    "foreachParallel": "Parallel",
-    "foreachSequential": "Sequential",
-    "foreachShared": "Shared worktree",
-    "foreachWorktree": "Per-step worktree",
-    "gateBlocks": "",
-    "gateMode": "",
-    "joinAll": "",
-    "joinAny": "",
-    "joinMode": "",
-    "joinQuorum": "",
-    "mergeBoundaryNote": "",
+    "codeNote": "샌드박스에서 TypeScript를 실행합니다. 구문은 저장 시 검증됩니다.",
+    "codeSource": "소스(TypeScript)",
+    "codeTimeout": "제한 시간(ms)",
+    "edgeConditionLabel": "조건: {{condition}}",
+    "edgeInspector": "에지",
+    "edgeNoVerdict": "— 성공(판정 없음) —",
+    "edgeRework": "재작업 에지(되돌아가기, 제한됨)",
+    "edgeReworkNote": "재작업 에지는 유일하게 허용되는 순환입니다 — for-each 단계 인스턴스 내에서 되돌아가며, 최대 재작업 횟수로 제한됩니다.",
+    "edgeVerdict": "검토 판정",
+    "failureCollect": "수집(모두 대기)",
+    "failureFailFast": "빠른 실패(형제 취소)",
+    "failurePolicy": "분기 실패 시",
+    "foreachConcurrency": "동시성",
+    "foreachEmptyHint": "여기로 단계 실행 노드를 끌어다 놓으세요",
+    "foreachIsolation": "격리",
+    "foreachMaxRework": "최대 재작업 횟수",
+    "foreachMode": "모드",
+    "foreachNote": "계획된 각 단계마다 한 번씩 확장됩니다. 단계 실행 노드(및 선택적으로 단계 검토)를 영역에 놓으세요.",
+    "foreachParallel": "병렬",
+    "foreachSequential": "순차",
+    "foreachShared": "공유 워크트리",
+    "foreachWorktree": "단계별 워크트리",
+    "gateBlocks": "게이트(차단)",
+    "gateMode": "게이트 모드",
+    "joinAll": "모든 분기",
+    "joinAny": "임의 분기",
+    "joinMode": "조인 모드",
+    "joinQuorum": "정족수(n)",
+    "mergeBoundaryNote": "이 표시 앞의 단계는 병합 전에 실행되고, 뒤의 단계는 병합 후에 실행됩니다.",
     "parseArtifact": "Artifact",
     "parseParser": "Parser",
-    "quorumN": "",
-    "releaseCapacity": "",
-    "releaseCondition": "",
-    "releaseDependency": "",
-    "releaseExternal": "",
-    "releaseManual": "",
-    "releaseTimer": "",
+    "quorumN": "정족수 개수(n)",
+    "releaseCapacity": "다운스트림 용량",
+    "releaseCondition": "릴리스 조건",
+    "releaseDependency": "종속성 완료",
+    "releaseExternal": "외부 이벤트",
+    "releaseManual": "수동 승격",
+    "releaseTimer": "타이머",
     "reviewCode": "Code review",
     "reviewModel": "Review model (optional)",
     "reviewNote": "Verdicts route as outcome edges. Click an outgoing edge to set its verdict and rework behavior.",
     "reviewPlan": "Plan review",
     "reviewType": "Review type",
-    "splitNote": "",
+    "splitNote": "분기는 이 노드에서 동시에 실행됩니다. 분기 내에서는 실행 및 병합 이음새가 허용되지 않습니다.",
     "stepExecuteLabel": "Step execute"
   },
   "workflows": {
@@ -6800,37 +6800,37 @@
     "saveFailed": "필드 저장 실패"
   },
   "workflowFields": {
-    "add": "Add field",
-    "addOption": "Add option",
-    "badge": "Render as badge",
-    "default": "Default",
-    "defaultLabel": "Default value",
-    "defaultTrue": "Default on",
-    "duplicateId": "A field with that id already exists",
-    "editId": "Edit id",
-    "empty": "No custom fields yet. Add a field to extend the task form and cards.",
-    "idLabel": "Field id",
-    "idWarn": "Changing the id discards values stored under the old id (remove + add).",
-    "nameLabel": "Field name",
-    "newFieldName": "New field",
-    "newOptionLabel": "Option 1",
-    "noDefault": "— none —",
-    "optionColor": "Option color",
-    "optionLabel": "Option label",
-    "optionN": "Option {{n}}",
-    "optionValue": "Option value",
-    "options": "Options",
-    "placement": "Placement",
-    "placementCard": "Card badge",
-    "placementDetail": "Detail (inline)",
-    "placementSection": "Detail section",
-    "readOnlyHint": "Built-in workflows are read-only — duplicate to edit",
-    "remove": "Remove field",
-    "removeOption": "Remove option",
-    "required": "Required",
-    "title": "Fields",
-    "typeLabel": "Type",
-    "widget": "Widget",
-    "widgetDefault": "Default"
+    "add": "필드 추가",
+    "addOption": "옵션 추가",
+    "badge": "배지로 표시",
+    "default": "기본값",
+    "defaultLabel": "기본값",
+    "defaultTrue": "기본 켜짐",
+    "duplicateId": "해당 id를 가진 필드가 이미 있습니다",
+    "editId": "id 편집",
+    "empty": "아직 사용자 지정 필드가 없습니다. 필드를 추가하여 작업 양식과 카드를 확장하세요.",
+    "idLabel": "필드 id",
+    "idWarn": "id를 변경하면 이전 id로 저장된 값이 삭제됩니다(제거 후 추가).",
+    "nameLabel": "필드 이름",
+    "newFieldName": "새 필드",
+    "newOptionLabel": "옵션 1",
+    "noDefault": "— 없음 —",
+    "optionColor": "옵션 색상",
+    "optionLabel": "옵션 레이블",
+    "optionN": "옵션 {{n}}",
+    "optionValue": "옵션 값",
+    "options": "옵션",
+    "placement": "배치",
+    "placementCard": "카드 배지",
+    "placementDetail": "세부 정보(인라인)",
+    "placementSection": "세부 정보 섹션",
+    "readOnlyHint": "기본 제공 워크플로는 읽기 전용입니다 — 편집하려면 복제하세요",
+    "remove": "필드 제거",
+    "removeOption": "옵션 제거",
+    "required": "필수",
+    "title": "필드",
+    "typeLabel": "유형",
+    "widget": "위젯",
+    "widgetDefault": "기본값"
   }
 }
diff --git a/packages/i18n/locales/zh-CN/app.json b/packages/i18n/locales/zh-CN/app.json
index 3501c606c8..0a5e98b13a 100644
--- a/packages/i18n/locales/zh-CN/app.json
+++ b/packages/i18n/locales/zh-CN/app.json
@@ -6717,50 +6717,50 @@
   },
   "workflowNodes": {
     "advisory": "",
-    "codeNote": "Runs sandboxed TypeScript. Syntax is validated at save.",
-    "codeSource": "Source (TypeScript)",
-    "codeTimeout": "Timeout (ms)",
-    "edgeConditionLabel": "Condition: {{condition}}",
-    "edgeInspector": "Edge",
-    "edgeNoVerdict": "— success (no verdict) —",
-    "edgeRework": "Rework edge (loop back, bounded)",
-    "edgeReworkNote": "Rework edges are the only legal cycles — they loop back within the for-each step instance, bounded by Max rework cycles.",
-    "edgeVerdict": "Review verdict",
-    "failureCollect": "",
-    "failureFailFast": "",
-    "failurePolicy": "",
-    "foreachConcurrency": "Concurrency",
-    "foreachEmptyHint": "Drag a step-execute node here",
-    "foreachIsolation": "Isolation",
-    "foreachMaxRework": "Max rework cycles",
-    "foreachMode": "Mode",
-    "foreachNote": "Expands once per planned step. Drop a step-execute node (and optional step-review) into the region.",
-    "foreachParallel": "Parallel",
-    "foreachSequential": "Sequential",
-    "foreachShared": "Shared worktree",
-    "foreachWorktree": "Per-step worktree",
-    "gateBlocks": "",
-    "gateMode": "",
-    "joinAll": "",
-    "joinAny": "",
-    "joinMode": "",
-    "joinQuorum": "",
-    "mergeBoundaryNote": "",
+    "codeNote": "在沙箱中运行 TypeScript。语法在保存时校验。",
+    "codeSource": "源代码（TypeScript）",
+    "codeTimeout": "超时（毫秒）",
+    "edgeConditionLabel": "条件：{{condition}}",
+    "edgeInspector": "连线",
+    "edgeNoVerdict": "— 成功（无裁定）—",
+    "edgeRework": "返工连线（回环，有界）",
+    "edgeReworkNote": "返工连线是唯一合法的循环 — 它们在 for-each 步骤实例内回环，受最大返工次数限制。",
+    "edgeVerdict": "审查裁定",
+    "failureCollect": "收集（等待全部）",
+    "failureFailFast": "快速失败（取消同级）",
+    "failurePolicy": "分支失败时",
+    "foreachConcurrency": "并发",
+    "foreachEmptyHint": "将步骤执行节点拖到此处",
+    "foreachIsolation": "隔离",
+    "foreachMaxRework": "最大返工次数",
+    "foreachMode": "模式",
+    "foreachNote": "每个计划步骤展开一次。将步骤执行节点（以及可选的步骤审查）放入该区域。",
+    "foreachParallel": "并行",
+    "foreachSequential": "顺序",
+    "foreachShared": "共享工作树",
+    "foreachWorktree": "每步骤工作树",
+    "gateBlocks": "关卡（阻断）",
+    "gateMode": "关卡模式",
+    "joinAll": "所有分支",
+    "joinAny": "任意分支",
+    "joinMode": "合并模式",
+    "joinQuorum": "法定数（n）",
+    "mergeBoundaryNote": "此标记之前的步骤在合并前运行；之后的步骤在合并后运行。",
     "parseArtifact": "Artifact",
     "parseParser": "Parser",
-    "quorumN": "",
-    "releaseCapacity": "",
-    "releaseCondition": "",
-    "releaseDependency": "",
-    "releaseExternal": "",
-    "releaseManual": "",
-    "releaseTimer": "",
+    "quorumN": "法定数（n）",
+    "releaseCapacity": "下游容量",
+    "releaseCondition": "释放条件",
+    "releaseDependency": "依赖完成",
+    "releaseExternal": "外部事件",
+    "releaseManual": "手动提升",
+    "releaseTimer": "定时器",
     "reviewCode": "Code review",
     "reviewModel": "Review model (optional)",
     "reviewNote": "Verdicts route as outcome edges. Click an outgoing edge to set its verdict and rework behavior.",
     "reviewPlan": "Plan review",
     "reviewType": "Review type",
-    "splitNote": "",
+    "splitNote": "分支从此节点并发运行。分支内不允许执行和合并接缝。",
     "stepExecuteLabel": "Step execute"
   },
   "workflows": {
@@ -6800,37 +6800,37 @@
     "saveFailed": "保存字段失败"
   },
   "workflowFields": {
-    "add": "Add field",
-    "addOption": "Add option",
-    "badge": "Render as badge",
-    "default": "Default",
-    "defaultLabel": "Default value",
-    "defaultTrue": "Default on",
-    "duplicateId": "A field with that id already exists",
-    "editId": "Edit id",
-    "empty": "No custom fields yet. Add a field to extend the task form and cards.",
-    "idLabel": "Field id",
-    "idWarn": "Changing the id discards values stored under the old id (remove + add).",
-    "nameLabel": "Field name",
-    "newFieldName": "New field",
-    "newOptionLabel": "Option 1",
-    "noDefault": "— none —",
-    "optionColor": "Option color",
-    "optionLabel": "Option label",
-    "optionN": "Option {{n}}",
-    "optionValue": "Option value",
-    "options": "Options",
-    "placement": "Placement",
-    "placementCard": "Card badge",
-    "placementDetail": "Detail (inline)",
-    "placementSection": "Detail section",
-    "readOnlyHint": "Built-in workflows are read-only — duplicate to edit",
-    "remove": "Remove field",
-    "removeOption": "Remove option",
-    "required": "Required",
-    "title": "Fields",
-    "typeLabel": "Type",
-    "widget": "Widget",
-    "widgetDefault": "Default"
+    "add": "添加字段",
+    "addOption": "添加选项",
+    "badge": "显示为徽章",
+    "default": "默认",
+    "defaultLabel": "默认值",
+    "defaultTrue": "默认开启",
+    "duplicateId": "已存在使用该 id 的字段",
+    "editId": "编辑 id",
+    "empty": "尚无自定义字段。添加字段以扩展任务表单和卡片。",
+    "idLabel": "字段 id",
+    "idWarn": "更改 id 会丢弃以旧 id 存储的值（移除 + 添加）。",
+    "nameLabel": "字段名称",
+    "newFieldName": "新字段",
+    "newOptionLabel": "选项 1",
+    "noDefault": "— 无 —",
+    "optionColor": "选项颜色",
+    "optionLabel": "选项标签",
+    "optionN": "选项 {{n}}",
+    "optionValue": "选项值",
+    "options": "选项",
+    "placement": "放置位置",
+    "placementCard": "卡片徽章",
+    "placementDetail": "详情（内联）",
+    "placementSection": "详情区块",
+    "readOnlyHint": "内置工作流为只读 — 复制以进行编辑",
+    "remove": "移除字段",
+    "removeOption": "移除选项",
+    "required": "必填",
+    "title": "字段",
+    "typeLabel": "类型",
+    "widget": "控件",
+    "widgetDefault": "默认"
   }
 }
diff --git a/packages/i18n/locales/zh-TW/app.json b/packages/i18n/locales/zh-TW/app.json
index ff35266f83..6597e96803 100644
--- a/packages/i18n/locales/zh-TW/app.json
+++ b/packages/i18n/locales/zh-TW/app.json
@@ -6717,50 +6717,50 @@
   },
   "workflowNodes": {
     "advisory": "",
-    "codeNote": "Runs sandboxed TypeScript. Syntax is validated at save.",
-    "codeSource": "Source (TypeScript)",
-    "codeTimeout": "Timeout (ms)",
-    "edgeConditionLabel": "Condition: {{condition}}",
-    "edgeInspector": "Edge",
-    "edgeNoVerdict": "— success (no verdict) —",
-    "edgeRework": "Rework edge (loop back, bounded)",
-    "edgeReworkNote": "Rework edges are the only legal cycles — they loop back within the for-each step instance, bounded by Max rework cycles.",
-    "edgeVerdict": "Review verdict",
-    "failureCollect": "",
-    "failureFailFast": "",
-    "failurePolicy": "",
-    "foreachConcurrency": "Concurrency",
-    "foreachEmptyHint": "Drag a step-execute node here",
-    "foreachIsolation": "Isolation",
-    "foreachMaxRework": "Max rework cycles",
-    "foreachMode": "Mode",
-    "foreachNote": "Expands once per planned step. Drop a step-execute node (and optional step-review) into the region.",
-    "foreachParallel": "Parallel",
-    "foreachSequential": "Sequential",
-    "foreachShared": "Shared worktree",
-    "foreachWorktree": "Per-step worktree",
-    "gateBlocks": "",
-    "gateMode": "",
-    "joinAll": "",
-    "joinAny": "",
-    "joinMode": "",
-    "joinQuorum": "",
-    "mergeBoundaryNote": "",
+    "codeNote": "在沙箱中執行 TypeScript。語法會在儲存時驗證。",
+    "codeSource": "原始碼（TypeScript）",
+    "codeTimeout": "逾時（毫秒）",
+    "edgeConditionLabel": "條件：{{condition}}",
+    "edgeInspector": "連線",
+    "edgeNoVerdict": "— 成功（無裁定）—",
+    "edgeRework": "返工連線（回圈返回，有界）",
+    "edgeReworkNote": "返工連線是唯一合法的循環 — 它們在 for-each 步驟實例內回圈返回，受最大返工次數限制。",
+    "edgeVerdict": "審查裁定",
+    "failureCollect": "收集（等待全部）",
+    "failureFailFast": "快速失敗（取消同層）",
+    "failurePolicy": "分支失敗時",
+    "foreachConcurrency": "並行數",
+    "foreachEmptyHint": "將步驟執行節點拖曳至此",
+    "foreachIsolation": "隔離",
+    "foreachMaxRework": "最大返工次數",
+    "foreachMode": "模式",
+    "foreachNote": "每個規劃步驟展開一次。將步驟執行節點（以及選擇性的步驟審查）放入該區域。",
+    "foreachParallel": "平行",
+    "foreachSequential": "循序",
+    "foreachShared": "共用工作樹",
+    "foreachWorktree": "每步驟工作樹",
+    "gateBlocks": "關卡（阻擋）",
+    "gateMode": "關卡模式",
+    "joinAll": "所有分支",
+    "joinAny": "任一分支",
+    "joinMode": "合併模式",
+    "joinQuorum": "法定人數（n）",
+    "mergeBoundaryNote": "此標記之前的步驟在合併前執行；之後的步驟在合併後執行。",
     "parseArtifact": "Artifact",
     "parseParser": "Parser",
-    "quorumN": "",
-    "releaseCapacity": "",
-    "releaseCondition": "",
-    "releaseDependency": "",
-    "releaseExternal": "",
-    "releaseManual": "",
-    "releaseTimer": "",
+    "quorumN": "法定人數（n）",
+    "releaseCapacity": "下游容量",
+    "releaseCondition": "釋放條件",
+    "releaseDependency": "相依完成",
+    "releaseExternal": "外部事件",
+    "releaseManual": "手動提升",
+    "releaseTimer": "計時器",
     "reviewCode": "Code review",
     "reviewModel": "Review model (optional)",
     "reviewNote": "Verdicts route as outcome edges. Click an outgoing edge to set its verdict and rework behavior.",
     "reviewPlan": "Plan review",
     "reviewType": "Review type",
-    "splitNote": "",
+    "splitNote": "分支從此節點並行執行。分支內不允許執行與合併接縫。",
     "stepExecuteLabel": "Step execute"
   },
   "workflows": {
@@ -6800,37 +6800,37 @@
     "saveFailed": "儲存欄位失敗"
   },
   "workflowFields": {
-    "add": "Add field",
-    "addOption": "Add option",
-    "badge": "Render as badge",
-    "default": "Default",
-    "defaultLabel": "Default value",
-    "defaultTrue": "Default on",
-    "duplicateId": "A field with that id already exists",
-    "editId": "Edit id",
-    "empty": "No custom fields yet. Add a field to extend the task form and cards.",
-    "idLabel": "Field id",
-    "idWarn": "Changing the id discards values stored under the old id (remove + add).",
-    "nameLabel": "Field name",
-    "newFieldName": "New field",
-    "newOptionLabel": "Option 1",
-    "noDefault": "— none —",
-    "optionColor": "Option color",
-    "optionLabel": "Option label",
-    "optionN": "Option {{n}}",
-    "optionValue": "Option value",
-    "options": "Options",
-    "placement": "Placement",
-    "placementCard": "Card badge",
-    "placementDetail": "Detail (inline)",
-    "placementSection": "Detail section",
-    "readOnlyHint": "Built-in workflows are read-only — duplicate to edit",
-    "remove": "Remove field",
-    "removeOption": "Remove option",
-    "required": "Required",
-    "title": "Fields",
-    "typeLabel": "Type",
-    "widget": "Widget",
-    "widgetDefault": "Default"
+    "add": "新增欄位",
+    "addOption": "新增選項",
+    "badge": "顯示為徽章",
+    "default": "預設",
+    "defaultLabel": "預設值",
+    "defaultTrue": "預設開啟",
+    "duplicateId": "已存在使用該 id 的欄位",
+    "editId": "編輯 id",
+    "empty": "尚無自訂欄位。新增欄位以擴充工作表單與卡片。",
+    "idLabel": "欄位 id",
+    "idWarn": "變更 id 會捨棄以舊 id 儲存的值（移除 + 新增）。",
+    "nameLabel": "欄位名稱",
+    "newFieldName": "新欄位",
+    "newOptionLabel": "選項 1",
+    "noDefault": "— 無 —",
+    "optionColor": "選項顏色",
+    "optionLabel": "選項標籤",
+    "optionN": "選項 {{n}}",
+    "optionValue": "選項值",
+    "options": "選項",
+    "placement": "放置位置",
+    "placementCard": "卡片徽章",
+    "placementDetail": "詳細資料（內嵌）",
+    "placementSection": "詳細資料區段",
+    "readOnlyHint": "內建工作流程為唯讀 — 複製以進行編輯",
+    "remove": "移除欄位",
+    "removeOption": "移除選項",
+    "required": "必填",
+    "title": "欄位",
+    "typeLabel": "類型",
+    "widget": "控制項",
+    "widgetDefault": "預設"
   }
 }