pi-webdesk 0.1.0

package/dist/packages/protocol/src/index.js

@@ -0,0 +1,1863 @@
+// packages/protocol/src/index.ts
+import { z } from "zod";
+var PROTOCOL_VERSION = "protocol-v1";
+var WORKSPACE_SCHEMA_VERSION = 5;
+var taskIdSchema = z.string().min(1);
+var nonNegativeInt = z.number().int().min(0);
+var runtimeModelInfoSchema = z.object({
+  provider: z.string().min(1).max(200),
+  id: z.string().min(1).max(500),
+  name: z.string().min(1).max(500)
+}).strict();
+var runtimeStatusPayloadSchema = z.object({
+  state: z.enum(["starting", "ready", "needs_auth", "exited", "failed"]),
+  model: runtimeModelInfoSchema.nullable().optional(),
+  detail: z.string().optional()
+});
+var taskApprovalSchema = z.object({
+  approvalId: z.uuid(),
+  /** Pi's identity for the exact intercepted call this decision covers. */
+  toolCallId: z.string().min(1).max(500),
+  toolName: z.string().min(1).max(200),
+  summary: z.string().min(1).max(1e5),
+  requestedAtMs: z.number().int().nonnegative(),
+  expiresAtMs: z.number().int().positive()
+}).strict();
+var approvalRequestedPayloadSchema = taskApprovalSchema;
+var approvalResolvedPayloadSchema = z.object({
+  approvalId: z.uuid(),
+  resolution: z.enum(["approved", "denied", "timeout", "superseded"])
+});
+var agentActivityPayloadSchema = z.object({
+  phase: z.enum(["agent-start", "agent-end", "agent-settled", "turn-start", "turn-end"])
+});
+var logPayloadSchema = z.object({
+  level: z.enum(["info", "warning", "error"]),
+  message: z.string()
+});
+var assistantDeltaPayloadSchema = z.object({
+  text: z.string()
+});
+var toolActivitySchema = z.object({
+  toolCallId: z.string().min(1).max(500),
+  name: z.string().min(1).max(200),
+  status: z.enum(["queued", "running", "succeeded", "failed", "incomplete"]),
+  input: z.string().max(2e4),
+  output: z.string().max(2e4),
+  inputOmittedChars: nonNegativeInt,
+  outputOmittedChars: nonNegativeInt,
+  path: z.string().max(4096).optional()
+}).strict();
+var envelopeBase = {
+  protocol: z.literal(PROTOCOL_VERSION),
+  taskId: taskIdSchema,
+  runtimeGeneration: nonNegativeInt,
+  sequence: nonNegativeInt,
+  timestamp: nonNegativeInt
+};
+var daemonEventSchema = z.discriminatedUnion("type", [
+  z.object({
+    ...envelopeBase,
+    type: z.literal("runtime-status"),
+    payload: runtimeStatusPayloadSchema
+  }),
+  z.object({
+    ...envelopeBase,
+    type: z.literal("approval-requested"),
+    payload: approvalRequestedPayloadSchema
+  }),
+  z.object({
+    ...envelopeBase,
+    type: z.literal("approval-resolved"),
+    payload: approvalResolvedPayloadSchema
+  }),
+  z.object({
+    ...envelopeBase,
+    type: z.literal("agent-activity"),
+    payload: agentActivityPayloadSchema
+  }),
+  z.object({
+    ...envelopeBase,
+    type: z.literal("log"),
+    payload: logPayloadSchema
+  }),
+  z.object({
+    ...envelopeBase,
+    type: z.literal("assistant-delta"),
+    payload: assistantDeltaPayloadSchema
+  }),
+  z.object({
+    ...envelopeBase,
+    type: z.literal("tool-activity"),
+    payload: toolActivitySchema
+  })
+]);
+function parseDaemonEvent(value) {
+  return daemonEventSchema.parse(value);
+}
+function safeParseDaemonEvent(value) {
+  return daemonEventSchema.safeParse(value);
+}
+function createDaemonEventFactory(init) {
+  const now = init.now ?? Date.now;
+  let sequence = 0;
+  return (type, payload) => parseDaemonEvent({
+    protocol: PROTOCOL_VERSION,
+    taskId: init.taskId,
+    runtimeGeneration: init.runtimeGeneration,
+    sequence: sequence++,
+    timestamp: now(),
+    type,
+    payload
+  });
+}
+var serviceSessionSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("service-session"),
+  authenticated: z.literal(true),
+  /** Unix epoch milliseconds after which the session is no longer valid. */
+  sessionExpiresAt: nonNegativeInt
+});
+function parseServiceSession(value) {
+  return serviceSessionSchema.parse(value);
+}
+function safeParseServiceSession(value) {
+  return serviceSessionSchema.safeParse(value);
+}
+var serverControlMessageSchema = z.discriminatedUnion("type", [
+  z.object({
+    protocol: z.literal(PROTOCOL_VERSION),
+    type: z.literal("service-ready"),
+    /** Unix epoch milliseconds at which the daemon accepted the channel. */
+    timestamp: nonNegativeInt,
+    /** Expiry of the session that authenticated this channel. */
+    sessionExpiresAt: nonNegativeInt
+  })
+]);
+function parseServerControlMessage(value) {
+  return serverControlMessageSchema.parse(value);
+}
+function safeParseServerControlMessage(value) {
+  return serverControlMessageSchema.safeParse(value);
+}
+var sessionEntryIdSchema = z.string().min(1).max(500);
+var MAX_SESSION_TRANSCRIPT_ITEMS = 200;
+var MAX_SESSION_TRANSCRIPT_TEXT_CHARS = 2e4;
+var textTranscriptItemSchema = z.object({
+  /** Pi session entry id backing this item. */
+  id: sessionEntryIdSchema,
+  role: z.enum(["user", "assistant"]),
+  text: z.string().max(MAX_SESSION_TRANSCRIPT_TEXT_CHARS),
+  /** Characters omitted from the tail to keep reconnect payloads bounded. */
+  omittedChars: nonNegativeInt
+}).strict();
+var sessionTranscriptItemSchema = z.union([
+  textTranscriptItemSchema,
+  z.object({
+    id: sessionEntryIdSchema,
+    role: z.literal("tool"),
+    /** Pi tool-call identity backs this item, with its result attached. */
+    tool: toolActivitySchema
+  }).strict()
+]);
+var sessionTreeNodeSchema = z.lazy(
+  () => z.object({
+    id: sessionEntryIdSchema,
+    parentId: sessionEntryIdSchema.nullable(),
+    kind: z.string().min(1).max(100),
+    role: z.string().min(1).max(100).optional(),
+    label: z.string().max(500).optional(),
+    preview: z.string().max(200).optional(),
+    onActivePath: z.boolean(),
+    children: z.array(sessionTreeNodeSchema)
+  }).strict()
+);
+var sessionTreeSchema = z.object({
+  roots: z.array(sessionTreeNodeSchema),
+  leafId: sessionEntryIdSchema.nullable(),
+  /** The full tree remains in Pi; this projection hit its node/depth cap. */
+  truncated: z.boolean()
+}).strict();
+var taskRuntimeSnapshotSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("task-runtime-snapshot"),
+  taskId: taskIdSchema,
+  runtimeGeneration: nonNegativeInt,
+  /**
+   * Daemon event cursor at capture time. Live delivery resumes with the
+   * next sequence; null when this generation has produced no events.
+   */
+  lastSequence: nonNegativeInt.nullable(),
+  state: z.enum(["idle", "starting", "ready", "needs_auth", "exited", "failed"]),
+  working: z.boolean(),
+  approval: taskApprovalSchema.nullable(),
+  model: runtimeModelInfoSchema.nullable(),
+  detail: z.string().max(1e3).optional(),
+  /**
+   * Canonical conversation along Pi's active branch; null when Pi could not
+   * be consulted (no live runtime, or the runtime request failed).
+   */
+  transcript: z.array(sessionTranscriptItemSchema).max(MAX_SESSION_TRANSCRIPT_ITEMS).nullable(),
+  transcriptUnavailableReason: z.enum(["runtime-not-live", "pi-request-failed"]).optional(),
+  /** Older transcript items omitted from this bounded snapshot. */
+  omittedTranscriptItems: nonNegativeInt,
+  sessionTree: sessionTreeSchema.nullable(),
+  /**
+   * True when non-canonical in-flight output (a still-streaming turn) could
+   * not be reconstructed; the UI must surface an explicit gap marker rather
+   * than silently joining partial streams.
+   */
+  inFlightGap: z.boolean()
+}).strict();
+function parseTaskRuntimeSnapshot(value) {
+  return taskRuntimeSnapshotSchema.parse(value);
+}
+var taskEventsReplaySchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("task-events-replay"),
+  taskId: taskIdSchema,
+  runtimeGeneration: nonNegativeInt,
+  /** The client's presented cursor; replayed events begin after it. */
+  afterSequence: nonNegativeInt,
+  /** The daemon's cursor; equal to afterSequence when nothing was missed. */
+  lastSequence: nonNegativeInt
+}).strict();
+var taskEventsErrorSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("task-events-error"),
+  taskId: taskIdSchema,
+  code: z.enum(["task-not-found", "snapshot-failed"]),
+  message: z.string().min(1).max(500)
+}).strict();
+var taskSubscribeMessageSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("task-subscribe"),
+  taskId: z.uuid(),
+  cursor: z.object({
+    runtimeGeneration: nonNegativeInt,
+    lastSequence: nonNegativeInt
+  }).strict().nullable()
+}).strict();
+var clientMessageSchema = z.discriminatedUnion("type", [taskSubscribeMessageSchema]);
+function safeParseClientMessage(value) {
+  return clientMessageSchema.safeParse(value);
+}
+var serverMessageSchema = z.union([
+  serverControlMessageSchema,
+  daemonEventSchema,
+  taskRuntimeSnapshotSchema,
+  taskEventsReplaySchema,
+  taskEventsErrorSchema
+]);
+function parseServerMessage(value) {
+  return serverMessageSchema.parse(value);
+}
+function safeParseServerMessage(value) {
+  return serverMessageSchema.safeParse(value);
+}
+var absolutePathSchema = z.string().min(1).max(4096).startsWith("/");
+var gitCommitSchema = z.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/);
+var entityIdSchema = z.uuid();
+var TASK_VALIDATION_MAX_COMMAND_CHARS = 4096;
+var TASK_VALIDATION_MAX_OUTPUT_CHARS = 1e5;
+var TASK_VALIDATION_MAX_DURATION_MS = 6e5;
+var taskValidationCommandSchema = z.string().min(1).max(TASK_VALIDATION_MAX_COMMAND_CHARS).refine(
+  (value) => value.trim().length > 0,
+  "Validation commands must contain a non-whitespace character."
+).refine(
+  // Newlines and tabs are legitimate in multi-line commands. Reject every
+  // other Unicode control/format character, including bidi overrides, so
+  // the exact runnable command remains visually trustworthy without being
+  // trimmed, escaped, or otherwise rewritten.
+  (value) => [...value].every(
+    (character) => character === "\n" || character === "	" || !/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}\p{Cs}\p{Default_Ignorable_Code_Point}]/u.test(character) && (!new RegExp("\\p{Zs}", "u").test(character) || character === " ") && !/[\u115F\u1160\u2800\u3164\uFFA0]/u.test(character)
+  ),
+  "Validation commands must not contain invisible control, formatting, separator, or filler characters other than newlines, tabs, and ordinary spaces."
+);
+var runTaskValidationRequestSchema = z.object({ command: taskValidationCommandSchema }).strict();
+var worktreeStateFingerprintSchema = z.string().regex(/^[0-9a-f]{64}$/);
+var taskValidationResultSchema = z.object({
+  /** Exact validated user-authored command, preserved verbatim. */
+  command: taskValidationCommandSchema,
+  outcome: z.enum(["passed", "failed", "timed-out", "error"]),
+  /** Shell exit code, when the process exited on its own. */
+  exitCode: z.number().int().min(0).max(255).nullable(),
+  /** Terminating signal name, when the process was killed. */
+  signal: z.string().min(1).max(20).nullable(),
+  /** Combined stdout/stderr with control characters visibly escaped. */
+  output: z.string().max(TASK_VALIDATION_MAX_OUTPUT_CHARS),
+  /** True when captured output was cut at the display bound. */
+  outputTruncated: z.boolean(),
+  /** Characters dropped from the output tail (reported, never silent). */
+  omittedOutputChars: nonNegativeInt,
+  startedAtMs: nonNegativeInt,
+  finishedAtMs: nonNegativeInt,
+  /** Worktree-state fingerprint captured immediately before the run. */
+  stateFingerprint: worktreeStateFingerprintSchema
+}).strict().superRefine((result, context) => {
+  if (result.finishedAtMs < result.startedAtMs) {
+    context.addIssue({
+      code: "custom",
+      path: ["finishedAtMs"],
+      message: "A validation cannot finish before it started."
+    });
+  }
+  if (result.outcome === "passed" && (result.exitCode !== 0 || result.signal !== null)) {
+    context.addIssue({
+      code: "custom",
+      path: ["outcome"],
+      message: "A passed validation requires exit code 0 and no signal."
+    });
+  }
+  if (result.outcome === "failed" && (result.exitCode === null || result.exitCode === 0) && result.signal === null) {
+    context.addIssue({
+      code: "custom",
+      path: ["outcome"],
+      message: "A failed validation requires a nonzero exit code or a signal."
+    });
+  }
+  if (result.outcome === "error" && (result.exitCode !== null || result.signal !== null)) {
+    context.addIssue({
+      code: "custom",
+      path: ["outcome"],
+      message: "An error outcome carries no exit code or signal."
+    });
+  }
+  if (result.exitCode !== null && result.signal !== null) {
+    context.addIssue({
+      code: "custom",
+      path: ["signal"],
+      message: "A process exits with either a code or a signal, never both."
+    });
+  }
+  if (result.outputTruncated !== result.omittedOutputChars > 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["outputTruncated"],
+      message: "Truncation state and omitted character count must agree."
+    });
+  }
+});
+var taskValidationSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("task-validation"),
+  taskId: entityIdSchema,
+  result: taskValidationResultSchema.nullable(),
+  /** True while a validation process is executing for this task. */
+  running: z.boolean(),
+  /**
+   * True when the result's pre-run fingerprint no longer matches the live
+   * worktree state (or that state could not be captured). A stale result
+   * must never be presented as current.
+   */
+  stale: z.boolean(),
+  /** Unix epoch milliseconds when the daemon derived this status. */
+  capturedAtMs: nonNegativeInt
+}).strict().superRefine((validation, context) => {
+  if (validation.result === null && validation.stale) {
+    context.addIssue({
+      code: "custom",
+      path: ["stale"],
+      message: "Only a recorded result can be stale."
+    });
+  }
+});
+var taskValidationErrorSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("task-validation-error"),
+  code: z.enum([
+    "invalid-request",
+    "task-not-found",
+    "task-not-ready",
+    "validation-running",
+    "commit-in-progress",
+    "merge-in-progress",
+    "archive-in-progress",
+    "agent-working",
+    "validation-failed",
+    "internal-error"
+  ]),
+  message: z.string().min(1).max(500)
+}).strict();
+function parseTaskValidation(value) {
+  return taskValidationSchema.parse(value);
+}
+function safeParseTaskValidation(value) {
+  return taskValidationSchema.safeParse(value);
+}
+var taskMergeModeSchema = z.enum(["fast-forward", "merge-commit"]);
+var repositoryPendingMergeSchema = z.object({
+  taskId: entityIdSchema,
+  preflightId: entityIdSchema,
+  mode: taskMergeModeSchema,
+  targetBranch: z.string().min(1).max(1024),
+  previousTargetHead: gitCommitSchema,
+  newTargetHead: gitCommitSchema,
+  recordedAtMs: nonNegativeInt
+}).strict().refine((record) => record.previousTargetHead !== record.newTargetHead, {
+  message: "A pending merge must advance the target branch.",
+  path: ["newTargetHead"]
+});
+var repositoryRecordSchema = z.object({
+  id: entityIdSchema,
+  rootPath: absolutePathSchema,
+  commonDir: absolutePathSchema,
+  displayName: z.string().min(1).max(255),
+  headCommit: gitCommitSchema,
+  branch: z.string().min(1).max(1024).nullable(),
+  createdAtMs: nonNegativeInt,
+  /** Interrupted-merge intent awaiting explicit recovery; schema v4. */
+  pendingMerge: repositoryPendingMergeSchema.optional()
+}).strict();
+var worktreeRecoveryFactsSchema = z.object({
+  branch: z.string().min(1).max(1024),
+  worktreePath: absolutePathSchema,
+  baseCommit: gitCommitSchema,
+  branchExists: z.boolean().nullable(),
+  targetRegisteredAsWorktree: z.boolean().nullable(),
+  targetExistsOnDisk: z.boolean().nullable()
+}).strict();
+var taskRecordBase = {
+  id: entityIdSchema,
+  repositoryId: entityIdSchema,
+  title: z.string().min(1).max(200),
+  branch: z.string().min(1).max(1024),
+  worktreePath: absolutePathSchema,
+  baseCommit: gitCommitSchema,
+  createdAtMs: nonNegativeInt
+};
+var taskReadyMetadata = {
+  /** Exact Pi-owned session file associated with this task. */
+  piSessionFile: absolutePathSchema.optional(),
+  /** Durable floor for runtime generations; never decreases or reuses. */
+  runtimeGeneration: nonNegativeInt.optional(),
+  /** Latest completed validation run; running records are never persisted. */
+  validation: taskValidationResultSchema.optional()
+};
+var taskFailureSchema = z.object({
+  code: z.string().min(1).max(100),
+  message: z.string().min(1).max(500),
+  recoveryFacts: worktreeRecoveryFactsSchema.optional()
+}).strict();
+var runtimeProcessRecordSchema = z.object({
+  runtimeGeneration: z.number().int().positive(),
+  pid: z.number().int().positive(),
+  processGroupId: z.number().int().positive(),
+  sessionId: z.number().int().positive(),
+  /** Boot identity stored separately so a reboot can safely retire a stale lease. */
+  bootFingerprint: z.string().regex(/^[0-9a-f]{64}$/).optional(),
+  startFingerprint: z.string().regex(/^[0-9a-f]{64}$/),
+  recordedAtMs: nonNegativeInt
+}).strict().refine((record) => record.pid === record.processGroupId && record.pid === record.sessionId, {
+  message: "The supervised Pi process must lead its dedicated process group and session.",
+  path: ["processGroupId"]
+});
+var taskRecordSchema = z.discriminatedUnion("status", [
+  z.object({ ...taskRecordBase, status: z.literal("provisioning") }).strict(),
+  z.object({
+    ...taskRecordBase,
+    status: z.literal("ready"),
+    ...taskReadyMetadata,
+    /** Crash-recovery lease for the currently supervised Pi process. */
+    runtimeProcess: runtimeProcessRecordSchema.optional()
+  }).strict().refine(
+    (task) => task.runtimeProcess === void 0 || task.runtimeProcess.runtimeGeneration === task.runtimeGeneration,
+    {
+      message: "Runtime process ownership must match the task's current generation.",
+      path: ["runtimeProcess", "runtimeGeneration"]
+    }
+  ),
+  z.object({
+    ...taskRecordBase,
+    status: z.literal("failed"),
+    failure: taskFailureSchema
+  }).strict(),
+  z.object({
+    ...taskRecordBase,
+    status: z.literal("archived"),
+    ...taskReadyMetadata,
+    archivedAtMs: nonNegativeInt
+  }).strict()
+]);
+var workspaceStateSchema = z.object({
+  schemaVersion: z.literal(WORKSPACE_SCHEMA_VERSION),
+  repositories: z.array(repositoryRecordSchema),
+  tasks: z.array(taskRecordSchema)
+}).strict().superRefine((state, context) => {
+  const repositoryIds = /* @__PURE__ */ new Set();
+  const repositoryRoots = /* @__PURE__ */ new Set();
+  const repositoryCommonDirs = /* @__PURE__ */ new Set();
+  for (const [index, repository] of state.repositories.entries()) {
+    if (repositoryIds.has(repository.id)) {
+      context.addIssue({
+        code: "custom",
+        message: "Repository ids must be unique.",
+        path: ["repositories", index, "id"]
+      });
+    }
+    repositoryIds.add(repository.id);
+    if (repositoryRoots.has(repository.rootPath)) {
+      context.addIssue({
+        code: "custom",
+        message: "Repository roots must be unique.",
+        path: ["repositories", index, "rootPath"]
+      });
+    }
+    repositoryRoots.add(repository.rootPath);
+    if (repositoryCommonDirs.has(repository.commonDir)) {
+      context.addIssue({
+        code: "custom",
+        message: "Repository common Git directories must be unique.",
+        path: ["repositories", index, "commonDir"]
+      });
+    }
+    repositoryCommonDirs.add(repository.commonDir);
+  }
+  const taskIds = /* @__PURE__ */ new Set();
+  const tasksById = /* @__PURE__ */ new Map();
+  const taskWorktreePaths = /* @__PURE__ */ new Set();
+  const taskBranches = /* @__PURE__ */ new Set();
+  for (const [index, task] of state.tasks.entries()) {
+    if (taskIds.has(task.id)) {
+      context.addIssue({
+        code: "custom",
+        message: "Task ids must be unique.",
+        path: ["tasks", index, "id"]
+      });
+    }
+    taskIds.add(task.id);
+    tasksById.set(task.id, task);
+    if (!repositoryIds.has(task.repositoryId)) {
+      context.addIssue({
+        code: "custom",
+        message: "Every task must reference a registered repository.",
+        path: ["tasks", index, "repositoryId"]
+      });
+    }
+    if (taskWorktreePaths.has(task.worktreePath)) {
+      context.addIssue({
+        code: "custom",
+        message: "Task worktree paths must be unique.",
+        path: ["tasks", index, "worktreePath"]
+      });
+    }
+    taskWorktreePaths.add(task.worktreePath);
+    const branchKey = `${task.repositoryId}\0${task.branch}`;
+    if (taskBranches.has(branchKey)) {
+      context.addIssue({
+        code: "custom",
+        message: "Task branches must be unique within a repository.",
+        path: ["tasks", index, "branch"]
+      });
+    }
+    taskBranches.add(branchKey);
+  }
+  for (const [index, repository] of state.repositories.entries()) {
+    const pendingTaskId = repository.pendingMerge?.taskId;
+    if (pendingTaskId === void 0) continue;
+    const pendingTask = tasksById.get(pendingTaskId);
+    if (pendingTask === void 0 || pendingTask.repositoryId !== repository.id || pendingTask.status !== "ready") {
+      context.addIssue({
+        code: "custom",
+        message: "A pending merge must reference a ready task in its repository.",
+        path: ["repositories", index, "pendingMerge", "taskId"]
+      });
+    }
+  }
+});
+var preMergeRepositorySchema = repositoryRecordSchema.refine(
+  (repository) => repository.pendingMerge === void 0,
+  "Workspace schemas before v4 cannot contain pending merge records."
+);
+var preArchiveTaskSchema = taskRecordSchema.refine(
+  (task) => task.status !== "archived",
+  "Workspace schemas before v5 cannot contain archived tasks."
+);
+var workspaceStateV1Schema = z.object({
+  schemaVersion: z.literal(1),
+  repositories: z.array(preMergeRepositorySchema),
+  tasks: z.array(
+    preArchiveTaskSchema.refine(
+      (task) => task.status !== "ready" || task.validation === void 0,
+      "Workspace schema v1 cannot contain validation results."
+    )
+  )
+}).strict();
+var workspaceStateV2Schema = z.object({
+  schemaVersion: z.literal(2),
+  repositories: z.array(preMergeRepositorySchema),
+  tasks: z.array(
+    preArchiveTaskSchema.refine(
+      (task) => task.status !== "ready" || task.validation === void 0,
+      "Workspace schema v2 cannot contain validation results."
+    )
+  )
+}).strict();
+var workspaceStateV3Schema = z.object({
+  schemaVersion: z.literal(3),
+  repositories: z.array(preMergeRepositorySchema),
+  tasks: z.array(preArchiveTaskSchema)
+}).strict();
+var workspaceStateV4Schema = z.object({
+  schemaVersion: z.literal(4),
+  repositories: z.array(repositoryRecordSchema),
+  tasks: z.array(preArchiveTaskSchema)
+}).strict();
+var workspaceSnapshotSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("workspace-snapshot"),
+  state: workspaceStateSchema
+}).strict();
+var registerRepositoryRequestSchema = z.object({ path: absolutePathSchema }).strict();
+var createTaskRequestSchema = z.object({
+  repositoryId: entityIdSchema,
+  title: z.string().trim().min(1).max(200),
+  baseRef: z.string().trim().min(1).max(1024)
+}).strict();
+var taskArchiveRequestSchema = z.object({}).strict();
+var workspaceErrorSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("workspace-error"),
+  code: z.enum([
+    "invalid-request",
+    "repository-already-registered",
+    "repository-not-found",
+    "task-not-found",
+    "task-not-ready",
+    "task-busy",
+    "task-recovery-required",
+    "git-preflight-failed",
+    "git-conflict",
+    "git-incomplete",
+    "workspace-unavailable",
+    "internal-error"
+  ]),
+  message: z.string().min(1).max(500)
+}).strict();
+function parseWorkspaceSnapshot(value) {
+  return workspaceSnapshotSchema.parse(value);
+}
+function safeParseWorkspaceSnapshot(value) {
+  return workspaceSnapshotSchema.safeParse(value);
+}
+var TASK_REVIEW_MAX_FILES = 200;
+var TASK_REVIEW_MAX_FILE_DIFF_CHARS = 2e4;
+var TASK_REVIEW_MAX_TOTAL_DIFF_CHARS = 2e5;
+var reviewPathSchema = z.string().min(1).max(4096);
+var taskReviewFileSchema = z.object({
+  /** Opaque stable identity from the unsanitized Git status record. */
+  entryId: z.string().regex(/^[0-9a-f]{64}$/),
+  /** Repository-relative path with control characters visibly escaped. */
+  path: reviewPathSchema,
+  /** Rename/copy source path, when Git recorded one. */
+  previousPath: reviewPathSchema.nullable(),
+  kind: z.enum([
+    "added",
+    "modified",
+    "deleted",
+    "renamed",
+    "copied",
+    "type-changed",
+    "untracked",
+    "conflicted"
+  ]),
+  /** The index differs from HEAD for this path. */
+  staged: z.boolean(),
+  /** The working tree differs from the index for this path. */
+  unstaged: z.boolean(),
+  /** Git identified binary content; no text diff exists. */
+  binary: z.boolean(),
+  /**
+   * Bounded unified diff text, or null when `diffOmittedReason` explains
+   * its absence. May be empty when index and worktree states cancel out.
+   */
+  diff: z.string().max(TASK_REVIEW_MAX_FILE_DIFF_CHARS).nullable(),
+  /** True when the diff was cut at a per-file or total bound. */
+  diffTruncated: z.boolean(),
+  diffOmittedReason: z.enum(["binary", "too-large", "total-budget", "review-budget", "diff-failed"]).nullable()
+}).strict().superRefine((file, context) => {
+  if (file.diff === null === (file.diffOmittedReason === null)) {
+    context.addIssue({
+      code: "custom",
+      path: ["diff"],
+      message: "A missing diff requires exactly one omission reason."
+    });
+  }
+  if (file.binary !== (file.diffOmittedReason === "binary")) {
+    context.addIssue({
+      code: "custom",
+      path: ["binary"],
+      message: "Binary state and binary omission reason must agree."
+    });
+  }
+  if (file.diffTruncated && file.diff === null) {
+    context.addIssue({
+      code: "custom",
+      path: ["diffTruncated"],
+      message: "Only a present text diff can be truncated."
+    });
+  }
+  if ((file.kind === "renamed" || file.kind === "copied") !== (file.previousPath !== null)) {
+    context.addIssue({
+      code: "custom",
+      path: ["previousPath"],
+      message: "Only rename and copy records carry a previous path."
+    });
+  }
+});
+var taskReviewSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("task-review"),
+  taskId: entityIdSchema,
+  /** Exact worktree HEAD commit the review was derived against. */
+  headCommit: gitCommitSchema,
+  /** Current worktree branch, or null when HEAD is detached. */
+  branch: z.string().min(1).max(1024).nullable(),
+  /** True when Git reported no staged, unstaged, or untracked changes. */
+  clean: z.boolean(),
+  files: z.array(taskReviewFileSchema).max(TASK_REVIEW_MAX_FILES),
+  /** Total Git status entries, including any beyond the file cap. */
+  totalChangedFiles: nonNegativeInt,
+  /** Git status entries dropped by the file cap (reported, never silent). */
+  omittedFiles: nonNegativeInt,
+  /** True when the total diff budget cut or suppressed at least one diff. */
+  totalDiffTruncated: z.boolean(),
+  /** Unix epoch milliseconds when the daemon derived these facts. */
+  capturedAtMs: nonNegativeInt
+}).strict().superRefine((review, context) => {
+  if (review.totalChangedFiles !== review.files.length + review.omittedFiles) {
+    context.addIssue({
+      code: "custom",
+      path: ["totalChangedFiles"],
+      message: "Listed plus omitted entries must equal the total status entries."
+    });
+  }
+  if (review.clean !== (review.totalChangedFiles === 0)) {
+    context.addIssue({
+      code: "custom",
+      path: ["clean"],
+      message: "Clean state must exactly match an empty changed-file set."
+    });
+  }
+  const entryIds = /* @__PURE__ */ new Set();
+  for (const [index, file] of review.files.entries()) {
+    if (entryIds.has(file.entryId)) {
+      context.addIssue({
+        code: "custom",
+        path: ["files", index, "entryId"],
+        message: "Review entry identifiers must be unique."
+      });
+    }
+    entryIds.add(file.entryId);
+  }
+  let totalDiffChars = 0;
+  for (const file of review.files) totalDiffChars += file.diff?.length ?? 0;
+  if (totalDiffChars > TASK_REVIEW_MAX_TOTAL_DIFF_CHARS) {
+    context.addIssue({
+      code: "custom",
+      path: ["files"],
+      message: "Total diff content exceeds the task review payload bound."
+    });
+  }
+  const exhaustedReviewBudget = review.files.some(
+    (file) => file.diffOmittedReason === "total-budget" || file.diffOmittedReason === "review-budget"
+  );
+  if (exhaustedReviewBudget && !review.totalDiffTruncated) {
+    context.addIssue({
+      code: "custom",
+      path: ["totalDiffTruncated"],
+      message: "A review-level omission must mark the total diff truncated."
+    });
+  }
+});
+var taskReviewErrorSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("task-review-error"),
+  code: z.enum([
+    "invalid-request",
+    "task-not-found",
+    "task-not-ready",
+    "review-failed",
+    "internal-error"
+  ]),
+  message: z.string().min(1).max(500)
+}).strict();
+function parseTaskReview(value) {
+  return taskReviewSchema.parse(value);
+}
+function safeParseTaskReview(value) {
+  return taskReviewSchema.safeParse(value);
+}
+var TASK_COMMIT_MAX_MESSAGE_CHARS = 5e3;
+var TASK_COMMIT_MAX_FILES = TASK_REVIEW_MAX_FILES;
+var TASK_COMMIT_MAX_FILE_DIFF_CHARS = TASK_REVIEW_MAX_FILE_DIFF_CHARS;
+var TASK_COMMIT_MAX_TOTAL_DIFF_CHARS = TASK_REVIEW_MAX_TOTAL_DIFF_CHARS;
+var taskCommitMessageSchema = z.string().min(1).max(TASK_COMMIT_MAX_MESSAGE_CHARS).refine(
+  (value) => value.trim().length > 0,
+  "Commit messages must contain a non-whitespace character."
+).refine(
+  // Same visual-trust rule as validation commands: newlines and tabs are
+  // legitimate, every other invisible control/format/separator/filler
+  // character is rejected so the exact recorded message is trustworthy.
+  (value) => [...value].every(
+    (character) => character === "\n" || character === "	" || !/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}\p{Cs}\p{Default_Ignorable_Code_Point}]/u.test(character) && (!new RegExp("\\p{Zs}", "u").test(character) || character === " ") && !/[\u115F\u1160\u2800\u3164\uFFA0]/u.test(character)
+  ),
+  "Commit messages must not contain invisible control, formatting, separator, or filler characters other than newlines, tabs, and ordinary spaces."
+);
+var taskCommitPreflightRequestSchema = z.object({ message: taskCommitMessageSchema }).strict();
+var taskCommitFileSchema = z.object({
+  /** Opaque stable identity from the raw parent-vs-tree diff record. */
+  entryId: z.string().regex(/^[0-9a-f]{64}$/),
+  /** Repository-relative path with control characters visibly escaped. */
+  path: reviewPathSchema,
+  /** Rename/copy source path, when Git recorded one. */
+  previousPath: reviewPathSchema.nullable(),
+  kind: z.enum(["added", "modified", "deleted", "renamed", "copied", "type-changed"]),
+  /** Git identified binary content; no text diff exists. */
+  binary: z.boolean(),
+  /** Bounded unified diff between parent commit and frozen tree, or null. */
+  diff: z.string().max(TASK_COMMIT_MAX_FILE_DIFF_CHARS).nullable(),
+  diffTruncated: z.boolean(),
+  diffOmittedReason: z.enum(["binary", "too-large", "total-budget", "review-budget", "diff-failed"]).nullable()
+}).strict().superRefine((file, context) => {
+  if (file.diff === null === (file.diffOmittedReason === null)) {
+    context.addIssue({
+      code: "custom",
+      path: ["diff"],
+      message: "A missing diff requires exactly one omission reason."
+    });
+  }
+  if (file.binary !== (file.diffOmittedReason === "binary")) {
+    context.addIssue({
+      code: "custom",
+      path: ["binary"],
+      message: "Binary state and binary omission reason must agree."
+    });
+  }
+  if (file.diffTruncated && file.diff === null) {
+    context.addIssue({
+      code: "custom",
+      path: ["diffTruncated"],
+      message: "Only a present text diff can be truncated."
+    });
+  }
+  if ((file.kind === "renamed" || file.kind === "copied") !== (file.previousPath !== null)) {
+    context.addIssue({
+      code: "custom",
+      path: ["previousPath"],
+      message: "Only rename and copy records carry a previous path."
+    });
+  }
+});
+var taskCommitValidationVerdictSchema = z.enum([
+  "current-passed",
+  "current-failed",
+  "stale",
+  "none"
+]);
+var taskCommitPreflightSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("task-commit-preflight"),
+  taskId: entityIdSchema,
+  /** One-shot daemon-memory token; invalid after expiry, supersession, use, restart, or any state change. */
+  preflightId: entityIdSchema,
+  branch: z.string().min(1).max(1024),
+  /** Exact parent commit the frozen tree will be committed on top of. */
+  parentCommit: gitCommitSchema,
+  /** Frozen tree object; the published commit carries exactly this tree. */
+  treeOid: gitCommitSchema,
+  /** Exact user-authored commit message this approval covers. */
+  message: taskCommitMessageSchema,
+  /** Post-filter included changes, derived strictly from parent and tree. */
+  files: z.array(taskCommitFileSchema).max(TASK_COMMIT_MAX_FILES),
+  totalFiles: z.number().int().min(1),
+  omittedFiles: nonNegativeInt,
+  totalDiffTruncated: z.boolean(),
+  /** True when the commit includes content beyond the staged index. */
+  stagedDivergence: z.boolean(),
+  validationVerdict: taskCommitValidationVerdictSchema,
+  /** True for every verdict except current-passed. */
+  acknowledgementRequired: z.boolean(),
+  /** Ordinary commit hooks are always bypassed; fixed by design. */
+  hooksBypassed: z.literal(true),
+  createdAtMs: nonNegativeInt,
+  /** Unix epoch milliseconds after which this preflight cannot execute. */
+  expiresAtMs: z.number().int().positive()
+}).strict().superRefine((preflight, context) => {
+  if (preflight.totalFiles !== preflight.files.length + preflight.omittedFiles) {
+    context.addIssue({
+      code: "custom",
+      path: ["totalFiles"],
+      message: "Listed plus omitted entries must equal the total change entries."
+    });
+  }
+  if (preflight.acknowledgementRequired !== (preflight.validationVerdict !== "current-passed")) {
+    context.addIssue({
+      code: "custom",
+      path: ["acknowledgementRequired"],
+      message: "Every verdict except current-passed requires acknowledgement."
+    });
+  }
+  if (preflight.expiresAtMs <= preflight.createdAtMs) {
+    context.addIssue({
+      code: "custom",
+      path: ["expiresAtMs"],
+      message: "A preflight must expire after it was created."
+    });
+  }
+  const entryIds = /* @__PURE__ */ new Set();
+  for (const [index, file] of preflight.files.entries()) {
+    if (entryIds.has(file.entryId)) {
+      context.addIssue({
+        code: "custom",
+        path: ["files", index, "entryId"],
+        message: "Commit entry identifiers must be unique."
+      });
+    }
+    entryIds.add(file.entryId);
+  }
+  let totalDiffChars = 0;
+  for (const file of preflight.files) totalDiffChars += file.diff?.length ?? 0;
+  if (totalDiffChars > TASK_COMMIT_MAX_TOTAL_DIFF_CHARS) {
+    context.addIssue({
+      code: "custom",
+      path: ["files"],
+      message: "Total diff content exceeds the commit preflight payload bound."
+    });
+  }
+});
+var executeTaskCommitRequestSchema = z.object({
+  preflightId: entityIdSchema,
+  /**
+   * Dedicated, explicit acknowledgement that the validation verdict shown
+   * at preflight was seen. Must be true for every verdict except
+   * current-passed; never implied by the approval click alone.
+   */
+  acknowledgeValidation: z.boolean()
+}).strict();
+var taskCommitResultSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("task-commit-result"),
+  taskId: entityIdSchema,
+  branch: z.string().min(1).max(1024),
+  /** Published commit; its tree provably equals the approved treeOid. */
+  commit: gitCommitSchema,
+  treeOid: gitCommitSchema,
+  parentCommit: gitCommitSchema,
+  /** True when commit.gpgSign was enabled and the commit was signed. */
+  signed: z.boolean(),
+  /**
+   * Honest post-publication facts: the commit exists on the branch even
+   * when these are false; nothing is rolled back or repaired destructively.
+   */
+  indexSynced: z.boolean(),
+  headVerified: z.boolean(),
+  capturedAtMs: nonNegativeInt
+}).strict();
+var taskCommitErrorSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("task-commit-error"),
+  code: z.enum([
+    "invalid-request",
+    "task-not-found",
+    "task-not-ready",
+    "commit-in-progress",
+    "merge-in-progress",
+    "archive-in-progress",
+    "validation-running",
+    "agent-working",
+    "commit-conflicted",
+    "nothing-to-commit",
+    "identity-missing",
+    "state-unsupported",
+    "preflight-not-found",
+    "preflight-outdated",
+    "acknowledgement-required",
+    "branch-moved",
+    "signing-failed",
+    "commit-failed",
+    "internal-error"
+  ]),
+  message: z.string().min(1).max(500)
+}).strict();
+function parseTaskCommitPreflight(value) {
+  return taskCommitPreflightSchema.parse(value);
+}
+function safeParseTaskCommitPreflight(value) {
+  return taskCommitPreflightSchema.safeParse(value);
+}
+function parseTaskCommitResult(value) {
+  return taskCommitResultSchema.parse(value);
+}
+function safeParseTaskCommitResult(value) {
+  return taskCommitResultSchema.safeParse(value);
+}
+var TASK_MERGE_MAX_FILES = TASK_REVIEW_MAX_FILES;
+var TASK_MERGE_MAX_FILE_DIFF_CHARS = TASK_REVIEW_MAX_FILE_DIFF_CHARS;
+var TASK_MERGE_MAX_TOTAL_DIFF_CHARS = TASK_REVIEW_MAX_TOTAL_DIFF_CHARS;
+var TASK_MERGE_MAX_COMMIT_SUBJECTS = 20;
+var TASK_MERGE_MAX_COMMIT_SUBJECT_CHARS = 200;
+var TASK_MERGE_MAX_CONFLICT_PATHS = 20;
+var branchNameSchema = z.string().min(1).max(1024);
+var mergeApprovalBranchSchema = branchNameSchema.refine(
+  (value) => [...value].every(
+    (character) => !/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}\p{Cs}\p{Default_Ignorable_Code_Point}]/u.test(character) && (!new RegExp("\\p{Zs}", "u").test(character) || character === " ") && !/[\u115F\u1160\u2800\u3164\uFFA0]/u.test(character)
+  ),
+  "Merge approval branch names must not contain invisible or formatting characters."
+);
+var taskMergePreflightRequestSchema = z.object({
+  /** Optional merge-commit message; ignored for a fast-forward. */
+  message: taskCommitMessageSchema.optional()
+}).strict();
+var taskMergePreflightSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("task-merge-preflight"),
+  taskId: entityIdSchema,
+  /** One-shot daemon-memory token; invalid after expiry, supersession, use, restart, or any state change on either side. */
+  preflightId: entityIdSchema,
+  mode: taskMergeModeSchema,
+  taskBranch: mergeApprovalBranchSchema,
+  /** Fixed registered target branch; never chosen by the browser. */
+  targetBranch: mergeApprovalBranchSchema,
+  /** Exact task-branch head this approval covers. */
+  taskHead: gitCommitSchema,
+  /** Exact target-branch head this approval covers. */
+  targetHead: gitCommitSchema,
+  /** Exact merge-result tree; the published target tree equals this OID. */
+  mergedTree: gitCommitSchema,
+  /** Effective merge-commit message; null exactly for a fast-forward. */
+  mergeMessage: taskCommitMessageSchema.nullable(),
+  /** Changes the merge publishes, derived strictly from targetHead → mergedTree. */
+  files: z.array(taskCommitFileSchema).max(TASK_MERGE_MAX_FILES),
+  totalFiles: nonNegativeInt,
+  omittedFiles: nonNegativeInt,
+  totalDiffTruncated: z.boolean(),
+  /** Task commits not yet on the target branch. */
+  commitCount: z.number().int().min(1),
+  /** Escaped first-line subjects of the newest merged commits, bounded. */
+  commitSubjects: z.array(z.string().min(1).max(TASK_MERGE_MAX_COMMIT_SUBJECT_CHARS)).max(TASK_MERGE_MAX_COMMIT_SUBJECTS),
+  validationVerdict: taskCommitValidationVerdictSchema,
+  /**
+   * True when the published tree is exactly the validated task snapshot
+   * (fast-forward). A merge commit's result tree was never validated, so
+   * this is false for every merge commit.
+   */
+  validationCoversResult: z.boolean(),
+  /** True unless a fast-forward is covered by a current passing validation. */
+  acknowledgementRequired: z.boolean(),
+  /** Ordinary merge hooks are always bypassed; fixed by design. */
+  hooksBypassed: z.literal(true),
+  createdAtMs: nonNegativeInt,
+  /** Unix epoch milliseconds after which this preflight cannot execute. */
+  expiresAtMs: z.number().int().positive()
+}).strict().superRefine((preflight, context) => {
+  if (preflight.taskBranch === preflight.targetBranch) {
+    context.addIssue({
+      code: "custom",
+      path: ["targetBranch"],
+      message: "A task can never merge into its own branch."
+    });
+  }
+  if (preflight.totalFiles !== preflight.files.length + preflight.omittedFiles) {
+    context.addIssue({
+      code: "custom",
+      path: ["totalFiles"],
+      message: "Listed plus omitted entries must equal the total change entries."
+    });
+  }
+  if (preflight.mode === "fast-forward" !== (preflight.mergeMessage === null)) {
+    context.addIssue({
+      code: "custom",
+      path: ["mergeMessage"],
+      message: "Exactly the merge-commit mode carries an effective merge message."
+    });
+  }
+  if (preflight.validationCoversResult !== (preflight.mode === "fast-forward")) {
+    context.addIssue({
+      code: "custom",
+      path: ["validationCoversResult"],
+      message: "Only a fast-forward publishes the validated task snapshot itself."
+    });
+  }
+  if (preflight.acknowledgementRequired !== (preflight.validationVerdict !== "current-passed" || preflight.mode === "merge-commit")) {
+    context.addIssue({
+      code: "custom",
+      path: ["acknowledgementRequired"],
+      message: "Acknowledgement is required unless a fast-forward is covered by a current passing validation."
+    });
+  }
+  if (preflight.commitSubjects.length > preflight.commitCount) {
+    context.addIssue({
+      code: "custom",
+      path: ["commitSubjects"],
+      message: "Listed commit subjects cannot exceed the merged commit count."
+    });
+  }
+  if (preflight.expiresAtMs <= preflight.createdAtMs) {
+    context.addIssue({
+      code: "custom",
+      path: ["expiresAtMs"],
+      message: "A preflight must expire after it was created."
+    });
+  }
+  const entryIds = /* @__PURE__ */ new Set();
+  for (const [index, file] of preflight.files.entries()) {
+    if (entryIds.has(file.entryId)) {
+      context.addIssue({
+        code: "custom",
+        path: ["files", index, "entryId"],
+        message: "Merge entry identifiers must be unique."
+      });
+    }
+    entryIds.add(file.entryId);
+  }
+  let totalDiffChars = 0;
+  for (const file of preflight.files) totalDiffChars += file.diff?.length ?? 0;
+  if (totalDiffChars > TASK_MERGE_MAX_TOTAL_DIFF_CHARS) {
+    context.addIssue({
+      code: "custom",
+      path: ["files"],
+      message: "Total diff content exceeds the merge preflight payload bound."
+    });
+  }
+});
+var executeTaskMergeRequestSchema = z.object({
+  preflightId: entityIdSchema,
+  /**
+   * Dedicated, explicit acknowledgement of the validation coverage shown at
+   * preflight. Required for every preflight whose acknowledgementRequired
+   * is true; never implied by the approval click alone.
+   */
+  acknowledgeValidation: z.boolean()
+}).strict();
+var taskMergeResultSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("task-merge-result"),
+  taskId: entityIdSchema,
+  mode: taskMergeModeSchema,
+  taskBranch: mergeApprovalBranchSchema,
+  targetBranch: mergeApprovalBranchSchema,
+  /** Exact source tip whose commits and merge result were approved. */
+  taskHead: gitCommitSchema,
+  previousTargetHead: gitCommitSchema,
+  /** Published target tip; its tree provably equals the approved mergedTree. */
+  newTargetHead: gitCommitSchema,
+  /** Created merge commit; null exactly for a fast-forward. */
+  mergeCommit: gitCommitSchema.nullable(),
+  treeOid: gitCommitSchema,
+  /** True when commit.gpgSign was enabled and the merge commit was signed. */
+  signed: z.boolean(),
+  /**
+   * Honest post-publication facts: the merge is on the target branch even
+   * when these are false; nothing is rolled back or repaired destructively.
+   * A false targetSynced leaves a durable pending-sync recovery state.
+   */
+  targetSynced: z.boolean(),
+  targetHeadVerified: z.boolean(),
+  capturedAtMs: nonNegativeInt
+}).strict().superRefine((result, context) => {
+  if (result.mode === "merge-commit" !== (result.mergeCommit !== null)) {
+    context.addIssue({
+      code: "custom",
+      path: ["mergeCommit"],
+      message: "Exactly the merge-commit mode creates a new merge commit."
+    });
+  }
+  if (result.mergeCommit !== null && result.mergeCommit !== result.newTargetHead) {
+    context.addIssue({
+      code: "custom",
+      path: ["newTargetHead"],
+      message: "A published merge commit is the new target tip."
+    });
+  }
+  if (result.mode === "fast-forward" && result.signed) {
+    context.addIssue({
+      code: "custom",
+      path: ["signed"],
+      message: "A fast-forward creates no new object and is never signed by Webdesk."
+    });
+  }
+  if (result.mode === "fast-forward" && result.newTargetHead !== result.taskHead) {
+    context.addIssue({
+      code: "custom",
+      path: ["newTargetHead"],
+      message: "A fast-forward publishes the exact approved task head."
+    });
+  }
+  if (result.targetSynced && !result.targetHeadVerified) {
+    context.addIssue({
+      code: "custom",
+      path: ["targetHeadVerified"],
+      message: "A synced target checkout must also have its published head verified."
+    });
+  }
+});
+var taskMergeErrorSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("task-merge-error"),
+  code: z.enum([
+    "invalid-request",
+    "task-not-found",
+    "task-not-ready",
+    "repository-not-found",
+    "merge-in-progress",
+    "commit-in-progress",
+    "archive-in-progress",
+    "validation-running",
+    "agent-working",
+    "task-dirty",
+    "target-dirty",
+    "target-unavailable",
+    "target-mismatched",
+    "wrong-base",
+    "unrelated-histories",
+    "already-merged",
+    "nothing-to-merge",
+    "merge-conflicted",
+    "state-unsupported",
+    "target-path-occupied",
+    "identity-missing",
+    "preflight-not-found",
+    "preflight-outdated",
+    "acknowledgement-required",
+    "ref-cas-failed",
+    "publication-unknown",
+    "signing-failed",
+    "sync-pending",
+    "sync-not-pending",
+    "git-version-unsupported",
+    "merge-failed",
+    "internal-error"
+  ]),
+  message: z.string().min(1).max(500),
+  /** Escaped conflicted paths, bounded; only for merge-conflicted. */
+  conflictPaths: z.array(reviewPathSchema).max(TASK_MERGE_MAX_CONFLICT_PATHS).optional(),
+  /** Conflicted paths beyond the display bound (reported, never silent). */
+  omittedConflictPaths: nonNegativeInt.optional()
+}).strict().superRefine((error, context) => {
+  if (error.code !== "merge-conflicted" && (error.conflictPaths !== void 0 || error.omittedConflictPaths !== void 0)) {
+    context.addIssue({
+      code: "custom",
+      path: ["conflictPaths"],
+      message: "Only a merge conflict carries conflicted-path facts."
+    });
+  }
+  if (error.omittedConflictPaths !== void 0 && error.conflictPaths === void 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["omittedConflictPaths"],
+      message: "An omitted conflict count requires the retained conflicted paths."
+    });
+  }
+});
+var repositoryMergeSyncResultSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("repository-merge-sync-result"),
+  repositoryId: entityIdSchema,
+  outcome: z.enum([
+    "synced",
+    "publication-unconfirmed",
+    "publication-unconfirmed-cleared",
+    "advanced-integrated",
+    "target-moved",
+    "target-moved-cleared"
+  ]),
+  taskId: entityIdSchema,
+  mode: taskMergeModeSchema,
+  targetBranch: mergeApprovalBranchSchema,
+  previousTargetHead: gitCommitSchema,
+  newTargetHead: gitCommitSchema,
+  /** Foreign target tip observed when the ref moved externally. */
+  currentTargetHead: gitCommitSchema.nullable(),
+  pendingMergeCleared: z.boolean(),
+  capturedAtMs: nonNegativeInt
+}).strict().superRefine((result, context) => {
+  const retainsPending = ["publication-unconfirmed", "target-moved"].includes(result.outcome);
+  if (result.pendingMergeCleared !== !retainsPending) {
+    context.addIssue({
+      code: "custom",
+      path: ["pendingMergeCleared"],
+      message: "An unconfirmed or externally moved target retains the pending merge record."
+    });
+  }
+  const reportsCurrentHead = [
+    "publication-unconfirmed",
+    "publication-unconfirmed-cleared",
+    "advanced-integrated",
+    "target-moved",
+    "target-moved-cleared"
+  ].includes(result.outcome);
+  if (reportsCurrentHead !== (result.currentTargetHead !== null)) {
+    context.addIssue({
+      code: "custom",
+      path: ["currentTargetHead"],
+      message: "Unconfirmed, advanced, or externally moved outcomes report the observed tip."
+    });
+  }
+});
+var repositoryMergeSyncRequestSchema = z.object({
+  /** Explicit dismissal after Webdesk first returned the exact recovery head for inspection. */
+  acknowledgeRecoveryDismissal: z.boolean().optional().default(false)
+}).strict();
+function parseTaskMergePreflight(value) {
+  return taskMergePreflightSchema.parse(value);
+}
+function safeParseTaskMergePreflight(value) {
+  return taskMergePreflightSchema.safeParse(value);
+}
+function parseTaskMergeResult(value) {
+  return taskMergeResultSchema.parse(value);
+}
+function safeParseTaskMergeResult(value) {
+  return taskMergeResultSchema.safeParse(value);
+}
+function safeParseRepositoryMergeSyncResult(value) {
+  return repositoryMergeSyncResultSchema.safeParse(value);
+}
+var taskRuntimeStateSchema = z.enum([
+  "idle",
+  "starting",
+  "ready",
+  "needs_auth",
+  "exited",
+  "failed"
+]);
+var taskRuntimeModelSchema = runtimeModelInfoSchema;
+var taskRuntimeStatusSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("task-runtime"),
+  taskId: entityIdSchema,
+  runtimeGeneration: nonNegativeInt,
+  /** Last daemon event included in this status snapshot. */
+  lastSequence: nonNegativeInt.nullable(),
+  state: taskRuntimeStateSchema,
+  working: z.boolean(),
+  /** Current approval, if any; included so reconnect does not lose it. */
+  approval: taskApprovalSchema.nullable().default(null),
+  model: taskRuntimeModelSchema.nullable().optional(),
+  detail: z.string().max(1e3).optional()
+}).strict().superRefine((status, context) => {
+  const hasLiveCursor = status.lastSequence !== null;
+  if (status.state === "idle" === hasLiveCursor) {
+    context.addIssue({
+      code: "custom",
+      path: ["lastSequence"],
+      message: "Idle runtimes have no cursor; all other states require one."
+    });
+  }
+});
+var promptTaskRequestSchema = z.object({
+  message: z.string().trim().min(1).max(2e4)
+}).strict();
+var steerTaskRequestSchema = promptTaskRequestSchema;
+var taskSessionTreeSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("task-session-tree"),
+  taskId: taskIdSchema,
+  runtimeGeneration: nonNegativeInt,
+  sessionTree: sessionTreeSchema
+}).strict();
+function safeParseTaskSessionTree(value) {
+  return taskSessionTreeSchema.safeParse(value);
+}
+var selectTaskModelRequestSchema = z.object({
+  provider: z.string().min(1).max(200),
+  modelId: z.string().min(1).max(500)
+}).strict();
+var resolveTaskApprovalRequestSchema = z.object({
+  approvalId: z.uuid(),
+  decision: z.enum(["approve", "deny"])
+}).strict();
+var taskRuntimeErrorSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("task-runtime-error"),
+  code: z.enum([
+    "invalid-request",
+    "task-not-found",
+    "task-not-ready",
+    "runtime-not-ready",
+    "runtime-not-working",
+    "runtime-auth-required",
+    "runtime-busy",
+    "runtime-recovery-required",
+    "runtime-start-failed",
+    "runtime-request-failed",
+    "runtime-unavailable",
+    "approval-not-pending",
+    "internal-error"
+  ]),
+  message: z.string().min(1).max(500)
+}).strict();
+function parseTaskRuntimeStatus(value) {
+  return taskRuntimeStatusSchema.parse(value);
+}
+function safeParseTaskRuntimeStatus(value) {
+  return taskRuntimeStatusSchema.safeParse(value);
+}
+var piAuthMethodTypeSchema = z.enum(["api_key", "oauth"]);
+var piAuthExternalUrlSchema = z.url().max(4096).refine((value) => {
+  const url = new URL(value);
+  return url.protocol === "https:" || url.protocol === "http:" && (url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "[::1]");
+}, "Pi authentication links must use HTTPS, except for loopback HTTP callbacks");
+var piAuthMethodSchema = z.object({
+  type: piAuthMethodTypeSchema,
+  label: z.string().min(1).max(200)
+}).strict();
+var piAuthModelSchema = z.object({
+  id: z.string().min(1).max(500),
+  provider: z.string().min(1).max(200),
+  name: z.string().min(1).max(500),
+  reasoning: z.boolean()
+}).strict();
+var piAuthProviderSchema = z.object({
+  id: z.string().min(1).max(200),
+  name: z.string().min(1).max(200),
+  authenticated: z.boolean(),
+  source: z.string().min(1).max(200).optional(),
+  authType: piAuthMethodTypeSchema.optional(),
+  methods: z.array(piAuthMethodSchema),
+  models: z.array(piAuthModelSchema)
+}).strict();
+var piAuthPromptBase = {
+  id: entityIdSchema,
+  message: z.string().min(1).max(2e3)
+};
+var piAuthPromptSchema = z.discriminatedUnion("type", [
+  z.object({
+    ...piAuthPromptBase,
+    type: z.literal("text"),
+    placeholder: z.string().max(500).optional()
+  }).strict(),
+  z.object({
+    ...piAuthPromptBase,
+    type: z.literal("secret"),
+    placeholder: z.string().max(500).optional()
+  }).strict(),
+  z.object({
+    ...piAuthPromptBase,
+    type: z.literal("manual_code"),
+    placeholder: z.string().max(500).optional()
+  }).strict(),
+  z.object({
+    ...piAuthPromptBase,
+    type: z.literal("select"),
+    options: z.array(
+      z.object({
+        id: z.string().min(1).max(500),
+        label: z.string().min(1).max(500),
+        description: z.string().max(1e3).optional()
+      }).strict()
+    )
+  }).strict()
+]);
+var piAuthNoticeSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("info"),
+    message: z.string().min(1).max(2e3),
+    links: z.array(
+      z.object({
+        url: piAuthExternalUrlSchema,
+        label: z.string().max(500).optional()
+      }).strict()
+    ).optional()
+  }).strict(),
+  z.object({
+    type: z.literal("auth_url"),
+    url: piAuthExternalUrlSchema,
+    instructions: z.string().max(2e3).optional()
+  }).strict(),
+  z.object({
+    type: z.literal("device_code"),
+    userCode: z.string().min(1).max(500),
+    verificationUri: piAuthExternalUrlSchema,
+    intervalSeconds: nonNegativeInt.optional(),
+    expiresInSeconds: nonNegativeInt.optional()
+  }).strict(),
+  z.object({
+    type: z.literal("progress"),
+    message: z.string().min(1).max(2e3)
+  }).strict()
+]);
+var piAuthOperationSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("pi-auth-operation"),
+  id: entityIdSchema,
+  providerId: z.string().min(1).max(200),
+  method: piAuthMethodTypeSchema,
+  state: z.enum(["running", "waiting", "succeeded", "failed", "cancelled"]),
+  prompt: piAuthPromptSchema.nullable(),
+  notice: piAuthNoticeSchema.nullable(),
+  error: z.string().min(1).max(1e3).optional()
+}).strict();
+var piAuthSnapshotSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("pi-auth-snapshot"),
+  providers: z.array(piAuthProviderSchema),
+  /** Optional so a current client can accept an older protocol-v1 daemon snapshot. */
+  activeOperation: piAuthOperationSchema.nullable().optional()
+}).strict();
+var startPiAuthRequestSchema = z.object({
+  providerId: z.string().min(1).max(200),
+  method: piAuthMethodTypeSchema
+}).strict();
+var respondPiAuthRequestSchema = z.object({
+  promptId: entityIdSchema,
+  value: z.string().min(1).max(2e4)
+}).strict();
+var piAuthErrorSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("pi-auth-error"),
+  code: z.enum([
+    "invalid-request",
+    "operation-not-found",
+    "operation-conflict",
+    "provider-unavailable",
+    "auth-unavailable",
+    "internal-error"
+  ]),
+  message: z.string().min(1).max(500)
+}).strict();
+var PI_CONFIGURATION_MAX_RESOURCES = 500;
+var PI_CONFIGURATION_MAX_PACKAGES = 100;
+var PI_CONFIGURATION_MAX_SETTINGS = 64;
+var PI_CONFIGURATION_MAX_DIAGNOSTICS = 100;
+var piConfigurationDisplayPathSchema = z.string().max(4096);
+var piConfigurationValueSchema = z.string().max(2e3).nullable();
+var piResourceSchema = z.object({
+  kind: z.enum(["extension", "skill", "prompt", "theme"]),
+  name: z.string().min(1).max(500),
+  description: z.string().max(2e3).nullable(),
+  path: piConfigurationDisplayPathSchema,
+  scope: z.enum(["user", "project", "temporary"]),
+  origin: z.enum(["package", "top-level"]),
+  source: z.string().min(1).max(1e3),
+  enabled: z.boolean(),
+  disabledReason: z.enum(["filtered", "project-untrusted"]).nullable()
+}).strict();
+var piPackageSchema = z.object({
+  source: z.string().min(1).max(1e3),
+  scope: z.enum(["user", "project"]),
+  filtered: z.boolean(),
+  installed: z.boolean(),
+  installedPath: piConfigurationDisplayPathSchema.nullable(),
+  enabled: z.boolean()
+}).strict();
+var piSettingProjectionSchema = z.object({
+  key: z.string().min(1).max(200),
+  label: z.string().min(1).max(500),
+  category: z.enum(["model", "behavior", "display", "tools", "privacy"]),
+  globalValue: piConfigurationValueSchema,
+  projectValue: piConfigurationValueSchema,
+  effectiveValue: z.string().min(1).max(2e3),
+  effectiveScope: z.enum(["default", "user", "project"])
+}).strict();
+var piResourceDiagnosticSchema = z.object({
+  severity: z.enum(["warning", "error"]),
+  message: z.string().min(1).max(2e3),
+  path: piConfigurationDisplayPathSchema.nullable()
+}).strict();
+var piConfigurationSnapshotSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("pi-configuration-snapshot"),
+  taskId: entityIdSchema,
+  piVersion: z.string().min(1).max(100),
+  cwd: piConfigurationDisplayPathSchema,
+  agentDir: piConfigurationDisplayPathSchema,
+  settingsPaths: z.object({
+    global: piConfigurationDisplayPathSchema,
+    project: piConfigurationDisplayPathSchema,
+    trust: piConfigurationDisplayPathSchema
+  }).strict(),
+  trust: z.object({
+    required: z.boolean(),
+    effective: z.boolean(),
+    savedDecision: z.boolean().nullable(),
+    savedAtPath: piConfigurationDisplayPathSchema.nullable(),
+    defaultPolicy: z.enum(["ask", "always", "never"])
+  }).strict(),
+  packages: z.array(piPackageSchema).max(PI_CONFIGURATION_MAX_PACKAGES),
+  resources: z.array(piResourceSchema).max(PI_CONFIGURATION_MAX_RESOURCES),
+  settings: z.array(piSettingProjectionSchema).max(PI_CONFIGURATION_MAX_SETTINGS),
+  diagnostics: z.array(piResourceDiagnosticSchema).max(PI_CONFIGURATION_MAX_DIAGNOSTICS),
+  omitted: z.object({
+    packages: nonNegativeInt,
+    resources: nonNegativeInt,
+    diagnostics: nonNegativeInt
+  }).strict()
+}).strict();
+var piConfigurationErrorSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("pi-configuration-error"),
+  code: z.enum([
+    "invalid-request",
+    "task-not-found",
+    "task-not-ready",
+    "inspection-timeout",
+    "inspection-failed"
+  ]),
+  message: z.string().min(1).max(500)
+}).strict();
+var PI_SESSION_CATALOG_MAX_ENTRIES = 200;
+var piSessionCatalogItemSchema = z.object({
+  selectionId: entityIdSchema,
+  sessionId: z.string().min(1).max(500),
+  name: z.string().min(1).max(200).nullable(),
+  cwd: absolutePathSchema,
+  firstMessage: z.string().max(500),
+  createdAtMs: nonNegativeInt,
+  modifiedAtMs: nonNegativeInt,
+  messageCount: nonNegativeInt
+}).strict();
+var piSessionCatalogSnapshotSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("pi-session-catalog"),
+  sessions: z.array(piSessionCatalogItemSchema).max(PI_SESSION_CATALOG_MAX_ENTRIES),
+  omitted: nonNegativeInt,
+  expiresAtMs: nonNegativeInt
+}).strict();
+var continuePiSessionRequestSchema = z.object({
+  selectionId: entityIdSchema,
+  repositoryId: entityIdSchema,
+  title: z.string().trim().min(1).max(200),
+  baseRef: z.string().trim().min(1).max(1024)
+}).strict();
+var continuePiSessionResultSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("pi-session-continuation-result"),
+  taskId: entityIdSchema,
+  sourceSessionId: z.string().min(1).max(500),
+  continuation: z.discriminatedUnion("status", [
+    z.object({ status: z.literal("continued") }).strict(),
+    z.object({
+      status: z.literal("failed"),
+      message: z.string().min(1).max(500)
+    }).strict()
+  ]),
+  snapshot: workspaceSnapshotSchema
+}).strict();
+var piSessionCatalogErrorSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("pi-session-catalog-error"),
+  code: z.enum([
+    "invalid-request",
+    "selection-expired",
+    "session-unavailable",
+    "repository-mismatch",
+    "continuation-unavailable"
+  ]),
+  message: z.string().min(1).max(500)
+}).strict();
+var PITA_PREFERENCES_SCHEMA_VERSION = 1;
+var pitaPaletteSchema = z.enum([
+  "warm-sand",
+  "cool-slate",
+  "moss",
+  "graphite",
+  "amethyst",
+  "ocean"
+]);
+var pitaAppearancePreferencesSchema = z.object({
+  palette: pitaPaletteSchema,
+  mode: z.enum(["light", "dark", "system"]),
+  density: z.enum(["comfortable", "compact"]),
+  sidebarWidth: z.number().int().min(200).max(360),
+  sidebarVisible: z.boolean(),
+  contextPanel: z.enum(["right", "left", "hidden"])
+}).strict();
+var pitaPreferencesSnapshotSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("pita-preferences-snapshot"),
+  schemaVersion: z.literal(PITA_PREFERENCES_SCHEMA_VERSION),
+  repositoryId: entityIdSchema.nullable(),
+  global: pitaAppearancePreferencesSchema,
+  repository: pitaAppearancePreferencesSchema.nullable(),
+  effective: pitaAppearancePreferencesSchema
+}).strict();
+var updatePitaPreferencesRequestSchema = z.object({
+  scope: z.enum(["global", "repository"]),
+  repositoryId: entityIdSchema.nullable(),
+  action: z.enum(["apply", "reset"]),
+  preferences: pitaAppearancePreferencesSchema.nullable()
+}).strict().superRefine((request, context) => {
+  if (request.scope === "repository" && request.repositoryId === null) {
+    context.addIssue({
+      code: "custom",
+      path: ["repositoryId"],
+      message: "Repository preferences require a repository id."
+    });
+  }
+  if (request.action === "apply" && request.preferences === null) {
+    context.addIssue({
+      code: "custom",
+      path: ["preferences"],
+      message: "Applying preferences requires a complete preference value."
+    });
+  }
+  if (request.action === "reset" && request.preferences !== null) {
+    context.addIssue({
+      code: "custom",
+      path: ["preferences"],
+      message: "Reset requests cannot carry preference values."
+    });
+  }
+});
+var pitaPreferencesErrorSchema = z.object({
+  protocol: z.literal(PROTOCOL_VERSION),
+  type: z.literal("pita-preferences-error"),
+  code: z.enum(["invalid-request", "repository-not-found", "preferences-unavailable"]),
+  message: z.string().min(1).max(500)
+}).strict();
+export {
+  MAX_SESSION_TRANSCRIPT_ITEMS,
+  MAX_SESSION_TRANSCRIPT_TEXT_CHARS,
+  PITA_PREFERENCES_SCHEMA_VERSION,
+  PI_CONFIGURATION_MAX_DIAGNOSTICS,
+  PI_CONFIGURATION_MAX_PACKAGES,
+  PI_CONFIGURATION_MAX_RESOURCES,
+  PI_CONFIGURATION_MAX_SETTINGS,
+  PI_SESSION_CATALOG_MAX_ENTRIES,
+  PROTOCOL_VERSION,
+  TASK_COMMIT_MAX_FILES,
+  TASK_COMMIT_MAX_FILE_DIFF_CHARS,
+  TASK_COMMIT_MAX_MESSAGE_CHARS,
+  TASK_COMMIT_MAX_TOTAL_DIFF_CHARS,
+  TASK_MERGE_MAX_COMMIT_SUBJECTS,
+  TASK_MERGE_MAX_COMMIT_SUBJECT_CHARS,
+  TASK_MERGE_MAX_CONFLICT_PATHS,
+  TASK_MERGE_MAX_FILES,
+  TASK_MERGE_MAX_FILE_DIFF_CHARS,
+  TASK_MERGE_MAX_TOTAL_DIFF_CHARS,
+  TASK_REVIEW_MAX_FILES,
+  TASK_REVIEW_MAX_FILE_DIFF_CHARS,
+  TASK_REVIEW_MAX_TOTAL_DIFF_CHARS,
+  TASK_VALIDATION_MAX_COMMAND_CHARS,
+  TASK_VALIDATION_MAX_DURATION_MS,
+  TASK_VALIDATION_MAX_OUTPUT_CHARS,
+  WORKSPACE_SCHEMA_VERSION,
+  agentActivityPayloadSchema,
+  approvalRequestedPayloadSchema,
+  approvalResolvedPayloadSchema,
+  assistantDeltaPayloadSchema,
+  clientMessageSchema,
+  continuePiSessionRequestSchema,
+  continuePiSessionResultSchema,
+  createDaemonEventFactory,
+  createTaskRequestSchema,
+  daemonEventSchema,
+  executeTaskCommitRequestSchema,
+  executeTaskMergeRequestSchema,
+  logPayloadSchema,
+  parseDaemonEvent,
+  parseServerControlMessage,
+  parseServerMessage,
+  parseServiceSession,
+  parseTaskCommitPreflight,
+  parseTaskCommitResult,
+  parseTaskMergePreflight,
+  parseTaskMergeResult,
+  parseTaskReview,
+  parseTaskRuntimeSnapshot,
+  parseTaskRuntimeStatus,
+  parseTaskValidation,
+  parseWorkspaceSnapshot,
+  piAuthErrorSchema,
+  piAuthMethodSchema,
+  piAuthMethodTypeSchema,
+  piAuthModelSchema,
+  piAuthNoticeSchema,
+  piAuthOperationSchema,
+  piAuthPromptSchema,
+  piAuthProviderSchema,
+  piAuthSnapshotSchema,
+  piConfigurationErrorSchema,
+  piConfigurationSnapshotSchema,
+  piPackageSchema,
+  piResourceDiagnosticSchema,
+  piResourceSchema,
+  piSessionCatalogErrorSchema,
+  piSessionCatalogItemSchema,
+  piSessionCatalogSnapshotSchema,
+  piSettingProjectionSchema,
+  pitaAppearancePreferencesSchema,
+  pitaPaletteSchema,
+  pitaPreferencesErrorSchema,
+  pitaPreferencesSnapshotSchema,
+  promptTaskRequestSchema,
+  registerRepositoryRequestSchema,
+  repositoryMergeSyncRequestSchema,
+  repositoryMergeSyncResultSchema,
+  repositoryPendingMergeSchema,
+  repositoryRecordSchema,
+  resolveTaskApprovalRequestSchema,
+  respondPiAuthRequestSchema,
+  runTaskValidationRequestSchema,
+  runtimeModelInfoSchema,
+  runtimeProcessRecordSchema,
+  runtimeStatusPayloadSchema,
+  safeParseClientMessage,
+  safeParseDaemonEvent,
+  safeParseRepositoryMergeSyncResult,
+  safeParseServerControlMessage,
+  safeParseServerMessage,
+  safeParseServiceSession,
+  safeParseTaskCommitPreflight,
+  safeParseTaskCommitResult,
+  safeParseTaskMergePreflight,
+  safeParseTaskMergeResult,
+  safeParseTaskReview,
+  safeParseTaskRuntimeStatus,
+  safeParseTaskSessionTree,
+  safeParseTaskValidation,
+  safeParseWorkspaceSnapshot,
+  selectTaskModelRequestSchema,
+  serverControlMessageSchema,
+  serverMessageSchema,
+  serviceSessionSchema,
+  sessionTranscriptItemSchema,
+  sessionTreeNodeSchema,
+  sessionTreeSchema,
+  startPiAuthRequestSchema,
+  steerTaskRequestSchema,
+  taskApprovalSchema,
+  taskArchiveRequestSchema,
+  taskCommitErrorSchema,
+  taskCommitFileSchema,
+  taskCommitMessageSchema,
+  taskCommitPreflightRequestSchema,
+  taskCommitPreflightSchema,
+  taskCommitResultSchema,
+  taskCommitValidationVerdictSchema,
+  taskEventsErrorSchema,
+  taskEventsReplaySchema,
+  taskIdSchema,
+  taskMergeErrorSchema,
+  taskMergeModeSchema,
+  taskMergePreflightRequestSchema,
+  taskMergePreflightSchema,
+  taskMergeResultSchema,
+  taskRecordSchema,
+  taskReviewErrorSchema,
+  taskReviewFileSchema,
+  taskReviewSchema,
+  taskRuntimeErrorSchema,
+  taskRuntimeModelSchema,
+  taskRuntimeSnapshotSchema,
+  taskRuntimeStateSchema,
+  taskRuntimeStatusSchema,
+  taskSessionTreeSchema,
+  taskSubscribeMessageSchema,
+  taskValidationCommandSchema,
+  taskValidationErrorSchema,
+  taskValidationResultSchema,
+  taskValidationSchema,
+  toolActivitySchema,
+  updatePitaPreferencesRequestSchema,
+  workspaceErrorSchema,
+  workspaceSnapshotSchema,
+  workspaceStateSchema,
+  workspaceStateV1Schema,
+  workspaceStateV2Schema,
+  workspaceStateV3Schema,
+  workspaceStateV4Schema,
+  worktreeRecoveryFactsSchema
+};