@graphrefly/ts 0.0.0 → 0.0.1

package/dist/solutions/work-item/scheduling.cjs

@@ -0,0 +1,2454 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/solutions/work-item/scheduling.ts
+var scheduling_exports = {};
+__export(scheduling_exports, {
+  acceptanceCriteriaChanged: () => acceptanceCriteriaChanged,
+  validateAcceptanceCriteria: () => validateAcceptanceCriteria,
+  validateVerificationPlan: () => validateVerificationPlan,
+  validateWorkItemDraft: () => validateWorkItemDraft,
+  validateWorkItemEffectPlan: () => validateWorkItemEffectPlan,
+  verificationPlanChanged: () => verificationPlanChanged,
+  workItemAuthoringProjector: () => workItemAuthoringProjector,
+  workItemCreatedFromDraft: () => workItemCreatedFromDraft,
+  workItemEffectPlanProjector: () => workItemEffectPlanProjector,
+  workItemSpawnProposed: () => workItemSpawnProposed,
+  workItemVerificationRequestLowerer: () => workItemVerificationRequestLowerer,
+  workItemVerificationResultMapper: () => workItemVerificationResultMapper
+});
+module.exports = __toCommonJS(scheduling_exports);
+
+// src/protocol/messages.ts
+var SENTINEL = void 0;
+
+// src/ctx/types.ts
+function depWaves(ctx, depIndex) {
+  return ctx.waveData[depIndex] ?? [];
+}
+function depBatch(ctx, depIndex) {
+  const waves = depWaves(ctx, depIndex);
+  if (waves.length === 0) return null;
+  const flattened = waves.flat().filter((v) => v !== SENTINEL);
+  return flattened.length === 0 ? [] : flattened;
+}
+
+// src/solutions/work-item/scheduling.ts
+var executionRelevantDefaults = /* @__PURE__ */ new Set([
+  "detail",
+  "detailRefs",
+  "acceptanceCriteria",
+  "verificationPlan",
+  "verificationSteps",
+  "dependencies"
+]);
+var draftPatchKeys = /* @__PURE__ */ new Set([
+  "summary",
+  "detail",
+  "detailRefs",
+  "acceptanceCriteria",
+  "verificationPlan",
+  "verificationSteps",
+  "kind",
+  "priority",
+  "tags",
+  "owner",
+  "assignee",
+  "deadlineMs",
+  "customFields",
+  "sourceRefs",
+  "metadata"
+]);
+function workItemCreatedFromDraft(workItemId, draft, opts = {}) {
+  return {
+    kind: "work-item-created",
+    eventId: opts.eventId ?? `${workItemId}:created`,
+    workItemId,
+    draft,
+    authorId: opts.authorId,
+    createdAtMs: opts.createdAtMs,
+    sourceRefs: opts.sourceRefs,
+    metadata: opts.metadata
+  };
+}
+function workItemSpawnProposed(proposalId, draft, opts = {}) {
+  return {
+    kind: "work-item-spawn-proposed",
+    proposalId,
+    draft,
+    parentWorkItemId: opts.parentWorkItemId,
+    proposedBy: opts.proposedBy,
+    sourceRefs: opts.sourceRefs,
+    metadata: opts.metadata
+  };
+}
+function acceptanceCriteriaChanged(workItemId, acceptanceCriteria, opts) {
+  return {
+    kind: "acceptance-criteria-changed",
+    eventId: opts.eventId,
+    workItemId,
+    acceptanceCriteria,
+    authorId: opts.authorId,
+    changedAtMs: opts.changedAtMs,
+    sourceRefs: opts.sourceRefs,
+    metadata: opts.metadata
+  };
+}
+function verificationPlanChanged(workItemId, verificationPlan, opts) {
+  return {
+    kind: "verification-plan-changed",
+    eventId: opts.eventId,
+    workItemId,
+    verificationPlan,
+    authorId: opts.authorId,
+    changedAtMs: opts.changedAtMs,
+    sourceRefs: opts.sourceRefs,
+    metadata: opts.metadata
+  };
+}
+function validateWorkItemDraft(draft, opts = {}) {
+  const out = [];
+  if (!isRecord(draft)) {
+    return [issue("malformed-draft", "WorkItemDraft must be an object", opts.workItemId)];
+  }
+  if (typeof draft.summary !== "string") {
+    out.push(issue("missing-required-field", "WorkItemDraft.summary is required", opts.workItemId));
+  } else if (draft.summary.trim() === "") {
+    out.push(issue("missing-required-field", "WorkItemDraft.summary is required", opts.workItemId));
+  }
+  const criteria = draft.acceptanceCriteria === void 0 || Array.isArray(draft.acceptanceCriteria) ? draft.acceptanceCriteria : void 0;
+  if (draft.acceptanceCriteria !== void 0 && criteria === void 0) {
+    out.push(
+      issue(
+        "malformed-draft",
+        "WorkItemDraft.acceptanceCriteria must be an array",
+        opts.workItemId
+      )
+    );
+  }
+  out.push(...validateAcceptanceCriteria(criteria ?? [], opts));
+  if (draft.verificationPlan !== void 0 && !isVerificationPlanShape(draft.verificationPlan)) {
+    out.push(
+      issue("malformed-draft", "WorkItemDraft.verificationPlan is malformed", opts.workItemId)
+    );
+  }
+  if (draft.verificationSteps !== void 0 && !Array.isArray(draft.verificationSteps)) {
+    out.push(
+      issue("malformed-draft", "WorkItemDraft.verificationSteps must be an array", opts.workItemId)
+    );
+  }
+  const plan = normalizePlanFromUnknown(draft);
+  if (plan !== void 0) {
+    out.push(...validateVerificationPlan(plan, criteria ?? [], opts));
+  }
+  return out;
+}
+function validateAcceptanceCriteria(criteria, opts = {}) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const criterion of criteria) {
+    if (!isRecord(criterion)) {
+      out.push(issue("malformed-draft", "AcceptanceCriterion must be an object", opts.workItemId));
+      continue;
+    }
+    if (typeof criterion.criterionId !== "string" || criterion.criterionId === "") {
+      out.push(
+        issue(
+          "missing-required-field",
+          "AcceptanceCriterion.criterionId is required",
+          opts.workItemId
+        )
+      );
+      continue;
+    }
+    if (seen.has(criterion.criterionId)) {
+      out.push(
+        issue(
+          "duplicate-id",
+          `Duplicate acceptance criterion id '${criterion.criterionId}'`,
+          opts.workItemId,
+          { criterionId: criterion.criterionId }
+        )
+      );
+    }
+    seen.add(criterion.criterionId);
+    if (typeof criterion.statement !== "string" || criterion.statement.trim() === "") {
+      out.push(
+        issue(
+          "missing-required-field",
+          "AcceptanceCriterion.statement is required",
+          opts.workItemId,
+          { criterionId: criterion.criterionId }
+        )
+      );
+    }
+  }
+  return out;
+}
+function validateVerificationPlan(plan, criteria = [], opts = {}) {
+  const out = [];
+  if (!isRecord(plan) || !Array.isArray(plan.steps)) {
+    return [issue("malformed-draft", "VerificationPlan.steps must be an array", opts.workItemId)];
+  }
+  const criterionIds = new Set(criteria.map((criterion) => criterion.criterionId));
+  const stepIds = /* @__PURE__ */ new Set();
+  const modes = new Set(opts.allowedModes ?? ["auto", "manual", "hybrid"]);
+  const effectKinds = new Set(opts.allowedEffectKinds ?? ["verification"]);
+  for (const step of plan.steps) {
+    if (!isRecord(step)) {
+      out.push(issue("malformed-draft", "VerificationStep must be an object", opts.workItemId));
+      continue;
+    }
+    if (typeof step.stepId !== "string" || step.stepId === "") {
+      out.push(
+        issue("missing-required-field", "VerificationStep.stepId is required", opts.workItemId)
+      );
+      continue;
+    }
+    if (stepIds.has(step.stepId)) {
+      out.push(
+        issue("duplicate-id", `Duplicate verification step id '${step.stepId}'`, opts.workItemId, {
+          stepId: step.stepId
+        })
+      );
+    }
+    stepIds.add(step.stepId);
+    if (typeof step.mode !== "string" || !modes.has(step.mode)) {
+      out.push(
+        issue(
+          "unsupported-mode",
+          `Unsupported verification step mode '${step.mode}'`,
+          opts.workItemId,
+          { stepId: step.stepId }
+        )
+      );
+    }
+    if (step.effectKind !== void 0 && (typeof step.effectKind !== "string" || !effectKinds.has(step.effectKind))) {
+      out.push(
+        issue(
+          "unsupported-effect-kind",
+          `Unsupported verification effect kind '${step.effectKind}'`,
+          opts.workItemId,
+          { stepId: step.stepId }
+        )
+      );
+    }
+    const verifiesCriteriaIds = Array.isArray(step.verifiesCriteriaIds) ? step.verifiesCriteriaIds : [];
+    for (const criterionId of verifiesCriteriaIds) {
+      if (!criterionIds.has(criterionId)) {
+        out.push(
+          issue("dangling-ref", `Unknown acceptance criterion '${criterionId}'`, opts.workItemId, {
+            stepId: step.stepId,
+            criterionId
+          })
+        );
+      }
+    }
+  }
+  for (const step of plan.steps) {
+    if (!isRecord(step) || typeof step.stepId !== "string") continue;
+    const dependsOnStepIds = Array.isArray(step.dependsOnStepIds) ? step.dependsOnStepIds : [];
+    for (const depId of dependsOnStepIds) {
+      if (!stepIds.has(depId)) {
+        out.push(
+          issue("dangling-ref", `Unknown verification dependency '${depId}'`, opts.workItemId, {
+            stepId: step.stepId
+          })
+        );
+      }
+    }
+  }
+  const cycle = findCycle(
+    plan.steps.filter(
+      (step) => isRecord(step) && typeof step.stepId === "string" && Array.isArray(step.dependsOnStepIds)
+    )
+  );
+  if (cycle !== void 0) {
+    out.push(
+      issue(
+        "cyclic-dependency",
+        `Verification step cycle detected: ${cycle.join(" -> ")}`,
+        opts.workItemId,
+        { stepId: cycle[0] }
+      )
+    );
+  }
+  return out;
+}
+function workItemAuthoringProjector(graph, opts) {
+  const name = opts.name ?? "workItemAuthoring";
+  const runtime = graph.node(
+    [opts.facts],
+    (ctx) => {
+      const state = ctx.state.get() ?? {
+        workItems: /* @__PURE__ */ new Map(),
+        seenEvents: /* @__PURE__ */ new Set(),
+        statusSeq: 0,
+        auditSeq: 0
+      };
+      for (const raw of depBatch(ctx, 0) ?? [])
+        reduceAuthoring(ctx, state, raw, opts.policy);
+      ctx.state.set(state);
+    },
+    {
+      name: `${name}/runtime`,
+      factory: "workItemAuthoringProjector",
+      partial: true,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  return {
+    workItems: project(
+      graph,
+      runtime,
+      `${name}/workItems`,
+      "workItemAuthoringWorkItems",
+      (fact) => fact.kind === "work-item" ? fact.value : void 0
+    ),
+    status: project(
+      graph,
+      runtime,
+      `${name}/status`,
+      "workItemAuthoringStatus",
+      (fact) => fact.kind === "status" ? fact.value : void 0
+    ),
+    issues: project(
+      graph,
+      runtime,
+      `${name}/issues`,
+      "workItemAuthoringIssues",
+      (fact) => fact.kind === "issue" ? fact.value : void 0
+    ),
+    audit: project(
+      graph,
+      runtime,
+      `${name}/audit`,
+      "workItemAuthoringAudit",
+      (fact) => fact.kind === "audit" ? fact.value : void 0
+    )
+  };
+}
+function workItemVerificationRequestLowerer(graph, opts) {
+  const name = opts.name ?? "workItemVerificationRequests";
+  const deps = [opts.workItems];
+  const dispatchIntentIndex = opts.dispatchIntents === void 0 ? -1 : deps.push(opts.dispatchIntents) - 1;
+  const verificationResultIndex = opts.verificationResults === void 0 ? -1 : deps.push(opts.verificationResults) - 1;
+  const runtime = graph.node(
+    deps,
+    (ctx) => {
+      const state = ctx.state.get() ?? {
+        workItems: /* @__PURE__ */ new Map(),
+        emittedKeys: /* @__PURE__ */ new Set(),
+        passedSteps: /* @__PURE__ */ new Map(),
+        statusSeq: 0,
+        auditSeq: 0
+      };
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const workItem = raw;
+        state.workItems.set(workItem.workItemId, workItem);
+        lowerPlan(ctx, state, workItem, opts.policy);
+      }
+      if (dispatchIntentIndex >= 0) {
+        for (const raw of depBatch(ctx, dispatchIntentIndex) ?? [])
+          lowerIntent(ctx, state, raw, opts.policy);
+      }
+      if (verificationResultIndex >= 0) {
+        for (const raw of depBatch(ctx, verificationResultIndex) ?? [])
+          recordVerificationResult(ctx, state, raw, opts.policy);
+      }
+      ctx.state.set(state);
+    },
+    {
+      name: `${name}/runtime`,
+      factory: "workItemVerificationRequestLowerer",
+      partial: true,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  return {
+    effectRequests: project(
+      graph,
+      runtime,
+      `${name}/effectRequests`,
+      "workItemVerificationEffectRequests",
+      (fact) => fact.kind === "request" ? fact.value : void 0
+    ),
+    status: project(
+      graph,
+      runtime,
+      `${name}/status`,
+      "workItemVerificationRequestStatus",
+      (fact) => fact.kind === "status" ? fact.value : void 0
+    ),
+    issues: project(
+      graph,
+      runtime,
+      `${name}/issues`,
+      "workItemVerificationRequestIssues",
+      (fact) => fact.kind === "issue" ? fact.value : void 0
+    ),
+    audit: project(
+      graph,
+      runtime,
+      `${name}/audit`,
+      "workItemVerificationRequestAudit",
+      (fact) => fact.kind === "audit" ? fact.value : void 0
+    )
+  };
+}
+function workItemVerificationResultMapper(graph, opts) {
+  const name = opts.name ?? "workItemVerificationResults";
+  const deps = opts.policies === void 0 ? [opts.workItems, opts.evidence] : [opts.workItems, opts.evidence, opts.policies];
+  const runtime = graph.node(
+    deps,
+    (ctx) => {
+      const state = ctx.state.get() ?? {
+        workItems: /* @__PURE__ */ new Map(),
+        policies: /* @__PURE__ */ new Map(),
+        evidenceById: /* @__PURE__ */ new Map(),
+        resultEvidence: /* @__PURE__ */ new Set(),
+        proposalKeys: /* @__PURE__ */ new Set(),
+        statusSeq: 0,
+        auditSeq: 0
+      };
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const workItem = raw;
+        state.workItems.set(workItem.workItemId, workItem);
+        replayEvidence(ctx, state, workItem.workItemId);
+      }
+      if (opts.policies !== void 0) {
+        for (const raw of depBatch(ctx, 2) ?? []) {
+          const policy = raw;
+          const issues = validateMappingPolicy(policy);
+          if (issues.length > 0) {
+            for (const item of issues) emit(ctx, "issue", item);
+            emitResultStatus(ctx, state, {
+              state: "rejected",
+              code: "policy-mismatch",
+              metadata: { policyId: isRecord(policy) ? policy.policyId : void 0 }
+            });
+            continue;
+          }
+          state.policies.set(policy.policyId, policy);
+        }
+        for (const evidence of state.evidenceById.values()) {
+          mapEvidence(ctx, state, evidence, true);
+        }
+      }
+      for (const raw of depBatch(ctx, 1) ?? [])
+        mapEvidence(ctx, state, raw);
+      ctx.state.set(state);
+    },
+    {
+      name: `${name}/runtime`,
+      factory: "workItemVerificationResultMapper",
+      partial: true,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  return {
+    results: project(
+      graph,
+      runtime,
+      `${name}/results`,
+      "workItemVerificationResults",
+      (fact) => fact.kind === "result" ? fact.value : void 0
+    ),
+    proposals: project(
+      graph,
+      runtime,
+      `${name}/proposals`,
+      "workItemVerificationProposals",
+      (fact) => fact.kind === "proposal" ? fact.value : void 0
+    ),
+    status: project(
+      graph,
+      runtime,
+      `${name}/status`,
+      "workItemVerificationResultStatus",
+      (fact) => fact.kind === "status" ? fact.value : void 0
+    ),
+    issues: project(
+      graph,
+      runtime,
+      `${name}/issues`,
+      "workItemVerificationResultIssues",
+      (fact) => fact.kind === "issue" ? fact.value : void 0
+    ),
+    audit: project(
+      graph,
+      runtime,
+      `${name}/audit`,
+      "workItemVerificationResultAudit",
+      (fact) => fact.kind === "audit" ? fact.value : void 0
+    )
+  };
+}
+function validateWorkItemEffectPlan(proposal, workItem, policy = {}) {
+  const out = [];
+  if (!isRecord(proposal) || proposal.kind !== "work-item-effect-plan-proposed" || typeof proposal.planId !== "string" || proposal.planId.trim() === "" || typeof proposal.workItemId !== "string" || proposal.workItemId.trim() === "" || typeof proposal.executionInputRevision !== "number" || !Array.isArray(proposal.members)) {
+    return [
+      issue(
+        "malformed-draft",
+        "WorkItemEffectPlanProposed requires planId, workItemId, executionInputRevision, and members",
+        isRecord(proposal) && typeof proposal.workItemId === "string" ? proposal.workItemId : void 0
+      )
+    ];
+  }
+  if (proposal.joinPolicy !== void 0 && !isWorkItemEffectPlanJoinPolicy(proposal.joinPolicy)) {
+    out.push(
+      issue(
+        "policy-mismatch",
+        `Unsupported WorkItemEffectPlan join policy '${proposal.joinPolicy}'`,
+        proposal.workItemId,
+        { planId: proposal.planId, joinPolicy: proposal.joinPolicy }
+      )
+    );
+  }
+  if (workItem === void 0) {
+    out.push(
+      issue(
+        "dangling-ref",
+        `WorkItemEffectPlan '${proposal.planId}' references unknown WorkItem '${proposal.workItemId}'`,
+        proposal.workItemId,
+        { planId: proposal.planId }
+      )
+    );
+  } else if (proposal.executionInputRevision !== workItem.executionInputRevision) {
+    out.push(
+      issue(
+        "stale-execution-input",
+        `WorkItemEffectPlan '${proposal.planId}' targets stale execution input`,
+        proposal.workItemId,
+        {
+          planId: proposal.planId,
+          proposedRevision: proposal.executionInputRevision,
+          currentRevision: workItem.executionInputRevision
+        }
+      )
+    );
+  }
+  const memberIds = /* @__PURE__ */ new Set();
+  const allowedEffectKinds = policy.allowedEffectKinds === void 0 ? void 0 : new Set(policy.allowedEffectKinds);
+  for (const member of proposal.members) {
+    if (!isRecord(member)) {
+      out.push(
+        issue(
+          "malformed-draft",
+          "WorkItemEffectPlan member must be an object",
+          proposal.workItemId,
+          {
+            planId: proposal.planId
+          }
+        )
+      );
+      continue;
+    }
+    if (typeof member.memberId !== "string" || member.memberId.trim() === "") {
+      out.push(
+        issue(
+          "missing-required-field",
+          "WorkItemEffectPlan memberId is required",
+          proposal.workItemId,
+          { planId: proposal.planId }
+        )
+      );
+      continue;
+    }
+    if (memberIds.has(member.memberId)) {
+      out.push(
+        issue(
+          "duplicate-id",
+          `Duplicate WorkItemEffectPlan member id '${member.memberId}'`,
+          proposal.workItemId,
+          { planId: proposal.planId, planMemberId: member.memberId }
+        )
+      );
+    }
+    memberIds.add(member.memberId);
+    if (typeof member.effectKind !== "string" || member.effectKind.trim() === "") {
+      out.push(
+        issue(
+          "missing-required-field",
+          "WorkItemEffectPlan member effectKind is required",
+          proposal.workItemId,
+          { planId: proposal.planId, planMemberId: member.memberId }
+        )
+      );
+    } else if (allowedEffectKinds !== void 0 && !allowedEffectKinds.has(member.effectKind)) {
+      out.push(
+        issue(
+          "unsupported-effect-kind",
+          `Unsupported WorkItemEffectPlan effect kind '${member.effectKind}'`,
+          proposal.workItemId,
+          { planId: proposal.planId, planMemberId: member.memberId }
+        )
+      );
+    }
+    if (!isRecord(member.goal)) {
+      out.push(
+        issue(
+          "missing-required-field",
+          "WorkItemEffectPlan member goal is required",
+          proposal.workItemId,
+          { planId: proposal.planId, planMemberId: member.memberId }
+        )
+      );
+    }
+    for (const field of [
+      "dependsOnMemberIds",
+      "contextRefs",
+      "requirements",
+      "policyRefs",
+      "sourceRefs"
+    ]) {
+      if (member[field] !== void 0 && !Array.isArray(member[field])) {
+        out.push(
+          issue(
+            "malformed-draft",
+            `WorkItemEffectPlan member ${field} must be an array`,
+            proposal.workItemId,
+            { planId: proposal.planId, planMemberId: member.memberId, field }
+          )
+        );
+      }
+    }
+  }
+  for (const member of proposal.members) {
+    if (!isRecord(member) || typeof member.memberId !== "string") continue;
+    const deps = Array.isArray(member.dependsOnMemberIds) ? member.dependsOnMemberIds : [];
+    for (const depId of deps) {
+      if (!memberIds.has(depId)) {
+        out.push(
+          issue(
+            "dangling-ref",
+            `Unknown WorkItemEffectPlan dependency '${depId}'`,
+            proposal.workItemId,
+            { planId: proposal.planId, planMemberId: member.memberId, depId }
+          )
+        );
+      }
+    }
+  }
+  const cycle = findPlanCycle(
+    proposal.members.filter(
+      (member) => isRecord(member) && typeof member.memberId === "string" && Array.isArray(member.dependsOnMemberIds)
+    )
+  );
+  if (cycle !== void 0) {
+    out.push(
+      issue(
+        "cyclic-dependency",
+        `WorkItemEffectPlan member cycle detected: ${cycle.join(" -> ")}`,
+        proposal.workItemId,
+        { planId: proposal.planId, planMemberId: cycle[0] }
+      )
+    );
+  }
+  return out;
+}
+function workItemEffectPlanProjector(graph, opts) {
+  const name = opts.name ?? "workItemEffectPlans";
+  const deps = [opts.workItems, opts.proposals];
+  const evidenceIndex = opts.evidence === void 0 ? -1 : deps.push(opts.evidence) - 1;
+  const resultIndex = opts.effectRunResults === void 0 ? -1 : deps.push(opts.effectRunResults) - 1;
+  const now = opts.now ?? Date.now;
+  const runtime = graph.node(
+    deps,
+    (ctx) => {
+      const state = ctx.state.get() ?? emptyPlanState();
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const workItem = raw;
+        state.workItems.set(workItem.workItemId, workItem);
+        for (const proposal of state.proposals.values()) {
+          if (proposal.workItemId === workItem.workItemId)
+            admitPlan(ctx, state, proposal, opts.policy, now);
+        }
+      }
+      for (const raw of depBatch(ctx, 1) ?? []) {
+        const proposal = raw;
+        if (isRecord(proposal) && typeof proposal.planId === "string" && typeof proposal.workItemId === "string") {
+          const key = planKey(
+            proposal.workItemId,
+            proposal.planId,
+            proposal.executionInputRevision
+          );
+          if (key !== void 0) state.proposals.set(key, proposal);
+        }
+        admitPlan(ctx, state, proposal, opts.policy, now);
+      }
+      if (evidenceIndex >= 0) {
+        for (const raw of depBatch(ctx, evidenceIndex) ?? [])
+          recordPlanEvidence(ctx, state, raw);
+      }
+      if (resultIndex >= 0) {
+        for (const raw of depBatch(ctx, resultIndex) ?? [])
+          recordPlanResult(ctx, state, raw);
+      }
+      drainPlanWork(ctx, state, opts.policy);
+      ctx.state.set(state);
+    },
+    {
+      name: `${name}/runtime`,
+      factory: "workItemEffectPlanProjector",
+      partial: true,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  return {
+    admitted: project(
+      graph,
+      runtime,
+      `${name}/admitted`,
+      "workItemEffectPlansAdmitted",
+      (fact) => fact.kind === "admitted" ? fact.value : void 0
+    ),
+    rejected: project(
+      graph,
+      runtime,
+      `${name}/rejected`,
+      "workItemEffectPlansRejected",
+      (fact) => fact.kind === "rejected" ? fact.value : void 0
+    ),
+    effectRequests: project(
+      graph,
+      runtime,
+      `${name}/effectRequests`,
+      "workItemEffectPlanEffectRequests",
+      (fact) => fact.kind === "request" ? fact.value : void 0
+    ),
+    results: project(
+      graph,
+      runtime,
+      `${name}/results`,
+      "workItemEffectPlanResults",
+      (fact) => fact.kind === "result" ? fact.value : void 0
+    ),
+    status: project(
+      graph,
+      runtime,
+      `${name}/status`,
+      "workItemEffectPlanStatus",
+      (fact) => fact.kind === "status" ? fact.value : void 0
+    ),
+    issues: project(
+      graph,
+      runtime,
+      `${name}/issues`,
+      "workItemEffectPlanIssues",
+      (fact) => fact.kind === "issue" ? fact.value : void 0
+    ),
+    audit: project(
+      graph,
+      runtime,
+      `${name}/audit`,
+      "workItemEffectPlanAudit",
+      (fact) => fact.kind === "audit" ? fact.value : void 0
+    )
+  };
+}
+function emptyPlanState() {
+  return {
+    workItems: /* @__PURE__ */ new Map(),
+    proposals: /* @__PURE__ */ new Map(),
+    admitted: /* @__PURE__ */ new Map(),
+    rejected: /* @__PURE__ */ new Set(),
+    emittedMemberKeys: /* @__PURE__ */ new Set(),
+    statusKeys: /* @__PURE__ */ new Set(),
+    resultKeys: /* @__PURE__ */ new Set(),
+    requestByEffectRun: /* @__PURE__ */ new Map(),
+    requestByRequestId: /* @__PURE__ */ new Map(),
+    memberEvidence: /* @__PURE__ */ new Map(),
+    pendingEvidence: /* @__PURE__ */ new Map(),
+    pendingResults: /* @__PURE__ */ new Map(),
+    unmatchedEvidence: /* @__PURE__ */ new Set(),
+    unmatchedResults: /* @__PURE__ */ new Set(),
+    statusSeq: 0,
+    auditSeq: 0
+  };
+}
+function admitPlan(ctx, state, proposal, policy, now) {
+  if (!isRecord(proposal) || typeof proposal.planId !== "string") {
+    const issues2 = validateWorkItemEffectPlan(proposal, void 0, policy);
+    emitPlanIssues(ctx, state, issues2);
+    return;
+  }
+  const key = planKey(proposal.workItemId, proposal.planId, proposal.executionInputRevision);
+  if (key === void 0) {
+    const issues2 = validateWorkItemEffectPlan(proposal, void 0, policy);
+    emitPlanIssues(ctx, state, issues2);
+    return;
+  }
+  if (state.admitted.has(key) || state.rejected.has(key)) return;
+  const workItem = state.workItems.get(proposal.workItemId);
+  if (workItem === void 0) {
+    emitPlanStatusOnce(ctx, state, `${key}:deferred:missing-work-item`, {
+      workItemId: proposal.workItemId,
+      planId: proposal.planId,
+      executionInputRevision: proposal.executionInputRevision,
+      state: "deferred",
+      message: `WorkItemEffectPlan '${proposal.planId}' is waiting for WorkItem '${proposal.workItemId}'`,
+      sourceRefs: proposal.sourceRefs,
+      metadata: { reason: "missing-work-item" }
+    });
+    return;
+  }
+  const issues = validateWorkItemEffectPlan(proposal, workItem, policy);
+  if (issues.length > 0) {
+    state.rejected.add(key);
+    emitPlanIssues(ctx, state, issues);
+    const rejected = {
+      kind: "work-item-effect-plan-rejected",
+      planId: proposal.planId,
+      workItemId: proposal.workItemId,
+      executionInputRevision: proposal.executionInputRevision,
+      issues,
+      sourceRefs: proposal.sourceRefs,
+      rejectedAtMs: now(),
+      metadata: proposal.metadata
+    };
+    emitPlan(ctx, "rejected", rejected);
+    emitPlanStatus(ctx, state, {
+      workItemId: proposal.workItemId,
+      planId: proposal.planId,
+      executionInputRevision: proposal.executionInputRevision,
+      state: "rejected",
+      issues,
+      sourceRefs: proposal.sourceRefs,
+      metadata: { issueCodes: issues.map((item) => item.code) }
+    });
+    return;
+  }
+  const snapshot = normalizeEffectPlanSnapshot(proposal, policy);
+  const admitted = {
+    kind: "work-item-effect-plan-admitted",
+    planId: snapshot.planId,
+    workItemId: snapshot.workItemId,
+    executionInputRevision: snapshot.executionInputRevision,
+    plan: snapshot,
+    sourceRefs: immutableClone(proposal.sourceRefs),
+    admittedAtMs: now(),
+    metadata: immutableClone(proposal.metadata)
+  };
+  state.admitted.set(key, admitted);
+  emitPlan(ctx, "admitted", admitted);
+  emitPlanStatus(ctx, state, {
+    workItemId: admitted.workItemId,
+    planId: admitted.planId,
+    executionInputRevision: admitted.executionInputRevision,
+    state: "eligible",
+    sourceRefs: admitted.sourceRefs,
+    metadata: { memberCount: admitted.plan.members.length }
+  });
+}
+function drainPlanWork(ctx, state, policy) {
+  const maxPasses = state.admitted.size + state.pendingEvidence.size + state.pendingResults.size + state.emittedMemberKeys.size + 1;
+  for (let pass = 0; pass < maxPasses; pass += 1) {
+    let changed = false;
+    for (const admitted of state.admitted.values()) {
+      changed = lowerEligiblePlanMembers(ctx, state, admitted, policy) || changed;
+      derivePlanResult(ctx, state, admitted);
+    }
+    changed = replayPendingPlanFacts(ctx, state) || changed;
+    if (!changed) break;
+  }
+  for (const admitted of state.admitted.values()) derivePlanResult(ctx, state, admitted);
+}
+function lowerEligiblePlanMembers(ctx, state, admitted, policy) {
+  if (isAdmittedPlanStale(state, admitted)) {
+    emitStaleAdmittedPlanOnce(ctx, state, admitted);
+    return false;
+  }
+  let changed = false;
+  for (const member of admitted.plan.members) {
+    const coord = memberCoord(admitted, member.memberId);
+    if (state.memberEvidence.has(coord)) continue;
+    const missing = (member.dependsOnMemberIds ?? []).filter(
+      (memberId) => !memberSucceeded(state, admitted, memberId)
+    );
+    if (missing.length > 0) {
+      emitPlanStatusOnce(ctx, state, `${coord}:blocked:${missing.join(",")}`, {
+        workItemId: admitted.workItemId,
+        planId: admitted.planId,
+        executionInputRevision: admitted.executionInputRevision,
+        state: "blocked",
+        planMemberId: member.memberId,
+        issues: [
+          issue(
+            "blocked-prerequisite",
+            `WorkItemEffectPlan member '${member.memberId}' is blocked by prerequisites`,
+            admitted.workItemId,
+            { planId: admitted.planId, planMemberId: member.memberId, missingMemberIds: missing }
+          )
+        ],
+        sourceRefs: member.sourceRefs,
+        metadata: { missingMemberIds: missing }
+      });
+      continue;
+    }
+    if (state.emittedMemberKeys.has(coord)) continue;
+    state.emittedMemberKeys.add(coord);
+    changed = true;
+    const request = requestFromPlanMember(admitted, member, policy);
+    state.requestByEffectRun.set(request.effectRunId, request);
+    state.requestByRequestId.set(request.requestId, request);
+    emitPlan(ctx, "request", request);
+    emitPlanStatus(ctx, state, {
+      workItemId: admitted.workItemId,
+      planId: admitted.planId,
+      executionInputRevision: admitted.executionInputRevision,
+      state: "requested",
+      planMemberId: member.memberId,
+      requestId: request.requestId,
+      effectRunId: request.effectRunId,
+      sourceRefs: request.sourceRefs,
+      metadata: { effectKind: request.effectKind }
+    });
+  }
+  return changed;
+}
+function recordPlanEvidence(ctx, state, evidence) {
+  const coordinate = planCoordinateFromEvidence(state, evidence);
+  if (coordinate === void 0) {
+    state.pendingEvidence.set(evidence.evidenceId, evidence);
+    emitUnmatchedEvidence(ctx, state, `evidence:${evidence.evidenceId}`, evidence.workItemId, {
+      evidenceId: evidence.evidenceId,
+      effectRunId: evidence.effectRunId
+    });
+    return false;
+  }
+  if (emitConflictingPlanEvidenceCoordinate(ctx, state, evidence, coordinate)) return true;
+  const key = requiredPlanKey(
+    coordinate.workItemId,
+    coordinate.planId,
+    coordinate.executionInputRevision
+  );
+  const admitted = state.admitted.get(key);
+  if (admitted === void 0) {
+    state.pendingEvidence.set(evidence.evidenceId, evidence);
+    emitUnmatchedEvidence(ctx, state, `evidence:${evidence.evidenceId}`, coordinate.workItemId, {
+      evidenceId: evidence.evidenceId,
+      effectRunId: evidence.effectRunId,
+      planId: coordinate.planId,
+      planMemberId: coordinate.planMemberId,
+      executionInputRevision: coordinate.executionInputRevision
+    });
+    return false;
+  }
+  if (isAdmittedPlanStale(state, admitted)) {
+    emitStaleAdmittedPlanOnce(ctx, state, admitted);
+    return true;
+  }
+  if (!hasPlanMember(admitted, coordinate.planMemberId)) {
+    emitUnknownPlanMember(ctx, state, admitted, coordinate.planMemberId, {
+      evidenceId: evidence.evidenceId,
+      effectRunId: evidence.effectRunId
+    });
+    return true;
+  }
+  const recorded = recordMemberEvidence(ctx, state, admitted, coordinate.planMemberId, {
+    status: evidence.status,
+    requestId: coordinate.requestId ?? coordinate.request?.requestId,
+    effectRunId: evidence.effectRunId,
+    evidenceId: evidence.evidenceId,
+    effectRunResultId: evidence.effectRunResultId,
+    sourceRefs: evidence.sourceRefs
+  });
+  if (!recorded) return true;
+  emitPlanStatus(ctx, state, {
+    workItemId: coordinate.workItemId,
+    planId: coordinate.planId,
+    executionInputRevision: coordinate.executionInputRevision,
+    state: evidence.status === "completed" ? "completed" : "failed",
+    planMemberId: coordinate.planMemberId,
+    requestId: coordinate.requestId ?? coordinate.request?.requestId,
+    effectRunId: evidence.effectRunId,
+    evidenceId: evidence.evidenceId,
+    effectRunResultId: evidence.effectRunResultId,
+    sourceRefs: evidence.sourceRefs,
+    metadata: { evidenceStatus: evidence.status }
+  });
+  return true;
+}
+function emitConflictingPlanEvidenceCoordinate(ctx, state, evidence, coordinate) {
+  const expectedRequest = planRequestForCoordinate(state, coordinate);
+  const expectedRequestIdMismatch = expectedRequest !== void 0 && evidence.requestId !== void 0 && evidence.requestId !== expectedRequest.requestId;
+  if (expectedRequest !== void 0 && (expectedRequestIdMismatch || evidence.effectRunId !== expectedRequest.effectRunId)) {
+    emitPlanEvidenceCoordinateMismatch(ctx, state, evidence, coordinate, expectedRequest);
+    return true;
+  }
+  const requestRefs = [
+    evidence.requestId === void 0 ? void 0 : state.requestByRequestId.get(evidence.requestId),
+    state.requestByEffectRun.get(evidence.effectRunId)
+  ].filter((request) => request !== void 0);
+  const conflicting = requestRefs.find(
+    (request) => !requestMatchesPlanCoordinate(request, coordinate) || !requestMatchesEvidenceIdentity(request, evidence)
+  );
+  if (conflicting === void 0) return false;
+  emitPlanEvidenceCoordinateMismatch(ctx, state, evidence, coordinate, conflicting);
+  return true;
+}
+function emitPlanEvidenceCoordinateMismatch(ctx, state, evidence, coordinate, conflicting) {
+  const item = issue(
+    "dangling-ref",
+    "WorkItemEffectPlan evidence request/effectRun coordinates do not match its plan member coordinates",
+    evidence.workItemId,
+    {
+      evidenceId: evidence.evidenceId,
+      requestId: evidence.requestId,
+      effectRunId: evidence.effectRunId,
+      planId: coordinate.planId,
+      planMemberId: coordinate.planMemberId,
+      executionInputRevision: coordinate.executionInputRevision,
+      requestPlanId: conflicting.planId,
+      requestPlanMemberId: conflicting.planMemberId,
+      requestExecutionInputRevision: conflicting.executionInputRevision
+    }
+  );
+  emitPlan(ctx, "issue", item);
+  emitPlanStatus(ctx, state, {
+    workItemId: coordinate.workItemId,
+    planId: coordinate.planId,
+    executionInputRevision: coordinate.executionInputRevision,
+    state: "rejected",
+    planMemberId: coordinate.planMemberId,
+    requestId: evidence.requestId,
+    effectRunId: evidence.effectRunId,
+    evidenceId: evidence.evidenceId,
+    issues: [item],
+    sourceRefs: evidence.sourceRefs,
+    metadata: item.metadata
+  });
+}
+function requestMatchesPlanCoordinate(request, coordinate) {
+  return request.workItemId === coordinate.workItemId && request.planId === coordinate.planId && request.planMemberId === coordinate.planMemberId && request.executionInputRevision === coordinate.executionInputRevision;
+}
+function requestMatchesEvidenceIdentity(request, evidence) {
+  return (evidence.requestId === void 0 || evidence.requestId === request.requestId) && evidence.effectRunId === request.effectRunId;
+}
+function planRequestForCoordinate(state, coordinate) {
+  for (const request of state.requestByRequestId.values()) {
+    if (requestMatchesPlanCoordinate(request, coordinate)) return request;
+  }
+  return void 0;
+}
+function recordPlanResult(ctx, state, result) {
+  const coordinate = planCoordinateFromResult(state, result);
+  if (coordinate === void 0) {
+    state.pendingResults.set(result.resultId, result);
+    emitUnmatchedEvidence(ctx, state, `result:${result.resultId}`, void 0, {
+      effectRunResultId: result.resultId,
+      effectRunId: result.effectRunId
+    });
+    return false;
+  }
+  const key = requiredPlanKey(
+    coordinate.workItemId,
+    coordinate.planId,
+    coordinate.executionInputRevision
+  );
+  const admitted = state.admitted.get(key);
+  if (admitted === void 0) {
+    state.pendingResults.set(result.resultId, result);
+    emitUnmatchedEvidence(ctx, state, `result:${result.resultId}`, coordinate.workItemId, {
+      effectRunResultId: result.resultId,
+      effectRunId: result.effectRunId,
+      planId: coordinate.planId,
+      planMemberId: coordinate.planMemberId,
+      executionInputRevision: coordinate.executionInputRevision
+    });
+    return false;
+  }
+  if (isAdmittedPlanStale(state, admitted)) {
+    emitStaleAdmittedPlanOnce(ctx, state, admitted);
+    return true;
+  }
+  if (!hasPlanMember(admitted, coordinate.planMemberId)) {
+    emitUnknownPlanMember(ctx, state, admitted, coordinate.planMemberId, {
+      effectRunResultId: result.resultId,
+      effectRunId: result.effectRunId
+    });
+    return true;
+  }
+  const recorded = recordMemberEvidence(ctx, state, admitted, coordinate.planMemberId, {
+    status: result.status,
+    requestId: coordinate.request?.requestId,
+    effectRunId: result.effectRunId,
+    effectRunResultId: result.resultId,
+    sourceRefs: result.sourceRefs
+  });
+  if (!recorded) return true;
+  emitPlanStatus(ctx, state, {
+    workItemId: coordinate.workItemId,
+    planId: coordinate.planId,
+    executionInputRevision: coordinate.executionInputRevision,
+    state: result.status === "completed" ? "completed" : "failed",
+    planMemberId: coordinate.planMemberId,
+    requestId: coordinate.request?.requestId,
+    effectRunId: result.effectRunId,
+    effectRunResultId: result.resultId,
+    sourceRefs: result.sourceRefs,
+    metadata: { resultStatus: result.status }
+  });
+  return true;
+}
+function replayPendingPlanFacts(ctx, state) {
+  let changed = false;
+  for (const [evidenceId, evidence] of [...state.pendingEvidence]) {
+    if (recordPlanEvidence(ctx, state, evidence)) {
+      state.pendingEvidence.delete(evidenceId);
+      changed = true;
+    }
+  }
+  for (const [resultId, result] of [...state.pendingResults]) {
+    if (recordPlanResult(ctx, state, result)) {
+      state.pendingResults.delete(resultId);
+      changed = true;
+    }
+  }
+  return changed;
+}
+function planCoordinateFromEvidence(state, evidence) {
+  const topLevelRequest = evidence.requestId === void 0 ? void 0 : state.requestByRequestId.get(evidence.requestId);
+  const effectRunRequest = state.requestByEffectRun.get(evidence.effectRunId);
+  if (evidence.planId !== void 0 && evidence.planMemberId !== void 0 && evidence.executionInputRevision !== void 0) {
+    return {
+      workItemId: evidence.workItemId,
+      planId: evidence.planId,
+      executionInputRevision: evidence.executionInputRevision,
+      planMemberId: evidence.planMemberId,
+      requestId: topLevelRequest?.requestId ?? effectRunRequest?.requestId ?? evidence.requestId,
+      request: topLevelRequest ?? effectRunRequest
+    };
+  }
+  const request = effectRunRequest;
+  if (request?.planId !== void 0 && request.planMemberId !== void 0 && request.executionInputRevision !== void 0) {
+    return {
+      workItemId: request.workItemId,
+      planId: request.planId,
+      executionInputRevision: request.executionInputRevision,
+      planMemberId: request.planMemberId,
+      requestId: request.requestId,
+      request
+    };
+  }
+  const planId = stringMetadata(evidence.metadata, "planId");
+  const planMemberId = stringMetadata(evidence.metadata, "planMemberId");
+  const executionInputRevision = numberMetadata(evidence.metadata, "executionInputRevision");
+  const requestId = stringMetadata(evidence.metadata, "requestId");
+  if (planId === void 0 || planMemberId === void 0 || executionInputRevision === void 0)
+    return void 0;
+  return {
+    workItemId: evidence.workItemId,
+    planId,
+    executionInputRevision,
+    planMemberId,
+    requestId
+  };
+}
+function planCoordinateFromResult(state, result) {
+  const request = state.requestByEffectRun.get(result.effectRunId);
+  if (request?.planId !== void 0 && request.planMemberId !== void 0 && request.executionInputRevision !== void 0) {
+    return {
+      workItemId: request.workItemId,
+      planId: request.planId,
+      executionInputRevision: request.executionInputRevision,
+      planMemberId: request.planMemberId,
+      requestId: request.requestId,
+      request
+    };
+  }
+  const workItemId = sourceRefId(result.subjectRefs, "work-item") ?? sourceRefId(result.sourceRefs, "work-item");
+  const planId = stringMetadata(result.metadata, "planId");
+  const planMemberId = stringMetadata(result.metadata, "planMemberId");
+  const executionInputRevision = numberMetadata(result.metadata, "executionInputRevision");
+  if (workItemId === void 0 || planId === void 0 || planMemberId === void 0 || executionInputRevision === void 0)
+    return void 0;
+  return { workItemId, planId, executionInputRevision, planMemberId };
+}
+function recordMemberEvidence(ctx, state, admitted, planMemberId, evidence) {
+  const coord = memberCoord(admitted, planMemberId);
+  const existing = state.memberEvidence.get(coord);
+  if (existing !== void 0) {
+    const duplicateIssue = issue(
+      "duplicate-suppressed",
+      `WorkItemEffectPlan member '${planMemberId}' already has terminal evidence`,
+      admitted.workItemId,
+      {
+        planId: admitted.planId,
+        planMemberId,
+        existingEvidenceId: existing.evidenceId,
+        existingEffectRunResultId: existing.effectRunResultId,
+        evidenceId: evidence.evidenceId,
+        effectRunResultId: evidence.effectRunResultId
+      }
+    );
+    emitPlan(ctx, "issue", duplicateIssue);
+    emitPlanStatus(ctx, state, {
+      workItemId: admitted.workItemId,
+      planId: admitted.planId,
+      executionInputRevision: admitted.executionInputRevision,
+      state: "duplicate",
+      planMemberId,
+      requestId: evidence.requestId,
+      effectRunId: evidence.effectRunId,
+      evidenceId: evidence.evidenceId,
+      effectRunResultId: evidence.effectRunResultId,
+      issues: [duplicateIssue],
+      sourceRefs: evidence.sourceRefs
+    });
+    return false;
+  }
+  state.memberEvidence.set(coord, evidence);
+  return true;
+}
+function hasPlanMember(admitted, planMemberId) {
+  return admitted.plan.members.some((member) => member.memberId === planMemberId);
+}
+function isAdmittedPlanStale(state, admitted) {
+  const current = state.workItems.get(admitted.workItemId);
+  return current !== void 0 && current.executionInputRevision !== admitted.executionInputRevision;
+}
+function emitStaleAdmittedPlanOnce(ctx, state, admitted) {
+  const current = state.workItems.get(admitted.workItemId);
+  emitPlanStatusOnce(ctx, state, `${memberCoord(admitted, "plan")}:stale`, {
+    workItemId: admitted.workItemId,
+    planId: admitted.planId,
+    executionInputRevision: admitted.executionInputRevision,
+    state: "stale",
+    issues: [
+      issue(
+        "stale-execution-input",
+        `WorkItemEffectPlan '${admitted.planId}' targets stale execution input`,
+        admitted.workItemId,
+        {
+          planId: admitted.planId,
+          proposedRevision: admitted.executionInputRevision,
+          currentRevision: current?.executionInputRevision
+        }
+      )
+    ],
+    sourceRefs: admitted.sourceRefs,
+    metadata: { currentRevision: current?.executionInputRevision }
+  });
+}
+function emitUnknownPlanMember(ctx, state, admitted, planMemberId, metadata) {
+  const item = issue(
+    "dangling-ref",
+    `WorkItemEffectPlan evidence/result references unknown member '${planMemberId}'`,
+    admitted.workItemId,
+    { planId: admitted.planId, planMemberId, ...metadata }
+  );
+  emitPlan(ctx, "issue", item);
+  emitPlanStatus(ctx, state, {
+    workItemId: admitted.workItemId,
+    planId: admitted.planId,
+    executionInputRevision: admitted.executionInputRevision,
+    state: "rejected",
+    planMemberId,
+    issues: [item],
+    sourceRefs: admitted.sourceRefs,
+    metadata
+  });
+}
+function emitUnmatchedEvidence(ctx, state, key, workItemId, metadata) {
+  const seen = key.startsWith("evidence:") ? state.unmatchedEvidence : state.unmatchedResults;
+  if (seen.has(key)) return;
+  seen.add(key);
+  const item = issue(
+    "dangling-ref",
+    "WorkItemEffectPlan evidence/result could not be joined to an admitted plan member",
+    workItemId,
+    metadata
+  );
+  emitPlan(ctx, "issue", item);
+  emitPlanStatus(ctx, state, {
+    workItemId: workItemId ?? "unknown",
+    planId: typeof metadata.planId === "string" ? metadata.planId : "unknown",
+    executionInputRevision: typeof metadata.executionInputRevision === "number" ? metadata.executionInputRevision : 0,
+    state: "deferred",
+    issues: [item],
+    metadata
+  });
+}
+function derivePlanResult(ctx, state, admitted) {
+  const requiredMembers = admitted.plan.members.filter((member) => member.required !== false);
+  if (requiredMembers.length === 0) return;
+  const memberResults = [];
+  for (const member of admitted.plan.members) {
+    const evidence = state.memberEvidence.get(memberCoord(admitted, member.memberId));
+    if (evidence === void 0) continue;
+    memberResults.push({
+      planMemberId: member.memberId,
+      status: evidence.status,
+      requestId: evidence.requestId,
+      effectRunId: evidence.effectRunId,
+      evidenceId: evidence.evidenceId,
+      effectRunResultId: evidence.effectRunResultId
+    });
+  }
+  const hasRequiredFailed = requiredMembers.some((member) => {
+    const evidence = state.memberEvidence.get(memberCoord(admitted, member.memberId));
+    return evidence !== void 0 && evidence.status !== "completed";
+  });
+  const settledRequiredCount = requiredMembers.filter(
+    (member) => state.memberEvidence.has(memberCoord(admitted, member.memberId))
+  ).length;
+  const allRequiredSettled = settledRequiredCount === requiredMembers.length;
+  const requiredBlockedByFailure = requiredMembers.some(
+    (member) => memberBlockedByFailure(state, admitted, member.memberId, /* @__PURE__ */ new Set())
+  );
+  if (!hasRequiredFailed && !allRequiredSettled && !requiredBlockedByFailure) return;
+  const status = admitted.plan.joinPolicy === "evidence-only" ? "evidence-only" : hasRequiredFailed || requiredBlockedByFailure ? "failed" : "succeeded";
+  const key = memberCoord(admitted, "result");
+  if (state.resultKeys.has(key)) return;
+  state.resultKeys.add(key);
+  const result = {
+    kind: "work-item-effect-plan-result",
+    resultId: `work-item-effect-plan-result:${admitted.workItemId}:${admitted.executionInputRevision}:${admitted.planId}`,
+    workItemId: admitted.workItemId,
+    planId: admitted.planId,
+    executionInputRevision: admitted.executionInputRevision,
+    status,
+    memberResults,
+    sourceRefs: admitted.sourceRefs
+  };
+  emitPlan(ctx, "result", result);
+  emitPlanStatus(ctx, state, {
+    workItemId: admitted.workItemId,
+    planId: admitted.planId,
+    executionInputRevision: admitted.executionInputRevision,
+    state: status === "succeeded" || status === "evidence-only" ? "completed" : "failed",
+    sourceRefs: admitted.sourceRefs,
+    metadata: { resultId: result.resultId, resultStatus: status }
+  });
+}
+function normalizeEffectPlanSnapshot(proposal, policy) {
+  const joinPolicy = proposal.joinPolicy ?? policy?.joinPolicy ?? "all-required";
+  const members = proposal.members.map(
+    (member) => Object.freeze({
+      ...member,
+      goal: immutableClone(member.goal),
+      dependsOnMemberIds: immutableClone(member.dependsOnMemberIds ?? []),
+      contextRefs: immutableClone(member.contextRefs),
+      requirements: immutableClone(member.requirements),
+      capacityHints: immutableClone(member.capacityHints),
+      limits: immutableClone(member.limits),
+      policyRefs: immutableClone(member.policyRefs),
+      sourceRefs: immutableClone(member.sourceRefs),
+      metadata: immutableClone(member.metadata)
+    })
+  );
+  return Object.freeze({
+    planId: proposal.planId,
+    workItemId: proposal.workItemId,
+    executionInputRevision: proposal.executionInputRevision,
+    members: Object.freeze(members),
+    joinPolicy,
+    limits: immutableClone(proposal.limits),
+    policyRefs: immutableClone(proposal.policyRefs),
+    sourceRefs: immutableClone(proposal.sourceRefs),
+    metadata: immutableClone(proposal.metadata)
+  });
+}
+function requestFromPlanMember(admitted, member, policy) {
+  const requestId = `work-item:${admitted.workItemId}:effect-plan:${admitted.executionInputRevision}:${admitted.planId}:${member.memberId}`;
+  const policyRefs = policy?.policyId === void 0 ? [...admitted.plan.policyRefs ?? [], ...member.policyRefs ?? []] : [
+    ...admitted.plan.policyRefs ?? [],
+    ...member.policyRefs ?? [],
+    ref("work-item-effect-plan-policy", policy.policyId)
+  ];
+  return {
+    kind: "work-item-effect-requested",
+    requestId,
+    workItemId: admitted.workItemId,
+    effectRunId: `effect-run:${requestId}`,
+    effectKind: member.effectKind,
+    executionInputRevision: admitted.executionInputRevision,
+    planId: admitted.planId,
+    planMemberId: member.memberId,
+    sourceRefs: [
+      ref("work-item", admitted.workItemId),
+      ref("work-item-revision", `${admitted.workItemId}:${admitted.executionInputRevision}`),
+      ref("work-item-effect-plan", admitted.planId),
+      ref("work-item-effect-plan-member", member.memberId),
+      ...admitted.plan.sourceRefs ?? [],
+      ...member.sourceRefs ?? []
+    ],
+    goal: member.goal,
+    policyRefs: policyRefs.length === 0 ? void 0 : policyRefs,
+    limits: member.limits ?? admitted.plan.limits,
+    idempotencyKey: member.idempotencyKey ?? `${admitted.workItemId}:effect-plan:${admitted.executionInputRevision}:${admitted.planId}:${member.memberId}`,
+    metadata: {
+      ...member.metadata ?? {},
+      executionInputRevision: admitted.executionInputRevision,
+      planId: admitted.planId,
+      planMemberId: member.memberId,
+      ...member.contextRefs === void 0 ? {} : { contextRefs: member.contextRefs },
+      ...member.requirements === void 0 ? {} : { requirements: member.requirements },
+      ...member.capacityHints === void 0 ? {} : { capacityHints: member.capacityHints }
+    }
+  };
+}
+function immutableClone(value) {
+  if (Array.isArray(value)) return Object.freeze(value.map((item) => immutableClone(item)));
+  if (!isRecord(value)) return value;
+  const out = {};
+  for (const [key, child] of Object.entries(value)) out[key] = immutableClone(child);
+  return Object.freeze(out);
+}
+function stringMetadata(metadata, key) {
+  const value = metadata?.[key];
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function numberMetadata(metadata, key) {
+  const value = metadata?.[key];
+  return typeof value === "number" ? value : void 0;
+}
+function sourceRefId(refs2, kind) {
+  return refs2?.find((sourceRef) => sourceRef.kind === kind)?.id;
+}
+function memberSucceeded(state, admitted, memberId) {
+  return state.memberEvidence.get(memberCoord(admitted, memberId))?.status === "completed";
+}
+function memberBlockedByFailure(state, admitted, memberId, seen) {
+  if (seen.has(memberId)) return false;
+  seen.add(memberId);
+  const evidence = state.memberEvidence.get(memberCoord(admitted, memberId));
+  if (evidence !== void 0) return evidence.status !== "completed";
+  const member = admitted.plan.members.find((item) => item.memberId === memberId);
+  return (member?.dependsOnMemberIds ?? []).some(
+    (depId) => memberBlockedByFailure(state, admitted, depId, seen)
+  );
+}
+function memberCoord(admitted, memberId) {
+  return `${admitted.workItemId}:${admitted.executionInputRevision}:${admitted.planId}:${memberId}`;
+}
+function planKey(workItemId, planId, executionInputRevision) {
+  if (workItemId === void 0 || planId === void 0 || executionInputRevision === void 0)
+    return void 0;
+  return `${workItemId}:${executionInputRevision}:${planId}`;
+}
+function requiredPlanKey(workItemId, planId, executionInputRevision) {
+  return `${workItemId}:${executionInputRevision}:${planId}`;
+}
+function emitPlanIssues(ctx, state, issues) {
+  for (const item of issues) emitPlan(ctx, "issue", item);
+  if (issues.length > 0) {
+    state.auditSeq += 1;
+    emitPlan(ctx, "audit", {
+      id: `work-item-effect-plan-issue:${state.auditSeq}`,
+      kind: "work-item-effect-plan-issue",
+      subjectId: issues[0]?.subjectId,
+      message: issues[0]?.message,
+      issueCode: issues[0]?.code,
+      metadata: { issueCodes: issues.map((item) => item.code) }
+    });
+  }
+}
+function emitPlanStatusOnce(ctx, state, key, status) {
+  if (state.statusKeys.has(key)) return;
+  state.statusKeys.add(key);
+  emitPlanStatus(ctx, state, status);
+}
+function emitPlanStatus(ctx, state, status) {
+  state.statusSeq += 1;
+  const statusFact = {
+    kind: "work-item-effect-plan-status",
+    statusId: `work-item-effect-plan-status:${state.statusSeq}`,
+    ...status
+  };
+  emitPlan(ctx, "status", statusFact);
+  state.auditSeq += 1;
+  emitPlan(ctx, "audit", {
+    id: `work-item-effect-plan-status:${state.auditSeq}`,
+    kind: "work-item-effect-plan-status",
+    subjectId: status.workItemId,
+    message: status.message,
+    sourceRefs: status.sourceRefs,
+    metadata: {
+      statusId: statusFact.statusId,
+      state: status.state,
+      planId: status.planId,
+      planMemberId: status.planMemberId,
+      executionInputRevision: status.executionInputRevision,
+      ...status.metadata ?? {}
+    }
+  });
+}
+function emitPlan(ctx, kind, value) {
+  ctx.down([["DATA", { kind, value }]]);
+}
+function isWorkItemEffectPlanJoinPolicy(value) {
+  return value === "all-required" || value === "evidence-only";
+}
+function findPlanCycle(members) {
+  const byId = new Map(members.map((member) => [member.memberId, member.dependsOnMemberIds ?? []]));
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const stack = [];
+  const visit = (id) => {
+    if (visiting.has(id)) return [...stack.slice(stack.indexOf(id)), id];
+    if (visited.has(id)) return void 0;
+    visiting.add(id);
+    stack.push(id);
+    for (const dep of byId.get(id) ?? []) {
+      if (!byId.has(dep)) continue;
+      const cycle = visit(dep);
+      if (cycle !== void 0) return cycle;
+    }
+    stack.pop();
+    visiting.delete(id);
+    visited.add(id);
+    return void 0;
+  };
+  for (const member of members) {
+    const cycle = visit(member.memberId);
+    if (cycle !== void 0) return cycle;
+  }
+  return void 0;
+}
+function reduceAuthoring(ctx, state, input, policy) {
+  if (input.kind === "work-item-spawn-proposed") {
+    const issues2 = validateWorkItemDraft(input.draft, { workItemId: input.parentWorkItemId });
+    if (issues2.length > 0) {
+      for (const item of issues2) emit(ctx, "issue", item);
+      emitStatus(ctx, state, {
+        state: "rejected",
+        code: issues2[0]?.code,
+        workItemId: input.parentWorkItemId,
+        message: issues2[0]?.message,
+        metadata: { proposalId: input.proposalId }
+      });
+      return;
+    }
+    emitStatus(ctx, state, {
+      state: "deferred",
+      workItemId: input.parentWorkItemId,
+      message: `WorkItem spawn proposal '${input.proposalId}' carries draft data but is not applied`,
+      metadata: { proposalId: input.proposalId }
+    });
+    return;
+  }
+  if (state.seenEvents.has(input.eventId)) {
+    emit(
+      ctx,
+      "issue",
+      issue("duplicate-id", `Duplicate WorkItem authoring id '${input.eventId}'`, input.workItemId)
+    );
+    return;
+  }
+  state.seenEvents.add(input.eventId);
+  if (input.kind === "work-item-created") {
+    if (state.workItems.has(input.workItemId)) {
+      emit(
+        ctx,
+        "issue",
+        issue("duplicate-id", `Duplicate WorkItem '${input.workItemId}'`, input.workItemId)
+      );
+      emitStatus(ctx, state, {
+        state: "duplicate",
+        code: "duplicate-id",
+        workItemId: input.workItemId,
+        metadata: { eventId: input.eventId }
+      });
+      return;
+    }
+    const issues2 = validateWorkItemDraft(input.draft, { workItemId: input.workItemId });
+    if (issues2.length > 0) {
+      reject(ctx, state, input.workItemId, issues2);
+      return;
+    }
+    const projection = {
+      ...input.draft,
+      verificationPlan: normalizePlan(input.draft),
+      workItemId: input.workItemId,
+      authoringRevision: 1,
+      executionInputRevision: 1,
+      lastEventId: input.eventId,
+      revisionSourceRefs: refs("work-item-authoring-fact", input.eventId, input.sourceRefs),
+      createdAtMs: input.createdAtMs,
+      updatedAtMs: input.createdAtMs
+    };
+    accept(ctx, state, projection);
+    return;
+  }
+  const existing = state.workItems.get(input.workItemId);
+  if (existing === void 0) {
+    emit(
+      ctx,
+      "issue",
+      issue(
+        "dangling-ref",
+        `Authoring fact '${input.eventId}' references unknown WorkItem '${input.workItemId}'`,
+        input.workItemId
+      )
+    );
+    return;
+  }
+  if (input.kind === "work-item-patched") {
+    if (!isRecord(input.patch)) {
+      reject(ctx, state, input.workItemId, [
+        issue("invalid-patch", "WorkItemPatch must be an object", input.workItemId)
+      ]);
+      return;
+    }
+    const invalidKeys = Object.keys(input.patch).filter((key) => !draftPatchKeys.has(key));
+    if (invalidKeys.length > 0) {
+      reject(ctx, state, input.workItemId, [
+        issue(
+          "invalid-patch",
+          `WorkItemPatch contains unsupported keys: ${invalidKeys.join(", ")}`,
+          input.workItemId,
+          {
+            invalidKeys
+          }
+        )
+      ]);
+      return;
+    }
+    const draft = applyDraftPatch(existing, input.patch);
+    const issues2 = validateWorkItemDraft(draft, { workItemId: input.workItemId });
+    if (issues2.length > 0) {
+      reject(ctx, state, input.workItemId, issues2);
+      return;
+    }
+    const touched = touchesExecutionRelevant(
+      input.patch,
+      executionRelevant(policy, input.executionRelevantFields)
+    );
+    accept(ctx, state, {
+      ...existing,
+      ...draft,
+      authoringRevision: existing.authoringRevision + 1,
+      executionInputRevision: touched ? existing.executionInputRevision + 1 : existing.executionInputRevision,
+      lastEventId: input.eventId,
+      revisionSourceRefs: refs("work-item-authoring-fact", input.eventId, input.sourceRefs),
+      updatedAtMs: input.patchedAtMs
+    });
+    return;
+  }
+  if (input.kind === "acceptance-criteria-changed") {
+    const issues2 = validateAcceptanceCriteria(input.acceptanceCriteria, {
+      workItemId: input.workItemId
+    });
+    if (issues2.length > 0) {
+      reject(ctx, state, input.workItemId, issues2);
+      return;
+    }
+    accept(ctx, state, {
+      ...existing,
+      acceptanceCriteria: input.acceptanceCriteria,
+      authoringRevision: existing.authoringRevision + 1,
+      executionInputRevision: existing.executionInputRevision + 1,
+      lastEventId: input.eventId,
+      revisionSourceRefs: refs("work-item-authoring-fact", input.eventId, input.sourceRefs),
+      updatedAtMs: input.changedAtMs
+    });
+    return;
+  }
+  const issues = validateVerificationPlan(
+    input.verificationPlan,
+    existing.acceptanceCriteria ?? [],
+    { workItemId: input.workItemId }
+  );
+  if (issues.length > 0) {
+    reject(ctx, state, input.workItemId, issues);
+    return;
+  }
+  accept(ctx, state, {
+    ...existing,
+    verificationPlan: input.verificationPlan,
+    verificationSteps: input.verificationPlan.steps,
+    authoringRevision: existing.authoringRevision + 1,
+    executionInputRevision: existing.executionInputRevision + 1,
+    lastEventId: input.eventId,
+    revisionSourceRefs: refs("work-item-authoring-fact", input.eventId, input.sourceRefs),
+    updatedAtMs: input.changedAtMs
+  });
+}
+function lowerPlan(ctx, state, workItem, policy) {
+  const plan = normalizePlan(workItem);
+  if (plan === void 0) {
+    emitRequestStatus(ctx, state, {
+      state: "needs-human-review",
+      code: "verification-unplanned",
+      workItemId: workItem.workItemId
+    });
+    return;
+  }
+  const issues = validateVerificationPlan(plan, workItem.acceptanceCriteria ?? [], {
+    workItemId: workItem.workItemId,
+    allowedModes: policy?.allowedModes,
+    allowedEffectKinds: policy?.allowedEffectKinds
+  });
+  if (issues.length > 0) {
+    for (const item of issues) emit(ctx, "issue", item);
+    return;
+  }
+  if (policy?.autoRun === false) {
+    emitRequestStatus(ctx, state, {
+      state: "deferred",
+      code: "policy-mismatch",
+      workItemId: workItem.workItemId,
+      revision: workItem.authoringRevision,
+      executionInputRevision: workItem.executionInputRevision,
+      metadata: { policyId: policy.policyId, reason: "auto-run-disabled" }
+    });
+    return;
+  }
+  for (const step of plan.steps) {
+    if (isStepSatisfied(state, workItem, step.stepId)) {
+      emitRequestStatus(ctx, state, {
+        state: "duplicate",
+        code: "duplicate-suppressed",
+        workItemId: workItem.workItemId,
+        revision: workItem.authoringRevision,
+        executionInputRevision: workItem.executionInputRevision,
+        stepId: step.stepId,
+        message: `Verification step '${step.stepId}' already has valid evidence`
+      });
+      continue;
+    }
+    if (step.mode === "manual") {
+      emitRequestStatus(ctx, state, {
+        state: "needs-human-review",
+        code: "manual-review-required",
+        workItemId: workItem.workItemId,
+        stepId: step.stepId
+      });
+      continue;
+    }
+    const missingPrerequisites = (step.dependsOnStepIds ?? []).filter(
+      (stepId) => !isStepSatisfied(state, workItem, stepId)
+    );
+    if (missingPrerequisites.length > 0) {
+      emitRequestStatus(ctx, state, {
+        state: "blocked",
+        code: "blocked-prerequisite",
+        workItemId: workItem.workItemId,
+        stepId: step.stepId,
+        metadata: { missingStepIds: missingPrerequisites }
+      });
+      continue;
+    }
+    emitRequest(ctx, state, requestFromStep(workItem, plan, step, policy));
+  }
+}
+function lowerIntent(ctx, state, intent, policy) {
+  const workItem = state.workItems.get(intent.workItemId);
+  if (workItem === void 0) {
+    emit(
+      ctx,
+      "issue",
+      issue(
+        "dangling-ref",
+        `Dispatch intent '${intent.intentId}' references unknown WorkItem '${intent.workItemId}'`,
+        intent.workItemId
+      )
+    );
+    return;
+  }
+  if (intent.executionInputRevision !== workItem.executionInputRevision) {
+    emit(
+      ctx,
+      "issue",
+      issue(
+        "stale-execution-input",
+        `Dispatch intent '${intent.intentId}' targets stale execution input`,
+        intent.workItemId,
+        {
+          intentRevision: intent.executionInputRevision,
+          currentRevision: workItem.executionInputRevision,
+          stalePolicy: policy?.stalePolicy ?? "review"
+        }
+      )
+    );
+    emitRequestStatus(ctx, state, {
+      state: "stale",
+      code: "stale-execution-input",
+      workItemId: intent.workItemId,
+      executionInputRevision: workItem.executionInputRevision,
+      metadata: { intentId: intent.intentId }
+    });
+    return;
+  }
+  const effectKind = intent.effectKind ?? intent.targetKind;
+  const allowedEffectKinds = new Set(policy?.allowedEffectKinds ?? ["verification"]);
+  if (!allowedEffectKinds.has(effectKind)) {
+    emit(
+      ctx,
+      "issue",
+      issue(
+        "unsupported-effect-kind",
+        `Dispatch intent '${intent.intentId}' targets unsupported effect kind '${effectKind}'`,
+        intent.workItemId,
+        { intentId: intent.intentId, effectKind }
+      )
+    );
+    emitRequestStatus(ctx, state, {
+      state: "rejected",
+      code: "unsupported-effect-kind",
+      workItemId: intent.workItemId,
+      executionInputRevision: workItem.executionInputRevision,
+      metadata: { intentId: intent.intentId, effectKind }
+    });
+    return;
+  }
+  emitRequest(ctx, state, requestFromIntent(workItem, intent));
+}
+function recordVerificationResult(ctx, state, result, policy) {
+  if (result.status !== "passed") return;
+  const workItem = state.workItems.get(result.workItemId);
+  if (workItem === void 0) {
+    emit(
+      ctx,
+      "issue",
+      issue(
+        "dangling-ref",
+        `Verification result '${result.resultId}' references unknown WorkItem '${result.workItemId}'`,
+        result.workItemId
+      )
+    );
+    return;
+  }
+  if (result.executionInputRevision !== workItem.executionInputRevision) {
+    emit(
+      ctx,
+      "issue",
+      issue(
+        "stale-revision",
+        `Verification result '${result.resultId}' targets stale execution input`,
+        result.workItemId
+      )
+    );
+    return;
+  }
+  const key = revisionKey(result.workItemId, result.executionInputRevision);
+  const passedSteps = state.passedSteps.get(key) ?? /* @__PURE__ */ new Set();
+  for (const stepId of result.verificationStepIds) passedSteps.add(stepId);
+  state.passedSteps.set(key, passedSteps);
+  lowerPlan(ctx, state, workItem, policy);
+}
+function mapEvidence(ctx, state, evidence, replay = false) {
+  if (!replay && state.evidenceById.has(evidence.evidenceId)) {
+    emit(
+      ctx,
+      "issue",
+      issue(
+        "duplicate-suppressed",
+        `Duplicate evidence '${evidence.evidenceId}'`,
+        evidence.workItemId
+      )
+    );
+    return;
+  }
+  state.evidenceById.set(evidence.evidenceId, evidence);
+  const workItem = state.workItems.get(evidence.workItemId);
+  if (workItem === void 0) {
+    emit(
+      ctx,
+      "issue",
+      issue(
+        "dangling-ref",
+        `Evidence '${evidence.evidenceId}' references unknown WorkItem '${evidence.workItemId}'`,
+        evidence.workItemId
+      )
+    );
+    return;
+  }
+  const revision = typeof evidence.metadata?.executionInputRevision === "number" ? evidence.metadata.executionInputRevision : void 0;
+  if (revision !== workItem.executionInputRevision) {
+    emit(
+      ctx,
+      "issue",
+      issue(
+        "stale-revision",
+        `Evidence '${evidence.evidenceId}' targets stale revision`,
+        evidence.workItemId
+      )
+    );
+    emitResultStatus(ctx, state, {
+      state: "stale",
+      code: "stale-revision",
+      workItemId: evidence.workItemId,
+      executionInputRevision: workItem.executionInputRevision
+    });
+    return;
+  }
+  const stepIds = stringArray(evidence.metadata?.verificationStepIds);
+  const criterionIds = stringArray(evidence.metadata?.acceptanceCriterionIds);
+  if (stepIds.length === 0 || criterionIds.length === 0) {
+    emit(
+      ctx,
+      "issue",
+      issue(
+        "ambiguous-coverage",
+        `Evidence '${evidence.evidenceId}' lacks coverage refs`,
+        evidence.workItemId
+      )
+    );
+    return;
+  }
+  const coverageIssue = validateEvidenceCoverage(workItem, stepIds, criterionIds);
+  if (coverageIssue !== void 0) {
+    emit(ctx, "issue", {
+      ...coverageIssue,
+      message: `Evidence '${evidence.evidenceId}' has invalid verification coverage: ${coverageIssue.message}`
+    });
+    emitResultStatus(ctx, state, {
+      state: "rejected",
+      code: coverageIssue.code,
+      workItemId: evidence.workItemId,
+      executionInputRevision: workItem.executionInputRevision,
+      metadata: { evidenceId: evidence.evidenceId }
+    });
+    return;
+  }
+  const result = {
+    kind: "verification-result-recorded",
+    resultId: `verification-result:${evidence.evidenceId}`,
+    workItemId: evidence.workItemId,
+    evidenceId: evidence.evidenceId,
+    effectRunId: evidence.effectRunId,
+    effectRunResultId: evidence.effectRunResultId,
+    executionInputRevision: revision,
+    verificationStepIds: stepIds,
+    acceptanceCriterionIds: criterionIds,
+    status: resultStatus(evidence.status),
+    output: evidence.output,
+    error: evidence.error,
+    reason: evidence.reason,
+    sourceRefs: evidence.sourceRefs,
+    recordedAtMs: evidence.recordedAtMs,
+    metadata: evidence.metadata
+  };
+  if (!state.resultEvidence.has(evidence.evidenceId)) {
+    state.resultEvidence.add(evidence.evidenceId);
+    emit(ctx, "result", result);
+    emitResultStatus(ctx, state, {
+      state: "result-recorded",
+      workItemId: evidence.workItemId,
+      executionInputRevision: revision,
+      metadata: { resultId: result.resultId }
+    });
+  }
+  const policyIds = [
+    ...new Set(
+      (evidence.sourceRefs ?? []).filter((sourceRef) => sourceRef.kind === "work-item-verification-mapping-policy").map((sourceRef) => sourceRef.id)
+    )
+  ];
+  if (policyIds.length === 0) return;
+  for (const policyId of policyIds) {
+    const policy = state.policies.get(policyId);
+    if (policy === void 0) {
+      if (!replay) {
+        emit(
+          ctx,
+          "issue",
+          issue(
+            "missing-policy",
+            `Missing verification mapping policy '${policyId}'`,
+            evidence.workItemId,
+            { policyId }
+          )
+        );
+        emitResultStatus(ctx, state, {
+          state: "deferred",
+          code: "missing-policy",
+          workItemId: evidence.workItemId,
+          executionInputRevision: revision,
+          metadata: { evidenceId: evidence.evidenceId, policyId }
+        });
+      }
+      continue;
+    }
+    for (const [index, spec] of (policy.actionProposals ?? []).entries()) {
+      if (spec.behavior !== void 0 && spec.behavior !== "propose") {
+        emit(ctx, "issue", actionProposalIssue(policy, spec, evidence, "unsupported behavior"));
+        continue;
+      }
+      if (spec.actionKind.length === 0) {
+        emit(ctx, "issue", actionProposalIssue(policy, spec, evidence, "empty actionKind"));
+        continue;
+      }
+      if (spec.statuses !== void 0 && !spec.statuses.includes(evidence.status)) continue;
+      const outputKind = evidence.output?.kind;
+      if (spec.outputKinds !== void 0 && (outputKind === void 0 || !spec.outputKinds.includes(outputKind)))
+        continue;
+      const proposalKey = `${evidence.evidenceId}:${policy.policyId}:${index}:${spec.actionKind}`;
+      if (state.proposalKeys.has(proposalKey)) continue;
+      state.proposalKeys.add(proposalKey);
+      emit(ctx, "proposal", {
+        kind: "work-item-domain-action-proposal",
+        proposalId: `verification:${result.resultId}:${policy.policyId}:${index}:${spec.actionKind}`,
+        workItemId: result.workItemId,
+        actionKind: spec.actionKind,
+        effectRunId: result.effectRunId,
+        effectRunResultId: result.effectRunResultId,
+        evidenceId: result.evidenceId,
+        policyId: policy.policyId,
+        payload: actionProposalPayload(spec, evidence, result),
+        reason: spec.reason ?? evidence.reason,
+        sourceRefs: [
+          ref("work-item-evidence", evidence.evidenceId),
+          ref("verification-result", result.resultId),
+          ref("effect-run-result", result.effectRunResultId),
+          ref("work-item-verification-mapping-policy", policy.policyId)
+        ],
+        metadata: {
+          ...policy.metadata ?? {},
+          ...spec.metadata ?? {},
+          resultStatus: evidence.status
+        }
+      });
+      emitResultStatus(ctx, state, {
+        state: "domain-action-proposed",
+        workItemId: evidence.workItemId,
+        executionInputRevision: revision,
+        metadata: { actionKind: spec.actionKind, policyId: policy.policyId }
+      });
+    }
+  }
+}
+function requestFromStep(workItem, plan, step, policy) {
+  const requestId = `work-item:${workItem.workItemId}:verification:${workItem.executionInputRevision}:${plan.planId}:${step.stepId}`;
+  const effectKind = step.effectKind ?? "verification";
+  const criterionIds = step.verifiesCriteriaIds ?? (workItem.acceptanceCriteria ?? []).map((criterion) => criterion.criterionId);
+  const goal = goalWithInlineInput(
+    step.goal ?? { kind: effectKind, summary: step.title ?? workItem.summary },
+    step.input,
+    `verification-step:${step.stepId}:input`,
+    effectKind,
+    step.contextRefs
+  );
+  return {
+    kind: "work-item-effect-requested",
+    requestId,
+    workItemId: workItem.workItemId,
+    effectRunId: `effect-run:${requestId}`,
+    effectKind,
+    executionInputRevision: workItem.executionInputRevision,
+    sourceRefs: [
+      ref("work-item", workItem.workItemId),
+      ref("work-item-revision", `${workItem.workItemId}:${workItem.executionInputRevision}`),
+      ref("verification-plan", plan.planId),
+      ref("verification-step", step.stepId),
+      ...plan.sourceRefs ?? [],
+      ...step.sourceRefs ?? []
+    ],
+    goal,
+    policyRefs: policy?.policyId === void 0 ? step.policyRefs : [
+      ...step.policyRefs ?? [],
+      ref("work-item-verification-lowerer-policy", policy.policyId)
+    ],
+    idempotencyKey: `${workItem.workItemId}:verification:${workItem.executionInputRevision}:${plan.planId}:${step.stepId}`,
+    metadata: {
+      ...step.metadata ?? {},
+      executionInputRevision: workItem.executionInputRevision,
+      verificationPlanId: plan.planId,
+      verificationStepIds: [step.stepId],
+      acceptanceCriterionIds: criterionIds,
+      ...step.contextRefs === void 0 ? {} : { contextRefs: step.contextRefs },
+      ...step.requirements === void 0 ? {} : { requirements: step.requirements },
+      ...step.capacityHints === void 0 ? {} : { capacityHints: step.capacityHints }
+    }
+  };
+}
+function requestFromIntent(workItem, intent) {
+  const requestId = `work-item:${workItem.workItemId}:dispatch:${workItem.executionInputRevision}:${intent.intentId}`;
+  const effectKind = intent.effectKind ?? intent.targetKind;
+  return {
+    kind: "work-item-effect-requested",
+    requestId,
+    workItemId: workItem.workItemId,
+    effectRunId: `effect-run:${requestId}`,
+    effectKind,
+    executionInputRevision: workItem.executionInputRevision,
+    sourceRefs: [
+      ref("work-item", workItem.workItemId),
+      ref("work-item-dispatch-intent", intent.intentId),
+      ...intent.sourceRefs ?? []
+    ],
+    goal: intent.goal ?? { kind: effectKind, summary: intent.reason ?? workItem.summary },
+    policyRefs: intent.policyRefs,
+    limits: intent.limits,
+    idempotencyKey: intent.idempotencyKey ?? `${workItem.workItemId}:dispatch:${workItem.executionInputRevision}:${intent.intentId}`,
+    metadata: {
+      ...intent.metadata ?? {},
+      executionInputRevision: workItem.executionInputRevision,
+      verificationStepIds: intent.stepIds ?? [],
+      acceptanceCriterionIds: intent.acceptanceCriterionIds ?? [],
+      ...intent.contextRefs === void 0 ? {} : { contextRefs: intent.contextRefs },
+      ...intent.requirements === void 0 ? {} : { requirements: intent.requirements },
+      ...intent.capacityHints === void 0 ? {} : { capacityHints: intent.capacityHints }
+    }
+  };
+}
+function accept(ctx, state, projection) {
+  state.workItems.set(projection.workItemId, projection);
+  emit(ctx, "work-item", projection);
+  emitStatus(ctx, state, {
+    state: "projected",
+    workItemId: projection.workItemId,
+    revision: projection.authoringRevision,
+    executionInputRevision: projection.executionInputRevision,
+    metadata: { lastEventId: projection.lastEventId }
+  });
+}
+function reject(ctx, state, workItemId, issues) {
+  for (const item of issues) emit(ctx, "issue", item);
+  emitStatus(ctx, state, {
+    state: "rejected",
+    code: issues[0]?.code,
+    workItemId,
+    message: issues[0]?.message
+  });
+}
+function emitRequest(ctx, state, request) {
+  const key = request.idempotencyKey ?? request.requestId;
+  if (state.emittedKeys.has(key)) {
+    emitRequestStatus(ctx, state, {
+      state: "duplicate",
+      code: "duplicate-suppressed",
+      workItemId: request.workItemId,
+      metadata: { requestId: request.requestId }
+    });
+    return;
+  }
+  state.emittedKeys.add(key);
+  emit(ctx, "request", request);
+  emitRequestStatus(ctx, state, {
+    state: "request-emitted",
+    workItemId: request.workItemId,
+    executionInputRevision: request.executionInputRevision ?? request.metadata?.executionInputRevision,
+    metadata: { requestId: request.requestId }
+  });
+}
+function emitStatus(ctx, state, status) {
+  state.statusSeq += 1;
+  const statusFact = {
+    kind: "work-item-validation-status",
+    statusId: `work-item-authoring-status:${state.statusSeq}`,
+    ...status
+  };
+  emit(ctx, "status", statusFact);
+  emitAudit(ctx, state, "work-item-authoring-status", statusFact);
+}
+function emitRequestStatus(ctx, state, status) {
+  state.statusSeq += 1;
+  const statusFact = {
+    kind: "work-item-validation-status",
+    statusId: `work-item-verification-request-status:${state.statusSeq}`,
+    ...status
+  };
+  emit(ctx, "status", statusFact);
+  emitAudit(ctx, state, "work-item-verification-request-status", statusFact);
+}
+function emitResultStatus(ctx, state, status) {
+  state.statusSeq += 1;
+  const statusFact = {
+    kind: "work-item-validation-status",
+    statusId: `work-item-verification-result-status:${state.statusSeq}`,
+    ...status
+  };
+  emit(ctx, "status", statusFact);
+  emitAudit(ctx, state, "work-item-verification-result-status", statusFact);
+}
+function emitAudit(ctx, state, kind, status) {
+  state.auditSeq += 1;
+  emit(ctx, "audit", {
+    id: `${kind}:${state.auditSeq}`,
+    kind,
+    subjectId: status.workItemId,
+    message: status.message,
+    issueCode: status.code,
+    sourceRefs: status.sourceRefs,
+    metadata: {
+      statusId: status.statusId,
+      state: status.state,
+      revision: status.revision,
+      executionInputRevision: status.executionInputRevision,
+      ...status.metadata ?? {}
+    }
+  });
+}
+function emit(ctx, kind, value) {
+  ctx.down([["DATA", { kind, value }]]);
+}
+function project(graph, runtime, name, factory, select) {
+  return graph.node(
+    [runtime],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const selected = select(raw);
+        if (selected !== void 0) ctx.down([["DATA", selected]]);
+      }
+    },
+    { name, factory, partial: true, completeWhenDepsComplete: false, errorWhenDepsError: false }
+  );
+}
+function normalizePlan(draft) {
+  if (draft.verificationPlan !== void 0) return draft.verificationPlan;
+  if (draft.verificationSteps !== void 0)
+    return { planId: "default", steps: draft.verificationSteps };
+  return void 0;
+}
+function normalizePlanFromUnknown(draft) {
+  const verificationPlan = draft.verificationPlan;
+  if (verificationPlan !== void 0) {
+    if (!isRecord(verificationPlan) || !Array.isArray(verificationPlan.steps)) {
+      return { planId: "malformed", steps: [] };
+    }
+    return verificationPlan;
+  }
+  const verificationSteps = draft.verificationSteps;
+  if (verificationSteps !== void 0) {
+    if (!Array.isArray(verificationSteps)) return { planId: "malformed", steps: [] };
+    return { planId: "default", steps: verificationSteps };
+  }
+  return void 0;
+}
+function isVerificationPlanShape(value) {
+  return isRecord(value) && typeof value.planId === "string" && Array.isArray(value.steps);
+}
+function applyDraftPatch(existing, patch) {
+  return {
+    summary: patchValue(patch, existing, "summary"),
+    detail: patchValue(patch, existing, "detail"),
+    detailRefs: patchValue(patch, existing, "detailRefs"),
+    acceptanceCriteria: patchValue(patch, existing, "acceptanceCriteria"),
+    verificationPlan: patchValue(patch, existing, "verificationPlan"),
+    verificationSteps: patchValue(patch, existing, "verificationSteps"),
+    kind: patchValue(patch, existing, "kind"),
+    priority: patchValue(patch, existing, "priority"),
+    tags: patchValue(patch, existing, "tags"),
+    owner: patchValue(patch, existing, "owner"),
+    assignee: patchValue(patch, existing, "assignee"),
+    deadlineMs: patchValue(patch, existing, "deadlineMs"),
+    customFields: patchValue(patch, existing, "customFields"),
+    sourceRefs: patchValue(patch, existing, "sourceRefs"),
+    metadata: patchValue(patch, existing, "metadata")
+  };
+}
+function patchValue(patch, existing, key) {
+  return Object.hasOwn(patch, key) ? patch[key] : existing[key];
+}
+function validateEvidenceCoverage(workItem, stepIds, criterionIds) {
+  const plan = normalizePlan(workItem);
+  const validStepIds = new Set((plan?.steps ?? []).map((step) => step.stepId));
+  const validCriterionIds = new Set(
+    (workItem.acceptanceCriteria ?? []).map((criterion) => criterion.criterionId)
+  );
+  for (const stepId of stepIds) {
+    if (!validStepIds.has(stepId)) {
+      return issue("dangling-ref", `unknown verification step '${stepId}'`, workItem.workItemId, {
+        stepId
+      });
+    }
+  }
+  for (const criterionId of criterionIds) {
+    if (!validCriterionIds.has(criterionId)) {
+      return issue(
+        "dangling-ref",
+        `unknown acceptance criterion '${criterionId}'`,
+        workItem.workItemId,
+        { criterionId }
+      );
+    }
+  }
+  return void 0;
+}
+function executionRelevant(policy, fields) {
+  return /* @__PURE__ */ new Set([
+    ...executionRelevantDefaults,
+    ...policy?.executionRelevantFields ?? [],
+    ...fields ?? []
+  ]);
+}
+function touchesExecutionRelevant(patch, relevantFields) {
+  const paths = patchPaths(patch);
+  for (const path of paths) {
+    if (relevantFields.has(path)) return true;
+  }
+  return false;
+}
+function patchPaths(patch) {
+  const paths = [];
+  for (const [key, value] of Object.entries(patch)) {
+    paths.push(key);
+    if (isRecord(value)) {
+      for (const childKey of Object.keys(value)) paths.push(`${key}.${childKey}`);
+    }
+  }
+  return paths;
+}
+function isStepSatisfied(state, workItem, stepId) {
+  return state.passedSteps.get(revisionKey(workItem.workItemId, workItem.executionInputRevision))?.has(stepId) === true;
+}
+function revisionKey(workItemId, executionInputRevision) {
+  return `${workItemId}:${executionInputRevision}`;
+}
+function replayEvidence(ctx, state, workItemId) {
+  for (const evidence of state.evidenceById.values()) {
+    if (evidence.workItemId === workItemId) mapEvidence(ctx, state, evidence, true);
+  }
+}
+function validateMappingPolicy(policy) {
+  if (!isRecord(policy) || policy.kind !== "work-item-verification-mapping-policy" || typeof policy.policyId !== "string" || policy.policyId.trim() === "") {
+    return [
+      issue(
+        "policy-mismatch",
+        "WorkItemVerificationMappingPolicy requires kind and policyId",
+        void 0
+      )
+    ];
+  }
+  if (policy.actionProposals !== void 0 && !Array.isArray(policy.actionProposals)) {
+    return [
+      issue(
+        "policy-mismatch",
+        "WorkItemVerificationMappingPolicy.actionProposals must be an array",
+        void 0,
+        {
+          policyId: policy.policyId
+        }
+      )
+    ];
+  }
+  const out = [];
+  for (const [index, spec] of (policy.actionProposals ?? []).entries()) {
+    if (!isRecord(spec) || typeof spec.actionKind !== "string") {
+      out.push(
+        issue("policy-mismatch", "WorkItem action proposal requires actionKind", void 0, {
+          policyId: policy.policyId,
+          index
+        })
+      );
+    }
+  }
+  return out;
+}
+function findCycle(steps) {
+  const byId = new Map(steps.map((step) => [step.stepId, step.dependsOnStepIds ?? []]));
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const stack = [];
+  const visit = (id) => {
+    if (visiting.has(id)) return [...stack.slice(stack.indexOf(id)), id];
+    if (visited.has(id)) return void 0;
+    visiting.add(id);
+    stack.push(id);
+    for (const dep of byId.get(id) ?? []) {
+      if (!byId.has(dep)) continue;
+      const cycle = visit(dep);
+      if (cycle !== void 0) return cycle;
+    }
+    stack.pop();
+    visiting.delete(id);
+    visited.add(id);
+    return void 0;
+  };
+  for (const step of steps) {
+    const cycle = visit(step.stepId);
+    if (cycle !== void 0) return cycle;
+  }
+  return void 0;
+}
+function resultStatus(status) {
+  if (status === "completed") return "passed";
+  if (status === "failed") return "failed";
+  if (status === "blocked") return "blocked";
+  if (status === "canceled") return "canceled";
+  if (status === "timeout") return "timeout";
+  return "waived";
+}
+function goalWithInlineInput(goal, input, inputId, inputKind, subjectRefs) {
+  if (input === void 0 || goal.input !== void 0) return goal;
+  return {
+    ...goal,
+    input: {
+      inputId,
+      inputKind,
+      dataMode: "inline",
+      value: input,
+      subjectRefs
+    }
+  };
+}
+function actionProposalPayload(spec, evidence, result) {
+  if (spec.payload !== void 0) return spec.payload;
+  if (spec.payloadFrom === "effect-run-result")
+    return { kind: "effect-run-result-ref", resultId: result.effectRunResultId };
+  if (spec.payloadFrom === "output") return evidence.output;
+  if (spec.payloadFrom === "evidence")
+    return { kind: "work-item-evidence-ref", evidenceId: evidence.evidenceId };
+  return void 0;
+}
+function actionProposalIssue(policy, spec, evidence, reason) {
+  return issue(
+    "policy-mismatch",
+    `Verification mapping policy '${policy.policyId}' has an invalid action proposal: ${reason}`,
+    evidence.workItemId,
+    { policyId: policy.policyId, actionKind: spec.actionKind }
+  );
+}
+function issue(code, message, workItemId, metadata) {
+  return {
+    kind: "issue",
+    code,
+    message,
+    severity: "error",
+    source: "work-item-scheduling",
+    subjectId: workItemId,
+    metadata
+  };
+}
+function refs(kind, id, rest) {
+  return [ref(kind, id), ...rest ?? []];
+}
+function ref(kind, id) {
+  return { kind, id };
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  acceptanceCriteriaChanged,
+  validateAcceptanceCriteria,
+  validateVerificationPlan,
+  validateWorkItemDraft,
+  validateWorkItemEffectPlan,
+  verificationPlanChanged,
+  workItemAuthoringProjector,
+  workItemCreatedFromDraft,
+  workItemEffectPlanProjector,
+  workItemSpawnProposed,
+  workItemVerificationRequestLowerer,
+  workItemVerificationResultMapper
+});
+//# sourceMappingURL=scheduling.cjs.map