@narumitw/pi-subagents 2.0.0 → 2.0.2

package/dist/chunks/chunk-OVPHFGKO.ts

@@ -0,0 +1,1769 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
+import {
+  redactPrivateText,
+  truncateUtf8
+} from "./chunk-H3FP6DLR.js";
+
+// src/workflow-tree-identity.ts
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+var WORKFLOW_TREE_IDENTITY_VERSION = "pi-subagents:workflow-tree:v1";
+var DEFAULT_WORKFLOW_TREE_MAX_BYTES = 1024 * 1024;
+var MAX_UNTRACKED_FILES = 256;
+async function captureWorkflowTreeIdentity(cwd, options = {}) {
+  const maxBytes = options.maxBytes ?? DEFAULT_WORKFLOW_TREE_MAX_BYTES;
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 1) {
+    throw new Error("Workflow tree identity maxBytes must be a positive safe integer");
+  }
+  throwIfAborted(options.signal);
+  let canonicalCwd;
+  try {
+    canonicalCwd = await fs.promises.realpath(path.resolve(cwd));
+  } catch {
+    throw new Error("Workflow verification requires a readable Git repository directory");
+  }
+  const rootOutput = await git(
+    canonicalCwd,
+    ["rev-parse", "--show-toplevel"],
+    64 * 1024,
+    options.signal
+  ).catch((error) => {
+    throw normalizedGitError(error, "Workflow verification requires a Git repository");
+  });
+  let repositoryRoot;
+  try {
+    repositoryRoot = await fs.promises.realpath(rootOutput.toString("utf8").trim());
+  } catch {
+    throw new Error("Workflow verification requires a readable Git repository root");
+  }
+  const relativeCwd = path.relative(repositoryRoot, canonicalCwd);
+  if (relativeCwd.startsWith("..") || path.isAbsolute(relativeCwd)) {
+    throw new Error("Workflow verification cwd is outside its Git repository");
+  }
+  const submodules = await git(
+    repositoryRoot,
+    ["submodule", "status", "--recursive"],
+    64 * 1024,
+    options.signal
+  ).catch((error) => {
+    throw normalizedGitError(error, "Workflow tree identity could not inspect submodules");
+  });
+  if (submodules.toString("utf8").trim()) {
+    throw new Error("Workflow tree identity does not support repositories with submodules");
+  }
+  const head = (await git(repositoryRoot, ["rev-parse", "HEAD"], 64 * 1024, options.signal).catch((error) => {
+    throw normalizedGitError(error, "Workflow verification requires a stable Git HEAD");
+  })).toString("utf8").trim();
+  if (!/^[a-f0-9]{40,64}$/u.test(head)) {
+    throw new Error("Workflow verification requires a stable Git HEAD");
+  }
+  const commandLimit = maxBytes + 1;
+  const indexDiff = await git(
+    repositoryRoot,
+    ["diff", "--binary", "--no-ext-diff", "--cached", "HEAD", "--"],
+    commandLimit,
+    options.signal
+  ).catch((error) => {
+    throw normalizedGitError(error, "Workflow tree identity exceeded its size limit");
+  });
+  const worktreeDiff = await git(
+    repositoryRoot,
+    ["diff", "--binary", "--no-ext-diff", "--"],
+    commandLimit,
+    options.signal
+  ).catch((error) => {
+    throw normalizedGitError(error, "Workflow tree identity exceeded its size limit");
+  });
+  if (indexDiff.length > maxBytes || worktreeDiff.length > maxBytes) {
+    throw new Error("Workflow tree identity exceeded its size limit");
+  }
+  const untrackedOutput = await git(
+    repositoryRoot,
+    ["ls-files", "--others", "--exclude-standard", "-z"],
+    commandLimit,
+    options.signal
+  ).catch((error) => {
+    throw normalizedGitError(error, "Workflow tree identity exceeded its size limit");
+  });
+  const untrackedEntries = splitNul(untrackedOutput).sort(Buffer.compare);
+  if (untrackedEntries.length > MAX_UNTRACKED_FILES) {
+    throw new Error("Workflow tree identity exceeded its untracked-file limit");
+  }
+  if (indexDiff.length === 0 && worktreeDiff.length === 0 && untrackedEntries.length === 0) {
+    return identity("git-commit", hashParts([Buffer.from("commit\0"), Buffer.from(head)]));
+  }
+  let consumed = indexDiff.length + worktreeDiff.length + untrackedOutput.length;
+  if (consumed > maxBytes) throw new Error("Workflow tree identity exceeded its size limit");
+  const hasher = createHash("sha256");
+  hasher.update("pi-subagents:workflow-tree:v1\0");
+  updateHashFrame(hasher, "head", head);
+  updateHashFrame(hasher, "index-diff", indexDiff);
+  updateHashFrame(hasher, "worktree-diff", worktreeDiff);
+  for (const rawRelativePath of untrackedEntries) {
+    throwIfAborted(options.signal);
+    const relativePath = decodeGitPath(rawRelativePath);
+    const candidate = path.resolve(repositoryRoot, relativePath);
+    const relative2 = path.relative(repositoryRoot, candidate);
+    if (!relative2 || relative2.startsWith("..") || path.isAbsolute(relative2)) {
+      throw new Error("Workflow tree identity encountered an unsafe untracked path");
+    }
+    let bytes;
+    let kind;
+    try {
+      const stat = await fs.promises.lstat(candidate);
+      if (stat.isSymbolicLink()) {
+        kind = "symlink";
+        bytes = Buffer.from(await fs.promises.readlink(candidate), "utf8");
+      } else if (stat.isFile()) {
+        kind = "file";
+        if (stat.size > maxBytes - consumed) {
+          throw new Error("Workflow tree identity exceeded its size limit");
+        }
+        bytes = await readRegularFileNoFollow(candidate, stat, options.signal);
+      } else {
+        throw new Error("Workflow tree identity encountered an unsupported untracked file type");
+      }
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") throw error;
+      if (error instanceof Error && error.message.startsWith("Workflow tree identity")) {
+        throw error;
+      }
+      throw new Error("Workflow tree identity could not read an untracked entry");
+    }
+    consumed += rawRelativePath.length + bytes.length;
+    if (consumed > maxBytes) throw new Error("Workflow tree identity exceeded its size limit");
+    updateHashFrame(hasher, "untracked-kind", kind);
+    updateHashFrame(hasher, "untracked-path", rawRelativePath);
+    updateHashFrame(hasher, "untracked-content", bytes);
+  }
+  return identity("git-dirty", hasher.digest("hex"));
+}
+function sameWorkflowTreeIdentity(left, right) {
+  return isWorkflowTreeIdentity(left) && isWorkflowTreeIdentity(right) && left.kind === right.kind && left.digest === right.digest;
+}
+function isWorkflowTreeIdentity(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const candidate = value;
+  if (Object.keys(value).some(
+    (key) => !["version", "kind", "digest"].includes(key)
+  )) {
+    return false;
+  }
+  return candidate.version === WORKFLOW_TREE_IDENTITY_VERSION && (candidate.kind === "git-commit" || candidate.kind === "git-dirty") && typeof candidate.digest === "string" && /^[a-f0-9]{64}$/u.test(candidate.digest);
+}
+function identity(kind, digest) {
+  return { version: WORKFLOW_TREE_IDENTITY_VERSION, kind, digest };
+}
+function hashParts(parts) {
+  const hash = createHash("sha256");
+  for (const part of parts) hash.update(part);
+  return hash.digest("hex");
+}
+function updateHashFrame(hash, label, value) {
+  const labelBytes = Buffer.from(label, "utf8");
+  const valueBytes = typeof value === "string" ? Buffer.from(value, "utf8") : value;
+  const header = Buffer.allocUnsafe(8);
+  header.writeUInt32BE(labelBytes.length, 0);
+  header.writeUInt32BE(valueBytes.length, 4);
+  hash.update(header);
+  hash.update(labelBytes);
+  hash.update(valueBytes);
+}
+function splitNul(value) {
+  const entries = [];
+  let start = 0;
+  for (let index = 0; index < value.length; index++) {
+    if (value[index] !== 0) continue;
+    if (index > start) entries.push(value.subarray(start, index));
+    start = index + 1;
+  }
+  if (start < value.length) entries.push(value.subarray(start));
+  return entries;
+}
+function decodeGitPath(value) {
+  const decoded = value.toString("utf8");
+  if (!decoded || decoded.includes("\0") || !Buffer.from(decoded, "utf8").equals(value)) {
+    throw new Error("Workflow tree identity encountered an unsupported Git path encoding");
+  }
+  return decoded;
+}
+async function readRegularFileNoFollow(filePath, expected, signal) {
+  throwIfAborted(signal);
+  const handle = await fs.promises.open(filePath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+  try {
+    const before = await handle.stat();
+    if (!before.isFile() || before.dev !== expected.dev || before.ino !== expected.ino) {
+      throw new Error("Workflow tree identity file changed during capture");
+    }
+    const content = await handle.readFile({ signal });
+    const after = await handle.stat();
+    if (after.dev !== before.dev || after.ino !== before.ino || after.size !== before.size || after.mtimeMs !== before.mtimeMs) {
+      throw new Error("Workflow tree identity file changed during capture");
+    }
+    return content;
+  } finally {
+    await handle.close();
+  }
+}
+function git(cwd, args, maxBuffer, signal) {
+  throwIfAborted(signal);
+  return new Promise((resolve4, reject) => {
+    execFile(
+      "git",
+      ["-C", cwd, ...args],
+      { encoding: "buffer", maxBuffer, signal },
+      (error, stdout) => {
+        if (error) reject(error);
+        else resolve4(stdout);
+      }
+    );
+  });
+}
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  const error = new Error("Workflow tree identity capture was cancelled");
+  error.name = "AbortError";
+  throw error;
+}
+function normalizedGitError(error, fallback) {
+  if (error instanceof Error && error.name === "AbortError") return error;
+  const message = error instanceof Error ? error.message : String(error);
+  return new Error(
+    /maxBuffer|stdout.*large|SIGTERM/iu.test(message) ? `${fallback}: size limit` : fallback
+  );
+}
+
+// src/workflow-verification.ts
+var WORKFLOW_VERIFICATION_VERSION = "pi-subagents:workflow-verification:v1";
+var MAX_FIELD_BYTES = 2 * 1024;
+var MAX_ITEMS = 32;
+var MAX_EVIDENCE_BYTES = 6 * 1024;
+var MAX_LIMITATION_BYTES = 4 * 1024;
+var MAX_INSTRUCTION_LIST_BYTES = 8 * 1024;
+var ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/u;
+var PLAN_PATTERN = /^[a-f0-9]{64}$/u;
+function createWorkflowVerificationReceipt(result, context) {
+  validateContext(context);
+  const decision = verdict(result);
+  const boundedSummary = bound(result.summary);
+  if (!boundedSummary.value) throw new Error("Workflow verification verdict requires a summary");
+  const evidenceSource = [
+    ...result.claims.flatMap((claim) => claim.evidence),
+    ...result.verification.flatMap((item) => [item.summary, ...item.evidence ?? []])
+  ];
+  const evidence = boundList(evidenceSource, MAX_EVIDENCE_BYTES);
+  const limitations = boundList(
+    [...result.limitations, ...result.unresolvedDependencies],
+    MAX_LIMITATION_BYTES
+  );
+  if (decision === "rework" && limitations.values.length === 0) {
+    throw new Error("Workflow verification rework requires a limitation or unresolved dependency");
+  }
+  if (decision === "reject" && evidence.values.length === 0) {
+    throw new Error("Workflow verification reject requires evidence");
+  }
+  return {
+    version: WORKFLOW_VERIFICATION_VERSION,
+    decision,
+    targetTaskId: context.targetTaskId,
+    targetTaskGeneration: context.targetTaskGeneration,
+    targetExecutionPlanId: context.targetExecutionPlanId,
+    verifierTaskId: context.verifierTaskId,
+    verifierTaskGeneration: context.verifierTaskGeneration,
+    verifierExecutionPlanId: context.verifierExecutionPlanId,
+    treeIdentity: structuredClone(context.treeIdentity),
+    summary: boundedSummary.value,
+    evidence: evidence.values,
+    limitations: limitations.values,
+    createdAt: context.createdAt ?? Date.now(),
+    truncated: context.sourceTruncated === true || boundedSummary.truncated || evidence.truncated || limitations.truncated
+  };
+}
+function workflowVerificationInstruction(targetTaskId, treeIdentity, requirements = {}) {
+  if (!ID_PATTERN.test(targetTaskId) || !isWorkflowTreeIdentity(treeIdentity)) {
+    throw new Error("Workflow verification instruction received invalid executor metadata");
+  }
+  const acceptanceCriteria = boundList(
+    requirements.acceptanceCriteria ?? [],
+    MAX_INSTRUCTION_LIST_BYTES
+  ).values;
+  const requiredEvidence = boundList(
+    requirements.requiredEvidence ?? [],
+    MAX_INSTRUCTION_LIST_BYTES
+  ).values;
+  return [
+    "You are the independent verifier for one staged workflow result.",
+    `Target task: ${JSON.stringify(targetTaskId)}.`,
+    `Acceptance criteria: ${JSON.stringify(acceptanceCriteria)}.`,
+    `Required evidence: ${JSON.stringify(requiredEvidence)}.`,
+    `Exact Git-visible tree identity: ${treeIdentity.version}:${treeIdentity.kind}:${treeIdentity.digest}.`,
+    "Do not modify the repository; the executor will reject acceptance if the tree identity changes.",
+    "Return the requested pi-subagents:result:v2 object with exactly one verdict encoding.",
+    'Accept only with status "completed", reasonCode "verification-accepted", at least one passed verification item, no failed verification item, and no unresolved dependency.',
+    'Request rework only with status "partial" or "needs-input", reasonCode "verification-rework", and a concrete limitation or unresolved dependency.',
+    'Reject only with status "failed" or "abstained", reasonCode "verification-rejected", and concrete evidence.',
+    "Agreement, confidence, and the implementation worker's own verification claims are not proof."
+  ].join("\n");
+}
+function isWorkflowVerificationReceipt(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const receipt = value;
+  if (Object.keys(value).some(
+    (key) => ![
+      "version",
+      "decision",
+      "targetTaskId",
+      "targetTaskGeneration",
+      "targetExecutionPlanId",
+      "verifierTaskId",
+      "verifierTaskGeneration",
+      "verifierExecutionPlanId",
+      "treeIdentity",
+      "summary",
+      "evidence",
+      "limitations",
+      "createdAt",
+      "truncated"
+    ].includes(key)
+  )) {
+    return false;
+  }
+  return receipt.version === WORKFLOW_VERIFICATION_VERSION && (receipt.decision !== "rework" || Array.isArray(receipt.limitations) && receipt.limitations.length > 0) && (receipt.decision !== "reject" || Array.isArray(receipt.evidence) && receipt.evidence.length > 0) && ["accept", "rework", "reject"].includes(String(receipt.decision)) && typeof receipt.targetTaskId === "string" && ID_PATTERN.test(receipt.targetTaskId) && Number.isSafeInteger(receipt.targetTaskGeneration) && Number(receipt.targetTaskGeneration) >= 1 && typeof receipt.targetExecutionPlanId === "string" && PLAN_PATTERN.test(receipt.targetExecutionPlanId) && typeof receipt.verifierTaskId === "string" && ID_PATTERN.test(receipt.verifierTaskId) && Number.isSafeInteger(receipt.verifierTaskGeneration) && Number(receipt.verifierTaskGeneration) >= 1 && typeof receipt.verifierExecutionPlanId === "string" && PLAN_PATTERN.test(receipt.verifierExecutionPlanId) && isWorkflowTreeIdentity(receipt.treeIdentity) && typeof receipt.summary === "string" && receipt.summary.length > 0 && Buffer.byteLength(receipt.summary, "utf8") <= MAX_FIELD_BYTES && validStrings(receipt.evidence, MAX_EVIDENCE_BYTES) && validStrings(receipt.limitations, MAX_LIMITATION_BYTES) && typeof receipt.createdAt === "number" && Number.isFinite(receipt.createdAt) && receipt.createdAt >= 0 && typeof receipt.truncated === "boolean";
+}
+function verdict(result) {
+  if (result.version !== "pi-subagents:result:v2") {
+    throw new Error("Workflow verification requires structured-v2");
+  }
+  if (result.reasonCode === "verification-accepted" && result.status === "completed") {
+    if (result.verification.some((item) => item.status === "failed")) {
+      throw new Error("Workflow verification accept cannot contain failed evidence");
+    }
+    if (!result.verification.some((item) => item.status === "passed")) {
+      throw new Error("Workflow verification accept requires passed evidence");
+    }
+    if (result.unresolvedDependencies.length > 0) {
+      throw new Error("Workflow verification accept cannot contain unresolved dependencies");
+    }
+    return "accept";
+  }
+  if (result.reasonCode === "verification-rework" && (result.status === "partial" || result.status === "needs-input")) {
+    return "rework";
+  }
+  if (result.reasonCode === "verification-rejected" && (result.status === "failed" || result.status === "abstained")) {
+    return "reject";
+  }
+  throw new Error("Workflow verification result does not contain a valid verdict");
+}
+function validateContext(context) {
+  for (const [label, value] of [
+    ["target task", context.targetTaskId],
+    ["verifier task", context.verifierTaskId]
+  ]) {
+    if (!ID_PATTERN.test(value))
+      throw new Error(`Workflow verification has an invalid ${label} id`);
+  }
+  for (const [label, value] of [
+    ["target", context.targetTaskGeneration],
+    ["verifier", context.verifierTaskGeneration]
+  ]) {
+    if (!Number.isSafeInteger(value) || value < 1) {
+      throw new Error(`Workflow verification has an invalid ${label} task generation`);
+    }
+  }
+  for (const value of [context.targetExecutionPlanId, context.verifierExecutionPlanId]) {
+    if (!PLAN_PATTERN.test(value)) {
+      throw new Error("Workflow verification has an invalid execution plan identity");
+    }
+  }
+  if (!isWorkflowTreeIdentity(context.treeIdentity)) {
+    throw new Error("Workflow verification has an invalid tree identity");
+  }
+  if (context.sourceTruncated !== void 0 && typeof context.sourceTruncated !== "boolean") {
+    throw new Error("Workflow verification has an invalid truncation state");
+  }
+  if (context.createdAt !== void 0 && (!Number.isFinite(context.createdAt) || context.createdAt < 0)) {
+    throw new Error("Workflow verification has an invalid creation time");
+  }
+}
+function bound(value) {
+  const redacted = redactPrivateText(value).trim();
+  const truncated = truncateUtf8(redacted, MAX_FIELD_BYTES);
+  return { value: truncated.text, truncated: truncated.truncated };
+}
+function boundList(values, maxTotalBytes) {
+  let truncated = values.length > MAX_ITEMS;
+  let remaining = maxTotalBytes;
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of values.slice(0, MAX_ITEMS)) {
+    if (remaining < 1) {
+      truncated = true;
+      break;
+    }
+    const redacted = redactPrivateText(raw).trim();
+    const item = truncateUtf8(redacted, Math.min(MAX_FIELD_BYTES, remaining));
+    truncated ||= item.truncated;
+    if (!item.text || seen.has(item.text)) continue;
+    seen.add(item.text);
+    result.push(item.text);
+    remaining -= Buffer.byteLength(item.text, "utf8");
+  }
+  return { values: result, truncated };
+}
+function validStrings(value, maxTotalBytes) {
+  return Array.isArray(value) && value.length <= MAX_ITEMS && value.reduce(
+    (total, item) => total + (typeof item === "string" ? Buffer.byteLength(item, "utf8") : maxTotalBytes + 1),
+    0
+  ) <= maxTotalBytes && value.every(
+    (item) => typeof item === "string" && item.length > 0 && Buffer.byteLength(item, "utf8") <= MAX_FIELD_BYTES
+  );
+}
+
+// src/work-item-persistence.ts
+import { createHash as createHash2 } from "node:crypto";
+import * as fs2 from "node:fs";
+import * as path3 from "node:path";
+import { getAgentDir, withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+
+// src/integration-controller.ts
+import * as path2 from "node:path";
+function verifyManagedIntegration(expected, candidate) {
+  if (candidate.taskId !== expected.taskId || candidate.taskGeneration !== expected.taskGeneration) {
+    throw new Error("Managed integration rejected stale task generation");
+  }
+  if (candidate.baseRepositoryGeneration !== expected.baseRepositoryGeneration) {
+    throw new Error("Managed integration rejected stale base repository generation");
+  }
+  if (candidate.executionPlanId !== expected.executionPlanId) {
+    throw new Error("Managed integration rejected stale execution plan identity");
+  }
+  if (!sameRecord(candidate.dependencyVersions, expected.dependencyVersions)) {
+    throw new Error("Managed integration rejected stale dependency versions");
+  }
+  if (!sameRecord(candidate.readSetVersions, expected.readSetVersions)) {
+    throw new Error("Managed integration rejected stale read-set versions");
+  }
+  if (candidate.patchDigest !== expected.patchDigest) {
+    throw new Error("Managed integration rejected patch digest mismatch");
+  }
+  const allowedScopes = expected.allowedScopes.map(normalizedPath);
+  if (!candidate.changedPaths.every((changedPath) => {
+    const normalizedChangedPath = normalizedPath(changedPath);
+    return allowedScopes.some(
+      (scope) => normalizedChangedPath === scope || normalizedChangedPath.startsWith(`${scope}${path2.sep}`)
+    );
+  })) {
+    throw new Error("Managed integration rejected a path outside the accepted scope");
+  }
+  if (expected.requiredEvidence.some((id) => !candidate.evidence[id])) {
+    throw new Error("Managed integration rejected missing required evidence");
+  }
+  if (!candidate.verifier.freshContext || !candidate.verifier.exactIntegratedTree) {
+    throw new Error("Managed integration requires a fresh verifier on the exact integrated tree");
+  }
+  if (candidate.verifier.status !== "accepted") {
+    throw new Error(`Managed integration verifier returned ${candidate.verifier.status}`);
+  }
+  return {
+    status: "accepted",
+    taskId: expected.taskId,
+    taskGeneration: expected.taskGeneration,
+    patchDigest: expected.patchDigest,
+    executionPlanId: expected.executionPlanId
+  };
+}
+function normalizedPath(value) {
+  if (!value || value.includes("\0")) throw new Error("Managed integration scope is invalid");
+  return path2.resolve(path2.sep, value.replaceAll("\\", path2.sep));
+}
+function sameRecord(left, right) {
+  const leftEntries = Object.entries(left).sort(([a], [b]) => a.localeCompare(b));
+  const rightEntries = Object.entries(right).sort(([a], [b]) => a.localeCompare(b));
+  return JSON.stringify(leftEntries) === JSON.stringify(rightEntries);
+}
+
+// src/verification-receipt.ts
+import { Type } from "typebox";
+import { Check } from "typebox/value";
+var VERIFICATION_RECEIPT_VERSION = "pi-subagents:verification-receipt:v1";
+var MAX_FIELD_BYTES2 = 4 * 1024;
+var MAX_OUTPUT_BYTES = 2 * 1024;
+var MAX_RECEIPT_BYTES = 12 * 1024;
+var MAX_LIST_ITEMS = 64;
+var MAX_RECORD_ITEMS = 64;
+var ID_PATTERN2 = "^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$";
+var SHA_PATTERN = "^[a-f0-9]{64}$";
+var REPOSITORY_GENERATION_PATTERN = "^[a-f0-9]{40,64}$";
+var BoundedId = Type.String({ pattern: ID_PATTERN2, maxLength: 256 });
+var Sha256 = Type.String({ pattern: SHA_PATTERN, maxLength: 64 });
+var BoundedText = Type.String({ minLength: 1, maxLength: MAX_FIELD_BYTES2 });
+var TreeIdentitySchema = Type.Object(
+  {
+    version: Type.Literal(WORKFLOW_TREE_IDENTITY_VERSION),
+    kind: Type.Union([Type.Literal("git-commit"), Type.Literal("git-dirty")]),
+    digest: Sha256
+  },
+  { additionalProperties: false }
+);
+var StringRecordSchema = Type.Record(
+  Type.String({ minLength: 1, maxLength: 4096 }),
+  Type.String({ minLength: 1, maxLength: MAX_FIELD_BYTES2 }),
+  { maxProperties: MAX_RECORD_ITEMS }
+);
+var VerificationCheckReceiptSchema = Type.Object(
+  {
+    id: BoundedId,
+    command: Type.String({ minLength: 1, maxLength: 256 }),
+    args: Type.Array(Type.String({ maxLength: 4096 }), { maxItems: 64 }),
+    cwd: Type.String({ minLength: 1, maxLength: 4096 }),
+    status: Type.Union([Type.Literal("passed"), Type.Literal("failed")]),
+    exitCode: Type.Integer({ minimum: -1, maximum: 255 }),
+    stdout: Type.String({ maxLength: MAX_OUTPUT_BYTES }),
+    stderr: Type.String({ maxLength: MAX_OUTPUT_BYTES }),
+    durationMs: Type.Integer({ minimum: 0 }),
+    truncated: Type.Boolean()
+  },
+  { additionalProperties: false }
+);
+var VerificationReceiptSchema = Type.Object(
+  {
+    version: Type.Literal(VERIFICATION_RECEIPT_VERSION),
+    decision: Type.Union([Type.Literal("accept"), Type.Literal("rework"), Type.Literal("reject")]),
+    targetTaskId: BoundedId,
+    targetTaskGeneration: Type.Integer({ minimum: 1 }),
+    targetExecutionPlanId: Sha256,
+    verifierTaskId: BoundedId,
+    verifierTaskGeneration: Type.Integer({ minimum: 1 }),
+    verifierExecutionPlanId: Sha256,
+    verifierAgent: BoundedId,
+    beforeTreeIdentity: TreeIdentitySchema,
+    afterTreeIdentity: TreeIdentitySchema,
+    baseRepositoryGeneration: Type.String({
+      pattern: REPOSITORY_GENERATION_PATTERN,
+      maxLength: 64
+    }),
+    patchDigest: Sha256,
+    changedPaths: Type.Array(Type.String({ minLength: 1, maxLength: 4096 }), {
+      maxItems: MAX_LIST_ITEMS
+    }),
+    allowedScopes: Type.Array(Type.String({ minLength: 1, maxLength: 4096 }), {
+      minItems: 1,
+      maxItems: MAX_LIST_ITEMS
+    }),
+    dependencyVersions: StringRecordSchema,
+    readSetVersions: StringRecordSchema,
+    acceptanceCriteria: Type.Array(BoundedText, { maxItems: MAX_LIST_ITEMS }),
+    requiredEvidenceIds: Type.Array(BoundedId, { maxItems: MAX_LIST_ITEMS }),
+    evidence: StringRecordSchema,
+    checks: Type.Array(VerificationCheckReceiptSchema, { maxItems: 32 }),
+    summary: BoundedText,
+    findings: Type.Array(BoundedText, { maxItems: MAX_LIST_ITEMS }),
+    createdAt: Type.Number({ minimum: 0 }),
+    sourceTruncated: Type.Boolean()
+  },
+  { additionalProperties: false }
+);
+function createVerificationReceipt(input) {
+  const receipt = {
+    version: VERIFICATION_RECEIPT_VERSION,
+    decision: input.decision,
+    targetTaskId: input.targetTaskId,
+    targetTaskGeneration: input.targetTaskGeneration,
+    targetExecutionPlanId: input.targetExecutionPlanId,
+    verifierTaskId: input.verifierTaskId,
+    verifierTaskGeneration: input.verifierTaskGeneration,
+    verifierExecutionPlanId: input.verifierExecutionPlanId,
+    verifierAgent: input.verifierAgent,
+    beforeTreeIdentity: structuredClone(input.beforeTreeIdentity),
+    afterTreeIdentity: structuredClone(input.afterTreeIdentity),
+    baseRepositoryGeneration: input.baseRepositoryGeneration,
+    patchDigest: input.patchDigest,
+    changedPaths: boundList2(input.changedPaths, MAX_FIELD_BYTES2),
+    allowedScopes: boundList2(input.allowedScopes, MAX_FIELD_BYTES2),
+    dependencyVersions: boundRecord(input.dependencyVersions),
+    readSetVersions: boundRecord(input.readSetVersions),
+    acceptanceCriteria: boundList2(input.acceptanceCriteria, MAX_FIELD_BYTES2),
+    requiredEvidenceIds: boundList2(input.requiredEvidenceIds, 256),
+    evidence: boundRecord(input.evidence),
+    checks: input.checks.slice(0, 32).map(boundCheck),
+    summary: boundRequired(input.summary, MAX_FIELD_BYTES2, "summary"),
+    findings: boundList2(input.findings, MAX_FIELD_BYTES2),
+    createdAt: input.createdAt,
+    sourceTruncated: input.sourceTruncated || input.checks.length > 32 || input.checks.some(
+      (check) => check.truncated || check.args.length > 64 || check.args.some((value) => Buffer.byteLength(value, "utf8") > 4096) || Buffer.byteLength(check.stdout, "utf8") > MAX_OUTPUT_BYTES || Buffer.byteLength(check.stderr, "utf8") > MAX_OUTPUT_BYTES
+    ) || input.requiredEvidenceIds.some((value) => Buffer.byteLength(value, "utf8") > 256) || [
+      input.changedPaths,
+      input.allowedScopes,
+      input.acceptanceCriteria,
+      input.requiredEvidenceIds,
+      input.findings
+    ].some(
+      (values) => values.length > MAX_LIST_ITEMS || values.some((value) => Buffer.byteLength(value, "utf8") > MAX_FIELD_BYTES2)
+    ) || [input.dependencyVersions, input.readSetVersions, input.evidence].some(
+      (value) => Object.keys(value).length > MAX_RECORD_ITEMS || Object.entries(value).some(
+        ([key, item]) => Buffer.byteLength(key, "utf8") > 4096 || Buffer.byteLength(item, "utf8") > MAX_FIELD_BYTES2
+      )
+    )
+  };
+  assertReceiptSemantics(receipt);
+  if (!Check(VerificationReceiptSchema, receipt)) {
+    throw new Error("Verification receipt contains invalid executor metadata");
+  }
+  if (Buffer.byteLength(JSON.stringify(receipt), "utf8") > MAX_RECEIPT_BYTES) {
+    throw new Error("Verification receipt exceeded its total size limit");
+  }
+  return receipt;
+}
+function isVerificationReceipt(value) {
+  if (!Check(VerificationReceiptSchema, value) || Buffer.byteLength(JSON.stringify(value), "utf8") > MAX_RECEIPT_BYTES) {
+    return false;
+  }
+  try {
+    assertReceiptSemantics(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function assertReceiptSemantics(receipt) {
+  if (receipt.beforeTreeIdentity.kind !== receipt.afterTreeIdentity.kind || receipt.beforeTreeIdentity.digest !== receipt.afterTreeIdentity.digest) {
+    throw new Error("Verification receipt rejected submitted-state drift");
+  }
+  const missingEvidence = receipt.requiredEvidenceIds.filter((id) => !receipt.evidence[id]);
+  if (receipt.decision === "accept" && missingEvidence.length > 0) {
+    throw new Error(
+      `Verification receipt is missing required evidence: ${missingEvidence.join(", ")}`
+    );
+  }
+  if (receipt.decision === "accept" && receipt.checks.some((check) => check.status !== "passed")) {
+    throw new Error("Verification receipt cannot accept a failed check");
+  }
+  if (receipt.decision === "rework" && receipt.findings.length === 0) {
+    throw new Error("Verification receipt rework requires a concrete finding");
+  }
+  if (receipt.decision === "reject" && receipt.findings.length === 0) {
+    throw new Error("Verification receipt reject requires a concrete finding");
+  }
+  for (const values of [
+    receipt.changedPaths,
+    receipt.allowedScopes,
+    receipt.acceptanceCriteria,
+    receipt.requiredEvidenceIds,
+    receipt.findings
+  ]) {
+    if (new Set(values).size !== values.length) {
+      throw new Error("Verification receipt contains duplicate bounded values");
+    }
+  }
+  if (new Set(receipt.checks.map((check) => check.id)).size !== receipt.checks.length) {
+    throw new Error("Verification receipt contains duplicate check ids");
+  }
+}
+function boundCheck(check) {
+  const stdout = boundOptional(check.stdout, MAX_OUTPUT_BYTES);
+  const stderr = boundOptional(check.stderr, MAX_OUTPUT_BYTES);
+  return {
+    id: boundRequired(check.id, 256, "check id"),
+    command: boundRequired(check.command, 256, "check command"),
+    args: check.args.slice(0, 64).map((value) => boundOptional(value, 4096).value),
+    cwd: boundRequired(check.cwd, 4096, "check cwd"),
+    status: check.status,
+    exitCode: check.exitCode,
+    stdout: stdout.value,
+    stderr: stderr.value,
+    durationMs: Math.max(0, Math.floor(check.durationMs)),
+    truncated: check.truncated || stdout.truncated || stderr.truncated || check.args.length > 64
+  };
+}
+function boundList2(values, maxItemBytes) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values.slice(0, MAX_LIST_ITEMS)) {
+    const bounded2 = boundOptional(value, maxItemBytes).value;
+    if (!bounded2 || seen.has(bounded2)) continue;
+    seen.add(bounded2);
+    result.push(bounded2);
+  }
+  return result;
+}
+function boundRecord(value) {
+  const entries = Object.entries(value).slice(0, MAX_RECORD_ITEMS);
+  return Object.fromEntries(
+    entries.map(([key, item]) => [
+      boundRequired(key, 4096, "record key"),
+      boundRequired(item, MAX_FIELD_BYTES2, "record value")
+    ])
+  );
+}
+function boundRequired(value, maxBytes, label) {
+  const bounded2 = boundOptional(value, maxBytes).value;
+  if (!bounded2) throw new Error(`Verification receipt requires ${label}`);
+  return bounded2;
+}
+function boundOptional(value, maxBytes) {
+  const redacted = redactPrivateText(value).trim();
+  const bounded2 = truncateUtf8(redacted, maxBytes);
+  return { value: bounded2.text, truncated: bounded2.truncated };
+}
+
+// src/work-item-ledger.ts
+var WORK_ITEM_LEDGER_VERSION = "pi-subagents:work-ledger:v3";
+var LEGACY_WORK_ITEM_LEDGER_VERSIONS = /* @__PURE__ */ new Set([
+  "pi-subagents:work-ledger:v1",
+  "pi-subagents:work-ledger:v2"
+]);
+var WORK_ITEM_ACCEPTANCE_VERSION = "pi-subagents:work-acceptance:v1";
+var MAX_ITEMS2 = 64;
+var MAX_IDENTIFIER_LENGTH = 256;
+var MAX_TEXT_LENGTH = 16 * 1024;
+var MAX_LIST_ITEMS2 = 50;
+var TERMINAL_STATES = /* @__PURE__ */ new Set([
+  "completed",
+  "failed",
+  "interrupted",
+  "stale",
+  "invalidated"
+]);
+var WorkItemLedger = class _WorkItemLedger {
+  constructor(workflowId) {
+    this.workflowId = workflowId;
+  }
+  workflowId;
+  items = /* @__PURE__ */ new Map();
+  generation = 0;
+  static create(input) {
+    validateIdentifier(input.workflowId, "workflowId");
+    if (!Array.isArray(input.items) || input.items.length < 1 || input.items.length > MAX_ITEMS2) {
+      throw new Error(`WorkItem workflow must contain 1-${MAX_ITEMS2} items`);
+    }
+    const ledger = new _WorkItemLedger(input.workflowId);
+    for (const definition of input.items) ledger.addDefinition(definition);
+    ledger.linkAndValidate();
+    ledger.refreshReadyState();
+    return ledger;
+  }
+  get(id) {
+    const item = this.items.get(id);
+    return item ? structuredClone(item) : void 0;
+  }
+  readyItems() {
+    this.refreshReadyState();
+    return [...this.items.values()].filter((item) => item.state === "ready").sort((left, right) => left.id.localeCompare(right.id)).map((item) => structuredClone(item));
+  }
+  start(id, agentId) {
+    const item = this.require(id);
+    if (item.state !== "ready") {
+      throw new Error(`WorkItem ${id} cannot start while ${item.state}`);
+    }
+    validateIdentifier(agentId, "agentId");
+    item.state = "running";
+    item.assignedAgentId = agentId;
+    item.generation = ++this.generation;
+    return structuredClone(item);
+  }
+  complete(id, input) {
+    const item = this.require(id);
+    this.assertMutable(item);
+    if (item.acceptanceRequired) {
+      throw new Error(`WorkItem ${id} requires executor-owned acceptance staging`);
+    }
+    if (item.state !== "running") {
+      throw new Error(`WorkItem ${id} cannot complete while ${item.state}`);
+    }
+    if (input.taskGeneration !== item.taskGeneration) {
+      throw new Error(`WorkItem ${id} rejected a stale task generation`);
+    }
+    item.acceptedExecutionPlanId = input.executionPlanId?.slice(0, 256);
+    item.artifactHistory.push(...item.artifacts.map((artifact) => structuredClone(artifact)));
+    item.artifacts = normalizeArtifacts(input.artifacts ?? [], id, this.generation + 1);
+    item.verificationAccepted = false;
+    item.stagedTreeIdentity = void 0;
+    item.verificationReceipt = void 0;
+    item.acceptanceState = "not-required";
+    item.state = "completed";
+    item.generation = ++this.generation;
+    this.refreshReadyState();
+    return structuredClone(item);
+  }
+  stageForVerifiedAcceptance(id, input) {
+    const item = this.require(id);
+    this.assertMutable(item);
+    if (!item.acceptanceRequired || !item.integrationOwner) {
+      throw new Error(`WorkItem ${id} is not a verified integration target`);
+    }
+    if (item.state !== "running") {
+      throw new Error(`WorkItem ${id} cannot stage acceptance while ${item.state}`);
+    }
+    if (input.taskGeneration !== item.taskGeneration) {
+      throw new Error(`WorkItem ${id} rejected a stale task generation`);
+    }
+    validatePlanId(input.executionPlanId, "staged execution plan");
+    validateSubmission(input);
+    item.acceptedExecutionPlanId = input.executionPlanId;
+    item.artifactHistory.push(...item.artifacts.map((artifact) => structuredClone(artifact)));
+    item.artifacts = normalizeArtifacts(input.artifacts ?? [], id, this.generation + 1);
+    item.verificationAccepted = false;
+    item.acceptanceState = "pending";
+    item.stagedTreeIdentity = structuredClone(input.treeIdentity);
+    item.submission = {
+      treeIdentity: structuredClone(input.treeIdentity),
+      baseRepositoryGeneration: input.baseRepositoryGeneration,
+      patchDigest: input.patchDigest,
+      changedPaths: [...input.changedPaths],
+      fileVersions: { ...input.fileVersions }
+    };
+    item.acceptanceReceipt = void 0;
+    item.state = "completed";
+    item.generation = ++this.generation;
+    this.refreshReadyState();
+    return structuredClone(item);
+  }
+  stageForVerification(id, input) {
+    const item = this.require(id);
+    this.assertMutable(item);
+    if (item.state !== "running") {
+      throw new Error(`WorkItem ${id} cannot stage verification while ${item.state}`);
+    }
+    if (input.taskGeneration !== item.taskGeneration) {
+      throw new Error(`WorkItem ${id} rejected a stale task generation`);
+    }
+    validatePlanId(input.executionPlanId, "staged execution plan");
+    if (!isWorkflowTreeIdentity(input.treeIdentity)) {
+      throw new Error(`WorkItem ${id} received an invalid staged tree identity`);
+    }
+    item.acceptedExecutionPlanId = input.executionPlanId;
+    item.artifactHistory.push(...item.artifacts.map((artifact) => structuredClone(artifact)));
+    item.artifacts = normalizeArtifacts(input.artifacts ?? [], id, this.generation + 1);
+    item.verificationAccepted = false;
+    item.stagedTreeIdentity = structuredClone(input.treeIdentity);
+    item.verificationReceipt = void 0;
+    item.state = "awaiting-verification";
+    item.generation = ++this.generation;
+    this.refreshReadyState();
+    return structuredClone(item);
+  }
+  completeVerification(verifierId, input) {
+    const verifier = this.require(verifierId);
+    this.assertMutable(verifier);
+    if (verifier.state !== "running" || !verifier.verifierFor) {
+      throw new Error(`WorkItem ${verifierId} is not a running verifier`);
+    }
+    if (input.taskGeneration !== verifier.taskGeneration) {
+      throw new Error(`WorkItem ${verifierId} rejected a stale verifier generation`);
+    }
+    validatePlanId(input.executionPlanId, "verifier execution plan");
+    if (!isWorkflowVerificationReceipt(input.receipt)) {
+      throw new Error(`WorkItem ${verifierId} received an invalid verification receipt`);
+    }
+    const target = this.require(verifier.verifierFor);
+    if (target.state !== "awaiting-verification") {
+      throw new Error(`WorkItem ${target.id} is not awaiting verification`);
+    }
+    assertReceiptMatches(target, verifier, input.executionPlanId, input.receipt);
+    verifier.acceptedExecutionPlanId = input.executionPlanId;
+    verifier.verificationReceipt = void 0;
+    verifier.verificationAccepted = false;
+    verifier.state = "completed";
+    verifier.generation = ++this.generation;
+    target.verificationReceipt = structuredClone(input.receipt);
+    target.verificationAccepted = input.receipt.decision === "accept";
+    target.outcomeReason = input.receipt.decision === "accept" ? void 0 : input.receipt.decision === "rework" ? "verification-rework" : "verification-rejected";
+    if (input.receipt.decision === "accept") {
+      target.artifacts = target.artifacts.map((artifact) => ({ ...artifact, verified: true }));
+      target.state = "completed";
+    } else {
+      target.state = input.receipt.decision === "rework" ? "blocked" : "failed";
+      this.invalidateDependents(target.id, verifier.id, target.outcomeReason);
+    }
+    target.generation = ++this.generation;
+    this.refreshReadyState();
+    return { target: structuredClone(target), verifier: structuredClone(verifier) };
+  }
+  recordVerificationDecision(verifierId, input) {
+    const verifier = this.require(verifierId);
+    if (verifier.state !== "running" || !verifier.verifierFor) {
+      throw new Error(`WorkItem ${verifierId} is not a running verifier`);
+    }
+    if (input.taskGeneration !== verifier.taskGeneration) {
+      throw new Error(`WorkItem ${verifierId} rejected a stale verifier generation`);
+    }
+    validatePlanId(input.executionPlanId, "verifier execution plan");
+    if (!isVerificationReceipt(input.receipt) || input.receipt.decision === "accept") {
+      throw new Error(`WorkItem ${verifierId} received an invalid non-acceptance receipt`);
+    }
+    const target = this.require(verifier.verifierFor);
+    assertVerifiedReceiptMatches(target, verifier, input.executionPlanId, input.receipt);
+    verifier.acceptedExecutionPlanId = input.executionPlanId;
+    verifier.state = "completed";
+    verifier.generation = ++this.generation;
+    target.acceptanceReceipt = structuredClone(input.receipt);
+    target.acceptanceReceiptHistory.push(structuredClone(input.receipt));
+    target.verificationAccepted = false;
+    if (input.receipt.decision === "rework" && target.reworkCount < target.maxReworkCycles) {
+      target.reworkCount++;
+      target.acceptanceState = "rework-requested";
+      target.state = "blocked";
+      target.outcomeReason = "verification-rework";
+    } else {
+      target.acceptanceState = "rejected";
+      target.state = "failed";
+      target.outcomeReason = input.receipt.decision === "rework" ? "verification-rework-exhausted" : "verification-rejected";
+    }
+    target.generation = ++this.generation;
+    this.invalidateDependents(target.id, verifier.id, target.outcomeReason);
+    this.refreshReadyState();
+    return { target: structuredClone(target), verifier: structuredClone(verifier) };
+  }
+  beginVerificationRework(id) {
+    const target = this.require(id);
+    if (target.acceptanceState !== "rework-requested" || target.state !== "blocked") {
+      throw new Error(`WorkItem ${id} has no accepted rework request`);
+    }
+    const verifier = [...this.items.values()].find((item) => item.verifierFor === id);
+    if (verifier?.state !== "completed") {
+      throw new Error(`WorkItem ${id} has no completed verifier for rework`);
+    }
+    target.artifactHistory.push(...target.artifacts.map((artifact) => structuredClone(artifact)));
+    target.artifacts = [];
+    target.state = "pending";
+    target.acceptanceState = "pending";
+    target.taskGeneration++;
+    target.assignedAgentId = void 0;
+    target.acceptedExecutionPlanId = void 0;
+    target.stagedTreeIdentity = void 0;
+    target.submission = void 0;
+    target.verificationAccepted = false;
+    target.outcomeReason = void 0;
+    target.generation = ++this.generation;
+    verifier.state = "pending";
+    verifier.taskGeneration++;
+    verifier.assignedAgentId = void 0;
+    verifier.acceptedExecutionPlanId = void 0;
+    verifier.outcomeReason = void 0;
+    verifier.generation = ++this.generation;
+    this.resetReworkDependents(target.id, verifier.id);
+    this.refreshReadyState();
+    return structuredClone(target);
+  }
+  failVerification(verifierId, reason) {
+    const verifier = this.require(verifierId);
+    if (!verifier.verifierFor) throw new Error(`WorkItem ${verifierId} is not a verifier`);
+    const target = this.require(verifier.verifierFor);
+    const boundedReason = bounded(reason, MAX_TEXT_LENGTH);
+    if (!boundedReason) throw new Error("Verification failure requires a reason");
+    if (!TERMINAL_STATES.has(verifier.state)) {
+      verifier.state = "failed";
+      verifier.outcomeReason = boundedReason;
+      verifier.generation = ++this.generation;
+    }
+    if (target.state === "awaiting-verification" || target.state === "completed" && target.acceptanceState === "pending") {
+      target.state = "failed";
+      if (target.acceptanceRequired) target.acceptanceState = "rejected";
+      target.verificationAccepted = false;
+      target.outcomeReason = boundedReason;
+      target.generation = ++this.generation;
+    }
+    const invalidated = this.invalidateDependents(target.id, verifier.id, boundedReason);
+    return [structuredClone(target), structuredClone(verifier), ...invalidated];
+  }
+  settle(id, state, reason) {
+    const item = this.require(id);
+    this.assertMutable(item);
+    if (item.state !== "running" && item.state !== "awaiting-verification" && !(item.state === "completed" && item.acceptanceState === "pending") && item.state !== "ready" && item.state !== "pending") {
+      throw new Error(`WorkItem ${id} cannot settle while ${item.state}`);
+    }
+    item.state = state;
+    if (item.acceptanceRequired) item.acceptanceState = "rejected";
+    item.outcomeReason = reason ? bounded(reason, MAX_TEXT_LENGTH) : void 0;
+    item.generation = ++this.generation;
+    this.refreshReadyState();
+    return structuredClone(item);
+  }
+  acceptIntegration(id, expected, candidate, verified) {
+    const item = this.require(id);
+    if (!item.integrationOwner) {
+      throw new Error(`WorkItem ${id} is not the integration owner`);
+    }
+    if (expected.taskId !== id || expected.taskGeneration !== item.taskGeneration) {
+      throw new Error(`WorkItem ${id} integration expectation has a stale generation`);
+    }
+    if (!verified) {
+      if (item.state !== "running" || item.acceptanceRequired) {
+        throw new Error(`WorkItem ${id} cannot integrate while ${item.state}`);
+      }
+      verifyManagedIntegration(expected, candidate);
+      item.verificationAccepted = true;
+      item.generation = ++this.generation;
+      return structuredClone(item);
+    }
+    if (item.state !== "completed" || item.acceptanceState !== "pending") {
+      throw new Error(`WorkItem ${id} is not pending verified acceptance`);
+    }
+    const verifier = this.require(verified.verifierId);
+    if (verifier.state !== "running" || verifier.verifierFor !== id || verified.verifierTaskGeneration !== verifier.taskGeneration) {
+      throw new Error(`WorkItem ${verified.verifierId} is not the current verifier`);
+    }
+    if (!isVerificationReceipt(verified.receipt) || verified.receipt.decision !== "accept") {
+      throw new Error("Managed integration requires an accepting verification receipt");
+    }
+    assertVerifiedReceiptMatches(
+      item,
+      verifier,
+      verified.verifierExecutionPlanId,
+      verified.receipt
+    );
+    verifyManagedIntegration(expected, candidate);
+    item.verificationAccepted = true;
+    item.acceptanceState = "accepted";
+    item.acceptanceReceipt = structuredClone(verified.receipt);
+    item.acceptanceReceiptHistory.push(structuredClone(verified.receipt));
+    item.artifacts = item.artifacts.map((artifact) => ({ ...artifact, verified: true }));
+    item.outcomeReason = void 0;
+    item.generation = ++this.generation;
+    verifier.acceptedExecutionPlanId = verified.verifierExecutionPlanId;
+    verifier.state = "completed";
+    verifier.generation = ++this.generation;
+    this.refreshReadyState();
+    return structuredClone(item);
+  }
+  rerun(id) {
+    const item = this.require(id);
+    if (item.acceptanceState === "accepted") {
+      throw new Error(`WorkItem ${id} has terminal accepted evidence`);
+    }
+    if (!["blocked", "needs-input", "failed", "interrupted", "stale", "invalidated"].includes(
+      item.state
+    )) {
+      throw new Error(`WorkItem ${id} cannot rerun while ${item.state}`);
+    }
+    item.state = "pending";
+    item.taskGeneration++;
+    item.assignedAgentId = void 0;
+    item.acceptedExecutionPlanId = void 0;
+    item.outcomeReason = void 0;
+    item.verificationAccepted = false;
+    item.acceptanceState = item.acceptanceRequired ? "pending" : "not-required";
+    item.stagedTreeIdentity = void 0;
+    item.submission = void 0;
+    item.verificationReceipt = void 0;
+    item.acceptanceReceipt = void 0;
+    item.generation = ++this.generation;
+    this.refreshReadyState();
+    return structuredClone(item);
+  }
+  invalidate(id, reason) {
+    const root = this.require(id);
+    const normalizedReason = bounded(reason, MAX_TEXT_LENGTH);
+    if (!normalizedReason) throw new Error("WorkItem invalidation requires a reason");
+    const ordered = [];
+    const queue = [root.id];
+    const seen = /* @__PURE__ */ new Set();
+    while (queue.length > 0) {
+      const currentId = queue.shift();
+      if (!currentId || seen.has(currentId)) continue;
+      seen.add(currentId);
+      const item = this.require(currentId);
+      if (item.acceptanceState === "accepted") {
+        throw new Error(`WorkItem ${item.id} has terminal accepted evidence`);
+      }
+      ordered.push(item);
+      queue.push(...item.dependents);
+    }
+    return ordered.map((item) => {
+      item.state = item.id === root.id ? "stale" : "invalidated";
+      if (item.acceptanceRequired) item.acceptanceState = "rejected";
+      item.taskGeneration++;
+      item.invalidationReasons.push(`${root.id}:${normalizedReason}`);
+      item.generation = ++this.generation;
+      return structuredClone(item);
+    });
+  }
+  snapshot() {
+    return {
+      version: WORK_ITEM_LEDGER_VERSION,
+      workflowId: this.workflowId,
+      generation: this.generation,
+      items: [...this.items.values()].sort((left, right) => left.id.localeCompare(right.id)).map((item) => structuredClone(item))
+    };
+  }
+  static restore(snapshot) {
+    const storedVersion = snapshot?.version;
+    if (!snapshot || storedVersion !== WORK_ITEM_LEDGER_VERSION && !LEGACY_WORK_ITEM_LEDGER_VERSIONS.has(String(storedVersion)) || !Number.isSafeInteger(snapshot.generation) || snapshot.generation < 0) {
+      throw new Error("Unsupported or malformed WorkItem ledger snapshot");
+    }
+    const isLegacySnapshot = storedVersion !== WORK_ITEM_LEDGER_VERSION;
+    const isV1Snapshot = storedVersion === "pi-subagents:work-ledger:v1";
+    if (!Array.isArray(snapshot.items) || snapshot.items.length < 1 || snapshot.items.length > MAX_ITEMS2) {
+      throw new Error("Malformed WorkItem ledger items");
+    }
+    const storedItems = snapshot.items.map(
+      (item) => isLegacySnapshot ? normalizeLegacyAcceptance(item, isV1Snapshot) : item
+    );
+    for (const item of storedItems) validateStoredRecord(item, snapshot.generation);
+    const ledger = _WorkItemLedger.create({
+      workflowId: snapshot.workflowId,
+      items: storedItems.map((item) => ({
+        id: item.id,
+        objective: item.objective,
+        dependencies: item.dependencies,
+        inputArtifacts: item.inputArtifacts,
+        inputArtifactVersions: item.requiredArtifactVersions,
+        requiredCapabilities: item.requiredCapabilities,
+        requiredTools: item.requiredTools,
+        selectedAgentName: item.selectedAgentName,
+        sideEffectPolicy: item.sideEffectPolicy,
+        readPaths: item.readPaths,
+        writePaths: item.writePaths,
+        ownershipKeys: item.ownershipKeys,
+        acceptanceCriteria: item.acceptanceCriteria,
+        requiredEvidence: item.requiredEvidence,
+        integrationOwner: item.integrationOwner,
+        verifierFor: item.verifierFor,
+        dependencyPolicy: item.dependencyPolicy,
+        acceptanceRequired: item.acceptanceRequired,
+        maxReworkCycles: item.maxReworkCycles
+      }))
+    });
+    ledger.generation = snapshot.generation;
+    for (const stored of storedItems) {
+      const item = ledger.require(stored.id);
+      const interruptedAcceptance = stored.acceptanceRequired && stored.state === "completed" && stored.acceptanceState === "pending";
+      item.state = stored.state === "running" || stored.state === "awaiting-verification" || interruptedAcceptance ? "interrupted" : stored.state;
+      item.generation = stored.generation;
+      item.taskGeneration = stored.taskGeneration ?? 1;
+      item.assignedAgentId = stored.assignedAgentId;
+      item.acceptedExecutionPlanId = stored.acceptedExecutionPlanId;
+      item.inputArtifactVersions = { ...stored.inputArtifactVersions };
+      item.artifacts = normalizeStoredArtifacts(
+        stored.artifacts,
+        stored.id,
+        stored.generation,
+        !isV1Snapshot
+      );
+      item.artifactHistory = normalizeStoredArtifacts(
+        stored.artifactHistory ?? [],
+        stored.id,
+        stored.generation,
+        !isV1Snapshot
+      );
+      item.acceptanceStateVersion = WORK_ITEM_ACCEPTANCE_VERSION;
+      item.acceptanceRequired = stored.acceptanceRequired;
+      item.acceptanceState = interruptedAcceptance ? "rejected" : stored.acceptanceState;
+      item.reworkCount = stored.reworkCount;
+      item.maxReworkCycles = stored.maxReworkCycles;
+      item.verificationAccepted = isV1Snapshot ? false : stored.verificationAccepted;
+      item.stagedTreeIdentity = stored.stagedTreeIdentity ? structuredClone(stored.stagedTreeIdentity) : void 0;
+      item.verificationReceipt = !isV1Snapshot && stored.verificationReceipt ? structuredClone(stored.verificationReceipt) : void 0;
+      item.acceptanceReceipt = stored.acceptanceReceipt ? structuredClone(stored.acceptanceReceipt) : void 0;
+      item.acceptanceReceiptHistory = stored.acceptanceReceiptHistory.map(
+        (receipt) => structuredClone(receipt)
+      );
+      item.submission = stored.submission ? structuredClone(stored.submission) : void 0;
+      item.invalidationReasons = [...stored.invalidationReasons];
+      item.outcomeReason = interruptedAcceptance ? "verification-interrupted" : stored.outcomeReason;
+    }
+    ledger.validateRestoredVerificationLinks();
+    return ledger;
+  }
+  validateRestoredVerificationLinks() {
+    for (const target of this.items.values()) {
+      const receipt = target.verificationReceipt;
+      if (receipt) {
+        const verifier2 = this.items.get(receipt.verifierTaskId);
+        if (!verifier2 || verifier2.verifierFor !== target.id || verifier2.state !== "completed" || verifier2.taskGeneration !== receipt.verifierTaskGeneration || verifier2.acceptedExecutionPlanId !== receipt.verifierExecutionPlanId) {
+          throw new Error(`Malformed stored WorkItem verification link for ${target.id}`);
+        }
+      }
+      const acceptanceReceipt = target.acceptanceReceipt;
+      if (!acceptanceReceipt || target.acceptanceState === "pending") continue;
+      const verifier = this.items.get(acceptanceReceipt.verifierTaskId);
+      if (!verifier || verifier.verifierFor !== target.id || verifier.state !== "completed" || verifier.taskGeneration !== acceptanceReceipt.verifierTaskGeneration || verifier.acceptedExecutionPlanId !== acceptanceReceipt.verifierExecutionPlanId || acceptanceReceipt.targetTaskId !== target.id || acceptanceReceipt.targetTaskGeneration !== target.taskGeneration || acceptanceReceipt.targetExecutionPlanId !== target.acceptedExecutionPlanId) {
+        throw new Error(`Malformed stored WorkItem acceptance link for ${target.id}`);
+      }
+    }
+  }
+  addDefinition(definition) {
+    validateIdentifier(definition.id, "WorkItem id");
+    if (this.items.has(definition.id)) throw new Error(`Duplicate WorkItem id ${definition.id}`);
+    const objective = bounded(definition.objective, MAX_TEXT_LENGTH);
+    if (!objective) throw new Error(`WorkItem ${definition.id} requires an objective`);
+    this.items.set(definition.id, {
+      id: definition.id,
+      objective,
+      dependencies: uniqueBounded(definition.dependencies, "dependency"),
+      dependents: [],
+      state: "pending",
+      generation: 0,
+      taskGeneration: 1,
+      acceptedExecutionPlanId: void 0,
+      inputArtifacts: uniqueBounded(definition.inputArtifacts ?? [], "input artifact"),
+      inputArtifactVersions: {},
+      requiredArtifactVersions: normalizeVersionMap(definition.inputArtifactVersions),
+      requiredCapabilities: uniqueBounded(
+        definition.requiredCapabilities ?? [],
+        "required capability"
+      ),
+      requiredTools: uniqueBounded(definition.requiredTools ?? [], "required tool"),
+      selectedAgentName: definition.selectedAgentName,
+      sideEffectPolicy: definition.sideEffectPolicy ?? "mutating",
+      artifacts: [],
+      artifactHistory: [],
+      readPaths: uniqueBounded(definition.readPaths ?? [], "read path"),
+      writePaths: uniqueBounded(definition.writePaths ?? [], "write path"),
+      ownershipKeys: uniqueBounded(definition.ownershipKeys ?? [], "ownership key"),
+      acceptanceCriteria: uniqueBounded(
+        definition.acceptanceCriteria ?? [],
+        "acceptance criterion"
+      ),
+      requiredEvidence: uniqueBounded(definition.requiredEvidence ?? [], "required evidence"),
+      integrationOwner: definition.integrationOwner === true,
+      verifierFor: definition.verifierFor,
+      dependencyPolicy: definition.dependencyPolicy ?? "completed",
+      acceptanceStateVersion: WORK_ITEM_ACCEPTANCE_VERSION,
+      acceptanceRequired: definition.acceptanceRequired === true,
+      acceptanceState: definition.acceptanceRequired === true ? "pending" : "not-required",
+      reworkCount: 0,
+      maxReworkCycles: definition.maxReworkCycles === 0 ? 0 : 1,
+      verificationAccepted: false,
+      stagedTreeIdentity: void 0,
+      verificationReceipt: void 0,
+      acceptanceReceipt: void 0,
+      acceptanceReceiptHistory: [],
+      submission: void 0,
+      invalidationReasons: [],
+      outcomeReason: void 0
+    });
+  }
+  linkAndValidate() {
+    const integrationOwners = [...this.items.values()].filter((item) => item.integrationOwner);
+    if (integrationOwners.length > 1)
+      throw new Error("Workflow can have only one integration owner");
+    for (const item of this.items.values()) {
+      if (item.acceptanceRequired && !item.integrationOwner) {
+        throw new Error(`WorkItem ${item.id} requires acceptance but is not integration owner`);
+      }
+      for (const dependency of item.dependencies) {
+        if (dependency === item.id) throw new Error(`WorkItem ${item.id} has a self cycle`);
+        const parent = this.items.get(dependency);
+        if (!parent) throw new Error(`WorkItem ${item.id} has missing dependency ${dependency}`);
+        parent.dependents.push(item.id);
+      }
+      if (item.verifierFor && !this.items.has(item.verifierFor)) {
+        throw new Error(`WorkItem ${item.id} verifies missing WorkItem ${item.verifierFor}`);
+      }
+      if (item.verifierFor && !item.dependencies.includes(item.verifierFor)) {
+        throw new Error(
+          `WorkItem ${item.id} must depend on the WorkItem it verifies (${item.verifierFor})`
+        );
+      }
+    }
+    const visiting = /* @__PURE__ */ new Set();
+    const visited = /* @__PURE__ */ new Set();
+    const visit = (id) => {
+      if (visiting.has(id)) throw new Error(`WorkItem dependency cycle includes ${id}`);
+      if (visited.has(id)) return;
+      visiting.add(id);
+      for (const dependency of this.require(id).dependencies) visit(dependency);
+      visiting.delete(id);
+      visited.add(id);
+    };
+    for (const id of this.items.keys()) visit(id);
+  }
+  refreshReadyState() {
+    for (const item of this.items.values()) {
+      if (item.state !== "pending") continue;
+      const dependencies = item.dependencies.map((id) => this.require(id));
+      const acceptedDependency = (dependency) => dependency.state === "completed" && (!dependency.acceptanceRequired || dependency.acceptanceState === "accepted");
+      const dependenciesReady = item.verifierFor ? dependencies.every(
+        (dependency) => dependency.id === item.verifierFor ? dependency.acceptanceRequired ? dependency.state === "completed" && dependency.acceptanceState === "pending" : dependency.state === "awaiting-verification" : acceptedDependency(dependency)
+      ) : item.dependencyPolicy === "settled" ? dependencies.every(
+        (dependency) => (!dependency.acceptanceRequired || dependency.acceptanceState === "accepted") && !["pending", "ready", "running", "awaiting-verification"].includes(
+          dependency.state
+        )
+      ) : dependencies.every(acceptedDependency);
+      if (!dependenciesReady) continue;
+      const available = /* @__PURE__ */ new Map();
+      for (const dependency of dependencies) {
+        for (const artifact of dependency.artifacts) available.set(artifact.id, artifact);
+      }
+      if (!item.inputArtifacts.every((artifact) => available.has(artifact))) continue;
+      if (!Object.entries(item.requiredArtifactVersions).every(
+        ([id, version]) => available.get(id)?.version === version
+      )) {
+        continue;
+      }
+      item.inputArtifactVersions = Object.fromEntries(
+        item.inputArtifacts.map((id) => [id, available.get(id)?.version ?? "unknown"])
+      );
+      item.state = "ready";
+      item.generation = this.generation;
+    }
+  }
+  resetReworkDependents(targetId, excludedId) {
+    const target = this.require(targetId);
+    const reworkReason = `${targetId}:verification-rework`;
+    const queue = target.dependents.filter((id) => id !== excludedId);
+    const seen = /* @__PURE__ */ new Set();
+    while (queue.length > 0) {
+      const currentId = queue.shift();
+      if (!currentId || seen.has(currentId)) continue;
+      seen.add(currentId);
+      const current = this.require(currentId);
+      queue.push(...current.dependents.filter((id) => id !== excludedId));
+      if (current.state !== "invalidated" || current.invalidationReasons.at(-1) !== reworkReason) {
+        continue;
+      }
+      current.artifactHistory.push(
+        ...current.artifacts.map((artifact) => structuredClone(artifact))
+      );
+      current.artifacts = [];
+      current.inputArtifactVersions = {};
+      current.state = "pending";
+      current.assignedAgentId = void 0;
+      current.acceptedExecutionPlanId = void 0;
+      current.outcomeReason = void 0;
+      current.verificationAccepted = false;
+      current.acceptanceState = current.acceptanceRequired ? "pending" : "not-required";
+      current.stagedTreeIdentity = void 0;
+      current.submission = void 0;
+      current.verificationReceipt = void 0;
+      current.acceptanceReceipt = void 0;
+      current.generation = ++this.generation;
+    }
+  }
+  invalidateDependents(targetId, excludedId, reason) {
+    const target = this.require(targetId);
+    const normalizedReason = bounded(reason ?? "verification-not-accepted", MAX_TEXT_LENGTH);
+    const queue = target.dependents.filter((id) => id !== excludedId);
+    const seen = /* @__PURE__ */ new Set();
+    const affected = [];
+    while (queue.length > 0) {
+      const currentId = queue.shift();
+      if (!currentId || seen.has(currentId)) continue;
+      seen.add(currentId);
+      const current = this.require(currentId);
+      current.state = "invalidated";
+      current.taskGeneration++;
+      current.invalidationReasons.push(`${targetId}:${normalizedReason}`);
+      current.generation = ++this.generation;
+      affected.push(structuredClone(current));
+      queue.push(...current.dependents.filter((id) => id !== excludedId));
+    }
+    return affected;
+  }
+  require(id) {
+    const item = this.items.get(id);
+    if (!item) throw new Error(`Unknown WorkItem ${id}`);
+    return item;
+  }
+  assertMutable(item) {
+    if (TERMINAL_STATES.has(item.state) && !(item.state === "completed" && item.acceptanceState === "pending")) {
+      throw new Error(`WorkItem ${item.id} is terminal (${item.state})`);
+    }
+  }
+};
+function assertReceiptMatches(target, verifier, verifierExecutionPlanId, receipt) {
+  if (receipt.targetTaskId !== target.id || receipt.targetTaskGeneration !== target.taskGeneration || receipt.targetExecutionPlanId !== target.acceptedExecutionPlanId || receipt.verifierTaskId !== verifier.id || receipt.verifierTaskGeneration !== verifier.taskGeneration || receipt.verifierExecutionPlanId !== verifierExecutionPlanId || !target.stagedTreeIdentity || !sameWorkflowTreeIdentity(receipt.treeIdentity, target.stagedTreeIdentity)) {
+    throw new Error("WorkItem verification receipt has stale or mismatched executor identity");
+  }
+}
+function assertVerifiedReceiptMatches(target, verifier, verifierExecutionPlanId, receipt) {
+  if (!target.acceptanceRequired || target.acceptanceState !== "pending" || target.state !== "completed" || !target.submission || receipt.targetTaskId !== target.id || receipt.targetTaskGeneration !== target.taskGeneration || receipt.targetExecutionPlanId !== target.acceptedExecutionPlanId || receipt.verifierTaskId !== verifier.id || receipt.verifierTaskGeneration !== verifier.taskGeneration || receipt.verifierExecutionPlanId !== verifierExecutionPlanId || receipt.verifierAgent !== verifier.assignedAgentId?.replace(/^agent:/u, "") || !sameWorkflowTreeIdentity(receipt.beforeTreeIdentity, target.submission.treeIdentity) || !sameWorkflowTreeIdentity(receipt.afterTreeIdentity, target.submission.treeIdentity) || receipt.baseRepositoryGeneration !== target.submission.baseRepositoryGeneration || receipt.patchDigest !== target.submission.patchDigest || JSON.stringify(receipt.changedPaths) !== JSON.stringify(target.submission.changedPaths) || JSON.stringify(receipt.allowedScopes) !== JSON.stringify(target.writePaths) || JSON.stringify(receipt.dependencyVersions) !== JSON.stringify(target.inputArtifactVersions) || JSON.stringify(receipt.readSetVersions) !== JSON.stringify(target.submission.fileVersions) || JSON.stringify(receipt.acceptanceCriteria) !== JSON.stringify(target.acceptanceCriteria) || JSON.stringify(receipt.requiredEvidenceIds) !== JSON.stringify(target.requiredEvidence)) {
+    throw new Error("WorkItem verification receipt has stale or mismatched managed identity");
+  }
+}
+function validatePlanId(value, label) {
+  if (!/^[a-f0-9]{64}$/u.test(value)) throw new Error(`Invalid ${label}`);
+}
+function validateSubmission(value) {
+  if (!isWorkflowTreeIdentity(value.treeIdentity) || !/^[a-f0-9]{40,64}$/u.test(value.baseRepositoryGeneration) || !/^[a-f0-9]{64}$/u.test(value.patchDigest) || !Array.isArray(value.changedPaths) || value.changedPaths.length > MAX_LIST_ITEMS2 || value.changedPaths.some(
+    (item) => typeof item !== "string" || !item || item.length > 4096 || item.startsWith("/") || item.startsWith("\\") || item.split(/[\\/]/u).includes("..")
+  ) || new Set(value.changedPaths).size !== value.changedPaths.length || value.changedPaths.reduce((total, item) => total + Buffer.byteLength(item, "utf8"), 0) > 8 * 1024 || JSON.stringify([...value.changedPaths].sort((left, right) => left.localeCompare(right))) !== JSON.stringify(value.changedPaths) || !value.fileVersions || typeof value.fileVersions !== "object" || Array.isArray(value.fileVersions) || Object.entries(value.fileVersions).length > MAX_LIST_ITEMS2 || JSON.stringify(
+    Object.keys(value.fileVersions).sort((left, right) => left.localeCompare(right))
+  ) !== JSON.stringify(value.changedPaths) || Object.entries(value.fileVersions).some(
+    ([key, digest]) => !key || key.length > 4096 || typeof digest !== "string" || digest !== "deleted" && !/^[a-f0-9]{64}$/u.test(digest)
+  )) {
+    throw new Error("WorkItem received malformed verification submission metadata");
+  }
+}
+function validSubmission(value) {
+  try {
+    validateSubmission(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeLegacyAcceptance(item, isV1) {
+  return {
+    ...structuredClone(item),
+    requiredEvidence: [],
+    acceptanceStateVersion: WORK_ITEM_ACCEPTANCE_VERSION,
+    acceptanceRequired: false,
+    acceptanceState: "not-required",
+    reworkCount: 0,
+    maxReworkCycles: 1,
+    verificationAccepted: isV1 ? false : item.verificationAccepted,
+    acceptanceReceipt: void 0,
+    acceptanceReceiptHistory: [],
+    submission: void 0
+  };
+}
+function validateStoredRecord(item, ledgerGeneration) {
+  const states = [
+    "pending",
+    "ready",
+    "running",
+    "awaiting-verification",
+    "blocked",
+    "needs-input",
+    "completed",
+    "failed",
+    "interrupted",
+    "stale",
+    "invalidated"
+  ];
+  if (!item || typeof item !== "object" || typeof item.objective !== "string" || item.objective.length === 0 || item.objective.length > MAX_TEXT_LENGTH || item.objective.trim() !== item.objective || !states.includes(item.state) || !Number.isSafeInteger(item.generation) || item.generation < 0 || item.generation > ledgerGeneration || !Number.isSafeInteger(item.taskGeneration) || item.taskGeneration < 1 || !Array.isArray(item.artifacts) || !validStoredArtifacts(item.artifacts, item.id, item.generation) || item.artifactHistory !== void 0 && !Array.isArray(item.artifactHistory) || item.artifactHistory !== void 0 && !validStoredArtifacts(item.artifactHistory, item.id, item.generation) || !item.inputArtifactVersions || typeof item.inputArtifactVersions !== "object" || Array.isArray(item.inputArtifactVersions) || item.assignedAgentId !== void 0 && !isValidIdentifier(item.assignedAgentId) || item.selectedAgentName !== void 0 && (typeof item.selectedAgentName !== "string" || item.selectedAgentName.length === 0 || item.selectedAgentName.length > MAX_IDENTIFIER_LENGTH || item.selectedAgentName.trim() !== item.selectedAgentName) || item.acceptanceStateVersion !== WORK_ITEM_ACCEPTANCE_VERSION || typeof item.acceptanceRequired !== "boolean" || !["not-required", "pending", "accepted", "rework-requested", "rejected"].includes(
+    item.acceptanceState
+  ) || !Number.isSafeInteger(item.reworkCount) || item.reworkCount < 0 || item.reworkCount > 1 || item.maxReworkCycles !== 0 && item.maxReworkCycles !== 1 || item.acceptanceRequired && !item.integrationOwner || !item.acceptanceRequired && item.acceptanceState !== "not-required" || typeof item.integrationOwner !== "boolean" || !["completed", "settled"].includes(item.dependencyPolicy) || !["read-only", "idempotent", "mutating"].includes(item.sideEffectPolicy) || item.verifierFor !== void 0 && !isValidIdentifier(item.verifierFor) || ![
+    item.dependencies,
+    item.dependents,
+    item.inputArtifacts,
+    item.requiredCapabilities,
+    item.requiredTools,
+    item.readPaths,
+    item.writePaths,
+    item.ownershipKeys,
+    item.acceptanceCriteria,
+    item.requiredEvidence
+  ].every(
+    (values) => Array.isArray(values) && values.every(
+      (value) => typeof value === "string" && value.length > 0 && value.length <= MAX_TEXT_LENGTH && value.trim() === value
+    )
+  ) || !item.requiredArtifactVersions || typeof item.requiredArtifactVersions !== "object" || Array.isArray(item.requiredArtifactVersions) || !Object.entries(item.requiredArtifactVersions).every(
+    ([id, version]) => isValidIdentifier(id) && typeof version === "string" && version.length > 0 && version.length <= MAX_IDENTIFIER_LENGTH && version.trim() === version
+  ) || item.acceptedExecutionPlanId !== void 0 && (typeof item.acceptedExecutionPlanId !== "string" || !/^[a-f0-9]{64}$/u.test(item.acceptedExecutionPlanId)) || !Object.entries(item.inputArtifactVersions).every(
+    ([id, value]) => isValidIdentifier(id) && typeof value === "string" && value.length > 0 && value.length <= MAX_IDENTIFIER_LENGTH && value.trim() === value
+  ) || !Array.isArray(item.invalidationReasons) || !item.invalidationReasons.every(
+    (reason) => typeof reason === "string" && reason.length > 0 && reason.length <= MAX_TEXT_LENGTH && reason.trim() === reason
+  ) || item.outcomeReason !== void 0 && (typeof item.outcomeReason !== "string" || item.outcomeReason.length > MAX_TEXT_LENGTH || item.outcomeReason.trim() !== item.outcomeReason) || typeof item.verificationAccepted !== "boolean" || item.stagedTreeIdentity !== void 0 && !isWorkflowTreeIdentity(item.stagedTreeIdentity) || item.verificationReceipt !== void 0 && (!isWorkflowVerificationReceipt(item.verificationReceipt) || !storedVerificationMatchesItem(item, item.verificationReceipt)) || item.acceptanceReceipt !== void 0 && (!isVerificationReceipt(item.acceptanceReceipt) || item.acceptanceState !== "pending" && !storedAcceptanceMatchesItem(item, item.acceptanceReceipt)) || !Array.isArray(item.acceptanceReceiptHistory) || item.acceptanceReceiptHistory.length > 2 || !item.acceptanceReceiptHistory.every(isVerificationReceipt) || item.acceptanceReceipt !== void 0 && JSON.stringify(item.acceptanceReceiptHistory.at(-1)) !== JSON.stringify(item.acceptanceReceipt) || item.reworkCount !== Math.min(
+    item.maxReworkCycles,
+    item.acceptanceReceiptHistory.filter((receipt) => receipt.decision === "rework").length
+  ) || item.submission !== void 0 && !validSubmission(item.submission) || item.acceptanceRequired && item.state === "completed" && item.acceptanceState === "pending" && (!item.submission || !item.acceptedExecutionPlanId) || item.acceptanceState === "accepted" && (item.acceptanceReceipt?.decision !== "accept" || !item.verificationAccepted) || item.acceptanceState === "rejected" && (!["failed", "interrupted", "stale", "invalidated", "blocked", "needs-input"].includes(
+    item.state
+  ) || item.acceptanceReceipt !== void 0 && item.acceptanceReceipt.decision !== "reject" && item.acceptanceReceipt.decision !== "rework") || item.acceptanceState === "rework-requested" && (item.state !== "blocked" || item.acceptanceReceipt?.decision !== "rework") || item.state === "awaiting-verification" && (!item.stagedTreeIdentity || !item.acceptedExecutionPlanId) || item.stagedTreeIdentity !== void 0 && item.state === "completed" && !item.acceptanceRequired && item.verificationReceipt === void 0) {
+    throw new Error(`Malformed stored WorkItem ${String(item?.id ?? "unknown")}`);
+  }
+}
+function storedAcceptanceMatchesItem(item, receipt) {
+  return item.acceptanceRequired && item.submission !== void 0 && receipt.targetTaskId === item.id && receipt.targetTaskGeneration === item.taskGeneration && receipt.targetExecutionPlanId === item.acceptedExecutionPlanId && sameWorkflowTreeIdentity(receipt.beforeTreeIdentity, item.submission.treeIdentity) && sameWorkflowTreeIdentity(receipt.afterTreeIdentity, item.submission.treeIdentity) && receipt.baseRepositoryGeneration === item.submission.baseRepositoryGeneration && receipt.patchDigest === item.submission.patchDigest && JSON.stringify(receipt.changedPaths) === JSON.stringify(item.submission.changedPaths) && JSON.stringify(receipt.allowedScopes) === JSON.stringify(item.writePaths) && JSON.stringify(receipt.dependencyVersions) === JSON.stringify(item.inputArtifactVersions) && JSON.stringify(receipt.readSetVersions) === JSON.stringify(item.submission.fileVersions) && JSON.stringify(receipt.acceptanceCriteria) === JSON.stringify(item.acceptanceCriteria) && JSON.stringify(receipt.requiredEvidenceIds) === JSON.stringify(item.requiredEvidence);
+}
+function storedVerificationMatchesItem(item, receipt) {
+  return !item.verifierFor && receipt.targetTaskId === item.id && receipt.targetTaskGeneration === item.taskGeneration && receipt.targetExecutionPlanId === item.acceptedExecutionPlanId && item.stagedTreeIdentity !== void 0 && sameWorkflowTreeIdentity(receipt.treeIdentity, item.stagedTreeIdentity) && item.verificationAccepted === (receipt.decision === "accept") && (receipt.decision === "accept" ? item.state === "completed" : receipt.decision === "rework" ? item.state === "blocked" : item.state === "failed");
+}
+function validStoredArtifacts(values, producerTaskId, itemGeneration) {
+  const seen = /* @__PURE__ */ new Set();
+  return values.every(
+    (artifact) => artifact !== null && typeof artifact === "object" && Object.keys(artifact).every(
+      (key) => ["id", "kind", "version", "digest", "producerTaskId", "generation", "verified"].includes(
+        key
+      )
+    ) && isValidIdentifier(artifact.id) && claimUnique(artifact.id, seen) && typeof artifact.kind === "string" && artifact.kind.length > 0 && artifact.kind.length <= MAX_IDENTIFIER_LENGTH && artifact.kind.trim() === artifact.kind && typeof artifact.version === "string" && artifact.version.length > 0 && artifact.version.length <= MAX_IDENTIFIER_LENGTH && artifact.version.trim() === artifact.version && (artifact.digest === void 0 || typeof artifact.digest === "string" && artifact.digest.length > 0 && artifact.digest.length <= MAX_TEXT_LENGTH && artifact.digest.trim() === artifact.digest) && artifact.producerTaskId === producerTaskId && Number.isSafeInteger(artifact.generation) && Number(artifact.generation) >= 0 && Number(artifact.generation) <= itemGeneration && typeof artifact.verified === "boolean"
+  );
+}
+function claimUnique(value, seen) {
+  if (seen.has(value)) return false;
+  seen.add(value);
+  return true;
+}
+function normalizeStoredArtifacts(values, defaultProducerTaskId, defaultGeneration, preserveVerification) {
+  if (!validStoredArtifacts(values, defaultProducerTaskId, defaultGeneration)) {
+    throw new Error(`Malformed stored artifacts for WorkItem ${defaultProducerTaskId}`);
+  }
+  return values.map((value) => ({
+    ...structuredClone(value),
+    verified: preserveVerification && value.verified
+  }));
+}
+function normalizeArtifacts(values, producerTaskId, generation) {
+  if (values.length > MAX_LIST_ITEMS2) throw new Error("Too many WorkItem artifacts");
+  const seen = /* @__PURE__ */ new Set();
+  return values.map((value) => {
+    validateIdentifier(value.id, "artifact id");
+    if (seen.has(value.id)) throw new Error(`Duplicate artifact id ${value.id}`);
+    seen.add(value.id);
+    const kind = bounded(value.kind, MAX_IDENTIFIER_LENGTH);
+    const version = bounded(value.version, MAX_IDENTIFIER_LENGTH);
+    if (!kind || !version) throw new Error(`Artifact ${value.id} requires kind and version`);
+    return {
+      id: value.id,
+      kind,
+      version,
+      ...value.digest ? { digest: bounded(value.digest, MAX_TEXT_LENGTH) } : {},
+      producerTaskId,
+      generation,
+      verified: false
+    };
+  });
+}
+function normalizeVersionMap(value) {
+  if (value === void 0) return {};
+  const entries = Object.entries(value);
+  if (entries.length > MAX_LIST_ITEMS2) throw new Error("Too many artifact version requirements");
+  return Object.fromEntries(
+    entries.map(([id, version]) => {
+      validateIdentifier(id, "artifact version id");
+      const normalized = bounded(version, MAX_IDENTIFIER_LENGTH);
+      if (!normalized) throw new Error(`Artifact ${id} requires a version`);
+      return [id, normalized];
+    })
+  );
+}
+function uniqueBounded(values, label) {
+  if (!Array.isArray(values) || values.length > MAX_LIST_ITEMS2) {
+    throw new Error(`Too many WorkItem ${label} values`);
+  }
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    if (typeof value !== "string") throw new Error(`Invalid WorkItem ${label}`);
+    const normalized = bounded(value, MAX_TEXT_LENGTH);
+    if (!normalized) throw new Error(`Empty WorkItem ${label}`);
+    if (!seen.has(normalized)) result.push(normalized);
+    seen.add(normalized);
+  }
+  return result;
+}
+function isValidIdentifier(value) {
+  return typeof value === "string" && value.length >= 1 && value.length <= MAX_IDENTIFIER_LENGTH && /^[A-Za-z0-9][A-Za-z0-9._:-]*$/u.test(value);
+}
+function validateIdentifier(value, label) {
+  if (!isValidIdentifier(value)) {
+    throw new Error(`Invalid ${label}`);
+  }
+}
+function bounded(value, maxLength) {
+  return value.trim().slice(0, maxLength);
+}
+
+// src/work-item-persistence.ts
+var WORKFLOW_STATE_DIRECTORY = "pi-subagents-workflows";
+var DEFAULT_MAX_STORED_WORKFLOWS = 64;
+var DEFAULT_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
+var MAX_WORKFLOW_STATE_BYTES = 1024 * 1024;
+var WorkItemPersistence = class {
+  constructor(filePath, afterSave) {
+    this.filePath = filePath;
+    this.afterSave = afterSave;
+  }
+  filePath;
+  afterSave;
+  async save(snapshot) {
+    const filePath = path3.resolve(this.filePath);
+    const sanitized = sanitizeWorkflowSnapshot(snapshot);
+    const content = `${JSON.stringify(sanitized)}
+`;
+    if (Buffer.byteLength(content, "utf8") > MAX_WORKFLOW_STATE_BYTES) {
+      throw new Error("WorkItem workflow state exceeds the persistence size limit");
+    }
+    await withFileMutationQueue(filePath, async () => {
+      await fs2.promises.mkdir(path3.dirname(filePath), { recursive: true, mode: 448 });
+      const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+      try {
+        await fs2.promises.writeFile(temporary, content, { mode: 384 });
+        await fs2.promises.rename(temporary, filePath);
+      } finally {
+        await fs2.promises.rm(temporary, { force: true });
+      }
+    });
+    await this.afterSave?.();
+  }
+  load() {
+    const filePath = path3.resolve(this.filePath);
+    let source;
+    try {
+      const stat = fs2.statSync(filePath);
+      if (stat.size > MAX_WORKFLOW_STATE_BYTES)
+        throw new Error("workflow state exceeds size limit");
+      source = fs2.readFileSync(filePath, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") return void 0;
+      throw error;
+    }
+    try {
+      return WorkItemLedger.restore(JSON.parse(source));
+    } catch {
+      const quarantine = `${filePath}.invalid-${Date.now()}`;
+      try {
+        fs2.renameSync(filePath, quarantine);
+      } catch {
+      }
+      return void 0;
+    }
+  }
+};
+function createSessionWorkItemPersistence(owner, workflowId, options = {}) {
+  const maxStoredWorkflows = options.maxStoredWorkflows ?? DEFAULT_MAX_STORED_WORKFLOWS;
+  const retentionMs = options.retentionMs ?? DEFAULT_RETENTION_MS;
+  if (!Number.isSafeInteger(maxStoredWorkflows) || maxStoredWorkflows < 1) {
+    throw new Error("maxStoredWorkflows must be a positive safe integer");
+  }
+  if (!Number.isFinite(retentionMs) || retentionMs <= 0) {
+    throw new Error("workflow retentionMs must be a positive finite number");
+  }
+  const stateDir = resolveStateDirectory(options.stateDir);
+  const prefix = sessionPrefix(owner);
+  const filePath = path3.join(stateDir, `${prefix}-${stableId(workflowId)}.json`);
+  return new WorkItemPersistence(
+    filePath,
+    () => pruneSessionWorkflows(stateDir, prefix, maxStoredWorkflows, retentionMs)
+  );
+}
+function inspectSessionWorkflows(owner, options = {}) {
+  const stateDir = resolveStateDirectory(options.stateDir);
+  const prefix = `${sessionPrefix(owner)}-`;
+  const limit = options.maxStoredWorkflows ?? DEFAULT_MAX_STORED_WORKFLOWS;
+  if (!Number.isSafeInteger(limit) || limit < 1) {
+    throw new Error("maxStoredWorkflows must be a positive safe integer");
+  }
+  let entries;
+  try {
+    entries = fs2.readdirSync(stateDir, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { workflows: [], invalid: 0, omitted: 0 };
+    }
+    throw error;
+  }
+  const candidates = entries.filter(
+    (entry) => entry.isFile() && entry.name.startsWith(prefix) && entry.name.endsWith(".json")
+  ).map((entry) => {
+    const filePath = path3.join(stateDir, entry.name);
+    return { filePath, modifiedAt: safeModifiedAt(filePath) };
+  }).sort((left, right) => right.modifiedAt - left.modifiedAt);
+  const workflows = [];
+  let invalid = 0;
+  for (const candidate of candidates.slice(0, limit)) {
+    try {
+      const stat = fs2.statSync(candidate.filePath);
+      if (stat.size > MAX_WORKFLOW_STATE_BYTES)
+        throw new Error("workflow state exceeds size limit");
+      const source = fs2.readFileSync(candidate.filePath, "utf8");
+      workflows.push(
+        WorkItemLedger.restore(JSON.parse(source)).snapshot()
+      );
+    } catch {
+      invalid++;
+    }
+  }
+  return { workflows, invalid, omitted: Math.max(0, candidates.length - limit) };
+}
+function safeModifiedAt(filePath) {
+  try {
+    return fs2.statSync(filePath).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+function resolveStateDirectory(stateDir) {
+  return path3.resolve(stateDir ?? path3.join(getAgentDir(), WORKFLOW_STATE_DIRECTORY));
+}
+function sessionPrefix(owner) {
+  return stableId(`session:${owner}`);
+}
+function stableId(value) {
+  return createHash2("sha256").update(value).digest("hex").slice(0, 24);
+}
+async function pruneSessionWorkflows(stateDir, prefix, maxStoredWorkflows, retentionMs) {
+  await withFileMutationQueue(path3.join(stateDir, `${prefix}.prune`), async () => {
+    const cutoff = Date.now() - retentionMs;
+    const entries = (await fs2.promises.readdir(stateDir, { withFileTypes: true })).filter(
+      (entry) => entry.isFile() && entry.name.startsWith(`${prefix}-`) && entry.name.endsWith(".json")
+    ).map((entry) => path3.join(stateDir, entry.name));
+    const records = await Promise.all(
+      entries.map(async (filePath) => ({
+        filePath,
+        modifiedAt: (await fs2.promises.stat(filePath)).mtimeMs
+      }))
+    );
+    records.sort((left, right) => right.modifiedAt - left.modifiedAt);
+    await Promise.all(
+      records.filter((record, index) => index >= maxStoredWorkflows || record.modifiedAt < cutoff).map((record) => fs2.promises.rm(record.filePath, { force: true }))
+    );
+  });
+}
+function sanitizeWorkflowSnapshot(snapshot) {
+  const sanitized = structuredClone(snapshot);
+  for (const item of sanitized.items) {
+    item.objective = redact(item.objective);
+    item.selectedAgentName = item.selectedAgentName ? redact(item.selectedAgentName) : void 0;
+    item.requiredCapabilities = item.requiredCapabilities.map(redact);
+    item.requiredTools = item.requiredTools.map(redact);
+    item.readPaths = item.readPaths.map(redact);
+    item.writePaths = item.writePaths.map(redact);
+    item.ownershipKeys = item.ownershipKeys.map(redact);
+    item.acceptanceCriteria = item.acceptanceCriteria.map(redact);
+    item.requiredEvidence = item.requiredEvidence.map(redact);
+    item.invalidationReasons = item.invalidationReasons.map(redact);
+    item.outcomeReason = item.outcomeReason ? redact(item.outcomeReason) : void 0;
+    if (item.verificationReceipt) {
+      item.verificationReceipt.summary = redact(item.verificationReceipt.summary);
+      item.verificationReceipt.evidence = item.verificationReceipt.evidence.map(redact);
+      item.verificationReceipt.limitations = item.verificationReceipt.limitations.map(redact);
+    }
+    for (const receipt of [
+      ...item.acceptanceReceiptHistory,
+      ...item.acceptanceReceipt ? [item.acceptanceReceipt] : []
+    ]) {
+      receipt.summary = redact(receipt.summary);
+      receipt.findings = receipt.findings.map(redact);
+      receipt.changedPaths = receipt.changedPaths.map(redact);
+      receipt.allowedScopes = receipt.allowedScopes.map(redact);
+      receipt.acceptanceCriteria = receipt.acceptanceCriteria.map(redact);
+      receipt.requiredEvidenceIds = receipt.requiredEvidenceIds.map(redact);
+      receipt.dependencyVersions = redactRecord(receipt.dependencyVersions);
+      receipt.readSetVersions = redactRecord(receipt.readSetVersions);
+      receipt.evidence = redactRecord(receipt.evidence);
+      for (const check of receipt.checks) {
+        check.stdout = redact(check.stdout);
+        check.stderr = redact(check.stderr);
+      }
+    }
+    if (item.submission) {
+      item.submission.changedPaths = item.submission.changedPaths.map(redact);
+      item.submission.fileVersions = Object.fromEntries(
+        Object.entries(item.submission.fileVersions).map(([key, value]) => [redact(key), value])
+      );
+    }
+    for (const artifact of [...item.artifacts, ...item.artifactHistory]) {
+      artifact.kind = redact(artifact.kind);
+      artifact.version = redact(artifact.version);
+      artifact.digest = artifact.digest ? redact(artifact.digest) : void 0;
+    }
+  }
+  WorkItemLedger.restore(sanitized);
+  return sanitized;
+}
+function redactRecord(value) {
+  return Object.fromEntries(
+    Object.entries(value).map(([key, item]) => [redact(key), redact(item)])
+  );
+}
+function redact(value) {
+  return redactPrivateText(value).trim();
+}
+
+export {
+  captureWorkflowTreeIdentity,
+  sameWorkflowTreeIdentity,
+  createVerificationReceipt,
+  createWorkflowVerificationReceipt,
+  workflowVerificationInstruction,
+  WorkItemLedger,
+  createSessionWorkItemPersistence,
+  inspectSessionWorkflows
+};
+//# sourceMappingURL=chunk-OVPHFGKO.ts.map