@duypham93/openkit 0.2.0

package/.opencode/tests/multi-work-item-runtime.test.js

@@ -0,0 +1,369 @@
+const test = require("node:test")
+const assert = require("node:assert/strict")
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+
+const {
+  advanceStage,
+  claimTask,
+  createTask: createBoardTask,
+  listTasks,
+  reassignTask,
+  releaseTask,
+  selectActiveWorkItem,
+  setApproval,
+  setTaskStatus,
+  showState,
+  showWorkItemState,
+  startFeature,
+  startTask,
+  validateWorkItemBoard,
+} = require("../lib/workflow-state-controller")
+const { readWorkItemIndex, readWorkItemState } = require("../lib/work-item-store")
+
+function makeTempDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "openkit-multi-work-item-"))
+}
+
+function loadFixtureState() {
+  const fixturePath = path.resolve(__dirname, "../workflow-state.json")
+  return JSON.parse(fs.readFileSync(fixturePath, "utf8"))
+}
+
+function createTempStateFile() {
+  const dir = makeTempDir()
+  const opencodeDir = path.join(dir, ".opencode")
+  fs.mkdirSync(opencodeDir, { recursive: true })
+  const statePath = path.join(opencodeDir, "workflow-state.json")
+  fs.writeFileSync(statePath, `${JSON.stringify(loadFixtureState(), null, 2)}\n`, "utf8")
+  return statePath
+}
+
+function createTask(overrides = {}) {
+  return {
+    task_id: "TASK-1",
+    title: "Implement feature slice",
+    summary: "Controller-backed board validation",
+    kind: "implementation",
+    status: "ready",
+    primary_owner: null,
+    qa_owner: null,
+    depends_on: [],
+    blocked_by: [],
+    artifact_refs: [],
+    plan_refs: ["docs/plans/2026-03-21-feature.md"],
+    branch_or_worktree: null,
+    created_by: "TechLeadAgent",
+    created_at: "2026-03-21T00:00:00.000Z",
+    updated_at: "2026-03-21T00:00:00.000Z",
+    ...overrides,
+  }
+}
+
+function writeTaskBoard(statePath, workItemId, board) {
+  const projectRoot = path.dirname(path.dirname(statePath))
+  const boardPath = path.join(projectRoot, ".opencode", "work-items", workItemId, "tasks.json")
+  fs.mkdirSync(path.dirname(boardPath), { recursive: true })
+  fs.writeFileSync(boardPath, `${JSON.stringify(board, null, 2)}\n`, "utf8")
+}
+
+function advanceFullWorkItemToPlan(statePath) {
+  advanceStage("full_brief", statePath)
+  setApproval("pm_to_ba", "approved", "user", "2026-03-21", "Approved", statePath)
+  advanceStage("full_spec", statePath)
+  setApproval("ba_to_architect", "approved", "user", "2026-03-21", "Approved", statePath)
+  advanceStage("full_architecture", statePath)
+  setApproval("architect_to_tech_lead", "approved", "user", "2026-03-21", "Approved", statePath)
+  advanceStage("full_plan", statePath)
+}
+
+test("compatibility mirror refresh happens after the active work item pointer changes", () => {
+  const statePath = createTempStateFile()
+  const projectRoot = path.dirname(path.dirname(statePath))
+
+  startFeature("FEATURE-300", "first-feature", statePath)
+  startTask("quick", "TASK-300", "second-item", "Select a new quick task", statePath)
+
+  const indexBeforeSelection = readWorkItemIndex(projectRoot)
+  const mirrorBeforeSelection = JSON.parse(fs.readFileSync(statePath, "utf8"))
+  assert.equal(indexBeforeSelection.active_work_item_id, "task-300")
+  assert.equal(mirrorBeforeSelection.work_item_id, "task-300")
+
+  const result = selectActiveWorkItem("feature-300", statePath)
+  const indexAfterSelection = readWorkItemIndex(projectRoot)
+  const mirrorAfterSelection = JSON.parse(fs.readFileSync(statePath, "utf8"))
+  const activePerItemState = readWorkItemState(projectRoot, "feature-300")
+
+  assert.equal(result.state.work_item_id, "feature-300")
+  assert.equal(indexAfterSelection.active_work_item_id, "feature-300")
+  assert.deepEqual(mirrorAfterSelection, activePerItemState)
+})
+
+test("selectActiveWorkItem rewrites a stale compatibility mirror from the active per-item state", () => {
+  const statePath = createTempStateFile()
+  const projectRoot = path.dirname(path.dirname(statePath))
+
+  startFeature("FEATURE-305", "mirror-refresh", statePath)
+  startTask("quick", "TASK-305", "active-quick", "Use quick item as active selection", statePath)
+
+  fs.writeFileSync(
+    statePath,
+    `${JSON.stringify({
+      feature_id: "STALE-ITEM",
+      feature_slug: "stale-mirror",
+      mode: "full",
+      mode_reason: "stale",
+      routing_profile: {
+        work_intent: "feature",
+        behavior_delta: "extend",
+        dominant_uncertainty: "product",
+        scope_shape: "cross_boundary",
+        selection_reason: "stale",
+      },
+      current_stage: "full_done",
+      status: "done",
+      current_owner: "MasterOrchestrator",
+      artifacts: {
+        task_card: null,
+        brief: null,
+        spec: null,
+        architecture: null,
+        plan: null,
+        migration_report: null,
+        qa_report: null,
+        adr: [],
+      },
+      approvals: {
+        pm_to_ba: { status: "approved", approved_by: null, approved_at: null, notes: null },
+        ba_to_architect: { status: "approved", approved_by: null, approved_at: null, notes: null },
+        architect_to_tech_lead: { status: "approved", approved_by: null, approved_at: null, notes: null },
+        tech_lead_to_fullstack: { status: "approved", approved_by: null, approved_at: null, notes: null },
+        fullstack_to_qa: { status: "approved", approved_by: null, approved_at: null, notes: null },
+        qa_to_done: { status: "approved", approved_by: null, approved_at: null, notes: null },
+      },
+      issues: [],
+      retry_count: 0,
+      escalated_from: null,
+      escalation_reason: null,
+      updated_at: "2026-03-21T00:00:00.000Z",
+      work_item_id: "stale-item",
+    }, null, 2)}\n`,
+    "utf8",
+  )
+
+  const result = selectActiveWorkItem("task-305", statePath)
+  const mirrorAfterRefresh = JSON.parse(fs.readFileSync(statePath, "utf8"))
+  const activePerItemState = readWorkItemState(projectRoot, "task-305")
+
+  assert.equal(result.state.work_item_id, "task-305")
+  assert.equal(mirrorAfterRefresh.work_item_id, "task-305")
+  assert.deepEqual(mirrorAfterRefresh, activePerItemState)
+})
+
+test("per-item reads remain stable while active selection changes", () => {
+  const statePath = createTempStateFile()
+
+  startFeature("FEATURE-301", "feature-one", statePath)
+  startTask("quick", "TASK-301", "task-two", "Second tracked item", statePath)
+
+  const featureStateBefore = showWorkItemState("feature-301", statePath)
+  assert.equal(featureStateBefore.state.feature_id, "FEATURE-301")
+
+  selectActiveWorkItem("feature-301", statePath)
+
+  const activeState = showState(statePath)
+  const taskState = showWorkItemState("task-301", statePath)
+
+  assert.equal(activeState.state.work_item_id, "feature-301")
+  assert.equal(taskState.state.work_item_id, "task-301")
+  assert.equal(taskState.state.feature_id, "TASK-301")
+})
+
+test("active selection fails validation when switched to a quick work item carrying tasks.json", () => {
+  const statePath = createTempStateFile()
+
+  startFeature("FEATURE-302", "feature-valid", statePath)
+  startTask("quick", "TASK-302", "quick-invalid", "Quick item with stale board", statePath)
+  writeTaskBoard(statePath, "task-302", {
+    mode: "full",
+    current_stage: "full_plan",
+    tasks: [createTask()],
+    issues: [],
+  })
+
+  assert.throws(() => showState(statePath), /Quick mode cannot carry a task board/)
+
+  const featureState = showWorkItemState("feature-302", statePath)
+  assert.equal(featureState.state.work_item_id, "feature-302")
+})
+
+test("active selection fails validation when switched to a migration work item carrying tasks.json", () => {
+  const statePath = createTempStateFile()
+
+  startFeature("FEATURE-303", "feature-valid", statePath)
+  startTask("migration", "MIGRATE-302", "migration-invalid", "Migration item with stale board", statePath)
+  writeTaskBoard(statePath, "migrate-302", {
+    mode: "full",
+    current_stage: "full_plan",
+    tasks: [createTask()],
+    issues: [],
+  })
+
+  assert.throws(() => showState(statePath), /Migration mode cannot carry a task board/)
+
+  const featureState = showWorkItemState("feature-303", statePath)
+  assert.equal(featureState.state.work_item_id, "feature-303")
+})
+
+test("task-board helpers operate on a specific full work item without changing active selection", () => {
+  const statePath = createTempStateFile()
+
+  startFeature("FEATURE-400", "board-target", statePath)
+  selectActiveWorkItem("feature-400", statePath)
+  advanceFullWorkItemToPlan(statePath)
+  startTask("quick", "TASK-400", "active-quick-item", "Keep quick item active", statePath)
+
+  createBoardTask(
+    "feature-400",
+    {
+      task_id: "TASK-401",
+      title: "Controller board task",
+      summary: "Keep board edits scoped to the selected work item",
+      kind: "implementation",
+      plan_refs: ["docs/plans/2026-03-21-feature.md"],
+      created_by: "TechLeadAgent",
+    },
+    statePath,
+  )
+
+  const activeState = showState(statePath)
+  const featureTasks = listTasks("feature-400", statePath)
+  const validatedBoard = validateWorkItemBoard("feature-400", statePath)
+
+  assert.equal(activeState.state.work_item_id, "task-400")
+  assert.equal(featureTasks.tasks.length, 1)
+  assert.equal(featureTasks.tasks[0].task_id, "TASK-401")
+  assert.equal(validatedBoard.board.tasks[0].task_id, "TASK-401")
+})
+
+test("invalid worktree metadata does not persist partial task-board writes", () => {
+  const statePath = createTempStateFile()
+
+  startFeature("FEATURE-401", "rollback-invalid-worktree", statePath)
+  advanceFullWorkItemToPlan(statePath)
+
+  assert.throws(
+    () =>
+      createBoardTask(
+        "feature-401",
+        {
+          task_id: "TASK-401",
+          title: "Unsafe worktree",
+          summary: "Reject protected branch metadata",
+          kind: "implementation",
+          created_by: "TechLeadAgent",
+          worktree_metadata: {
+            task_id: "TASK-401",
+            branch: "main",
+            worktree_path: ".worktrees/task-401-parallel",
+          },
+        },
+        statePath,
+      ),
+    /must not target main/,
+  )
+
+  assert.equal(fs.existsSync(path.join(path.dirname(path.dirname(statePath)), ".opencode", "work-items", "feature-401", "tasks.json")), false)
+})
+
+test("qa-fail local rework keeps mutations scoped to the targeted work item", () => {
+  const statePath = createTempStateFile()
+
+  startFeature("FEATURE-402", "full-target", statePath)
+  selectActiveWorkItem("feature-402", statePath)
+  advanceFullWorkItemToPlan(statePath)
+  startTask("quick", "TASK-402", "active-quick", "Keep quick item active", statePath)
+
+  createBoardTask(
+    "feature-402",
+    {
+      task_id: "TASK-402A",
+      title: "Scoped local rework",
+      summary: "Only mutate target work item",
+      kind: "implementation",
+      status: "qa_in_progress",
+      primary_owner: "Dev-A",
+      qa_owner: "QA-Agent",
+      created_by: "TechLeadAgent",
+    },
+    statePath,
+  )
+
+  const result = setTaskStatus("feature-402", "TASK-402A", "claimed", statePath, {
+    requestedBy: "QAAgent",
+    finding: {
+      issue_id: "ISSUE-402",
+      task_id: "TASK-402A",
+      title: "Regression found during QA",
+      summary: "Fix one task-local implementation bug",
+      type: "bug",
+      severity: "medium",
+      rooted_in: "implementation",
+      recommended_owner: "FullstackAgent",
+      evidence: "Targeted regression reproduced in QA.",
+      artifact_refs: ["docs/qa/2026-03-21-feature-402.md"],
+      affects_tasks: ["TASK-402A"],
+      blocks_parallel_work: false,
+    },
+    rerouteDecision: {
+      stage: "full_implementation",
+      owner: "FullstackAgent",
+      decided_by: "TechLeadAgent",
+      reason: "Return only the failing task to implementation",
+    },
+  })
+
+  const activeState = showState(statePath)
+  const featureState = showWorkItemState("feature-402", statePath)
+  const board = listTasks("feature-402", statePath)
+
+  assert.equal(result.board.tasks[0].status, "claimed")
+  assert.equal(activeState.state.work_item_id, "task-402")
+  assert.equal(featureState.state.work_item_id, "feature-402")
+  assert.equal(board.tasks[0].status, "claimed")
+  assert.equal(featureState.state.current_stage, "full_implementation")
+  assert.equal(featureState.state.current_owner, "FullstackAgent")
+})
+
+test("explicit release and reassign flows stay scoped to the targeted work item", () => {
+  const statePath = createTempStateFile()
+
+  startFeature("FEATURE-403", "targeted-assignment", statePath)
+  selectActiveWorkItem("feature-403", statePath)
+  advanceFullWorkItemToPlan(statePath)
+  startTask("quick", "TASK-403", "active-quick", "Keep quick item active", statePath)
+
+  createBoardTask(
+    "feature-403",
+    {
+      task_id: "TASK-403A",
+      title: "Scoped reassignment",
+      summary: "Only mutate target work item assignments",
+      kind: "implementation",
+      created_by: "TechLeadAgent",
+    },
+    statePath,
+  )
+
+  claimTask("feature-403", "TASK-403A", "Dev-A", statePath, { requestedBy: "TechLeadAgent" })
+  reassignTask("feature-403", "TASK-403A", "Dev-B", statePath, { requestedBy: "TechLeadAgent" })
+  const releaseResult = releaseTask("feature-403", "TASK-403A", statePath, { requestedBy: "TechLeadAgent" })
+
+  const activeState = showState(statePath)
+  const featureTasks = listTasks("feature-403", statePath)
+
+  assert.equal(activeState.state.work_item_id, "task-403")
+  assert.equal(releaseResult.board.tasks[0].status, "ready")
+  assert.equal(featureTasks.tasks[0].primary_owner, null)
+})

package/.opencode/tests/parallel-execution-runtime.test.js

@@ -0,0 +1,259 @@
+const test = require("node:test")
+const assert = require("node:assert/strict")
+
+const {
+  VALID_ASSIGNMENT_AUTHORITIES,
+  decideQaFailLocalRework,
+  validateFailureIsolation,
+  validateParallelAssignments,
+  validateReassignmentAuthority,
+  validateTaskScopedFinding,
+  validateWorktreeMetadata,
+} = require("../lib/parallel-execution-rules")
+
+function makeTask(overrides = {}) {
+  return {
+    task_id: "TASK-11",
+    title: "Parallel execution rules",
+    status: "in_progress",
+    primary_owner: "Dev-A",
+    qa_owner: null,
+    ...overrides,
+  }
+}
+
+function makeFinding(overrides = {}) {
+  return {
+    issue_id: "ISSUE-11",
+    task_id: "TASK-11",
+    title: "Regression found during QA",
+    summary: "Fix task-local implementation bug",
+    type: "bug",
+    severity: "medium",
+    rooted_in: "implementation",
+    recommended_owner: "FullstackAgent",
+    evidence: "Targeted regression reproduced in QA.",
+    artifact_refs: ["docs/plans/2026-03-21-parallel-rollout.md"],
+    affects_tasks: ["TASK-11"],
+    blocks_parallel_work: false,
+    ...overrides,
+  }
+}
+
+test("primary-owner assignment validation is per task, not global across tasks", () => {
+  assert.doesNotThrow(() => validateParallelAssignments([
+    makeTask({ task_id: "TASK-11", primary_owner: "Dev-A", status: "in_progress" }),
+    makeTask({ task_id: "TASK-12", primary_owner: "Dev-B", status: "claimed" }),
+    makeTask({ task_id: "TASK-13", primary_owner: "Dev-A", status: "done" }),
+  ]))
+
+  assert.doesNotThrow(() => validateParallelAssignments([
+    makeTask({ task_id: "TASK-11", primary_owner: "Dev-A", status: "in_progress" }),
+    makeTask({ task_id: "TASK-12", primary_owner: "Dev-A", status: "claimed" }),
+  ]))
+
+  assert.throws(() => validateParallelAssignments([
+    makeTask({ task_id: "TASK-11", primary_owner: ["Dev-A"] }),
+  ]), /primary_owner.*non-empty string/)
+})
+
+test("qa-owner assignment validation is per task, not global across tasks", () => {
+  assert.doesNotThrow(() => validateParallelAssignments([
+    makeTask({ task_id: "TASK-11", status: "qa_in_progress", qa_owner: "QA-Agent" }),
+    makeTask({ task_id: "TASK-12", status: "done", qa_owner: "QA-Agent" }),
+  ]))
+
+  assert.doesNotThrow(() => validateParallelAssignments([
+    makeTask({ task_id: "TASK-11", status: "qa_ready", qa_owner: "QA-Agent" }),
+    makeTask({ task_id: "TASK-12", status: "qa_in_progress", qa_owner: "QA-Agent" }),
+  ]))
+
+  assert.throws(() => validateParallelAssignments([
+    makeTask({ task_id: "TASK-11", status: "qa_ready", qa_owner: ["QA-Agent"] }),
+  ]), /qa_owner.*non-empty string/)
+})
+
+test("reassignment authority allows initial assignment but restricts reassignment", () => {
+  assert.deepEqual(VALID_ASSIGNMENT_AUTHORITIES.primary_owner, ["MasterOrchestrator", "TechLeadAgent"])
+  assert.deepEqual(VALID_ASSIGNMENT_AUTHORITIES.qa_owner, ["MasterOrchestrator", "TechLeadAgent"])
+
+  assert.doesNotThrow(() => validateReassignmentAuthority({
+    task: makeTask({ primary_owner: null, status: "ready" }),
+    ownerField: "primary_owner",
+    requestedBy: "TechLeadAgent",
+    nextOwner: "Dev-A",
+  }))
+
+  assert.doesNotThrow(() => validateReassignmentAuthority({
+    task: makeTask({ primary_owner: "Dev-A", status: "in_progress" }),
+    ownerField: "primary_owner",
+    requestedBy: "TechLeadAgent",
+    nextOwner: "Dev-B",
+  }))
+
+  assert.doesNotThrow(() => validateReassignmentAuthority({
+    task: makeTask({ primary_owner: "Dev-A", status: "in_progress" }),
+    ownerField: "primary_owner",
+    requestedBy: "MasterOrchestrator",
+    nextOwner: "Dev-B",
+  }))
+
+  assert.doesNotThrow(() => validateReassignmentAuthority({
+    task: makeTask({ qa_owner: "QA-Agent", status: "qa_ready" }),
+    ownerField: "qa_owner",
+    requestedBy: "TechLeadAgent",
+    nextOwner: "QA-Agent-2",
+  }))
+
+  assert.throws(() => validateReassignmentAuthority({
+    task: makeTask({ qa_owner: null, status: "dev_done" }),
+    ownerField: "qa_owner",
+    requestedBy: "QAAgent",
+    nextOwner: "QA-Agent",
+  }), /MasterOrchestrator or TechLeadAgent.*qa_owner/)
+})
+
+test("task-scoped finding validation enforces routing-safe shape", () => {
+  assert.doesNotThrow(() => validateTaskScopedFinding(makeFinding(), makeTask()))
+
+  assert.throws(() => validateTaskScopedFinding(makeFinding({ task_id: "TASK-99" }), makeTask()), /task-scoped finding.*TASK-11/)
+  assert.throws(() => validateTaskScopedFinding(makeFinding({ artifact_refs: [] }), makeTask()), /artifact_refs/)
+  assert.throws(() => validateTaskScopedFinding(makeFinding({ affects_tasks: ["TASK-11", "TASK-12"] }), makeTask()), /affects_tasks/)
+})
+
+test("QA fail local rework routing allows only isolated implementation bugs", () => {
+  const decision = decideQaFailLocalRework({
+    mode: "full",
+    task: makeTask({ status: "qa_in_progress", primary_owner: "Dev-A", qa_owner: "QA-Agent" }),
+    finding: makeFinding(),
+    rerouteDecision: {
+      stage: "full_qa",
+      owner: "QAAgent",
+      decided_by: "TechLeadAgent",
+      reason: "Keep overall feature QA active while routing one task back for local rework",
+    },
+  })
+
+  assert.deepEqual(decision, {
+    allowed: true,
+    route: {
+      stage: "full_qa",
+      owner: "QAAgent",
+      decided_by: "TechLeadAgent",
+      reason: "Keep overall feature QA active while routing one task back for local rework",
+    },
+  })
+
+  const implementationDecision = decideQaFailLocalRework({
+    mode: "full",
+    task: makeTask({ status: "qa_in_progress", primary_owner: "Dev-A", qa_owner: "QA-Agent" }),
+    finding: makeFinding(),
+    rerouteDecision: {
+      stage: "full_implementation",
+      owner: "FullstackAgent",
+      decided_by: "MasterOrchestrator",
+      reason: "Aggregate risk requires implementation-stage reroute",
+    },
+  })
+
+  assert.deepEqual(implementationDecision.route, {
+    stage: "full_implementation",
+    owner: "FullstackAgent",
+    decided_by: "MasterOrchestrator",
+    reason: "Aggregate risk requires implementation-stage reroute",
+  })
+
+  assert.throws(() => decideQaFailLocalRework({
+    mode: "quick",
+    task: makeTask({ status: "qa_in_progress" }),
+    finding: makeFinding(),
+  }), /full mode/)
+
+  assert.throws(() => decideQaFailLocalRework({
+    mode: "full",
+    task: makeTask({ status: "qa_in_progress" }),
+    finding: makeFinding({ type: "design_flaw", rooted_in: "architecture", recommended_owner: "ArchitectAgent" }),
+  }), /design or requirements findings must not stay in local rework/)
+
+  assert.throws(() => decideQaFailLocalRework({
+    mode: "full",
+    task: makeTask({ status: "qa_in_progress" }),
+    finding: makeFinding(),
+    rerouteDecision: {
+      stage: "full_implementation",
+      owner: "FullstackAgent",
+      decided_by: "QAAgent",
+      reason: "QA should not self-authorize reroute decisions",
+    },
+  }), /field 'decided_by'.*MasterOrchestrator.*TechLeadAgent.*QAAgent/)
+
+  assert.throws(() => decideQaFailLocalRework({
+    mode: "full",
+    task: makeTask({ status: "qa_in_progress" }),
+    finding: makeFinding(),
+    rerouteDecision: {
+      stage: "full_done",
+      owner: "MasterOrchestrator",
+      decided_by: "MasterOrchestrator",
+      reason: "Invalid reroute target",
+    },
+  }), /field 'stage'.*full_qa.*full_implementation.*full_done/)
+
+  assert.throws(() => decideQaFailLocalRework({
+    mode: "full",
+    task: makeTask({ status: "qa_in_progress" }),
+    finding: makeFinding(),
+    rerouteDecision: {
+      stage: "full_qa",
+      owner: "MasterOrchestrator",
+      decided_by: "MasterOrchestrator",
+      reason: "Invalid reroute owner",
+    },
+  }), /field 'owner'.*QAAgent.*FullstackAgent.*MasterOrchestrator/)
+
+  assert.throws(() => decideQaFailLocalRework({
+    mode: "full",
+    task: makeTask({ status: "qa_in_progress" }),
+    finding: makeFinding(),
+    rerouteDecision: {
+      stage: "full_qa",
+      owner: "QAAgent",
+      decided_by: "MasterOrchestrator",
+      reason: "",
+    },
+  }), /reason.*non-empty string/)
+})
+
+test("failure isolation rules reject shared or blocking failures", () => {
+  assert.doesNotThrow(() => validateFailureIsolation(makeFinding(), makeTask()))
+
+  assert.throws(() => validateFailureIsolation(makeFinding({ blocks_parallel_work: true }), makeTask()), /blocks parallel work/)
+  assert.throws(() => validateFailureIsolation(makeFinding({ affects_tasks: ["TASK-11", "TASK-12"] }), makeTask()), /isolated to exactly one task/)
+  assert.throws(() => validateFailureIsolation(makeFinding({ severity: "critical" }), makeTask()), /critical failures require orchestrator escalation/)
+})
+
+test("worktree and branch metadata validation requires task-specific isolation metadata", () => {
+  assert.doesNotThrow(() => validateWorktreeMetadata({
+    task_id: "TASK-11",
+    branch: "task/TASK-11-parallel-execution",
+    worktree_path: ".worktrees/task-11-parallel-execution",
+  }))
+
+  assert.throws(() => validateWorktreeMetadata({
+    task_id: "TASK-11",
+    branch: "main",
+    worktree_path: ".worktrees/task-11-parallel-execution",
+  }), /branch.*must not target main/)
+
+  assert.throws(() => validateWorktreeMetadata({
+    task_id: "TASK-11",
+    branch: "task/TASK-99-other-work",
+    worktree_path: ".worktrees/task-11-parallel-execution",
+  }), /branch.*TASK-11/)
+
+  assert.throws(() => validateWorktreeMetadata({
+    task_id: "TASK-11",
+    branch: "task/TASK-11-parallel-execution",
+    worktree_path: "parallel-agent-rollout",
+  }), /worktree_path/)
+})