@loomhelm/multi-task-flow 0.2.6 → 0.2.8

package/toolkit/skills/multi-task-flow/tests/atomic-orchestration-schema.test.ts

@@ -49,6 +49,41 @@ test("derives business status and enforces contribution starting prerequisites",
   const node = atomicNode.parse({ kind: "work", id: "work-1", title: "Implement", purpose: "Implement", output: "code", acceptance: [], activity_type: "contribution", state: "starting", scope: { kind: "task", task_id: "task-1", delivery_unit_id: "du-1" }, runtime: { started_at: "2026-01-01T00:00:00Z", updated_at: "2026-01-01T00:00:00Z", evidence_refs: [] } });
   expect(() => validateContributionStart(node, { pr: { state: "unpublished" } } as any)).toThrow();
   expect(() => validateContributionStart(node, { pr: { state: "published", pr: ref, parent_branch: "main" }, parent_branch: "main" } as any)).not.toThrow();
+  expect(() => validateContributionStart(node, { pr: { state: "unpublished" } } as any, {
+    delivery_unit_kind: "bootstrap",
+    owner_kind: "main",
+    execution_owner: "main",
+    conversation_policy: "main_owned",
+    active: true,
+    workspace_ready: true,
+    parent_pr_status: "definitively_absent",
+  })).not.toThrow();
+  expect(() => validateContributionStart(node, { pr: { state: "closed", pr: ref, parent_branch: "main", closed_at: "2026-01-01T00:00:00Z", closed_reason: "provider_closed" } } as any, {
+    delivery_unit_kind: "bootstrap",
+    owner_kind: "main",
+    execution_owner: "main",
+    conversation_policy: "main_owned",
+    active: true,
+    workspace_ready: true,
+    parent_pr_status: "present",
+  })).toThrow();
+  expect(() => validateContributionStart(node, { pr: { state: "unpublished" } } as any, {
+    delivery_unit_kind: "bootstrap",
+    owner_kind: "main",
+    execution_owner: "main",
+    conversation_policy: "main_owned",
+    active: true,
+    workspace_ready: true,
+    parent_pr_status: "unknown",
+  })).toThrow();
+  expect(() => validateContributionStart(node, { pr: { state: "unpublished" } } as any, {
+    delivery_unit_kind: "bootstrap",
+    owner_kind: "main",
+    execution_owner: "task_agent",
+    conversation_policy: "task_agent",
+    active: true,
+    workspace_ready: true,
+  })).toThrow();
   expect(deriveBusinessStatus([node], { kind: "task", task_id: "task-1" })).toBe("running");
 });
 

package/toolkit/skills/multi-task-flow/tests/engine.test.ts

@@ -7,6 +7,7 @@ import {
   type Plan,
   type Task,
 } from "../lib/schema";
+import { deriveExecutionPhase } from "../lib/revisions";
 
 test("task execution policy rejects contradictory ownership and preserves legacy absence", () => {
   expect(taskExecutionPolicyIssues({ execution_owner: "main", conversation_policy: "main_owned", delivery_policy: "parent_pr" })).toEqual([]);
@@ -367,6 +368,34 @@ function approveV2(ledger: ReturnType<typeof v2Fixture>) {
   }));
 }
 
+function readyBootstrapFixture() {
+  const ledger = v2Fixture();
+  ledger.groups[0].delivery_unit_kind = "bootstrap";
+  ledger.groups[0].owner_kind = "main";
+  ledger.groups[0].agent_thread_id = null;
+  ledger.groups[0].atoms = [{
+    id: "workspace",
+    title: "Prepare parent",
+    purpose: "Prepare",
+    output: "Ready",
+    lifecycle_stage: "workspace_ready",
+    status: "completed",
+  }];
+  ledger.plans[0].group_atoms = ledger.groups[0].atoms.map(({ status, ...atom }: any) => ({ ...atom, group_id: "g" }));
+  ledger.groups[0].lifecycle.workspace_ready = "passed";
+  ledger.events.push({
+    id: "bootstrap-workspace-recorded",
+    type: "lifecycle_recorded",
+    subject_id: "g",
+    actor_id: "main-thread",
+    occurred_at: at,
+    recorded_at: at,
+    data: { target_type: "group", stage: "workspace_ready", evidence_ref: "workspace" },
+  });
+  approveV2(ledger);
+  return ledger;
+}
+
 test("contribution dispatch is blocked until the parent PR gate is complete", () => {
   const ledger = v2Fixture();
   approveV2(ledger);
@@ -396,6 +425,316 @@ test("contribution dispatch is blocked until the parent PR gate is complete", ()
     state: "running",
     occurred_at: at,
   }, { role: "task", thread_id: "task-a-thread" }))).toThrow("parent PR is created and verified");
+  try {
+    apply(ledger, "task-update", request(ledger, "blocked-task-start-details", {
+      task_id: "a",
+      state: "running",
+      occurred_at: at,
+    }, { role: "task", thread_id: "task-a-thread" }));
+  } catch (error) {
+    expect((error as any).details.recovery).toContain("retry task-update");
+  }
+});
+
+test("dispatch-claim recovery names its caller when only workspace readiness is missing", () => {
+  const ledger = v2Fixture();
+  approveV2(ledger);
+  ledger.groups[0].atoms = [
+    { id: "workspace", title: "Prepare parent", purpose: "Prepare", output: "Ready", lifecycle_stage: "workspace_ready", status: "planned" },
+    { id: "parent-pr", title: "Create parent PR", purpose: "Publish", output: "Created", lifecycle_stage: "pr_created", status: "completed" },
+  ];
+  ledger.plans[0].group_atoms = ledger.groups[0].atoms.map(({ status, ...atom }: any) => ({ ...atom, group_id: "g" }));
+  ledger.groups[0].lifecycle.pr_created = "passed";
+  const parentPr = providerPrReceipt("parent-pr", "parent", base, base);
+  ledger.groups[0].parent_pr = parentPr.pr;
+  ledger.facts.push({
+    id: "parent-branch-fact",
+    kind: "branch_published",
+    subject_id: "g",
+    status: "passed",
+    source: "github",
+    observed_at: at,
+    sha: base,
+    evidence_ref: "provider:parent",
+    receipt: providerBranchReceipt("parent", base),
+  });
+  ledger.facts.push({
+    id: "parent-pr-fact",
+    kind: "pr_published",
+    subject_id: "g",
+    status: "passed",
+    source: "github",
+    observed_at: at,
+    sha: base,
+    evidence_ref: "provider:parent-pr",
+    receipt: parentPr,
+  });
+
+  let dispatchError: any;
+  try {
+    apply(ledger, "dispatch-claim", request(ledger, "workspace-only-dispatch", {
+      task_id: "a",
+      operation_id: "workspace-only-dispatch-op",
+    }));
+  } catch (error) {
+    dispatchError = error;
+    expect((error as any).details.missing).toEqual(["workspace_ready"]);
+    expect((error as any).details.recovery).toContain("retry dispatch-claim");
+    expect((error as any).details.recovery).not.toContain("retry task-update");
+  }
+  expect(dispatchError).toBeDefined();
+});
+
+test("main-owned bootstrap contributions can start before the parent PR exists", () => {
+  const ledger = v2Fixture();
+  ledger.groups[0].delivery_unit_kind = "bootstrap";
+  ledger.groups[0].owner_kind = "main";
+  ledger.groups[0].agent_thread_id = null;
+  ledger.groups[0].atoms = [{
+    id: "workspace",
+    title: "Prepare parent",
+    purpose: "Prepare",
+    output: "Ready",
+    lifecycle_stage: "workspace_ready",
+    status: "planned",
+  }];
+  ledger.plans[0].group_atoms = ledger.groups[0].atoms.map(({ status, ...atom }: any) => ({ ...atom, group_id: "g" }));
+  const task = ledger.tasks[0];
+  task.execution_owner = "main";
+  task.conversation_policy = "main_owned";
+  task.delivery_policy = "parent_pr";
+  task.atoms = [{ id: "atom-a", title: "a", status: "planned" }];
+  approveV2(ledger);
+  ledger.facts.push({
+    id: "bootstrap-parent-pr-absent",
+    kind: "pr_published",
+    subject_id: "g",
+    status: "failed",
+    source: "github",
+    observed_at: at,
+    sha: null,
+    evidence_ref: "provider:bootstrap-parent-pr-absent",
+    receipt: {
+      provider: "github",
+      repository: "example/repo",
+      resource_type: "pr",
+      resource_id: "parent-pr",
+      branch: "parent",
+      target_branch: "main",
+      base_sha: null,
+      head_sha: null,
+      pr: null,
+      state: "absent",
+      evidence_ref: "provider:bootstrap-parent-pr-absent",
+    },
+  });
+
+  let bootstrapWorkspaceError: any;
+  try {
+    apply(ledger, "task-update", request(ledger, "bootstrap-main-before-workspace", {
+      task_id: task.id,
+      state: "running",
+      occurred_at: at,
+    }, main));
+  } catch (error) {
+    bootstrapWorkspaceError = error;
+    expect((error as any).message).toContain("delivery-unit workspace is ready");
+    expect((error as any).details.missing).toEqual(["workspace_ready"]);
+    expect((error as any).details.recovery).toContain("retry task-update");
+  }
+  expect(bootstrapWorkspaceError).toBeDefined();
+
+  ledger.groups[0].lifecycle.workspace_ready = "passed";
+  ledger.groups[0].atoms[0].status = "completed";
+  ledger.events.push({
+    id: "bootstrap-workspace-recorded",
+    type: "lifecycle_recorded",
+    subject_id: "g",
+    actor_id: "main-thread",
+    occurred_at: at,
+    recorded_at: at,
+    data: { target_type: "group", stage: "workspace_ready", evidence_ref: "workspace" },
+  });
+
+  ledger.groups[0].state = "planned";
+  expect(() => apply(ledger, "task-update", request(ledger, "bootstrap-planned-group", {
+    task_id: task.id,
+    state: "running",
+    occurred_at: at,
+  }, main))).toThrow("Task group is not active");
+  ledger.groups[0].state = "active";
+
+  apply(ledger, "task-update", request(ledger, "bootstrap-main-start", {
+    task_id: task.id,
+    state: "running",
+    occurred_at: at,
+  }, main));
+
+  expect(ledger.tasks[0].state).toBe("running");
+  expect(ledger.tasks[0].started_at).toBe(at);
+  expect(ledger.events.at(-1)?.type).toBe("task_started");
+  expect(deriveExecutionPhase(ledger)).toBe("implementation");
+  const proposed = structuredClone(ledger.plans[0]);
+  proposed.id = "bootstrap-revision";
+  proposed.supersedes_id = ledger.execution_plan_id;
+  proposed.approval_id = null;
+  proposed.lifecycle = "proposed";
+  proposed.revision = null;
+  proposed.actions = proposed.actions.map((action: any) => ({
+    ...action,
+    target: action.group_id ? { type: "group", id: action.group_id } : { type: "task", id: action.task_id },
+  }));
+  const revisedTasks = structuredClone(ledger.tasks);
+  revisedTasks[0].owned_surfaces = ["src/changed-after-start"];
+  let migrationError: any;
+  try {
+    apply(ledger, "plan-propose", request(ledger, "bootstrap-boundary-change", {
+      plan: proposed,
+      groups: structuredClone(ledger.groups),
+      tasks: revisedTasks,
+      revision: {
+        reason: {
+          category: "owner_direction",
+          summary: "Update the implementation boundary after direct bootstrap start.",
+          evidence_refs: ["evidence://bootstrap-start"],
+          impact: "The started task requires explicit migration if its owned surface changes.",
+        },
+      },
+    }, main));
+  } catch (error) {
+    migrationError = error;
+  }
+  expect(migrationError?.code).toBe("TASK_MIGRATION_REQUIRED");
+  expect(ledger.groups[0].parent_pr).toBeNull();
+});
+
+test("bootstrap parent PR bypass requires explicit absence evidence", () => {
+  const ledger = readyBootstrapFixture();
+  const task = ledger.tasks[0];
+  task.execution_owner = "main";
+  task.conversation_policy = "main_owned";
+  task.delivery_policy = "parent_pr";
+  expect(() => apply(ledger, "task-update", request(ledger, "bootstrap-without-absence", {
+    task_id: task.id,
+    state: "running",
+    occurred_at: at,
+  }, main))).toThrow("parent PR is created and verified");
+});
+
+test("bootstrap parent PR bypass fails closed for uncertain publication and retained paths", () => {
+  for (const uncertainty of ["operation", "fact"] as const) {
+    const ledger = readyBootstrapFixture();
+    const task = ledger.tasks[0];
+    task.execution_owner = "main";
+    task.conversation_policy = "main_owned";
+    task.delivery_policy = "parent_pr";
+    if (uncertainty === "operation") {
+      ledger.operations.push({
+        id: "pending-parent-pr",
+        kind: "publish_pr",
+        actor_id: "main-thread",
+        target_id: "g",
+        status: "unknown",
+        request: { target_type: "group" },
+        expected_sha: null,
+        receipt_fact_id: null,
+        created_at: at,
+        updated_at: at,
+      });
+    } else {
+      ledger.facts.push({
+        id: "unknown-parent-pr",
+        kind: "pr_published",
+        subject_id: "g",
+        status: "unknown",
+        source: "github",
+        observed_at: at,
+        sha: null,
+        evidence_ref: "provider:unknown-parent-pr",
+        receipt: null,
+      });
+    }
+    expect(() => apply(ledger, "task-update", request(ledger, `bootstrap-uncertain-${uncertainty}`, {
+      task_id: task.id,
+      state: "running",
+      occurred_at: at,
+    }, main))).toThrow("parent PR is created and verified");
+    expect(ledger.tasks[0].state).toBe("planned");
+  }
+});
+
+test("regular and Task Agent bootstrap paths retain the parent PR gate after workspace readiness", () => {
+  const regular = readyBootstrapFixture();
+  regular.groups[0].delivery_unit_kind = "regular";
+  regular.groups[0].owner_kind = "group";
+  regular.groups[0].agent_thread_id = "group-thread";
+  regular.tasks[0].execution_owner = "main";
+  regular.tasks[0].conversation_policy = "main_owned";
+  regular.tasks[0].delivery_policy = "parent_pr";
+  expect(() => apply(regular, "task-update", request(regular, "regular-main-without-parent", {
+    task_id: "a",
+    state: "running",
+    occurred_at: at,
+  }, main))).toThrow("parent PR is created and verified");
+  expect(regular.tasks[0].state).toBe("planned");
+
+  const taskAgent = readyBootstrapFixture();
+  taskAgent.tasks[0].execution_owner = "task_agent";
+  taskAgent.tasks[0].conversation_policy = "task_agent";
+  taskAgent.tasks[0].delivery_policy = "child_pr";
+  taskAgent.tasks[0].thread_id = "task-a-thread";
+  taskAgent.tasks[0].state = "starting";
+  expect(() => apply(taskAgent, "task-update", request(taskAgent, "bootstrap-task-agent-without-parent", {
+    task_id: "a",
+    state: "running",
+    occurred_at: at,
+  }, { role: "task", thread_id: "task-a-thread" }))).toThrow("parent PR is created and verified");
+  expect(taskAgent.tasks[0].state).toBe("starting");
+});
+
+test("bootstrap dispatch-claim remains blocked for Task Agent work without a parent PR", () => {
+  const ledger = readyBootstrapFixture();
+  ledger.tasks[0].execution_owner = "task_agent";
+  ledger.tasks[0].conversation_policy = "task_agent";
+  ledger.tasks[0].delivery_policy = "child_pr";
+  expect(() => apply(ledger, "dispatch-claim", request(ledger, "bootstrap-dispatch-without-parent", {
+    task_id: "a",
+    operation_id: "bootstrap-dispatch-without-parent-op",
+  }))).toThrow("parent PR is created and verified");
+  expect(ledger.operations).toHaveLength(0);
+});
+
+test("closed parent PRs do not satisfy the retained contribution gate", () => {
+  const ledger = readyBootstrapFixture();
+  ledger.groups[0].delivery_unit_kind = "regular";
+  ledger.groups[0].owner_kind = "group";
+  ledger.groups[0].agent_thread_id = "group-thread";
+  ledger.groups[0].parent_pr = providerPrReceipt("closed-parent", "parent", base, base).pr;
+  ledger.groups[0].lifecycle.pr_created = "passed";
+  ledger.groups[0].atoms.push({ id: "parent-pr", title: "Create parent PR", purpose: "Publish", output: "Created", lifecycle_stage: "pr_created", status: "completed" });
+  ledger.plans[0].group_atoms = ledger.groups[0].atoms.map(({ status, ...atom }: any) => ({ ...atom, group_id: "g" }));
+  ledger.facts.push({
+    id: "closed-parent-pr",
+    kind: "pr_published",
+    subject_id: "g",
+    status: "passed",
+    source: "github",
+    observed_at: at,
+    sha: base,
+    evidence_ref: "provider:closed-parent-pr",
+    receipt: { ...providerPrReceipt("closed-parent", "parent", base, base), state: "absent" },
+  });
+  ledger.tasks[0].execution_owner = "task_agent";
+  ledger.tasks[0].conversation_policy = "task_agent";
+  ledger.tasks[0].delivery_policy = "child_pr";
+  ledger.tasks[0].thread_id = "task-a-thread";
+  ledger.tasks[0].state = "starting";
+  expect(() => apply(ledger, "task-update", request(ledger, "closed-parent-blocked", {
+    task_id: "a",
+    state: "running",
+    occurred_at: at,
+  }, { role: "task", thread_id: "task-a-thread" }))).toThrow("parent PR is created and verified");
+  expect(ledger.tasks[0].state).toBe("starting");
 });
 function providerBranchReceipt(branch: string, sha: string) {
   return {

package/toolkit/skills/multi-task-flow/tests/source-preview.test.ts

@@ -6,6 +6,7 @@ import { ServiceAuth } from "../lib/service-auth";
 import { ServiceState } from "../lib/service-state";
 import { servicePaths } from "../lib/service-paths";
 import { runDaemon } from "../lib/service-lifecycle";
+import { serviceCommand } from "../scripts/service";
 import { serviceFixture, fixtureRelease, fixtureLegacyRelease, fixtureRun } from "./service-fixture";
 
 test.each([
@@ -44,6 +45,34 @@ test.each([
     const url = new URL(ready.url);
     expect(url.hostname).toBe("127.0.0.1");
     expect((await fetch(url.origin + "/api/v1/runs")).status).toBe(401);
+    if (_name === "default") {
+      const state = new ServiceState(
+        servicePaths({
+          MULTI_TASK_FLOW_PROFILE: "development",
+          MULTI_TASK_FLOW_ROOT: ready.root,
+        }),
+      );
+      const login = (await serviceCommand("login", { run_id: ready.run_id }, state)) as {
+        login_url: string;
+      };
+      const loginResponse = await fetch(login.login_url, { redirect: "manual" });
+      expect(loginResponse.status).toBe(302);
+      const cookie = loginResponse.headers.get("set-cookie")?.split(";", 1)[0];
+      expect(cookie).toBeTruthy();
+      const runUrl = new URL(
+        loginResponse.headers.get("location") ?? "",
+        url.origin,
+      );
+      const page = await fetch(runUrl, { headers: { cookie: cookie! } });
+      expect(page.status).toBe(200);
+      expect(await page.text()).toContain("/service-client.js");
+      const view = await fetch(
+        new URL(`/runs/${ready.run_id}/api/view`, url.origin),
+        { headers: { cookie: cookie! } },
+      );
+      expect(view.status).toBe(200);
+      expect((await view.json()).view.orchestration.id).toBe(ready.run_id);
+    }
   } finally {
     clearTimeout(timer);
     child.kill("SIGTERM");

package/toolkit/skills/multi-task-flow/tests/ui/details-content.test.ts

@@ -237,6 +237,28 @@ describe("dashboard details content", () => {
 
   });
 
+  test("always shows task and delivery-unit requirement document status", () => {
+    const group = { id: "core", title: "核心", state: "running", agent_thread_id: null, parent_pr: { url: null }, requirements_path: null } as Group;
+    const task = { id: "task", title: "任务", group_id: "core", kind: "contribution", state: "running", is_ready: false, blocker: null, thread_id: null, pr: { url: null }, requirements_path: null, started_at: null, finished_at: null } as unknown as View["tasks"][number];
+    const view = { groups: [group], tasks: [task], actual_intervals: [], nodes: [], edges: [], follow_prs: [] } as unknown as View;
+    const details = createDetailContent({ getData: () => view, labels: {}, labelTask: () => "执行中", time: () => "未知", safeExternal: () => null });
+
+    details.showTask(task);
+    expect([...document.querySelectorAll(".detail-label")].some((node) => node.textContent === "任务要求")).toBe(true);
+    expect(document.getElementById("details-content")?.textContent).toContain("未配置任务文档");
+
+    details.showGroup(group);
+    expect([...document.querySelectorAll(".detail-label")].some((node) => node.textContent === "交付单元要求")).toBe(true);
+    expect(document.getElementById("details-content")?.textContent).toContain("未配置交付单元文档");
+
+    task.requirements_path = "requirements/task.md";
+    group.requirements_path = "requirements/group.md";
+    details.showTask(task);
+    expect(document.querySelector(".detail-value a")?.getAttribute("href")).toBe("api/document/task-task");
+    details.showGroup(group);
+    expect(document.querySelector(".detail-value a")?.getAttribute("href")).toBe("api/document/group-core");
+  });
+
   test("renders path provenance and hidden plan boundaries without flattening conditions", () => {
     const view = {
       orchestration: { id: "run", repository: { owner: "example", name: "repo", host: "github.com" }, revision: 1, updated_at: "2026-01-01T00:00:00.000Z", display_timezone: "UTC", max_running_tasks: 1, conversation_links_verified: true },

package/toolkit/skills/multi-task-flow/tests/view.test.ts

@@ -59,6 +59,33 @@ function withRuntimeEvidence<T extends ReturnType<typeof createPlanningDemoLedge
   return ledger;
 }
 
+function addDefinitiveAbsentParentPrFact(ledger: ReturnType<typeof createPlanningDemoLedger>, groupId: string) {
+  const group = ledger.groups.find((item) => item.id === groupId)!;
+  ledger.facts.push({
+    id: `${groupId}-parent-pr-absent`,
+    kind: "pr_published",
+    subject_id: groupId,
+    status: "failed",
+    source: ledger.repository.provider,
+    observed_at: ledger.updated_at,
+    sha: null,
+    evidence_ref: `${groupId}:parent-pr-absent`,
+    receipt: {
+      provider: ledger.repository.provider,
+      repository: `${ledger.repository.owner}/${ledger.repository.name}`,
+      resource_type: "pr",
+      resource_id: `${groupId}-parent-pr`,
+      branch: group.parent_branch,
+      target_branch: "main",
+      base_sha: null,
+      head_sha: null,
+      pr: null,
+      state: "absent",
+      evidence_ref: `${groupId}:parent-pr-absent`,
+    },
+  });
+}
+
 describe("timeline projections", () => {
   test("rejects incomplete plans before formal scheduling", () => {
     expect(() => validateSchedulablePlan(fixture([taskNode("a", null)], []))).toThrow("缺少原子任务");
@@ -169,6 +196,46 @@ describe("timeline projections", () => {
     });
   });
 
+  test("aligns bootstrap main-owned task readiness with the execution exception", () => {
+    const ledger = structuredClone(createPlanningDemoLedger(1_767_200_000_000));
+    ledger.contract_version = 2;
+    ledger.source_schema_version = null;
+    const group = ledger.groups.find((item) => item.id === "core")!;
+    const task = ledger.tasks.find((item) => item.group_id === group.id && item.kind === "contribution")!;
+    group.delivery_unit_kind = "bootstrap";
+    group.owner_kind = "main";
+    group.agent_thread_id = null;
+    group.state = "active";
+    group.lifecycle.workspace_ready = "passed";
+    group.atoms.find((atom) => atom.lifecycle_stage === "workspace_ready")!.status = "completed";
+    ledger.events.push({
+      id: "bootstrap-workspace-ready",
+      type: "lifecycle_recorded",
+      subject_id: group.id,
+      actor_id: ledger.control.owner_thread_id!,
+      occurred_at: ledger.updated_at,
+      recorded_at: ledger.updated_at,
+      data: { target_type: "group", stage: "workspace_ready", evidence_ref: "bootstrap-workspace" },
+    });
+    addDefinitiveAbsentParentPrFact(ledger, group.id);
+    task.execution_owner = "main";
+    task.conversation_policy = "main_owned";
+    task.delivery_policy = "parent_pr";
+    const view = buildView(ledger) as any;
+    const projected = view.tasks.find((item: any) => item.id === task.id);
+
+    expect(projected.dispatch_readiness).toBe("ready");
+    expect(projected.dispatch_diagnostics).not.toContainEqual(expect.objectContaining({ code: "DELIVERY_PARENT_PR_GATE_PENDING" }));
+
+    task.execution_owner = "task_agent";
+    task.conversation_policy = "task_agent";
+    task.delivery_policy = "child_pr";
+    const blockedView = buildView(ledger) as any;
+    const blocked = blockedView.tasks.find((item: any) => item.id === task.id);
+    expect(blocked.dispatch_readiness).toBe("blocked");
+    expect(blocked.dispatch_diagnostics).toContainEqual(expect.objectContaining({ code: "DELIVERY_PARENT_PR_GATE_PENDING" }));
+  });
+
   test("does not project a closed delivery unit as schedulable", () => {
     const ledger = withRuntimeEvidence(structuredClone(createPlanningDemoLedger(1_767_200_000_000)));
     ledger.contract_version = 2;
@@ -189,6 +256,88 @@ describe("timeline projections", () => {
     }));
   });
 
+  test("keeps bootstrap delivery-unit readiness behind active workspace state", () => {
+    const ledger = structuredClone(createPlanningDemoLedger(1_767_200_000_000));
+    const group = ledger.groups.find((item) => item.id === "core")!;
+    group.delivery_unit_kind = "bootstrap";
+    group.owner_kind = "main";
+    group.agent_thread_id = null;
+    group.state = "planned";
+    const planned = buildView(ledger) as any;
+    const plannedGroup = planned.groups.find((item: any) => item.id === group.id);
+    expect(plannedGroup.dispatch_readiness).toBe("blocked");
+    expect(planned.plan_state.dispatch_readiness).toBe("blocked");
+    expect(plannedGroup.dispatch_diagnostics).toContainEqual(expect.objectContaining({ code: "DELIVERY_UNIT_NOT_ACTIVE" }));
+
+    group.state = "active";
+    const activeWithoutWorkspace = buildView(ledger) as any;
+    const blockedGroup = activeWithoutWorkspace.groups.find((item: any) => item.id === group.id);
+    expect(blockedGroup.dispatch_readiness).toBe("blocked");
+    expect(blockedGroup.dispatch_diagnostics).toContainEqual(expect.objectContaining({ code: "DELIVERY_WORKSPACE_GATE_PENDING" }));
+  });
+
+  test("does not infer definitive parent PR absence from missing facts", () => {
+    const ledger = structuredClone(createPlanningDemoLedger(1_767_200_000_000));
+    const group = ledger.groups.find((item) => item.id === "core")!;
+    group.delivery_unit_kind = "bootstrap";
+    group.owner_kind = "main";
+    group.agent_thread_id = null;
+    group.state = "active";
+    group.lifecycle.workspace_ready = "passed";
+    group.atoms.find((atom) => atom.lifecycle_stage === "workspace_ready")!.status = "completed";
+    ledger.events.push({
+      id: "missing-parent-workspace-ready",
+      type: "lifecycle_recorded",
+      subject_id: group.id,
+      actor_id: ledger.control.owner_thread_id!,
+      occurred_at: ledger.updated_at,
+      recorded_at: ledger.updated_at,
+      data: { target_type: "group", stage: "workspace_ready", evidence_ref: "missing-parent-workspace" },
+    });
+    const view = buildView(ledger) as any;
+    const projected = view.groups.find((item: any) => item.id === group.id);
+    expect(projected.dispatch_readiness).toBe("blocked");
+    expect(projected.dispatch_diagnostics).toContainEqual(expect.objectContaining({ code: "DELIVERY_PARENT_PR_GATE_PENDING" }));
+  });
+
+  test("does not project a closed parent PR as ready", () => {
+    const ledger = withRuntimeEvidence(structuredClone(createPlanningDemoLedger(1_767_200_000_000)));
+    ledger.contract_version = 2;
+    ledger.source_schema_version = null;
+    const group = ledger.groups.find((item) => item.id === "dashboard")!;
+    group.parent_pr = { provider: "github", repository: "example/repo", id: "parent-pr", url: "https://github.com/example/repo/pull/1" };
+    group.lifecycle.pr_created = "passed";
+    group.atoms.push({ id: "parent-pr", title: "Create parent PR", purpose: "Publish", output: "Created", lifecycle_stage: "pr_created", status: "completed" });
+    ledger.plans[0]!.group_atoms = ledger.groups.flatMap((item) => item.atoms.map(({ status, ...atom }: any) => ({ ...atom, group_id: item.id })));
+    ledger.facts.push({
+      id: "closed-parent-pr",
+      kind: "pr_published",
+      subject_id: group.id,
+      status: "passed",
+      source: "github",
+      observed_at: at,
+      sha: null,
+      evidence_ref: "provider:closed-parent-pr",
+      receipt: {
+        provider: "github",
+        repository: "example/repo",
+        resource_type: "pr",
+        resource_id: "parent-pr",
+        branch: "main",
+        target_branch: "main",
+        base_sha: null,
+        head_sha: null,
+        pr: { provider: "github", repository: "example/repo", id: "parent-pr", url: "https://github.com/example/repo/pull/1" },
+        state: "absent",
+        evidence_ref: "provider:closed-parent-pr",
+      },
+    });
+    const view = buildView(ledger) as any;
+    const projected = view.groups.find((item: any) => item.id === group.id);
+    expect(projected.dispatch_readiness).toBe("blocked");
+    expect(projected.dispatch_diagnostics).toContainEqual(expect.objectContaining({ code: "DELIVERY_PARENT_PR_GATE_PENDING" }));
+  });
+
   test("projects an unresolved group conversation creation as unknown", () => {
     const ledger = structuredClone(createPlanningDemoLedger(1_767_200_000_000));
     ledger.contract_version = 2;

package/toolkit/skills/multi-task-flow/web/app.css

@@ -399,6 +399,7 @@ time[data-local-timestamp] { cursor: help; font-variant-numeric: tabular-nums; }
 .detail-empty-output::before { width: 5px; height: 5px; flex: none; border: 1px solid currentColor; border-radius: 50%; content: ""; }
 .detail-empty-output::after { content: attr(data-empty-label); }
 .detail-value a { color: var(--accent); text-decoration: underline; text-underline-offset: 3px; }
+.detail-placeholder { color: var(--muted); font-style: italic; }
 .mobile-close { display: grid; }
 .details-backdrop { display: none; }
 .hover-preview { position: fixed; z-index: 50; width: min(280px, calc(100vw - 24px)); max-height: min(420px, calc(100vh - 24px)); overflow: auto; padding: 12px 14px; border: 1px solid var(--border); border-radius: var(--radius-card); color: var(--text); background: var(--raised); box-shadow: var(--shadow); opacity: 0; pointer-events: auto; transform: translateY(5px) scale(.98); transform-origin: center; transition: opacity 140ms ease-out, transform 180ms cubic-bezier(.16, 1, .3, 1), visibility 0s linear 180ms; visibility: hidden; }
@@ -695,6 +696,9 @@ time[data-local-timestamp] { cursor: help; font-variant-numeric: tabular-nums; }
 #atomic-graph .react-flow__node-card { pointer-events:none !important; }
 #atomic-graph .react-flow__node-card > .atomic-dependency-card { pointer-events:auto; }
 #atomic-graph .react-flow__node.selected .atomic-dependency-card { outline:2px solid var(--accent); outline-offset:3px; }
+#atomic-graph .atomic-dependency-card { border-color: var(--node-color, var(--border)); background: var(--raised); box-shadow: 0 3px 10px #00000022; }
+#atomic-graph .atomic-dependency-card[data-state="planned"] { border-style: dashed; }
+#atomic-graph .atomic-dependency-card[data-state="blocked"] { background: color-mix(in srgb, var(--raised) 92%, var(--negative) 8%); }
 #atomic-graph .react-flow__handle { opacity:0; width:1px; height:1px; border:0; pointer-events:none; }
 #atomic-graph .react-flow__attribution { background:var(--surface); color:var(--muted); font-size:9px; }
 .atomic-dependency-scope { margin-top:6px; color:var(--muted); font-size:11px; line-height:15px; overflow-wrap:anywhere; }