@get-bb/plugin-sdk 0.4.12 → 0.4.14

package/dist/provider-bridge.js

@@ -3314,75 +3314,11 @@ var threadEventTypeSchema = z18.string().refine(
   "Invalid thread event type"
 );
 
-// ../domain/src/claude-task-tools.ts
-import { z as z19 } from "zod";
-var claudeTaskToolNameValues = [
-  "TaskCreate",
-  "TaskGet",
-  "TaskList",
-  "TaskUpdate"
-];
-var claudeTaskToolNameSchema = z19.enum(claudeTaskToolNameValues);
-var claudeTaskStatusValues = ["pending", "in_progress", "completed"];
-var claudeTaskStatusSchema = z19.enum(claudeTaskStatusValues);
-var claudeTaskUpdateStatusValues = [
-  ...claudeTaskStatusValues,
-  "deleted"
-];
-var claudeTaskUpdateStatusSchema = z19.enum(claudeTaskUpdateStatusValues);
-var claudeTaskListStatusValues = [
-  ...claudeTaskStatusValues,
-  "deleted"
-];
-var claudeTaskListStatusSchema = z19.enum(claudeTaskListStatusValues);
-var claudeTaskCreateArgsSchema = z19.object({
-  activeForm: z19.string().optional(),
-  subject: z19.string()
-}).passthrough();
-var claudeTaskGetArgsSchema = z19.object({
-  taskId: z19.string()
-}).passthrough();
-var claudeTaskUpdateArgsSchema = z19.object({
-  activeForm: z19.string().optional(),
-  status: claudeTaskUpdateStatusSchema.optional(),
-  subject: z19.string().optional(),
-  taskId: z19.string()
-}).passthrough();
-var claudeTaskCreateOutputSchema = z19.object({
-  task: z19.object({
-    id: z19.string(),
-    subject: z19.string()
-  }).passthrough()
-}).passthrough();
-var claudeTaskGetOutputTaskSchema = z19.object({
-  id: z19.string(),
-  status: claudeTaskStatusSchema,
-  subject: z19.string()
-}).passthrough();
-var claudeTaskGetOutputSchema = z19.object({
-  task: claudeTaskGetOutputTaskSchema.nullable()
-}).passthrough();
-var claudeTaskUpdateOutputSchema = z19.object({
-  success: z19.boolean(),
-  taskId: z19.string()
-}).passthrough();
-var claudeTaskListItemSchema = z19.object({
-  id: z19.string(),
-  status: claudeTaskListStatusSchema,
-  subject: z19.string()
-}).passthrough();
-var claudeTaskListOutputSchema = z19.object({
-  tasks: z19.array(z19.unknown())
-}).passthrough();
-var claudeTaskToolOutputSchema = z19.union([
-  claudeTaskCreateOutputSchema,
-  claudeTaskGetOutputSchema,
-  claudeTaskListOutputSchema,
-  claudeTaskUpdateOutputSchema
-]);
+// ../domain/src/thread.ts
+import { z as z24 } from "zod";
 
 // ../domain/src/environment.ts
-import { z as z20 } from "zod";
+import { z as z19 } from "zod";
 var environmentStatusValues = [
   "provisioning",
   "ready",
@@ -3391,49 +3327,49 @@ var environmentStatusValues = [
   "destroying",
   "destroyed"
 ];
-var environmentStatusSchema = z20.enum(environmentStatusValues);
+var environmentStatusSchema = z19.enum(environmentStatusValues);
 var WORKSPACE_PROVISION_TYPES = [
   "unmanaged",
   "managed-worktree",
   "personal"
 ];
-var workspaceProvisionTypeSchema = z20.enum(WORKSPACE_PROVISION_TYPES);
+var workspaceProvisionTypeSchema = z19.enum(WORKSPACE_PROVISION_TYPES);
 var environmentWorkspaceDisplayKindValues = [
   "managed-worktree",
   "unmanaged-worktree",
   "other"
 ];
-var environmentWorkspaceDisplayKindSchema = z20.enum(
+var environmentWorkspaceDisplayKindSchema = z19.enum(
   environmentWorkspaceDisplayKindValues
 );
-var discoveredWorkspacePropertiesSchema = z20.object({
-  path: z20.string().min(1),
-  isGitRepo: z20.boolean(),
-  isWorktree: z20.boolean(),
-  branchName: z20.string().nullable(),
-  defaultBranch: z20.string().nullable()
-});
-var environmentSchema = z20.object({
-  id: z20.string(),
-  name: z20.string().nullable(),
-  projectId: z20.string(),
-  hostId: z20.string(),
-  path: z20.string().nullable(),
-  managed: z20.boolean(),
-  isGitRepo: z20.boolean(),
-  isWorktree: z20.boolean(),
+var discoveredWorkspacePropertiesSchema = z19.object({
+  path: z19.string().min(1),
+  isGitRepo: z19.boolean(),
+  isWorktree: z19.boolean(),
+  branchName: z19.string().nullable(),
+  defaultBranch: z19.string().nullable()
+});
+var environmentSchema = z19.object({
+  id: z19.string(),
+  name: z19.string().nullable(),
+  projectId: z19.string(),
+  hostId: z19.string(),
+  path: z19.string().nullable(),
+  managed: z19.boolean(),
+  isGitRepo: z19.boolean(),
+  isWorktree: z19.boolean(),
   workspaceProvisionType: workspaceProvisionTypeSchema,
-  branchName: z20.string().nullable(),
-  baseBranch: z20.string().nullable(),
-  defaultBranch: z20.string().nullable(),
-  mergeBaseBranch: z20.string().nullable(),
+  branchName: z19.string().nullable(),
+  baseBranch: z19.string().nullable(),
+  defaultBranch: z19.string().nullable(),
+  mergeBaseBranch: z19.string().nullable(),
   status: environmentStatusSchema,
-  createdAt: z20.number(),
-  updatedAt: z20.number()
+  createdAt: z19.number(),
+  updatedAt: z19.number()
 });
 
 // ../domain/src/git-checkout.ts
-import { z as z21 } from "zod";
+import { z as z20 } from "zod";
 var gitBranchForbiddenCharacterPattern = /[\u0000-\u001f\u007f\\:~^?*\[]/u;
 var gitBranchWhitespacePattern = /[ \t]/u;
 var gitReservedBranchNames = /* @__PURE__ */ new Set([
@@ -3452,74 +3388,74 @@ function isValidGitBranchName(name) {
     (component) => component.length > 0 && !component.startsWith(".") && !component.endsWith(".lock")
   );
 }
-var gitBranchNameSchema = z21.string().refine(isValidGitBranchName, { message: "Invalid git branch name" });
-var gitCheckoutRefSchema = z21.discriminatedUnion("kind", [
-  z21.object({
-    kind: z21.literal("branch"),
-    branchName: z21.string().min(1),
-    headSha: z21.string().min(1).nullable()
-  }),
-  z21.object({
-    kind: z21.literal("detached"),
-    headSha: z21.string().min(1).nullable()
-  }),
-  z21.object({
-    kind: z21.literal("unborn"),
-    branchName: z21.string().min(1).nullable()
-  }),
-  z21.object({
-    kind: z21.literal("unknown"),
-    reason: z21.string().min(1)
+var gitBranchNameSchema = z20.string().refine(isValidGitBranchName, { message: "Invalid git branch name" });
+var gitCheckoutRefSchema = z20.discriminatedUnion("kind", [
+  z20.object({
+    kind: z20.literal("branch"),
+    branchName: z20.string().min(1),
+    headSha: z20.string().min(1).nullable()
+  }),
+  z20.object({
+    kind: z20.literal("detached"),
+    headSha: z20.string().min(1).nullable()
+  }),
+  z20.object({
+    kind: z20.literal("unborn"),
+    branchName: z20.string().min(1).nullable()
+  }),
+  z20.object({
+    kind: z20.literal("unknown"),
+    reason: z20.string().min(1)
   })
 ]);
-var workspaceGitOperationSchema = z21.discriminatedUnion("kind", [
-  z21.object({ kind: z21.literal("none") }),
-  z21.object({
-    kind: z21.literal("merge"),
-    hasConflicts: z21.boolean()
-  }),
-  z21.object({
-    kind: z21.literal("rebase"),
-    hasConflicts: z21.boolean()
-  }),
-  z21.object({
-    kind: z21.literal("cherry-pick"),
-    hasConflicts: z21.boolean()
-  }),
-  z21.object({
-    kind: z21.literal("revert"),
-    hasConflicts: z21.boolean()
-  }),
-  z21.object({
-    kind: z21.literal("unknown"),
-    reason: z21.string().min(1),
-    hasConflicts: z21.boolean()
+var workspaceGitOperationSchema = z20.discriminatedUnion("kind", [
+  z20.object({ kind: z20.literal("none") }),
+  z20.object({
+    kind: z20.literal("merge"),
+    hasConflicts: z20.boolean()
+  }),
+  z20.object({
+    kind: z20.literal("rebase"),
+    hasConflicts: z20.boolean()
+  }),
+  z20.object({
+    kind: z20.literal("cherry-pick"),
+    hasConflicts: z20.boolean()
+  }),
+  z20.object({
+    kind: z20.literal("revert"),
+    hasConflicts: z20.boolean()
+  }),
+  z20.object({
+    kind: z20.literal("unknown"),
+    reason: z20.string().min(1),
+    hasConflicts: z20.boolean()
   })
 ]);
-var gitBranchRefClassificationSchema = z21.object({
-  name: z21.string().min(1),
-  kind: z21.enum(["local", "remote", "missing"])
+var gitBranchRefClassificationSchema = z20.object({
+  name: z20.string().min(1),
+  kind: z20.enum(["local", "remote", "missing"])
 });
-var defaultBranchRelationSchema = z21.enum([
+var defaultBranchRelationSchema = z20.enum([
   "equal",
   "local-behind",
   "local-ahead",
   "diverged",
   "unknown"
 ]);
-var projectSourceCheckoutSchema = z21.object({
+var projectSourceCheckoutSchema = z20.object({
   /** Local branches under refs/heads, safe for checkout and write targets. */
-  branches: z21.array(z21.string()),
-  branchesTruncated: z21.boolean(),
+  branches: z20.array(z20.string()),
+  branchesTruncated: z20.boolean(),
   checkout: gitCheckoutRefSchema,
-  defaultBranch: z21.string().min(1).nullable(),
+  defaultBranch: z20.string().min(1).nullable(),
   defaultBranchRelation: defaultBranchRelationSchema.nullable(),
-  hasUncommittedChanges: z21.boolean(),
+  hasUncommittedChanges: z20.boolean(),
   operation: workspaceGitOperationSchema,
-  originDefaultBranch: z21.string().min(1).nullable(),
+  originDefaultBranch: z20.string().min(1).nullable(),
   /** Remote-tracking branches under refs/remotes, for base/diff selection. */
-  remoteBranches: z21.array(z21.string()),
-  remoteBranchesTruncated: z21.boolean(),
+  remoteBranches: z20.array(z20.string()),
+  remoteBranchesTruncated: z20.boolean(),
   /**
    * Exact classification of the requested branch/ref, resolved before branch
    * list pagination so callers can validate selected refs even when they are
@@ -3528,269 +3464,8 @@ var projectSourceCheckoutSchema = z21.object({
   selectedBranch: gitBranchRefClassificationSchema.nullable()
 });
 
-// ../domain/src/host-list-limits.ts
-var FILE_LIST_QUERY_MAX_LENGTH = 256;
-var FILE_LIST_LIMIT_MAX = 1e4;
-var BRANCH_LIST_QUERY_MAX_LENGTH = 256;
-var BRANCH_LIST_LIMIT_MAX = 1e3;
-
-// ../domain/src/number-utils.ts
-function toPositiveNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
-}
-
-// ../domain/src/provider-fork.ts
-import { z as z22 } from "zod";
-var PROVIDER_FORK_VALUES = ["none", "tip", "checkpoint"];
-var providerForkSchema = z22.enum(PROVIDER_FORK_VALUES);
-
-// ../domain/src/provider-types.ts
-import { z as z23 } from "zod";
-var modelReasoningEffortSchema = z23.object({
-  reasoningEffort: reasoningLevelSchema,
-  description: z23.string()
-});
-var availableModelSchema = z23.object({
-  id: z23.string(),
-  model: z23.string(),
-  displayName: z23.string(),
-  /** Provider route used to run this model when it is distinct from the
-   * selected agent provider (for example, a model provider nested under Pi). */
-  routeProviderId: z23.string().min(1).optional(),
-  description: z23.string(),
-  supportedReasoningEfforts: z23.array(modelReasoningEffortSchema),
-  defaultReasoningEffort: reasoningLevelSchema,
-  isDefault: z23.boolean()
-});
-var providerCapabilitiesSchema = z23.object({
-  supportsThreadArchive: z23.boolean(),
-  supportsThreadRename: z23.boolean(),
-  supportsServiceTier: z23.boolean(),
-  supportsNativeUserQuestion: z23.boolean(),
-  supportsFork: z23.boolean(),
-  /**
-   * The provider can recreate a session at an earlier point, which is what
-   * edit-past-message rewind needs. Separate from `supportsFork`: ACP clones
-   * whole sessions (tip-only) and cannot stop at a checkpoint.
-   */
-  supportsSessionRewind: z23.boolean(),
-  permissionModes: z23.array(permissionModeSchema).min(1)
-});
-var providerComposerCommandSchema = z23.object({
-  trigger: promptMentionCommandTriggerSchema,
-  name: z23.string().min(1).regex(/^[^\s/$]+$/u),
-  trailingText: z23.string().regex(/^\s*$/u)
-});
-var providerComposerActionSchema = z23.discriminatedUnion("kind", [
-  z23.object({
-    kind: z23.literal("skills"),
-    trigger: promptMentionCommandTriggerSchema
-  }),
-  z23.object({
-    kind: z23.literal("plan"),
-    command: providerComposerCommandSchema
-  }),
-  z23.object({
-    kind: z23.literal("goal"),
-    command: providerComposerCommandSchema
-  })
-]);
-var providerStringsSchema = z23.object({
-  /** How to sign in on the host ("Run `claude` on the machine to sign in."). */
-  signInHint: z23.string().min(1),
-  /** Shown when a session's credentials expired. */
-  expiredHint: z23.string().min(1),
-  /** Where to install the agent. */
-  installUrl: z23.string().min(1),
-  /** Brand prefix stripped from model display names ("Claude "). */
-  brandPrefix: z23.string().min(1).optional(),
-  /** Plan-mode banner copy for providers that declare the `plan` action. */
-  planModeCopy: z23.string().min(1).optional(),
-  /** Per-theme tint for the provider icon. */
-  iconTint: z23.object({ light: z23.string().min(1), dark: z23.string().min(1) }).optional()
-});
-var providerOptionDescriptorSchema = z23.object({
-  id: z23.string().min(1),
-  label: z23.string().min(1),
-  description: z23.string().min(1).optional()
-});
-var providerExtensionKindInfoSchema = z23.object({
-  item: z23.boolean(),
-  state: z23.boolean()
-});
-var providerExtensionKindsSchema = z23.record(
-  extensionKindSchema,
-  providerExtensionKindInfoSchema
-);
-var providerInfoSchema = z23.object({
-  id: z23.string(),
-  displayName: z23.string(),
-  /**
-   * Declared grouping key shared by related providers (the ACP agents).
-   * Absent when the provider declared none. Grouping only.
-   */
-  family: z23.string().min(1).optional(),
-  logoUrl: z23.string().min(1).nullable(),
-  /** Sessionless maintenance methods declared by the provider plugin. */
-  experimental_providerHealth: z23.boolean(),
-  experimental_providerUsage: z23.boolean(),
-  experimental_providerInstallation: z23.boolean(),
-  capabilities: providerCapabilitiesSchema,
-  composerActions: z23.array(providerComposerActionSchema),
-  available: z23.boolean(),
-  // -------------------------------------------------------------------------
-  // Target-state projection (docs/provider-plugin-api.md §1). Optional and
-  // unfilled until WS2a projects them from the plugin declaration; absence
-  // means "the provider declared none", never a default. The `experimental_*`
-  // and `capabilities.supports*` fields above stay until WS2a stabilizes the
-  // surface as one unit.
-  // -------------------------------------------------------------------------
-  strings: providerStringsSchema.optional(),
-  serviceTiers: z23.array(providerOptionDescriptorSchema).optional(),
-  reasoningLevels: z23.array(providerOptionDescriptorSchema).optional(),
-  extensionKinds: providerExtensionKindsSchema.optional()
-});
-var providerRecoveryKindValues = [
-  "sessionArchived",
-  "authRequired",
-  "restartRecommended",
-  "staleTurn",
-  "rateLimited"
-];
-var providerRecoveryKindSchema = z23.enum(providerRecoveryKindValues);
-var toolCallOutputItemSchema = z23.discriminatedUnion("type", [
-  z23.object({
-    type: z23.literal("inputText"),
-    text: z23.string()
-  }),
-  z23.object({
-    type: z23.literal("inputImage"),
-    imageUrl: z23.string()
-  })
-]);
-var toolCallRequestSchema = z23.object({
-  requestId: z23.union([z23.string().min(1), z23.number()]),
-  threadId: z23.string().min(1),
-  providerThreadId: z23.string().min(1),
-  turnId: z23.string().min(1),
-  callId: z23.string().min(1),
-  tool: z23.string().min(1),
-  arguments: z23.unknown().optional()
-});
-var toolCallResponseSchema = z23.object({
-  contentItems: z23.array(toolCallOutputItemSchema),
-  success: z23.boolean()
-});
-var dynamicToolSchema = z23.object({
-  name: z23.string(),
-  description: z23.string(),
-  inputSchema: z23.unknown(),
-  presentation: threadEventItemPresentationSchema.optional()
-});
-
-// ../domain/src/reasoning-efforts.ts
-var NONE_REASONING_EFFORT = {
-  reasoningEffort: "none",
-  description: "No extended thinking"
-};
-var LOW_REASONING_EFFORT = {
-  reasoningEffort: "low",
-  description: "Low reasoning effort"
-};
-var MEDIUM_REASONING_EFFORT = {
-  reasoningEffort: "medium",
-  description: "Medium reasoning effort"
-};
-var HIGH_REASONING_EFFORT = {
-  reasoningEffort: "high",
-  description: "High reasoning effort"
-};
-var XHIGH_REASONING_EFFORT = {
-  reasoningEffort: "xhigh",
-  description: "Extra high reasoning effort"
-};
-var ULTRACODE_REASONING_EFFORT = {
-  reasoningEffort: "ultracode",
-  description: "Extra high reasoning effort plus multi-agent workflow orchestration"
-};
-var MAX_REASONING_EFFORT = {
-  reasoningEffort: "max",
-  description: "Maximum reasoning effort"
-};
-var ULTRA_REASONING_EFFORT = {
-  reasoningEffort: "ultra",
-  description: "Maximum reasoning with automatic task delegation"
-};
-var REASONING_EFFORT_BY_LEVEL = {
-  none: NONE_REASONING_EFFORT,
-  low: LOW_REASONING_EFFORT,
-  medium: MEDIUM_REASONING_EFFORT,
-  high: HIGH_REASONING_EFFORT,
-  xhigh: XHIGH_REASONING_EFFORT,
-  ultracode: ULTRACODE_REASONING_EFFORT,
-  max: MAX_REASONING_EFFORT,
-  ultra: ULTRA_REASONING_EFFORT
-};
-function reasoningEffortsForLevels(levels) {
-  return levels.map((level) => ({ ...REASONING_EFFORT_BY_LEVEL[level] }));
-}
-
-// ../domain/src/thread-git-diff.ts
-import { z as z24 } from "zod";
-var workspaceDiffTargetSchema = z24.discriminatedUnion("type", [
-  z24.object({
-    type: z24.literal("uncommitted")
-  }),
-  z24.object({
-    type: z24.literal("branch_committed"),
-    mergeBaseBranch: z24.string().min(1)
-  }),
-  z24.object({
-    type: z24.literal("all"),
-    mergeBaseBranch: z24.string().min(1)
-  }),
-  z24.object({
-    type: z24.literal("commit"),
-    sha: z24.string().regex(/^[0-9a-f]{4,40}$/iu)
-  })
-]);
-var rawDiffFileStatSchema = z24.object({
-  path: z24.string(),
-  previousPath: z24.string().nullable(),
-  statusLetter: z24.enum(["A", "M", "D", "R", "C", "T"]),
-  additions: z24.number().int().nonnegative(),
-  deletions: z24.number().int().nonnegative(),
-  binary: z24.boolean(),
-  origin: z24.enum(["tracked", "untracked"])
-});
-var threadGitDiffResponseSchema = z24.object({
-  diff: z24.string(),
-  truncated: z24.boolean(),
-  shortstat: z24.string(),
-  files: z24.string(),
-  /**
-   * Resolved merge-base SHA for `branch_committed` / `all` targets — the
-   * exact ref the diff was computed against. `null` for targets that don't
-   * use a merge-base (`uncommitted`, `commit`), and also when no merge-base
-   * exists (e.g. the branch has been removed locally). Callers fetching
-   * per-file content for context expansion must pass this SHA as the
-   * "old side" ref so the file content lines up with the diff's hunk
-   * coordinates — passing the branch name reads from its current tip, which
-   * may have diverged past the merge-base.
-   */
-  mergeBaseRef: z24.string().nullable()
-});
-
-// ../domain/src/thread-visibility.ts
-import { z as z25 } from "zod";
-var threadVisibilityValues = ["visible", "hidden"];
-var threadVisibilitySchema = z25.enum(threadVisibilityValues);
-
-// ../domain/src/thread.ts
-import { z as z28 } from "zod";
-
 // ../domain/src/thread-status.ts
-import { z as z26 } from "zod";
+import { z as z21 } from "zod";
 var threadStatusValues = [
   "idle",
   "starting",
@@ -3798,12 +3473,17 @@ var threadStatusValues = [
   "stopping",
   "error"
 ];
-var threadStatusSchema = z26.enum(threadStatusValues);
+var threadStatusSchema = z21.enum(threadStatusValues);
 
 // ../domain/src/thread-origin-kind.ts
-import { z as z27 } from "zod";
+import { z as z22 } from "zod";
 var threadOriginKindValues = ["fork"];
-var threadOriginKindSchema = z27.enum(threadOriginKindValues);
+var threadOriginKindSchema = z22.enum(threadOriginKindValues);
+
+// ../domain/src/thread-visibility.ts
+import { z as z23 } from "zod";
+var threadVisibilityValues = ["visible", "hidden"];
+var threadVisibilitySchema = z23.enum(threadVisibilityValues);
 
 // ../domain/src/thread.ts
 var threadRuntimeDisplayStatusValues = [
@@ -3812,19 +3492,19 @@ var threadRuntimeDisplayStatusValues = [
   "host-reconnecting",
   "waiting-for-host"
 ];
-var threadRuntimeDisplayStatusSchema = z28.enum(
+var threadRuntimeDisplayStatusSchema = z24.enum(
   threadRuntimeDisplayStatusValues
 );
-var threadRuntimeStateSchema = z28.object({
+var threadRuntimeStateSchema = z24.object({
   displayStatus: threadRuntimeDisplayStatusSchema,
-  hostReconnectGraceExpiresAt: z28.number().nullable()
+  hostReconnectGraceExpiresAt: z24.number().nullable()
 });
-var threadActivityStateSchema = z28.object({
-  activeWorkflowCount: z28.number().int().nonnegative(),
-  activeBackgroundAgentCount: z28.number().int().nonnegative(),
-  activeBackgroundCommandCount: z28.number().int().nonnegative(),
-  activePlanModeCount: z28.number().int().nonnegative(),
-  activeGoalCount: z28.number().int().nonnegative()
+var threadActivityStateSchema = z24.object({
+  activeWorkflowCount: z24.number().int().nonnegative(),
+  activeBackgroundAgentCount: z24.number().int().nonnegative(),
+  activeBackgroundCommandCount: z24.number().int().nonnegative(),
+  activePlanModeCount: z24.number().int().nonnegative(),
+  activeGoalCount: z24.number().int().nonnegative()
 });
 var workspaceStateValues = [
   "clean",
@@ -3833,8 +3513,8 @@ var workspaceStateValues = [
   "committed_unmerged",
   "dirty_and_committed_unmerged"
 ];
-var workspaceStateSchema = z28.enum(workspaceStateValues);
-var workspaceFileStatusKindSchema = z28.enum([
+var workspaceStateSchema = z24.enum(workspaceStateValues);
+var workspaceFileStatusKindSchema = z24.enum([
   "M",
   "A",
   "D",
@@ -3849,60 +3529,60 @@ var workspaceFileStatusKindSchema = z28.enum([
    */
   "?"
 ]);
-var workspaceFileStatusSchema = z28.object({
-  path: z28.string(),
+var workspaceFileStatusSchema = z24.object({
+  path: z24.string(),
   status: workspaceFileStatusKindSchema,
   /**
    * Per-file line counts from `git diff --numstat`. Null when the count is
    * unknown — binary files (numstat reports `-`) and untracked files (numstat
    * does not include them).
    */
-  insertions: z28.number().nullable(),
-  deletions: z28.number().nullable()
-});
-var workspaceCommitSummarySchema = z28.object({
-  sha: z28.string(),
-  shortSha: z28.string(),
-  subject: z28.string(),
-  authorName: z28.string(),
-  authoredAt: z28.number()
-});
-var workspaceChangeStatsSchema = z28.object({
-  insertions: z28.number(),
-  deletions: z28.number(),
+  insertions: z24.number().nullable(),
+  deletions: z24.number().nullable()
+});
+var workspaceCommitSummarySchema = z24.object({
+  sha: z24.string(),
+  shortSha: z24.string(),
+  subject: z24.string(),
+  authorName: z24.string(),
+  authoredAt: z24.number()
+});
+var workspaceChangeStatsSchema = z24.object({
+  insertions: z24.number(),
+  deletions: z24.number(),
   /** False when line totals omit files whose contents were intentionally not read. */
-  lineStatsComplete: z28.boolean(),
-  files: z28.array(workspaceFileStatusSchema)
+  lineStatsComplete: z24.boolean(),
+  files: z24.array(workspaceFileStatusSchema)
 });
 var workspaceWorkingTreeSchema = workspaceChangeStatsSchema.extend({
-  hasUncommittedChanges: z28.boolean(),
+  hasUncommittedChanges: z24.boolean(),
   state: workspaceStateSchema
 });
-var workspaceBranchSchema = z28.object({
-  currentBranch: z28.string().nullable(),
-  defaultBranch: z28.string()
+var workspaceBranchSchema = z24.object({
+  currentBranch: z24.string().nullable(),
+  defaultBranch: z24.string()
 });
 var workspaceMergeBaseSchema = workspaceChangeStatsSchema.extend({
-  mergeBaseBranch: z28.string(),
-  baseRef: z28.string().nullable(),
-  aheadCount: z28.number(),
-  behindCount: z28.number(),
-  hasCommittedUnmergedChanges: z28.boolean(),
-  commits: z28.array(workspaceCommitSummarySchema)
-});
-var workspaceStatusSchema = z28.object({
+  mergeBaseBranch: z24.string(),
+  baseRef: z24.string().nullable(),
+  aheadCount: z24.number(),
+  behindCount: z24.number(),
+  hasCommittedUnmergedChanges: z24.boolean(),
+  commits: z24.array(workspaceCommitSummarySchema)
+});
+var workspaceStatusSchema = z24.object({
   workingTree: workspaceWorkingTreeSchema,
   checkout: gitCheckoutRefSchema,
   branch: workspaceBranchSchema,
   mergeBase: workspaceMergeBaseSchema.nullable()
 });
-var gitHostPullRequestCheckStatusSchema = z28.enum([
+var gitHostPullRequestCheckStatusSchema = z24.enum([
   "queued",
   "in_progress",
   "completed",
   "unknown"
 ]);
-var gitHostPullRequestCheckConclusionSchema = z28.enum([
+var gitHostPullRequestCheckConclusionSchema = z24.enum([
   "success",
   "failure",
   "cancelled",
@@ -3914,19 +3594,19 @@ var gitHostPullRequestCheckConclusionSchema = z28.enum([
   "stale",
   "unknown"
 ]);
-var gitHostPullRequestCheckSchema = z28.object({
-  name: z28.string().min(1),
+var gitHostPullRequestCheckSchema = z24.object({
+  name: z24.string().min(1),
   status: gitHostPullRequestCheckStatusSchema,
   conclusion: gitHostPullRequestCheckConclusionSchema.nullable(),
-  url: z28.string().url().nullable(),
-  startedAt: z28.string().datetime().nullable()
+  url: z24.string().url().nullable(),
+  startedAt: z24.string().datetime().nullable()
 }).strict();
-var gitHostPullRequestReviewDecisionSchema = z28.enum([
+var gitHostPullRequestReviewDecisionSchema = z24.enum([
   "APPROVED",
   "CHANGES_REQUESTED",
   "REVIEW_REQUIRED"
 ]);
-var gitHostPullRequestMergeStateStatusSchema = z28.enum([
+var gitHostPullRequestMergeStateStatusSchema = z24.enum([
   "BEHIND",
   "BLOCKED",
   "CLEAN",
@@ -3936,65 +3616,65 @@ var gitHostPullRequestMergeStateStatusSchema = z28.enum([
   "UNKNOWN",
   "UNSTABLE"
 ]);
-var gitHostPullRequestMergeableSchema = z28.enum([
+var gitHostPullRequestMergeableSchema = z24.enum([
   "CONFLICTING",
   "MERGEABLE",
   "UNKNOWN"
 ]);
-var gitHostPullRequestSchema = z28.object({
-  number: z28.number().int().positive(),
-  title: z28.string(),
-  state: z28.enum(["OPEN", "CLOSED", "MERGED"]),
-  url: z28.string().url(),
-  isDraft: z28.boolean(),
-  baseRefName: z28.string(),
-  headRefName: z28.string(),
-  updatedAt: z28.string().datetime(),
-  checks: z28.array(gitHostPullRequestCheckSchema),
+var gitHostPullRequestSchema = z24.object({
+  number: z24.number().int().positive(),
+  title: z24.string(),
+  state: z24.enum(["OPEN", "CLOSED", "MERGED"]),
+  url: z24.string().url(),
+  isDraft: z24.boolean(),
+  baseRefName: z24.string(),
+  headRefName: z24.string(),
+  updatedAt: z24.string().datetime(),
+  checks: z24.array(gitHostPullRequestCheckSchema),
   reviewDecision: gitHostPullRequestReviewDecisionSchema.nullable(),
-  reviewRequestCount: z28.number().int().nonnegative(),
+  reviewRequestCount: z24.number().int().nonnegative(),
   mergeStateStatus: gitHostPullRequestMergeStateStatusSchema.nullable(),
   mergeable: gitHostPullRequestMergeableSchema.nullable()
 }).strict();
-var pullRequestStateSchema = z28.enum(["draft", "open", "merged", "closed"]);
-var threadPullRequestChecksStateSchema = z28.enum([
+var pullRequestStateSchema = z24.enum(["draft", "open", "merged", "closed"]);
+var threadPullRequestChecksStateSchema = z24.enum([
   "passing",
   "failing",
   "pending",
   "no_checks",
   "unknown"
 ]);
-var threadPullRequestChecksSchema = z28.object({
+var threadPullRequestChecksSchema = z24.object({
   state: threadPullRequestChecksStateSchema,
-  totalCount: z28.number().int().nonnegative(),
-  passedCount: z28.number().int().nonnegative(),
-  failedCount: z28.number().int().nonnegative(),
-  pendingCount: z28.number().int().nonnegative()
+  totalCount: z24.number().int().nonnegative(),
+  passedCount: z24.number().int().nonnegative(),
+  failedCount: z24.number().int().nonnegative(),
+  pendingCount: z24.number().int().nonnegative()
 }).strict();
-var threadPullRequestReviewStateSchema = z28.enum([
+var threadPullRequestReviewStateSchema = z24.enum([
   "approved",
   "changes_requested",
   "review_required",
   "review_requested",
   "none"
 ]);
-var threadPullRequestReviewSchema = z28.object({
+var threadPullRequestReviewSchema = z24.object({
   state: threadPullRequestReviewStateSchema,
-  reviewRequestCount: z28.number().int().nonnegative()
+  reviewRequestCount: z24.number().int().nonnegative()
 }).strict();
-var threadPullRequestMergeabilityStateSchema = z28.enum([
+var threadPullRequestMergeabilityStateSchema = z24.enum([
   "mergeable",
   "conflicts",
   "blocked",
   "draft",
   "unknown"
 ]);
-var threadPullRequestMergeabilitySchema = z28.object({
+var threadPullRequestMergeabilitySchema = z24.object({
   state: threadPullRequestMergeabilityStateSchema,
   mergeStateStatus: gitHostPullRequestMergeStateStatusSchema.nullable(),
   mergeable: gitHostPullRequestMergeableSchema.nullable()
 }).strict();
-var threadPullRequestAttentionStateSchema = z28.enum([
+var threadPullRequestAttentionStateSchema = z24.enum([
   "checks_failed",
   "checks_pending",
   "changes_requested",
@@ -4007,66 +3687,386 @@ var threadPullRequestAttentionStateSchema = z28.enum([
   "closed",
   "none"
 ]);
-var threadPullRequestSchema = z28.object({
-  number: z28.number().int().positive(),
-  title: z28.string(),
+var threadPullRequestSchema = z24.object({
+  number: z24.number().int().positive(),
+  title: z24.string(),
   state: pullRequestStateSchema,
-  url: z28.string().url(),
-  baseRefName: z28.string(),
-  headRefName: z28.string(),
-  updatedAt: z28.string().datetime(),
+  url: z24.string().url(),
+  baseRefName: z24.string(),
+  headRefName: z24.string(),
+  updatedAt: z24.string().datetime(),
   checks: threadPullRequestChecksSchema,
   review: threadPullRequestReviewSchema,
   mergeability: threadPullRequestMergeabilitySchema,
   attention: threadPullRequestAttentionStateSchema
 }).strict();
-var threadQueuedMessageSchema = z28.object({
-  id: z28.string(),
-  content: z28.array(promptInputSchema).min(1),
-  model: z28.string().min(1),
+var threadQueuedMessageSchema = z24.object({
+  id: z24.string(),
+  content: z24.array(promptInputSchema).min(1),
+  model: z24.string().min(1),
   reasoningLevel: reasoningLevelSchema,
   permissionMode: permissionModeSchema,
   serviceTier: serviceTierSchema,
-  groupWithNext: z28.boolean(),
-  createdAt: z28.number(),
-  updatedAt: z28.number()
-});
-var threadSchema = z28.object({
-  id: z28.string(),
-  projectId: z28.string(),
-  environmentId: z28.string().nullable(),
-  providerId: z28.string(),
-  title: z28.string().nullable(),
-  titleFallback: z28.string().nullable(),
-  sectionId: z28.string().nullable(),
+  groupWithNext: z24.boolean(),
+  createdAt: z24.number(),
+  updatedAt: z24.number()
+});
+var threadSchema = z24.object({
+  id: z24.string(),
+  projectId: z24.string(),
+  environmentId: z24.string().nullable(),
+  providerId: z24.string(),
+  title: z24.string().nullable(),
+  titleFallback: z24.string().nullable(),
+  sectionId: z24.string().nullable(),
   status: threadStatusSchema,
-  parentThreadId: z28.string().nullable(),
-  sourceThreadId: z28.string().nullable(),
+  parentThreadId: z24.string().nullable(),
+  sourceThreadId: z24.string().nullable(),
   originKind: threadOriginKindSchema.nullable(),
   /** Id of the plugin that spawned this thread; null for non-plugin origins. */
-  originPluginId: z28.string().nullable(),
+  originPluginId: z24.string().nullable(),
   visibility: threadVisibilitySchema,
-  archivedAt: z28.number().nullable(),
-  pinnedAt: z28.number().nullable(),
-  deletedAt: z28.number().nullable(),
-  lastReadAt: z28.number().nullable(),
-  latestAttentionAt: z28.number(),
-  createdAt: z28.number(),
-  updatedAt: z28.number()
+  archivedAt: z24.number().nullable(),
+  pinnedAt: z24.number().nullable(),
+  deletedAt: z24.number().nullable(),
+  lastReadAt: z24.number().nullable(),
+  latestAttentionAt: z24.number(),
+  createdAt: z24.number(),
+  updatedAt: z24.number()
 });
 var threadWithRuntimeSchema = threadSchema.extend({
   runtime: threadRuntimeStateSchema
 });
 var threadListEntrySchema = threadWithRuntimeSchema.extend({
   activity: threadActivityStateSchema,
-  pinSortKey: z28.string().nullable(),
-  hasPendingInteraction: z28.boolean(),
-  environmentHostId: z28.string().nullable(),
-  environmentName: z28.string().nullable(),
-  environmentBranchName: z28.string().nullable(),
+  pinSortKey: z24.string().nullable(),
+  hasPendingInteraction: z24.boolean(),
+  environmentHostId: z24.string().nullable(),
+  environmentName: z24.string().nullable(),
+  environmentBranchName: z24.string().nullable(),
   environmentWorkspaceDisplayKind: environmentWorkspaceDisplayKindSchema
 });
 
+// ../domain/src/claude-task-tools.ts
+import { z as z25 } from "zod";
+var claudeTaskToolNameValues = [
+  "TaskCreate",
+  "TaskGet",
+  "TaskList",
+  "TaskUpdate"
+];
+var claudeTaskToolNameSchema = z25.enum(claudeTaskToolNameValues);
+var claudeTaskStatusValues = ["pending", "in_progress", "completed"];
+var claudeTaskStatusSchema = z25.enum(claudeTaskStatusValues);
+var claudeTaskUpdateStatusValues = [
+  ...claudeTaskStatusValues,
+  "deleted"
+];
+var claudeTaskUpdateStatusSchema = z25.enum(claudeTaskUpdateStatusValues);
+var claudeTaskListStatusValues = [
+  ...claudeTaskStatusValues,
+  "deleted"
+];
+var claudeTaskListStatusSchema = z25.enum(claudeTaskListStatusValues);
+var claudeTaskCreateArgsSchema = z25.object({
+  activeForm: z25.string().optional(),
+  subject: z25.string()
+}).passthrough();
+var claudeTaskGetArgsSchema = z25.object({
+  taskId: z25.string()
+}).passthrough();
+var claudeTaskUpdateArgsSchema = z25.object({
+  activeForm: z25.string().optional(),
+  status: claudeTaskUpdateStatusSchema.optional(),
+  subject: z25.string().optional(),
+  taskId: z25.string()
+}).passthrough();
+var claudeTaskCreateOutputSchema = z25.object({
+  task: z25.object({
+    id: z25.string(),
+    subject: z25.string()
+  }).passthrough()
+}).passthrough();
+var claudeTaskGetOutputTaskSchema = z25.object({
+  id: z25.string(),
+  status: claudeTaskStatusSchema,
+  subject: z25.string()
+}).passthrough();
+var claudeTaskGetOutputSchema = z25.object({
+  task: claudeTaskGetOutputTaskSchema.nullable()
+}).passthrough();
+var claudeTaskUpdateOutputSchema = z25.object({
+  success: z25.boolean(),
+  taskId: z25.string()
+}).passthrough();
+var claudeTaskListItemSchema = z25.object({
+  id: z25.string(),
+  status: claudeTaskListStatusSchema,
+  subject: z25.string()
+}).passthrough();
+var claudeTaskListOutputSchema = z25.object({
+  tasks: z25.array(z25.unknown())
+}).passthrough();
+var claudeTaskToolOutputSchema = z25.union([
+  claudeTaskCreateOutputSchema,
+  claudeTaskGetOutputSchema,
+  claudeTaskListOutputSchema,
+  claudeTaskUpdateOutputSchema
+]);
+
+// ../domain/src/host-list-limits.ts
+var FILE_LIST_QUERY_MAX_LENGTH = 256;
+var FILE_LIST_LIMIT_MAX = 1e4;
+var BRANCH_LIST_QUERY_MAX_LENGTH = 256;
+var BRANCH_LIST_LIMIT_MAX = 1e3;
+
+// ../domain/src/number-utils.ts
+function toPositiveNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+
+// ../domain/src/provider-fork.ts
+import { z as z26 } from "zod";
+var PROVIDER_FORK_VALUES = ["none", "tip", "checkpoint"];
+var providerForkSchema = z26.enum(PROVIDER_FORK_VALUES);
+
+// ../domain/src/provider-types.ts
+import { z as z27 } from "zod";
+var modelReasoningEffortSchema = z27.object({
+  reasoningEffort: reasoningLevelSchema,
+  description: z27.string()
+});
+var availableModelSchema = z27.object({
+  id: z27.string(),
+  model: z27.string(),
+  displayName: z27.string(),
+  /** Provider route used to run this model when it is distinct from the
+   * selected agent provider (for example, a model provider nested under Pi). */
+  routeProviderId: z27.string().min(1).optional(),
+  description: z27.string(),
+  supportedReasoningEfforts: z27.array(modelReasoningEffortSchema),
+  defaultReasoningEffort: reasoningLevelSchema,
+  isDefault: z27.boolean()
+});
+var providerCapabilitiesSchema = z27.object({
+  supportsThreadArchive: z27.boolean(),
+  supportsThreadRename: z27.boolean(),
+  supportsServiceTier: z27.boolean(),
+  supportsNativeUserQuestion: z27.boolean(),
+  supportsFork: z27.boolean(),
+  /**
+   * The provider can recreate a session at an earlier point, which is what
+   * edit-past-message rewind needs. Separate from `supportsFork`: ACP clones
+   * whole sessions (tip-only) and cannot stop at a checkpoint.
+   */
+  supportsSessionRewind: z27.boolean(),
+  permissionModes: z27.array(permissionModeSchema).min(1)
+});
+var providerComposerCommandSchema = z27.object({
+  trigger: promptMentionCommandTriggerSchema,
+  name: z27.string().min(1).regex(/^[^\s/$]+$/u),
+  trailingText: z27.string().regex(/^\s*$/u)
+});
+var providerComposerActionSchema = z27.discriminatedUnion("kind", [
+  z27.object({
+    kind: z27.literal("skills"),
+    trigger: promptMentionCommandTriggerSchema
+  }),
+  z27.object({
+    kind: z27.literal("plan"),
+    command: providerComposerCommandSchema
+  }),
+  z27.object({
+    kind: z27.literal("goal"),
+    command: providerComposerCommandSchema
+  })
+]);
+var providerStringsSchema = z27.object({
+  /** How to sign in on the host ("Run `claude` on the machine to sign in."). */
+  signInHint: z27.string().min(1),
+  /** Shown when a session's credentials expired. */
+  expiredHint: z27.string().min(1),
+  /** Where to install the agent. */
+  installUrl: z27.string().min(1),
+  /** Brand prefix stripped from model display names ("Claude "). */
+  brandPrefix: z27.string().min(1).optional(),
+  /** Plan-mode banner copy for providers that declare the `plan` action. */
+  planModeCopy: z27.string().min(1).optional(),
+  /** Per-theme tint for the provider icon. */
+  iconTint: z27.object({ light: z27.string().min(1), dark: z27.string().min(1) }).optional()
+});
+var providerOptionDescriptorSchema = z27.object({
+  id: z27.string().min(1),
+  label: z27.string().min(1),
+  description: z27.string().min(1).optional()
+});
+var providerExtensionKindInfoSchema = z27.object({
+  item: z27.boolean(),
+  state: z27.boolean()
+});
+var providerExtensionKindsSchema = z27.record(
+  extensionKindSchema,
+  providerExtensionKindInfoSchema
+);
+var providerInfoSchema = z27.object({
+  id: z27.string(),
+  displayName: z27.string(),
+  /**
+   * Declared grouping key shared by related providers (the ACP agents).
+   * Absent when the provider declared none. Grouping only.
+   */
+  family: z27.string().min(1).optional(),
+  logoUrl: z27.string().min(1).nullable(),
+  /** Sessionless maintenance methods declared by the provider plugin. */
+  experimental_providerHealth: z27.boolean(),
+  experimental_providerUsage: z27.boolean(),
+  experimental_providerInstallation: z27.boolean(),
+  capabilities: providerCapabilitiesSchema,
+  composerActions: z27.array(providerComposerActionSchema),
+  available: z27.boolean(),
+  // -------------------------------------------------------------------------
+  // Target-state projection (docs/provider-plugin-api.md §1). Optional and
+  // unfilled until WS2a projects them from the plugin declaration; absence
+  // means "the provider declared none", never a default. The `experimental_*`
+  // and `capabilities.supports*` fields above stay until WS2a stabilizes the
+  // surface as one unit.
+  // -------------------------------------------------------------------------
+  strings: providerStringsSchema.optional(),
+  serviceTiers: z27.array(providerOptionDescriptorSchema).optional(),
+  reasoningLevels: z27.array(providerOptionDescriptorSchema).optional(),
+  extensionKinds: providerExtensionKindsSchema.optional()
+});
+var providerRecoveryKindValues = [
+  "sessionArchived",
+  "authRequired",
+  "restartRecommended",
+  "staleTurn",
+  "rateLimited"
+];
+var providerRecoveryKindSchema = z27.enum(providerRecoveryKindValues);
+var toolCallOutputItemSchema = z27.discriminatedUnion("type", [
+  z27.object({
+    type: z27.literal("inputText"),
+    text: z27.string()
+  }),
+  z27.object({
+    type: z27.literal("inputImage"),
+    imageUrl: z27.string()
+  })
+]);
+var toolCallRequestSchema = z27.object({
+  requestId: z27.union([z27.string().min(1), z27.number()]),
+  threadId: z27.string().min(1),
+  providerThreadId: z27.string().min(1),
+  turnId: z27.string().min(1),
+  callId: z27.string().min(1),
+  tool: z27.string().min(1),
+  arguments: z27.unknown().optional()
+});
+var toolCallResponseSchema = z27.object({
+  contentItems: z27.array(toolCallOutputItemSchema),
+  success: z27.boolean()
+});
+var dynamicToolSchema = z27.object({
+  name: z27.string(),
+  description: z27.string(),
+  inputSchema: z27.unknown(),
+  presentation: threadEventItemPresentationSchema.optional()
+});
+
+// ../domain/src/reasoning-efforts.ts
+var NONE_REASONING_EFFORT = {
+  reasoningEffort: "none",
+  description: "No extended thinking"
+};
+var LOW_REASONING_EFFORT = {
+  reasoningEffort: "low",
+  description: "Low reasoning effort"
+};
+var MEDIUM_REASONING_EFFORT = {
+  reasoningEffort: "medium",
+  description: "Medium reasoning effort"
+};
+var HIGH_REASONING_EFFORT = {
+  reasoningEffort: "high",
+  description: "High reasoning effort"
+};
+var XHIGH_REASONING_EFFORT = {
+  reasoningEffort: "xhigh",
+  description: "Extra high reasoning effort"
+};
+var ULTRACODE_REASONING_EFFORT = {
+  reasoningEffort: "ultracode",
+  description: "Extra high reasoning effort plus multi-agent workflow orchestration"
+};
+var MAX_REASONING_EFFORT = {
+  reasoningEffort: "max",
+  description: "Maximum reasoning effort"
+};
+var ULTRA_REASONING_EFFORT = {
+  reasoningEffort: "ultra",
+  description: "Maximum reasoning with automatic task delegation"
+};
+var REASONING_EFFORT_BY_LEVEL = {
+  none: NONE_REASONING_EFFORT,
+  low: LOW_REASONING_EFFORT,
+  medium: MEDIUM_REASONING_EFFORT,
+  high: HIGH_REASONING_EFFORT,
+  xhigh: XHIGH_REASONING_EFFORT,
+  ultracode: ULTRACODE_REASONING_EFFORT,
+  max: MAX_REASONING_EFFORT,
+  ultra: ULTRA_REASONING_EFFORT
+};
+function reasoningEffortsForLevels(levels) {
+  return levels.map((level) => ({ ...REASONING_EFFORT_BY_LEVEL[level] }));
+}
+
+// ../domain/src/thread-git-diff.ts
+import { z as z28 } from "zod";
+var workspaceDiffTargetSchema = z28.discriminatedUnion("type", [
+  z28.object({
+    type: z28.literal("uncommitted")
+  }),
+  z28.object({
+    type: z28.literal("branch_committed"),
+    mergeBaseBranch: z28.string().min(1)
+  }),
+  z28.object({
+    type: z28.literal("all"),
+    mergeBaseBranch: z28.string().min(1)
+  }),
+  z28.object({
+    type: z28.literal("commit"),
+    sha: z28.string().regex(/^[0-9a-f]{4,40}$/iu)
+  })
+]);
+var rawDiffFileStatSchema = z28.object({
+  path: z28.string(),
+  previousPath: z28.string().nullable(),
+  statusLetter: z28.enum(["A", "M", "D", "R", "C", "T"]),
+  additions: z28.number().int().nonnegative(),
+  deletions: z28.number().int().nonnegative(),
+  binary: z28.boolean(),
+  origin: z28.enum(["tracked", "untracked"])
+});
+var threadGitDiffResponseSchema = z28.object({
+  diff: z28.string(),
+  truncated: z28.boolean(),
+  shortstat: z28.string(),
+  files: z28.string(),
+  /**
+   * Resolved merge-base SHA for `branch_committed` / `all` targets — the
+   * exact ref the diff was computed against. `null` for targets that don't
+   * use a merge-base (`uncommitted`, `commit`), and also when no merge-base
+   * exists (e.g. the branch has been removed locally). Callers fetching
+   * per-file content for context expansion must pass this SHA as the
+   * "old side" ref so the file content lines up with the diff's hunk
+   * coordinates — passing the branch name reads from its current tip, which
+   * may have diverged past the merge-base.
+   */
+  mergeBaseRef: z28.string().nullable()
+});
+
 // ../provider-bridge-protocol/src/handshake.ts
 import { z as z29 } from "zod";
 var bridgeGrammarVersionsSchema = z29.tuple([z29.number().int().positive(), z29.number().int().positive()]).refine(([min, max]) => min <= max, {
@@ -4693,6 +4693,20 @@ var threadDeltaSchema = z35.discriminatedUnion("kind", [
     clientRequestId: clientTurnRequestIdSchema,
     providerTurnId: providerTurnIdSchema.optional()
   }),
+  /**
+   * Input the provider itself injected into the conversation, with no bb
+   * client request behind it (a pi extension's `sendMessage` custom message
+   * that triggered or steered a turn). The assembler records it as a
+   * `userMessage` item in the open turn so the transcript shows what the
+   * model was answering. Dropped silently when no turn is open: the provider
+   * appended it to its own context without running the agent, so there is no
+   * bb turn to attach it to.
+   */
+  z35.object({
+    kind: z35.literal("input.provider"),
+    text: z35.string().min(1),
+    parentRef: deltaKeyPartSchema.optional()
+  }),
   /**
    * An explicit provider signal opened work (pi `agent_start`, codex
    * `turn/started`). With `providerTurnId` the turn lives in the keyed
@@ -5411,8 +5425,13 @@ var threadStartCommandSchema = hostDaemonThreadTargetSchema.merge(hostDaemonThre
   inputGroups: z38.array(z38.array(promptInputSchema).min(1)).min(1).optional(),
   threadStoragePath: z38.string().min(1).optional(),
   /** Present means fork the new thread from this source provider session
-   *  instead of starting fresh; absent means a normal start. */
-  fork: z38.object({ sourceProviderThreadId: z38.string().min(1) }).optional()
+   *  instead of starting fresh; absent means a normal start. The clone
+   *  retains the source history through `sourceProviderCheckpointId`; an
+   *  absent checkpoint clones the session tip. */
+  fork: z38.object({
+    sourceProviderThreadId: z38.string().min(1),
+    sourceProviderCheckpointId: z38.string().min(1).optional()
+  }).optional()
 }).strict().superRefine((value, ctx) => {
   if (value.fork === void 0 && value.input.length === 0) {
     ctx.addIssue({