@loomhelm/multi-task-flow 0.2.7 → 0.2.9

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

@@ -25,6 +25,11 @@ test("represents closed PRs without treating them as success", () => {
   expect(parsed.state).toBe("closed");
 });
 
+test("represents a singleton task by the delivery-unit PR binding", () => {
+  const parsed = taskPrBinding.parse({ state: "shared_delivery_unit", delivery_unit_id: "du-1" });
+  expect(parsed).toEqual({ state: "shared_delivery_unit", delivery_unit_id: "du-1" });
+});
+
 test("rejects cyclic atomic graphs and empty planned milestones", () => {
   const nodes = [
     { kind: "milestone", id: "m-1", title: "M1", state: "planned", scope: { kind: "delivery_unit", delivery_unit_id: "du-1" }, acceptance: [{ kind: "node_satisfied", node_id: "w-1" }] },
@@ -49,6 +54,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/browser/README.md

@@ -5,7 +5,7 @@ The agreed seam is the rendered mock example: click a task to open details and c
 Build the existing `demo:static` surface and use its current owned preview server. In the Codex in-app browser REPL, bind the preview tab and viewport capability, import the checked-in runner, then run it:
 
 ```js
-var regression = await import("file:///absolute/repo/skills/multi-task-flow/tests/browser/card-width-regression.ts");
+var regression = await import("file:///absolute/repo/skills/multi-task-flow-runtime/tests/browser/card-width-regression.ts");
 await regression.checkCardWidths(tab, viewport);
 ```
 

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

@@ -1,45 +1,19 @@
 import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import { cpSync, existsSync, mkdtempSync, readFileSync, realpathSync, renameSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { cpSync, existsSync, mkdtempSync, realpathSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { test } from 'bun:test';
-import { checkSkillsInstallation } from '../scripts/check-skills-installation.ts';
 
-test('a source-only skills installation runs official TS entrypoints and detects missing resources', () => {
+test('the installable Skill tree excludes npm runtime resources', () => {
   const isolated = realpathSync(mkdtempSync(join(tmpdir(), 'loomhelm-skills-only-')));
-  const source = resolve(import.meta.dirname, '../..');
-  const manifest = JSON.parse(readFileSync(join(source,'source-manifest.json'),'utf8'));
-  const sources = new Set([...manifest.files,...manifest.additions].map(file => resolve(source,'..',file.path)));
+  const source = resolve(import.meta.dirname, '../../multi-task-flow');
   try {
-    cpSync(source, join(isolated,'skills'), { recursive:true, filter:path => !['node_modules','.cache','dist'].includes(path.split('/').at(-1)) && !path.endsWith('.node') && (!path.endsWith('.js') || sources.has(path)) });
-    const unprepared = checkSkillsInstallation(isolated,{probe:true});
-    assert.equal(unprepared.sourceComplete,true);
-    assert.equal(unprepared.ready,false); assert.equal(unprepared.ok,false);
-    assert.equal(unprepared.code,'SKILLS_RUNTIME_DEPENDENCY_MISSING');
-    assert.deepEqual(unprepared.dependencies.missing.sort(),['sharp','zod']);
-    assert.equal(unprepared.entrypoints.status,'blocked');
-    const install = spawnSync(process.execPath, ['install','--cwd',join(isolated,'skills'),'--frozen-lockfile','--ignore-scripts','--backend=copy'], {env:process.env,encoding:'utf8'});
-    assert.equal(install.status,0,install.stderr);
-    const report = checkSkillsInstallation(isolated,{probe:true});
-    assert.equal(report.ok,true,JSON.stringify(report)); assert.equal(report.ready,true);
-    assert.equal(report.skills,29); assert.deepEqual(report.requiredSparsePaths,['skills']);
-    assert.equal(existsSync(join(isolated,'bin')),false);
-    assert.equal(existsSync(join(isolated,'skills/bin/plan_review_view.js')),false);
-    assert.equal(existsSync(join(isolated,'skills/bin/native/posix.node')),false);
-    const plan=readFileSync(join(isolated,'skills/dev-plan/references/plan-cases/positive-fast-track.md'),'utf8');
-    const finalized=spawnSync('/bin/bash',['-p',join(isolated,'skills/bin/plan-cli.sh'),'--input','-'],{cwd:source,env:process.env,input:plan,encoding:'utf8',timeout:30000});
-    assert.equal(finalized.status,0,finalized.stderr); assert.match(finalized.stdout,/<proposed_plan>/);
-    const context=join(isolated,'skills/dot-codex-development/scripts/context.ts');
-    const original=readFileSync(context); writeFileSync(context,'// tampered');
-    assert.equal(checkSkillsInstallation(isolated).sourceComplete,false);
-    writeFileSync(context,original);
-    renameSync(context,join(isolated,'context.ts')); symlinkSync(join(isolated,'context.ts'),context);
-    assert.equal(checkSkillsInstallation(isolated).ok,false);
-    rmSync(context); renameSync(join(isolated,'context.ts'),context);
-    renameSync(join(isolated,'skills/bin'),join(isolated,'bin'));
-    const broken=checkSkillsInstallation(isolated,{probe:true});
-    assert.equal(broken.ok,false); assert.equal(broken.ready,false);
-    assert.ok(broken.missing.includes('skills/bin/plan_review_view.ts'));
-  } finally { rmSync(isolated,{recursive:true,force:true}); }
-},60000);
+    cpSync(source, join(isolated, 'multi-task-flow'), { recursive: true });
+    assert.equal(existsSync(join(isolated, 'multi-task-flow', 'SKILL.md')), true);
+    for (const name of ['data', 'dist', 'examples', 'lib', 'scripts', 'tests', 'web', 'package.json', 'bun.lock']) {
+      assert.equal(existsSync(join(isolated, 'multi-task-flow', name)), false, name);
+    }
+  } finally {
+    rmSync(isolated, { recursive: true, force: true });
+  }
+}, 60000);

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

@@ -0,0 +1,33 @@
+import { expect, test } from "bun:test";
+import { deliveryTopologyForGroup, validateDeliveryTopologies } from "../lib/schema";
+
+const task = (id: string, group_id: string, policy: "shared_delivery_unit" | "child_pr") => ({
+  id,
+  group_id,
+  kind: "contribution" as const,
+  disposition: "active" as const,
+  execution_owner: policy === "shared_delivery_unit" ? "delivery_agent" as const : "task_agent" as const,
+  conversation_policy: policy === "shared_delivery_unit" ? "delivery_owned" as const : "task_agent" as const,
+  delivery_policy: policy,
+});
+
+test("derives shared topology from one contribution task", () => {
+  const tasks = [task("task-a", "du-a", "shared_delivery_unit")];
+  expect(deliveryTopologyForGroup(tasks as any, "du-a")).toBe("shared_delivery");
+  expect(() => validateDeliveryTopologies(tasks as any, true)).not.toThrow();
+});
+
+test("derives multi-task topology without allowing shared policies", () => {
+  const tasks = [task("task-a", "du-a", "child_pr"), task("task-b", "du-a", "child_pr")];
+  expect(deliveryTopologyForGroup(tasks as any, "du-a")).toBe("multi_task_integration");
+  expect(() => validateDeliveryTopologies(tasks as any, true)).not.toThrow();
+  expect(() => validateDeliveryTopologies([task("task-a", "du-a", "shared_delivery_unit"), task("task-b", "du-a", "child_pr")] as any, true)).toThrow("multi-task delivery unit");
+});
+
+test("does not count verification tasks when deriving topology", () => {
+  const tasks = [
+    task("task-a", "du-a", "shared_delivery_unit"),
+    { id: "verify-a", group_id: "du-a", kind: "verification", disposition: "active" },
+  ];
+  expect(deliveryTopologyForGroup(tasks as any, "du-a")).toBe("shared_delivery");
+});

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/orchestrate.test.ts

@@ -627,7 +627,7 @@ describe("orchestrate init", () => {
   });
 
   test("documents init as an explicit mutation boundary", () => {
-    const skill = readFileSync(join(import.meta.dir, "../SKILL.md"), "utf8");
+    const skill = readFileSync(join(import.meta.dir, "../../multi-task-flow/SKILL.md"), "utf8");
     const design = readFileSync(
       join(
         import.meta.dir,
@@ -636,10 +636,8 @@ describe("orchestrate init", () => {
       "utf8",
     );
 
-    expect(skill).toContain("Initialization is a mutating runtime action");
-    expect(skill).toContain(
-      "must not call `init` or a native conversation-creation tool",
-    );
+    expect(skill).toContain("初始化是有副作用的运行时操作");
+    expect(skill).toContain("只读审查、诊断、代码探索或仅制定计划时不得调用本 Skill");
     expect(design).toContain("失败返回 `INVALID_INITIAL_STATE`");
     expect(design).toContain("不创建任务会话");
   });

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

@@ -22,6 +22,15 @@ describe("dashboard details content", () => {
     expect(document.querySelector(".detail-duration")?.textContent).toBe("未知");
     expect(duration(details.groupPreview(group))).toBe("未知");
   });
+  test("group details include the full Agent output at the end", () => {
+    const group = { id: "core", title: "核心", state: "closed", agent_thread_id: "thread-group", parent_pr: { url: null }, latest_agent_output: { thread_id: "thread-group", agent_state: "idle", stale: false, state: "available", text: "交付单元已完成", turn_id: null, message_id: null, phase: null, message_status: null, observed_at: null } } as Group;
+    const view = { groups: [group], tasks: [], actual_intervals: [] } as unknown as View;
+    const details = createDetailContent({ getData: () => view, labels: {}, labelTask: () => "", time: () => "", safeExternal: () => null });
+    details.showGroup(group);
+    const labels = [...document.querySelectorAll("#details-content .detail-label")].map((node) => node.textContent);
+    expect(labels.at(-1)).toBe("Agent 输出");
+    expect(document.querySelector(".detail-agent-output")?.textContent).toContain("交付单元已完成");
+  });
   test("keeps the summary outside the scroll body and preserves only the same object's reading position", () => {
     const group = { id: "same", title: "交付单元", state: "closed", parent_pr: { url: null } } as Group;
     const view = { groups: [group], tasks: [], actual_intervals: [] } as unknown as View;
@@ -237,6 +246,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 },