@narumitw/pi-subagents 2.1.4 → 3.0.0

package/dist/chunks/chunk-OVPHFGKO.ts

@@ -1,1769 +0,0 @@
-// @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.ts";
-
-// 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