@factory/droid-sdk 0.8.0 → 0.9.0

package/dist/{chunk-ROFAQUG4.mjs → chunk-KXDG5ZWS.mjs}

@@ -1874,8 +1874,6 @@ var ModelID = /* @__PURE__ */ ((ModelID2) => {
   ModelID2["CLAUDE_FABLE_5"] = "claude-fable-5";
   ModelID2["ATLAS_0721"] = "atlas-07-21";
   ModelID2["ASTER_0715"] = "aster-07-15";
-  ModelID2["AMBER_0709"] = "amber-07-09";
-  ModelID2["AGATE_0711"] = "agate-07-11";
   ModelID2["GPT_5"] = "gpt-5-2025-08-07";
   ModelID2["GPT_5_MINI"] = "gpt-5-mini-2025-08-07";
   ModelID2["GPT_5_NANO"] = "gpt-5-nano-2025-08-07";
@@ -1928,6 +1926,8 @@ var ModelID = /* @__PURE__ */ ((ModelID2) => {
   ModelID2["GLM_5_1"] = "glm-5.1";
   ModelID2["GLM_5_2"] = "glm-5.2";
   ModelID2["GLM_5_2_FAST"] = "glm-5.2-fast";
+  ModelID2["GLM_5_3"] = "glm-5.3";
+  ModelID2["GLM_5_3_FLASH"] = "glm-5.3-flash";
   ModelID2["INKLING"] = "inkling";
   ModelID2["NEMOTRON_3_ULTRA"] = "nemotron-3-ultra";
   ModelID2["SHIELD_RISK"] = "shield-risk";
@@ -2052,11 +2052,36 @@ var BugReportSourceSchema = z.object({
   osVersion: z.string().max(100).optional()
 });
 var ToolExecutionModeSchema = z.nativeEnum(ToolExecutionMode);
+var SdkClientMetadataSchema = z.object({
+  language: z.enum(["typescript", "python"]),
+  version: z.string().min(1).max(64).regex(/^[A-Za-z0-9.+-]+$/)
+});
+function formatSdkClientMetadata(metadata) {
+  return `${metadata.language}/${metadata.version}`;
+}
+var ClientRequestAttributionSchema = z.discriminatedUnion("client", [
+  z.object({
+    client: z.literal("sdk" /* SDK */),
+    sdk: SdkClientMetadataSchema
+  }),
+  z.object({
+    client: z.enum([
+      "web-desktop" /* WebDesktop */,
+      "web-app" /* WebApp */,
+      "web-workspace" /* WebWorkspace */,
+      "daemon" /* Daemon */,
+      "cli" /* CLI */,
+      "backend" /* Backend */
+    ])
+  })
+]);
 var TraceContextMetaSchema = z.object({
   /** W3C traceparent header value (e.g., "00-0af7651916cd43dd8448eb211c80319c-00f067aa0ba902b7-01") */
   traceparent: z.string().optional(),
   /** W3C tracestate header value for vendor-specific trace data */
-  tracestate: z.string().optional()
+  tracestate: z.string().optional(),
+  /** Authenticated caller attribution injected by a daemon before worker dispatch. */
+  requestAttribution: ClientRequestAttributionSchema.optional()
 });
 var JsonRpcEnvelopeSchema = z.object({
   jsonrpc: z.literal(JSONRPC_VERSION),
@@ -2511,6 +2536,17 @@ var ListModelsOptionsSchema = z5.object({
 var ListModelsResultSchema = z5.object({
   models: z5.array(ModelInfoSchema)
 });
+var ModelFallbackReasonSchema = z5.enum([
+  /** A BYOK `custom:*` id with no matching entry in the machine's settings. */
+  "custom_model_not_configured",
+  /** The model is no longer available to the org that requested it. */
+  "model_not_available_for_org"
+]);
+var ModelFallbackSchema = z5.object({
+  /** The unusable id, as requested. */
+  requestedModel: z5.string(),
+  reason: ModelFallbackReasonSchema
+});
 
 // ../droid-sdk-core/src/protocol/droid/schemas/mission-decomposition.ts
 import z6 from "zod";
@@ -2808,7 +2844,9 @@ var LEGACY_COMPACTION_MODEL_IDS = [
   "oxide-06-01",
   "oxbow-06-01",
   "owl-06-21",
-  "gantry-05-07"
+  "gantry-05-07",
+  "amber-07-09",
+  "agate-07-11"
 ];
 var SHIELD_MODEL_ID_VALUES_SET = new Set(
   SHIELD_MODEL_ID_VALUES
@@ -2878,7 +2916,10 @@ var McpOAuthConfigSchema = z10.union([
   McpOAuthOptionsSchema
 ]);
 var BuiltInModelIDSchema = z10.custom(
-  (value) => typeof value === "string" && Object.values(ModelID).some((modelId) => modelId === value) && !ROUTER_MODEL_IDS.some((routerId) => routerId === value)
+  (value) => typeof value === "string" && Object.values(ModelID).some((modelId) => modelId === value) && !ROUTER_MODEL_IDS.some((routerId) => routerId === value),
+  {
+    message: "Must be a supported built-in model ID."
+  }
 );
 var ENV_VAR_REFERENCE_PATTERN = /\$\{[A-Za-z_][A-Za-z0-9_]*\}/;
 var CustomModelBedrockRequestMetadataSchema = z10.record(
@@ -3818,8 +3859,8 @@ var InitializeSessionRequestParamsSchema = z14.object({
   sessionOriginHint: z14.nativeEnum(SessionOrigin).optional(),
   tags: z14.array(SessionTagSchema).optional(),
   privacyLevel: z14.enum(["private", "organization"]).optional(),
-  // Retained for wire compatibility. Organization-scoped local session
-  // behavior was reverted, so consumers intentionally ignore this value.
+  // Active organization that owns the local session. The daemon validates
+  // this against the authenticated connection before persisting it.
   organizationId: z14.string().optional(),
   title: z14.string().optional(),
   /**
@@ -3886,6 +3927,12 @@ var InitializeSessionRequestParamsSchema = z14.object({
    * (`<current-branch>-wt`) is preserved.
    */
   worktreeBaseBranch: WorktreeGitRefSchema.optional(),
+  /**
+   * Whether `worktreeBaseBranch` was selected from origin before it existed
+   * locally. The daemon fetches it and creates or copies it only when the
+   * session starts.
+   */
+  worktreeBaseBranchFromOrigin: z14.boolean().optional(),
   /**
    * Explicit branch name to create for the worktree, chosen by the user
    * through the branch selector's "Create branch" action. When provided,
@@ -3903,7 +3950,12 @@ var InitializeSessionRequestParamsSchema = z14.object({
    * ID of the setup profile to execute in the worktree after creation.
    * Must match a profile stored on the target daemon for the project.
    */
-  worktreeSetupProfileId: z14.string().uuid().optional()
+  worktreeSetupProfileId: z14.string().uuid().optional(),
+  /** Cross-machine parent lineage supplied by a trusted daemon. */
+  callingMetadata: z14.object({
+    callingSessionId: z14.string().min(1),
+    callingToolUseId: z14.string().min(1)
+  }).optional()
 }).merge(ToolOverrideParamsSchema);
 var LoadSessionRequestParamsSchema = z14.object({
   sessionId: z14.string(),
@@ -3940,6 +3992,7 @@ var LoadSessionRequestParamsSchema = z14.object({
 var AddUserMessageRequestParamsSchema = z14.object({
   messageId: z14.string().optional(),
   text: z14.string(),
+  content: z14.array(z14.union([TextBlockSchema, ImageBlockSchema])).min(1).optional(),
   images: Base64ImageSourceSchema.array().optional(),
   imagePaths: z14.string().array().optional(),
   files: DocumentSourceSchema.array().optional(),
@@ -4906,7 +4959,8 @@ var DaemonConnectionMetadataSchema = z15.object({
     connectAttemptId: z15.string().optional(),
     /** Low-cardinality trigger for the root computer-connect episode. */
     connectAttemptTrigger: z15.string().optional()
-  }).optional()
+  }).optional(),
+  sdk: SdkClientMetadataSchema.optional()
 });
 var DaemonAuthenticateRequestParamsSchema = z15.object({
   /** WorkOS JWT access token */
@@ -4930,7 +4984,13 @@ var DaemonAuthenticateRequestParamsSchema = z15.object({
   message: "Either token or apiKey must be provided"
 }).refine((data) => !data.actAsGrant || Boolean(data.token), {
   message: "actAsGrant requires token"
-});
+}).refine(
+  (data) => data.caller === "sdk" /* SDK */ === (data.metadata?.sdk !== void 0),
+  {
+    message: "SDK callers must provide SDK metadata",
+    path: ["metadata", "sdk"]
+  }
+);
 var DaemonAuthenticateRequestSchema = JsonRpcBaseRequestSchema.extend({
   method: z15.literal("daemon.authenticate" /* AUTHENTICATE */),
   params: DaemonAuthenticateRequestParamsSchema
@@ -5427,8 +5487,9 @@ function settleToolExecutionLifecyclePhase(phase) {
 }
 
 // ../droid-sdk-core/src/protocol/droid/schemas/constants.ts
-var FACTORY_PROTOCOL_VERSION = "1.187.0";
+var FACTORY_PROTOCOL_VERSION = "1.193.0";
 var FACTORY_CLIENT_HEADER = "X-Factory-Client";
+var FACTORY_SDK_HEADER = "X-Factory-Sdk";
 var FACTORY_CLIENT_VERSION = "X-Client-Version";
 var LEGACY_FACTORY_API_VERSION2 = LEGACY_FACTORY_API_VERSION;
 var JSONRPC_VERSION2 = JSONRPC_VERSION;
@@ -5820,7 +5881,19 @@ var DaemonRunAutomationResultSchema = z20.object({
   /** Template this automation was created from, when known. */
   templateId: z20.nativeEnum(AutomationTemplateId).optional(),
   cwd: z20.string(),
+  /**
+   * The model to run on. Omitted when the automation pins no model, and also
+   * when its configured model could not be resolved on this machine, in which
+   * case `modelFallback` explains the omission and the run uses the daemon
+   * default.
+   */
   model: z20.string().optional(),
+  /**
+   * Set when the automation's configured model was dropped because it does not
+   * resolve on this machine. The run still proceeds on the daemon default;
+   * callers surface this so the substitution is not silent.
+   */
+  modelFallback: ModelFallbackSchema.optional(),
   /** Optional reasoning effort for the run session. */
   reasoningEffort: z20.string().optional(),
   /**
@@ -5894,7 +5967,13 @@ var AutomationRunRecordSchema = z20.object({
   isRetry: z20.boolean().optional(),
   originalRunId: z20.string().optional(),
   /** Droid session that executed this run, when dispatched as a real session. */
-  sessionId: z20.string().optional()
+  sessionId: z20.string().optional(),
+  /**
+   * Set when this run's configured model was dropped at spawn time. Scheduled
+   * runs fire without a caller to receive the run-time result, so the history
+   * record is the only place the substitution can surface for them.
+   */
+  modelFallback: ModelFallbackSchema.optional()
 });
 var DaemonGetAutomationHistoryResultSchema = z20.object({
   automationId: z20.string(),
@@ -6906,6 +6985,7 @@ var SoftwareFactoryWorkstreamStateSchema = z28.enum([
   "draft",
   "active",
   "paused",
+  // Retained for wire compatibility with older clients. New writes archive.
   "canceled",
   "archived"
 ]);
@@ -6940,12 +7020,15 @@ var SoftwareFactoryWorkstreamSchema = z28.object({
   icon: z28.string().optional(),
   state: SoftwareFactoryWorkstreamStateSchema,
   userId: z28.string().optional(),
-  /** Owning team when the workstream is team-owned; absent otherwise. */
+  /**
+   * Team the workstream is attributed to. A label, not a visibility control:
+   * every workstream is readable by its whole org.
+   */
   owningTeamId: z28.string().optional(),
   /**
-   * Access mode gating human reads/writes: `team` (owning-team members),
-   * `private` (creator only). Absent on legacy rows, which are treated as
-   * open.
+   * Retired: workstreams are org-visible, so the backend no longer reports an
+   * access mode. Present only on rows written before the mode was retired, and
+   * kept in the schema because the protocol forbids removing a field.
    */
   accessMode: z28.enum(["team", "private"]).optional(),
   creationSessionId: z28.string().optional(),
@@ -6964,6 +7047,9 @@ var SoftwareFactoryWorkstreamSchema = z28.object({
   dashboardPort: z28.number().int().optional(),
   /** Public URL of the workstream's published Conjure dashboard site. */
   dashboardUrl: z28.string().optional(),
+  /** Pause proposed changes for human approval before investigation. */
+  requireChangeApproval: z28.boolean().optional(),
+  /** Pause completed investigation specifications for human approval. */
   requireApproval: z28.boolean(),
   reviewers: z28.array(z28.string()),
   createdAt: z28.string(),
@@ -7005,7 +7091,7 @@ var SoftwareFactoryActivitySchema = z28.object({
   id: z28.string(),
   changeId: z28.string(),
   workstreamId: z28.string(),
-  kind: z28.enum(["investigation", "implementation", "steward"]),
+  kind: z28.enum(["change_review", "investigation", "implementation", "steward"]),
   status: z28.enum(["pending", "in_progress", "completed", "failed", "canceled"]),
   reviewStatus: z28.enum(["awaiting", "approved", "declined", "commented"]).optional(),
   reviewComment: z28.string().optional(),
@@ -7087,15 +7173,15 @@ var DaemonSfCreateWorkstreamRequestParamsSchema = z28.object({
    */
   userId: z28.string().optional(),
   /**
-   * Owning team for a team-owned workstream. When set, the backend validates
-   * the acting principal may create for this team, stamps `access_mode='team'`,
-   * and issues the owner grant.
+   * Team to attribute the workstream to. When set, the backend validates the
+   * acting principal is linked to this team, stamps it, and issues the owner
+   * grant. It does not restrict who can read the workstream.
    */
   owningTeamId: z28.string().optional(),
   /**
-   * Omitting the access mode leaves the workstream legacy-open (org-visible);
-   * it is not defaulted to `private` server-side. Set `team`/`private` to
-   * enforce access.
+   * Accepted and ignored: workstreams are visible to the whole org, so the
+   * daemon drops this rather than forwarding it. Kept in the schema because the
+   * protocol forbids removing a field, and so an older client still validates.
    */
   accessMode: z28.enum(["team", "private"]).optional(),
   /** Creation session that owns the bootstrap interview. */
@@ -7106,6 +7192,7 @@ var DaemonSfCreateWorkstreamRequestParamsSchema = z28.object({
   repos: z28.array(z28.string()).optional(),
   workerConcurrency: z28.number().optional(),
   stewardConcurrency: z28.number().optional(),
+  requireChangeApproval: z28.boolean().optional(),
   requireApproval: z28.boolean().optional(),
   reviewers: z28.array(z28.string()).optional()
 });
@@ -7138,6 +7225,7 @@ var DaemonSfUpdateWorkstreamRequestParamsSchema = z28.object({
   stewardConcurrency: z28.number().optional(),
   dashboardPort: z28.number().optional(),
   dashboardUrl: z28.string().optional(),
+  requireChangeApproval: z28.boolean().optional(),
   requireApproval: z28.boolean().optional(),
   reviewers: z28.array(z28.string()).optional()
 });
@@ -7162,7 +7250,7 @@ var DaemonSfDeleteWorkstreamResultSchema = z28.object({
   automationsDeleted: z28.number(),
   /** Whether the workstream directory existed and was removed. */
   workstreamDirDeleted: z28.boolean(),
-  /** Number of remote (backend-scheduled) automations tagged to the workstream that were soft-deleted. */
+  /** Number of linked remote (backend-scheduled) automations that were soft-deleted. */
   remoteAutomationsDeleted: z28.number().optional()
 });
 var DaemonSfListEventsRequestParamsSchema = z28.object({
@@ -7595,7 +7683,9 @@ var DaemonInitializeSessionRequestParamsSchema = InitializeSessionRequestParamsS
    * message so worktree creation can honour it: a worktree that cuts a new
    * branch from its base starts from the base's freshly fetched remote ref
    * instead of the possibly stale local one. The pull that mutates an
-   * existing checkout still rides on the first message, not on init.
+   * existing checkout still rides on the first message, not on init. This
+   * controls an update from origin; origin-only checkout creation uses
+   * `createFromOrigin` on the checkout request instead.
    */
   pullFromOrigin: z31.boolean().optional()
 });
@@ -7618,7 +7708,8 @@ var DaemonAddUserMessageRequestParamsSchema = AddUserMessageRequestParamsSchema.
    * this message to the agent. Set by session-launch callers on the first
    * message only; a failed pull is not fatal, it arrives as its own
    * LLM-only message ahead of this one so the agent resolves it without the
-   * user's own text being touched.
+   * user's own text being touched. This updates the checked-out branch; it
+   * does not create an origin-only branch locally.
    */
   pullFromOrigin: z31.boolean().optional()
 });
@@ -7789,6 +7880,7 @@ var DaemonAvailableSessionInfoSchema = z31.object({
   // Parent session ID for child/worker sessions (from JSONL summary `callingSessionId` field)
   callingToolUseId: z31.string().optional(),
   // Parent tool use ID that spawned this child session (from JSONL summary)
+  organizationId: z31.string().optional(),
   tags: z31.array(SessionTagSchema).optional(),
   // Session tags for categorization
   // Drop only the worktree metadata (not the whole session, and not the whole
@@ -8031,11 +8123,41 @@ var DaemonRenameSessionRequestSchema = JsonRpcBaseRequestSchema.extend(
 );
 var DaemonRenameSessionResponseSchema = createAckCompatibleResponseSchema(DaemonRenameSessionResultSchema);
 var DaemonListGitBranchesRequestParamsSchema = z31.object({
-  cwd: z31.string()
+  cwd: z31.string(),
+  /**
+   * Whether to discover branches that exist only on origin. Optional so newer
+   * clients can continue listing local branches through older request shapes.
+   */
+  includeOriginBranches: z31.boolean().optional()
+});
+var DaemonCheckoutGitBranchConflictDataSchema = z31.object({
+  reason: z31.literal("branch_occupied_by_managed_worktree"),
+  worktree: z31.discriminatedUnion("lifecycle", [
+    SessionWorktreeMetadataSchema.pick({
+      path: true,
+      repoRoot: true
+    }).required().extend({
+      lifecycle: z31.literal("ephemeral" /* Ephemeral */),
+      sessionId: z31.string()
+    }),
+    SessionWorktreeMetadataSchema.pick({
+      path: true,
+      repoRoot: true
+    }).required().extend({
+      lifecycle: z31.literal("persistent" /* Persistent */)
+    })
+  ])
 });
 var DaemonListGitBranchesResultSchema = z31.object({
   isGitRepository: z31.boolean(),
   branches: z31.array(z31.string()),
+  /**
+   * Branches found on origin that do not yet exist locally. Optional for
+   * compatibility with daemons predating remote branch discovery.
+   */
+  originBranches: z31.array(z31.string()).optional(),
+  /** Whether origin branch discovery is still refreshing in the background. */
+  originBranchesPending: z31.boolean().optional(),
   currentBranch: z31.string().nullable(),
   /** The repository's default branch, when it has one. */
   defaultBranch: z31.string().optional(),
@@ -8046,7 +8168,9 @@ var DaemonListGitBranchesResultSchema = z31.object({
   checkedOutBranches: z31.array(
     z31.object({
       branch: z31.string(),
-      path: z31.string()
+      path: z31.string(),
+      /** Branch-switch conflict details for a Factory-managed worktree. */
+      conflict: DaemonCheckoutGitBranchConflictDataSchema.optional()
     })
   ).optional()
 });
@@ -8061,32 +8185,26 @@ var DaemonCheckoutGitBranchRequestParamsSchema = z31.object({
   cwd: z31.string(),
   branch: z31.string(),
   create: z31.boolean().optional(),
+  /**
+   * Create a local tracking branch from the same-named origin branch. This
+   * describes where the local branch comes from; it does not request a pull.
+   */
+  createFromOrigin: z31.boolean().optional(),
+  /**
+   * Pull the newly checked-out branch before returning. For an origin-only
+   * selection, use this with `createFromOrigin`.
+   */
+  pullFromOrigin: z31.boolean().optional(),
   resolution: z31.enum(["stash", "commit"]).optional()
 });
-var DaemonCheckoutGitBranchConflictDataSchema = z31.object({
-  reason: z31.literal("branch_occupied_by_managed_worktree"),
-  worktree: z31.discriminatedUnion("lifecycle", [
-    SessionWorktreeMetadataSchema.pick({
-      path: true,
-      repoRoot: true
-    }).required().extend({
-      lifecycle: z31.literal("ephemeral" /* Ephemeral */),
-      sessionId: z31.string()
-    }),
-    SessionWorktreeMetadataSchema.pick({
-      path: true,
-      repoRoot: true
-    }).required().extend({
-      lifecycle: z31.literal("persistent" /* Persistent */)
-    })
-  ])
-});
 var DaemonCheckoutGitBranchResultSchema = z31.discriminatedUnion(
   "status",
   [
     z31.object({
       status: z31.literal("checked_out"),
-      currentBranch: z31.string()
+      currentBranch: z31.string(),
+      /** Scrubbed git output when an active-session origin pull failed. */
+      pullFailure: z31.string().optional()
     }),
     z31.object({
       status: z31.literal("needs_resolution"),
@@ -9181,10 +9299,18 @@ var SESSION_INIT_TIMEOUT = 6e4;
 var MCP_AUTH_TIMEOUT = 3e5;
 var COMPACTION_TIMEOUT = 24e4;
 var REWIND_TIMEOUT = 6e4;
-var SDK_VERSION = "0.8.0";
+var SDK_VERSION = "0.9.0";
+var SDK_CLIENT_METADATA = {
+  language: "typescript",
+  version: SDK_VERSION
+};
+var SDK_REQUEST_ATTRIBUTION = {
+  client: "sdk" /* SDK */,
+  sdk: SDK_CLIENT_METADATA
+};
 var SDK_TAG = {
   name: "sdk",
-  metadata: { language: "typescript", version: SDK_VERSION }
+  metadata: SDK_CLIENT_METADATA
 };
 
 // src/schemas/constants.ts
@@ -9343,6 +9469,9 @@ function mergeSessionSettings(current, patch) {
   }
   return SessionSettingsSchema2.parse(merged);
 }
+function withSdkTag(tags = []) {
+  return [...tags.filter((tag) => tag.name !== SDK_TAG.name), SDK_TAG];
+}
 function unwrapResponseResult(response) {
   if (response.error) {
     throw new ProtocolError(response.error.message, {
@@ -10164,21 +10293,27 @@ function isPendingToolResultMarker(block) {
 }
 function buildUserMessageContentBlocks({
   text,
+  content,
   images,
   files,
   trimText = false,
   includeEmptyText = true
 }) {
-  const blocks = [];
-  for (const image of images ?? []) {
-    blocks.push({ type: "image" /* Image */, source: image });
+  const blocks = content?.length ? [...content] : [];
+  const hasExplicitContent = blocks.length > 0;
+  if (!hasExplicitContent) {
+    for (const image of images ?? []) {
+      blocks.push({ type: "image" /* Image */, source: image });
+    }
   }
   for (const file of files ?? []) {
     blocks.push({ type: "document" /* Document */, source: file });
   }
-  const value = trimText ? text?.trim() : text;
-  if (value !== void 0 && (includeEmptyText || value.length > 0)) {
-    blocks.push({ type: "text" /* Text */, text: value });
+  if (!hasExplicitContent) {
+    const value = trimText ? text?.trim() : text;
+    if (value !== void 0 && (includeEmptyText || value.length > 0)) {
+      blocks.push({ type: "text" /* Text */, text: value });
+    }
   }
   return blocks;
 }
@@ -12856,7 +12991,8 @@ async function connectWithRetry({
   ensureRunning,
   providerType,
   maxRetries = DEFAULT_MAX_RETRIES,
-  connectAttemptContext
+  connectAttemptContext,
+  onAttempts
 }) {
   if (ensureRunning) {
     await OtelTracing.trace("computer.ensure_running" /* COMPUTER_ENSURE_RUNNING */, ensureRunning, {
@@ -12914,6 +13050,12 @@ async function connectWithRetry({
     OtelTracing.setActiveSpanAttributes({
       ["factory.daemon.connect_attempts" /* FACTORY_DAEMON_CONNECT_ATTEMPTS */]: attempts
     });
+    if (attempts > 0) {
+      try {
+        onAttempts?.(attempts);
+      } catch {
+      }
+    }
   }
 }
 
@@ -14295,7 +14437,7 @@ function createWebSocketDaemonClient(config) {
 }
 
 // ../daemon-sdk/src/session/DaemonSessionController.ts
-import { EventEmitter as EventEmitter6 } from "eventemitter3";
+import { EventEmitter as EventEmitter4 } from "eventemitter3";
 import { v4 as uuidv47 } from "uuid";
 
 // ../daemon-sdk/src/session/connection-status.ts
@@ -14376,7 +14518,7 @@ var MessageRouter = class _MessageRouter extends EventEmitter3 {
               requestId: msg.id,
               sessionId: msg.params.sessionId,
               method: msg.method,
-              toolCount: msg.params.toolUses.length
+              count: msg.params.toolUses.length
             });
             this.emit("permissionRequest", {
               request: msg,
@@ -14403,7 +14545,7 @@ var MessageRouter = class _MessageRouter extends EventEmitter3 {
               requestId: msg.id,
               sessionId: msg.params.sessionId,
               method: msg.method,
-              questionCount: msg.params.questions.length,
+              count: msg.params.questions.length,
               toolCallId: msg.params.toolCallId
             });
             this.emit("askUserRequest", {
@@ -14515,7 +14657,7 @@ var MessageRouter = class _MessageRouter extends EventEmitter3 {
       "type"
     ]);
     logInfo("[MessageRouter] Received unsupported session notification", {
-      notificationType: notificationType ?? void 0,
+      type: notificationType ?? void 0,
       isError: !!protocolVersionMismatch,
       version: protocolVersionMismatch?.localFactoryProtocolVersion,
       sessionId: sessionId ?? void 0
@@ -14637,507 +14779,148 @@ var ReconnectionStrategy = class {
   }
 };
 
-// ../daemon-sdk/src/session/handlers/AskUserRequestHandler.ts
-import { EventEmitter as EventEmitter4 } from "eventemitter3";
-var AskUserRequestHandler = class _AskUserRequestHandler extends EventEmitter4 {
-  pendingRequests = /* @__PURE__ */ new Map();
-  handleAskUserRequest(request, id, sessionId, context) {
-    logInfo("[AskUserRequestHandler] Handling ask-user request", {
-      requestId: id,
-      sessionId,
-      toolCallId: request.params.toolCallId,
-      questionCount: request.params.questions.length
-    });
-    const pending = {
-      requestId: id,
-      sessionId,
-      toolCallId: request.params.toolCallId,
-      questions: request.params.questions,
-      timestamp: Date.now(),
-      ...context?.isRestored ? { isRestored: true } : {}
-    };
-    const existingRequest = this.pendingRequests.get(id);
-    if (existingRequest) {
-      this.pendingRequests.set(id, pending);
-      logInfo("[AskUserRequestHandler] Duplicate ask-user request replay", {
-        requestId: id,
-        sessionId
-      });
-      return;
-    }
-    this.pendingRequests.set(id, pending);
-    this.emit("askUserRequested", pending);
-  }
-  resolveAskUser(id, result) {
-    const pending = this.pendingRequests.get(id);
-    if (!pending) {
-      logWarn("[AskUserRequestHandler] No pending ask-user request found", {
-        requestId: id
-      });
-      return;
-    }
-    _AskUserRequestHandler.validateResult(pending, result);
-    this.pendingRequests.delete(id);
-    this.emit("askUserResolved", id, result);
-  }
-  clearAskUser(id) {
-    const pending = this.pendingRequests.get(id);
-    if (!pending) {
-      logWarn(
-        "[AskUserRequestHandler] No pending ask-user request found to clear",
-        {
-          requestId: id
-        }
-      );
-      return;
-    }
-    this.pendingRequests.delete(id);
-    this.emit("askUserResolved", id);
+// ../daemon-sdk/src/session/state/enums.ts
+var QueuedUserMessageKind = /* @__PURE__ */ ((QueuedUserMessageKind2) => {
+  QueuedUserMessageKind2["LocalDeferredAfterEsc"] = "local_deferred_after_esc";
+  QueuedUserMessageKind2["LocalPausedAfterEsc"] = "local_paused_after_esc";
+  QueuedUserMessageKind2["DaemonQueuedDiscardable"] = "daemon_queued_discardable";
+  QueuedUserMessageKind2["DaemonQueuedEndOfLoop"] = "daemon_queued_end_of_loop";
+  QueuedUserMessageKind2["LocalDeferredDuringManualCompaction"] = "local_deferred_during_manual_compaction";
+  return QueuedUserMessageKind2;
+})(QueuedUserMessageKind || {});
+var QueuedUserMessageDisplayGroup = /* @__PURE__ */ ((QueuedUserMessageDisplayGroup2) => {
+  QueuedUserMessageDisplayGroup2["Steering"] = "steering";
+  QueuedUserMessageDisplayGroup2["Queued"] = "queued";
+  return QueuedUserMessageDisplayGroup2;
+})(QueuedUserMessageDisplayGroup || {});
+
+// ../daemon-sdk/src/session/state/queuedUserMessageHelpers.ts
+var QUEUED_MESSAGE_KIND_METADATA = {
+  ["local_deferred_after_esc" /* LocalDeferredAfterEsc */]: {
+    displayGroup: "steering" /* Steering */
+  },
+  ["local_paused_after_esc" /* LocalPausedAfterEsc */]: {
+    reviewable: true,
+    displayGroup: "queued" /* Queued */,
+    reviewPriority: 1
+  },
+  ["daemon_queued_discardable" /* DaemonQueuedDiscardable */]: {
+    daemonBacked: true,
+    reviewable: true,
+    displayGroup: "steering" /* Steering */,
+    reviewPriority: 0
+  },
+  ["daemon_queued_end_of_loop" /* DaemonQueuedEndOfLoop */]: {
+    daemonBacked: true,
+    reviewable: true,
+    displayGroup: "queued" /* Queued */,
+    reviewPriority: 1
+  },
+  ["local_deferred_during_manual_compaction" /* LocalDeferredDuringManualCompaction */]: {
+    displayGroup: "queued" /* Queued */
   }
-  clearSessionAskUserRequests(sessionId) {
-    const requestsToRemove = Array.from(this.pendingRequests.values()).filter(
-      (request) => request.sessionId === sessionId
-    );
-    for (const request of requestsToRemove) {
-      this.clearAskUser(request.requestId);
+};
+function isDaemonQueuedMessageKind(kind) {
+  return QUEUED_MESSAGE_KIND_METADATA[kind].daemonBacked === true;
+}
+function isReviewableQueuedMessageKind(kind) {
+  return QUEUED_MESSAGE_KIND_METADATA[kind].reviewable === true;
+}
+function getQueuedUserMessageDisplayGroup(kind) {
+  return QUEUED_MESSAGE_KIND_METADATA[kind].displayGroup;
+}
+function getQueuedUserMessageReviewPriority(kind) {
+  return QUEUED_MESSAGE_KIND_METADATA[kind].reviewPriority ?? null;
+}
+function getQueuedUserMessageKindForQueuePlacement(queuePlacement) {
+  return queuePlacement === "end_of_loop" /* EndOfLoop */ ? "daemon_queued_end_of_loop" /* DaemonQueuedEndOfLoop */ : "daemon_queued_discardable" /* DaemonQueuedDiscardable */;
+}
+
+// ../daemon-sdk/src/session/queueLoadReconciliation.ts
+function getSendableContentFromBlocks(content) {
+  const images = [];
+  const files = [];
+  const textBlocks = [];
+  const orderedContent = [];
+  for (const block of content) {
+    if (block.type === "image" /* Image */) {
+      images.push(block.source);
+      orderedContent.push(block);
+    } else if (block.type === "document" /* Document */) {
+      files.push(block.source);
+    } else if (block.type === "text" /* Text */) {
+      textBlocks.push(block.text);
+      orderedContent.push(block);
     }
   }
-  cancelAskUser(id) {
-    this.resolveAskUser(id, { cancelled: true, answers: [] });
-  }
-  getPendingAskUserRequests() {
-    return Array.from(this.pendingRequests.values());
-  }
-  getPendingAskUserRequest(id) {
-    return this.pendingRequests.get(id);
+  return {
+    text: textBlocks.join("\n").trim(),
+    images,
+    files,
+    orderedContent
+  };
+}
+function getQueuePlacementForQueuedMessageKind(kind) {
+  return kind === "daemon_queued_end_of_loop" /* DaemonQueuedEndOfLoop */ ? "end_of_loop" /* EndOfLoop */ : "end_of_turn" /* EndOfTurn */;
+}
+function documentSourcesMatch(left, right) {
+  if (left.type !== right.type || left.mediaType !== right.mediaType) {
+    return false;
   }
-  clearAll() {
-    this.pendingRequests.clear();
+  if (left.type === "base64" /* Base64 */ && right.type === "base64" /* Base64 */) {
+    return left.data === right.data && left.name === right.name && left.parsedData === right.parsedData && left.path === right.path;
   }
-  destroy() {
-    this.clearAll();
-    this.removeAllListeners();
+  if (left.type === "text" /* Text */ && right.type === "text" /* Text */) {
+    return left.data === right.data && left.name === right.name && left.mime === right.mime;
   }
-  static validateResult(pending, result) {
-    if (result.cancelled === true) {
-      return;
+  return false;
+}
+function imageSourcesMatch(left, right) {
+  return left.type === right.type && left.data === right.data && left.mediaType === right.mediaType;
+}
+function arrayItemsMatch(left, right, matches) {
+  return left.length === right.length && left.every((leftItem, index) => matches(leftItem, right[index]));
+}
+function orderedContentBlocksMatch(left, right) {
+  return arrayItemsMatch(left, right, (leftBlock, rightBlock) => {
+    if (leftBlock.type !== rightBlock.type) return false;
+    if (leftBlock.type === "text" /* Text */ && rightBlock.type === "text" /* Text */) {
+      return leftBlock.text === rightBlock.text;
     }
-    const questionsByIndex = new Map(
-      pending.questions.map((q) => [q.index, q])
-    );
-    const answered = /* @__PURE__ */ new Set();
-    for (const answer of result.answers) {
-      const question = questionsByIndex.get(answer.index);
-      if (!question) {
-        throw new MetaError("Answer references unknown question index", {
-          requestId: pending.requestId,
-          index: answer.index
-        });
-      }
-      if (answered.has(answer.index)) {
-        throw new MetaError("Duplicate answers for question index", {
-          requestId: pending.requestId,
-          index: answer.index
-        });
-      }
-      answered.add(answer.index);
-    }
-    const missing = pending.questions.map((q) => q.index).filter((idx) => !answered.has(idx));
-    if (missing.length > 0) {
-      throw new MetaError("Missing answers for some questions", {
-        requestId: pending.requestId,
-        missing: missing.map(String)
-      });
-    }
-  }
-};
-
-// ../daemon-sdk/src/session/handlers/PendingUserActionStore.ts
-var PendingUserActionStore = class {
-  permissionsByToolUseId = /* @__PURE__ */ new Map();
-  askUsersBySession = /* @__PURE__ */ new Map();
-  savePermission(action) {
-    this.permissionsByToolUseId.set(action.toolUseId, action);
-    logInfo("[PendingUserActionStore] Stored permission for later replay", {
-      sessionId: action.sessionId,
-      requestId: action.requestId,
-      toolUseId: action.toolUseId,
-      selectedOptionLabel: action.selectedOption
-    });
-  }
-  saveAskUser(action) {
-    let map = this.askUsersBySession.get(action.sessionId);
-    if (!map) {
-      map = /* @__PURE__ */ new Map();
-      this.askUsersBySession.set(action.sessionId, map);
-    }
-    map.set(action.toolCallId, action);
-    logInfo("[PendingUserActionStore] Stored ask-user for later replay", {
-      sessionId: action.sessionId,
-      requestId: action.requestId,
-      toolCallId: action.toolCallId
-    });
-  }
-  /** Peek a buffered permission response by its globally-unique tool-use id. */
-  getForToolUse(toolUseId) {
-    return this.permissionsByToolUseId.get(toolUseId);
-  }
-  getForToolCall(sessionId, toolCallId) {
-    return this.askUsersBySession.get(sessionId)?.get(toolCallId);
-  }
-  /** Remove and return a buffered permission response by tool-use id. */
-  takeForToolUse(toolUseId) {
-    const action = this.permissionsByToolUseId.get(toolUseId);
-    if (!action) return void 0;
-    this.permissionsByToolUseId.delete(toolUseId);
-    return action;
-  }
-  takeForToolCall(sessionId, toolCallId) {
-    const map = this.askUsersBySession.get(sessionId);
-    if (!map) return void 0;
-    const action = map.get(toolCallId);
-    if (!action) return void 0;
-    map.delete(toolCallId);
-    if (map.size === 0) this.askUsersBySession.delete(sessionId);
-    return action;
-  }
-  getPermissionsForSession(sessionId) {
-    return Array.from(this.permissionsByToolUseId.values()).filter(
-      (action) => action.sessionId === sessionId
-    );
-  }
-  getAskUsersForSession(sessionId) {
-    const map = this.askUsersBySession.get(sessionId);
-    return map ? Array.from(map.values()) : [];
-  }
-  clearSession(sessionId) {
-    let permCount = 0;
-    for (const [toolUseId, action] of this.permissionsByToolUseId) {
-      if (action.sessionId === sessionId) {
-        this.permissionsByToolUseId.delete(toolUseId);
-        permCount += 1;
-      }
-    }
-    const askCount = this.askUsersBySession.get(sessionId)?.size ?? 0;
-    this.askUsersBySession.delete(sessionId);
-    const total = permCount + askCount;
-    if (total > 0) {
-      logInfo("[PendingUserActionStore] Cleared session", {
-        sessionId,
-        pendingRequestCount: permCount,
-        questionCount: askCount
-      });
+    if (leftBlock.type === "image" /* Image */ && rightBlock.type === "image" /* Image */) {
+      return imageSourcesMatch(leftBlock.source, rightBlock.source) && leftBlock.generated === rightBlock.generated;
     }
-    return total;
-  }
-  clearAll() {
-    this.permissionsByToolUseId.clear();
-    this.askUsersBySession.clear();
-  }
-  destroy() {
-    this.clearAll();
-  }
-};
-
-// ../daemon-sdk/src/session/handlers/PermissionRequestHandler.ts
-import { EventEmitter as EventEmitter5 } from "eventemitter3";
-function normalizeAssociatedSessionIds(sessionId, associatedSessionIds) {
-  return Array.from(/* @__PURE__ */ new Set([sessionId, ...associatedSessionIds ?? []]));
+    return false;
+  });
 }
-var PermissionRequestHandler = class extends EventEmitter5 {
-  pendingPermissions = /* @__PURE__ */ new Map();
-  statistics = {
-    total: 0,
-    approved: 0,
-    denied: 0,
-    timedOut: 0
-  };
-  /**
-   * Handle an incoming permission request
-   */
-  handlePermissionRequest(request, id, sessionId, context) {
-    logInfo("[PermissionRequestHandler] Handling permission request", {
-      requestId: id,
-      sessionId,
-      toolCount: request.params.toolUses.length,
-      options: request.params.options
-    });
-    const { options } = request.params;
-    const toolUses = request.params.toolUses.map((tool) => ({
-      ...tool,
-      toolUse: {
-        ...tool.toolUse,
-        input: getPermissionToolInputForDisplay2({
-          confirmationType: tool.confirmationType,
-          details: tool.details,
-          toolInput: tool.toolUse.input
-        })
-      }
-    }));
-    const requestAssociatedSessionIds = normalizeAssociatedSessionIds(
-      sessionId,
-      request.params.associatedSessionIds
-    );
-    const existingPermission = this.pendingPermissions.get(id);
-    const associatedSessionIds = existingPermission ? normalizeAssociatedSessionIds(sessionId, [
-      ...existingPermission.associatedSessionIds,
-      ...requestAssociatedSessionIds
-    ]) : requestAssociatedSessionIds;
-    const pendingPermission = {
-      requestId: id,
-      sessionId,
-      associatedSessionIds,
-      toolUses,
-      options,
-      timestamp: Date.now(),
-      ...context?.isRestored ? { isRestored: true } : {}
-    };
-    if (existingPermission) {
-      this.pendingPermissions.set(id, pendingPermission);
-      const addedSurface = associatedSessionIds.some(
-        (associatedSessionId) => !existingPermission.associatedSessionIds.includes(associatedSessionId)
-      );
-      logInfo(
-        "[PermissionRequestHandler] Duplicate permission request replay",
-        {
-          requestId: id,
-          sessionId
-        }
-      );
-      if (addedSurface) {
-        this.emit("permissionRequested", pendingPermission);
-      }
-      return;
-    }
-    const incomingToolUseIds = new Set(
-      toolUses.map((toolUse) => toolUse.toolUse.id)
-    );
-    for (const [pendingId, pending] of this.pendingPermissions.entries()) {
-      if (pending.toolUses.some(
-        (toolUse) => incomingToolUseIds.has(toolUse.toolUse.id)
-      )) {
-        this.clearPermission(pendingId, { emitResolved: true });
-      }
-    }
-    this.pendingPermissions.set(id, pendingPermission);
-    this.statistics.total++;
-    logInfo("[PermissionRequestHandler] Stored pending permission", {
-      requestId: id,
-      totalCount: this.pendingPermissions.size
-    });
-    logInfo("[PermissionRequestHandler] Emitting permissionRequested event", {
-      requestId: id
-    });
-    this.emit("permissionRequested", pendingPermission);
-  }
-  /**
-   * Resolve a permission request with user's choice
-   */
-  resolvePermission(id, option) {
-    const pending = this.pendingPermissions.get(id);
-    if (!pending) {
-      throw new MetaError("No pending permission found", { requestId: id });
-    }
-    const isValidOption = pending.options.some((opt) => opt.value === option);
-    if (!isValidOption) {
-      const allowedOptions = pending.options.map((opt) => opt.value);
-      throw new MetaError(
-        `Invalid permission option: ${option}. Allowed: ${allowedOptions.join(", ")}`,
-        {
-          requestId: id
-        }
-      );
-    }
-    this.pendingPermissions.delete(id);
-    if (option !== "cancel" /* Cancel */) {
-      this.statistics.approved++;
-    } else {
-      this.statistics.denied++;
-    }
-    this.emit("permissionResolved", id, option);
-  }
-  /**
-   * Clear a specific permission without an outcome.
-   */
-  clearPermission(id, options) {
-    this.pendingPermissions.delete(id);
-    if (options?.emitResolved) {
-      this.emit("permissionResolved", id);
-    }
-  }
-  /**
-   * Clear all pending permissions for a specific session.
-   *
-   * With `preserveRelayed`, permissions surfaced on multiple sessions (a
-   * relayed subagent permission whose `associatedSessionIds` extend beyond this
-   * session) are kept. loadSession uses this so reloading the parent doesn't
-   * wipe a child's still-pending prompt that the daemon's parent-session load
-   * never returns.
-   */
-  clearSessionPermissions(sessionId, options) {
-    const permissionsToRemove = [];
-    for (const [id, permission] of this.pendingPermissions.entries()) {
-      if (permission.sessionId !== sessionId) {
-        continue;
-      }
-      if (options?.preserveRelayed && permission.associatedSessionIds.some(
-        (associatedId) => associatedId !== sessionId
-      )) {
-        continue;
-      }
-      permissionsToRemove.push(id);
-    }
-    for (const id of permissionsToRemove) {
-      this.clearPermission(id, options);
-    }
-    logInfo("[PermissionRequestHandler] Cleared permissions for session", {
-      sessionId,
-      count: permissionsToRemove.length
+function hasCanonicalFallbackOrder(content) {
+  const fallbackContent = [
+    ...content.images.map(
+      (source) => ({
+        type: "image" /* Image */,
+        source
+      })
+    )
+  ];
+  if (content.text) {
+    fallbackContent.push({
+      type: "text" /* Text */,
+      text: content.text
     });
   }
-  /**
-   * Clear all pending permissions
-   */
-  clearAllPermissions() {
-    this.pendingPermissions.clear();
-  }
-  /**
-   * Get all pending permissions
-   */
-  getPendingPermissions() {
-    return Array.from(this.pendingPermissions.values());
-  }
-  getPendingPermissionsForSession(sessionId) {
-    return this.getPendingPermissions().filter(
-      (permission) => permission.associatedSessionIds.includes(sessionId)
-    );
-  }
-  /**
-   * Get a specific pending permission
-   */
-  getPendingPermission(id) {
-    return this.pendingPermissions.get(id);
-  }
-  /**
-   * Check if there are any pending permissions
-   */
-  hasPendingPermissions() {
-    return this.pendingPermissions.size > 0;
-  }
-  /**
-   * Destroy and clean up
-   */
-  destroy() {
-    this.clearAllPermissions();
-    this.removeAllListeners();
-  }
-};
-
-// ../daemon-sdk/src/session/state/enums.ts
-var QueuedUserMessageKind = /* @__PURE__ */ ((QueuedUserMessageKind2) => {
-  QueuedUserMessageKind2["LocalDeferredAfterEsc"] = "local_deferred_after_esc";
-  QueuedUserMessageKind2["LocalPausedAfterEsc"] = "local_paused_after_esc";
-  QueuedUserMessageKind2["DaemonQueuedDiscardable"] = "daemon_queued_discardable";
-  QueuedUserMessageKind2["DaemonQueuedEndOfLoop"] = "daemon_queued_end_of_loop";
-  QueuedUserMessageKind2["LocalDeferredDuringManualCompaction"] = "local_deferred_during_manual_compaction";
-  return QueuedUserMessageKind2;
-})(QueuedUserMessageKind || {});
-var QueuedUserMessageDisplayGroup = /* @__PURE__ */ ((QueuedUserMessageDisplayGroup2) => {
-  QueuedUserMessageDisplayGroup2["Steering"] = "steering";
-  QueuedUserMessageDisplayGroup2["Queued"] = "queued";
-  return QueuedUserMessageDisplayGroup2;
-})(QueuedUserMessageDisplayGroup || {});
-
-// ../daemon-sdk/src/session/state/queuedUserMessageHelpers.ts
-var QUEUED_MESSAGE_KIND_METADATA = {
-  ["local_deferred_after_esc" /* LocalDeferredAfterEsc */]: {
-    displayGroup: "steering" /* Steering */
-  },
-  ["local_paused_after_esc" /* LocalPausedAfterEsc */]: {
-    reviewable: true,
-    displayGroup: "queued" /* Queued */,
-    reviewPriority: 1
-  },
-  ["daemon_queued_discardable" /* DaemonQueuedDiscardable */]: {
-    daemonBacked: true,
-    reviewable: true,
-    displayGroup: "steering" /* Steering */,
-    reviewPriority: 0
-  },
-  ["daemon_queued_end_of_loop" /* DaemonQueuedEndOfLoop */]: {
-    daemonBacked: true,
-    reviewable: true,
-    displayGroup: "queued" /* Queued */,
-    reviewPriority: 1
-  },
-  ["local_deferred_during_manual_compaction" /* LocalDeferredDuringManualCompaction */]: {
-    displayGroup: "queued" /* Queued */
-  }
-};
-function isDaemonQueuedMessageKind(kind) {
-  return QUEUED_MESSAGE_KIND_METADATA[kind].daemonBacked === true;
-}
-function isReviewableQueuedMessageKind(kind) {
-  return QUEUED_MESSAGE_KIND_METADATA[kind].reviewable === true;
-}
-function getQueuedUserMessageDisplayGroup(kind) {
-  return QUEUED_MESSAGE_KIND_METADATA[kind].displayGroup;
-}
-function getQueuedUserMessageReviewPriority(kind) {
-  return QUEUED_MESSAGE_KIND_METADATA[kind].reviewPriority ?? null;
-}
-function getQueuedUserMessageKindForQueuePlacement(queuePlacement) {
-  return queuePlacement === "end_of_loop" /* EndOfLoop */ ? "daemon_queued_end_of_loop" /* DaemonQueuedEndOfLoop */ : "daemon_queued_discardable" /* DaemonQueuedDiscardable */;
-}
-
-// ../daemon-sdk/src/session/queueLoadReconciliation.ts
-function getSendableContentFromBlocks(content) {
-  const images = [];
-  const files = [];
-  const textBlocks = [];
-  for (const block of content) {
-    if (block.type === "image" /* Image */) {
-      images.push(block.source);
-    } else if (block.type === "document" /* Document */) {
-      files.push(block.source);
-    } else if (block.type === "text" /* Text */) {
-      textBlocks.push(block.text);
-    }
-  }
-  return {
-    text: textBlocks.join("\n").trim(),
-    images,
-    files
-  };
-}
-function getQueuePlacementForQueuedMessageKind(kind) {
-  return kind === "daemon_queued_end_of_loop" /* DaemonQueuedEndOfLoop */ ? "end_of_loop" /* EndOfLoop */ : "end_of_turn" /* EndOfTurn */;
-}
-function documentSourcesMatch(left, right) {
-  if (left.type !== right.type || left.mediaType !== right.mediaType) {
-    return false;
-  }
-  if (left.type === "base64" /* Base64 */ && right.type === "base64" /* Base64 */) {
-    return left.data === right.data && left.name === right.name && left.parsedData === right.parsedData && left.path === right.path;
-  }
-  if (left.type === "text" /* Text */ && right.type === "text" /* Text */) {
-    return left.data === right.data && left.name === right.name && left.mime === right.mime;
-  }
-  return false;
-}
-function imageSourcesMatch(left, right) {
-  return left.type === right.type && left.data === right.data && left.mediaType === right.mediaType;
-}
-function arrayItemsMatch(left, right, matches) {
-  return left.length === right.length && left.every((leftItem, index) => matches(leftItem, right[index]));
+  return orderedContentBlocksMatch(content.orderedContent, fallbackContent);
 }
 function sendableContentMatches(left, right) {
-  return left.text === right.text && arrayItemsMatch(left.images, right.images, imageSourcesMatch) && arrayItemsMatch(left.files, right.files, documentSourcesMatch);
+  const fallbackFieldsMatch = left.text === right.text && arrayItemsMatch(left.images, right.images, imageSourcesMatch) && arrayItemsMatch(left.files, right.files, documentSourcesMatch);
+  if (!fallbackFieldsMatch) return false;
+  if (left.files.length > 0 || right.files.length > 0) return true;
+  return hasCanonicalFallbackOrder(left) && hasCanonicalFallbackOrder(right) || orderedContentBlocksMatch(left.orderedContent, right.orderedContent);
 }
 function buildStaleQueuedMessageResubmitParams(message) {
   const content = getSendableContentFromBlocks(message.content);
   return {
     text: content.text,
+    ...content.files.length === 0 && !hasCanonicalFallbackOrder(content) ? { content: content.orderedContent } : {},
     ...content.images.length > 0 ? { images: content.images } : {},
     ...content.files.length > 0 ? { files: content.files } : {},
     queuePlacement: getQueuePlacementForQueuedMessageKind(message.kind)
@@ -15176,6 +14959,7 @@ async function reconcileQueuedMessagesAfterLoad(params) {
     (queuedMsg) => {
       const content = buildUserMessageContentBlocks2({
         text: queuedMsg.text,
+        content: queuedMsg.content,
         images: queuedMsg.images,
         files: queuedMsg.files
       });
@@ -15320,29 +15104,42 @@ function taskInvocationStatusForCompletionReason(reason) {
       return "failed" /* Failed */;
   }
 }
-var DaemonSessionController = class _DaemonSessionController extends EventEmitter6 {
+var DaemonSessionController = class _DaemonSessionController extends EventEmitter4 {
   daemonClient;
   messageRouter;
-  permissionHandler;
+  // Session-scoped prompt state (pending permissions, pending ask-user
+  // requests, buffered answers) lives on the shared app-lifetime
+  // MultiSessionStateManager, not on this per-connection controller, so it
+  // survives controller teardown/recreation. These accessors keep call sites
+  // unchanged.
+  get permissionHandler() {
+    return this.sessionStateManager.permissionRequests;
+  }
   // Per-session permission subscribers. A subagent (child Task) permission is
   // fanned out to every subscribed session in its `associatedSessionIds`, so a
   // child's prompt surfaces on both the child and its parent.
   sessionPermissionSubscribers = /* @__PURE__ */ new Map();
-  askUserHandler;
+  get askUserHandler() {
+    return this.sessionStateManager.askUserRequests;
+  }
   // Buffered prompt responses for inactive sessions.
-  pendingUserActionStore;
-  // Disconnected sessions whose prompt responses should be buffered.
-  inactiveSessions = /* @__PURE__ */ new Set();
-  // Sessions currently draining a batch of concurrent prompts (e.g. parallel
-  // foreground subagents each relaying an Execute permission to the parent
-  // session). While draining, a resume reflects one prompt being answered while
-  // siblings remain genuinely pending, so resume-driven auto-clear is
-  // suppressed until every prompt for the session has resolved.
-  sessionsWithConcurrentPrompts = /* @__PURE__ */ new Set();
-  // Sessions with a self-resume loadSession already in flight.
+  get pendingUserActionStore() {
+    return this.sessionStateManager.pendingUserActions;
+  }
+  // Teardown hooks for this controller's listeners on the shared prompt
+  // stores. The stores outlive the controller, so destroy() must detach
+  // exactly this controller's listeners (removeAllListeners would detach
+  // other controllers' too).
+  promptStoreUnsubscribes = [];
+  // Whether a session's worker is paused (buffer responses), whether a session
+  // is draining a concurrent prompt batch (suppress resume-driven auto-clear),
+  // and the spawn options replayed on self-resume all describe the *session*,
+  // not this connection, so they live on the shared app-lifetime
+  // MultiSessionStateManager and survive controller teardown/recreation.
+  // Sessions with a self-resume loadSession already in flight. Stays on this
+  // controller: it dedupes an in-flight RPC/retry loop on this connection's
+  // daemonClient, not session state.
   selfResumeInFlight = /* @__PURE__ */ new Set();
-  // Last loadSession spawn options, reused for self-resume.
-  sessionLoadOptions = /* @__PURE__ */ new Map();
   // addUserMessage responses can resolve after their CREATE_MESSAGE notification.
   // Track that ordering so an already-confirmed turn is not added to the
   // visible queue after its real user message has been rendered.
@@ -15400,9 +15197,6 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
     this.messageRouter = new MessageRouter({
       emitReceiveSpans: config.clientType !== "cli"
     });
-    this.permissionHandler = new PermissionRequestHandler();
-    this.askUserHandler = new AskUserRequestHandler();
-    this.pendingUserActionStore = new PendingUserActionStore();
     this.sessionStateManager = sessionStateManager;
     this.missionStateManager = missionStateManager ?? null;
     const reconnectDelegated = config.machineType === "local" /* Local */ ? config.reconnectDelegated ?? false : false;
@@ -15453,12 +15247,17 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
       this.connectAttemptContext = previous;
     }
   }
-  /**
-   * Check if the client is a desktop app.
-   * Uses injectable clientType from config instead of checking window.electronAPI.
-   */
-  isDesktopApp() {
-    return this.getClientType() === "desktop";
+  getFactoryClientType() {
+    switch (this.getClientType()) {
+      case "desktop":
+        return "web-desktop" /* WebDesktop */;
+      case "cli":
+        return "cli" /* CLI */;
+      case "sdk":
+        return "sdk" /* SDK */;
+      case "web":
+        return "web-app" /* WebApp */;
+    }
   }
   /**
    * Get the mission store for a session.
@@ -15763,9 +15562,10 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
       }
       case "droid_working_state_changed" /* DROID_WORKING_STATE_CHANGED */: {
         const { type: _, ...stateNotification } = notification;
+        const effectiveState = this.sessionStateManager.getSessionManager(sessionId)?.getDroidWorkingState() ?? stateNotification.newState;
         this.emit("droidWorkingStateChanged" /* DroidWorkingStateChanged */, {
           sessionId,
-          newState: stateNotification.newState
+          newState: effectiveState
         });
         break;
       }
@@ -16016,15 +15816,15 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
     }
     logInfo("[DaemonSessionController] Clearing pending user actions", {
       sessionId,
-      pendingRequestCount: pendingPermissionCount,
-      questionCount: pendingAskUserCount
+      pendingCount: pendingPermissionCount,
+      totalQuestions: pendingAskUserCount
     });
     this.permissionHandler.clearSessionPermissions(sessionId, {
       emitResolved: true,
       preserveRelayed: options?.preserveRelayedPermissions
     });
     this.askUserHandler.clearSessionAskUserRequests(sessionId);
-    this.sessionsWithConcurrentPrompts.delete(sessionId);
+    this.sessionStateManager.clearConcurrentPrompts(sessionId);
   }
   getPendingPermissionCountForSession(sessionId) {
     return this.permissionHandler.getPendingPermissions().filter(
@@ -16034,6 +15834,40 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
   hasPendingUserActionForSession(sessionId) {
     return this.getPendingPermissionCountForSession(sessionId) > 0 || this.askUserHandler.getPendingAskUserRequests().some((request) => request.sessionId === sessionId);
   }
+  /**
+   * A dead worker can be idle while its session is still waiting on a prompt
+   * owned by this controller. Keep the composite session state waiting until
+   * the buffered response is replayed or the prompt is explicitly cleared.
+   */
+  preserveInactivePendingUserActionState(sessionId) {
+    if (!this.sessionStateManager.isSessionInactive(sessionId) || !this.hasPendingUserActionForSession(sessionId)) {
+      return false;
+    }
+    const sessionManager = this.sessionStateManager.getSessionManager(sessionId);
+    if (sessionManager?.getDroidWorkingState() !== "waiting_for_tool_confirmation" /* WaitingForToolConfirmation */) {
+      sessionManager?.setWaitingForConfirmation();
+    }
+    return true;
+  }
+  /**
+   * Rewrite ONLY the inactivity-companion Idle: a paused worker reports Idle
+   * while its session still owes a prompt owned by this controller, and that
+   * bare Idle must not terminalize the composite state. A non-Idle
+   * notification is a genuine wake (a respawned worker or another attached
+   * client) and must pass through untouched — rewriting it would plant a
+   * Waiting state whose revision bump then defeats the load hydration guards
+   * while reconciliation clears the prompt, stranding the session in
+   * WaitingForToolConfirmation with zero answerable prompts.
+   */
+  getEffectiveStateNotification(notification, sessionId) {
+    if (notification.type === "droid_working_state_changed" /* DROID_WORKING_STATE_CHANGED */ && notification.newState === "idle" /* Idle */ && this.sessionStateManager.isSessionInactive(sessionId) && this.hasPendingUserActionForSession(sessionId)) {
+      return {
+        ...notification,
+        newState: "waiting_for_tool_confirmation" /* WaitingForToolConfirmation */
+      };
+    }
+    return notification;
+  }
   markConcurrentPermissionSurfaces(sessionIds) {
     const pendingPermissions = this.permissionHandler.getPendingPermissions();
     for (const sessionId of sessionIds) {
@@ -16045,15 +15879,15 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
       }
       for (const permission of pendingForSession) {
         for (const associatedSessionId of permission.associatedSessionIds) {
-          this.sessionsWithConcurrentPrompts.add(associatedSessionId);
+          this.sessionStateManager.markConcurrentPrompts(associatedSessionId);
         }
       }
     }
   }
   clearDrainedConcurrentPromptMarkers(sessionIds) {
     for (const sessionId of sessionIds) {
-      if (this.sessionsWithConcurrentPrompts.has(sessionId) && !this.hasPendingUserActionForSession(sessionId)) {
-        this.sessionsWithConcurrentPrompts.delete(sessionId);
+      if (this.sessionStateManager.hasConcurrentPrompts(sessionId) && !this.hasPendingUserActionForSession(sessionId)) {
+        this.sessionStateManager.clearConcurrentPrompts(sessionId);
       }
     }
   }
@@ -16071,27 +15905,27 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
    * draining a concurrent batch.
    *
    * An inactive session has NOT resumed — it paused (inactivity timeout /
-   * process exit) with its working state reset to Idle. SESSION_INACTIVITY
-   * deliberately preserves outstanding prompts "for later replay", so the
-   * Idle working-state notification that accompanies the pause must not be
-   * mistaken for a resume and clear them. The next successful loadSession
-   * reconciles prompts from the daemon (RT-321).
+   * process exit). SESSION_INACTIVITY deliberately preserves outstanding
+   * prompts "for later replay", so a raw Idle worker-state notification that
+   * accompanies the pause must not be mistaken for a resume and clear them.
+   * The controller keeps the effective session state waiting until the next
+   * successful loadSession reconciles prompts from the daemon.
    */
   clearStalePromptsOnResume(sessionId) {
-    if (this.inactiveSessions.has(sessionId)) {
+    if (this.sessionStateManager.isSessionInactive(sessionId)) {
       return;
     }
     const pendingPermissionCount = this.getPendingPermissionCountForSession(sessionId);
     const pendingAskUserCount = this.askUserHandler.getPendingAskUserRequests().filter((request) => request.sessionId === sessionId).length;
     if (pendingPermissionCount === 0 && pendingAskUserCount === 0) {
-      this.sessionsWithConcurrentPrompts.delete(sessionId);
+      this.sessionStateManager.clearConcurrentPrompts(sessionId);
       return;
     }
     if (pendingPermissionCount > 1 || pendingAskUserCount > 1) {
-      this.sessionsWithConcurrentPrompts.add(sessionId);
+      this.sessionStateManager.markConcurrentPrompts(sessionId);
       return;
     }
-    if (this.sessionsWithConcurrentPrompts.has(sessionId)) {
+    if (this.sessionStateManager.hasConcurrentPrompts(sessionId)) {
       return;
     }
     this.clearPendingUserActionsForSession(sessionId, {
@@ -16133,30 +15967,31 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
       }
       case "session_inactivity" /* SESSION_INACTIVITY */:
       case "session_process_exited" /* SESSION_PROCESS_EXITED */: {
-        this.inactiveSessions.add(sessionId);
+        this.sessionStateManager.markSessionInactive(sessionId);
         const pendingPermissionCount = this.permissionHandler.getPendingPermissions().filter((p) => p.sessionId === sessionId).length;
         const pendingAskUserCount = this.askUserHandler.getPendingAskUserRequests().filter((r) => r.sessionId === sessionId).length;
         logInfo(
           "[DaemonSessionController] Session became inactive; preserving pending prompts for later replay",
           {
             sessionId,
-            pendingRequestCount: pendingPermissionCount,
-            questionCount: pendingAskUserCount
+            pendingCount: pendingPermissionCount,
+            totalQuestions: pendingAskUserCount
           }
         );
         const sessionManager = this.sessionStateManager.getSessionManager(sessionId);
         if (sessionManager) {
-          sessionManager.stopStreaming();
+          const preservesPendingUserAction = this.preserveInactivePendingUserActionState(sessionId);
+          if (!preservesPendingUserAction && sessionManager.getDroidWorkingState() !== "idle" /* Idle */) {
+            sessionManager.applyDroidWorkingState("idle" /* Idle */);
+          }
           this.emit("droidWorkingStateChanged" /* DroidWorkingStateChanged */, {
             sessionId,
-            newState: "idle" /* Idle */
+            newState: sessionManager.getDroidWorkingState()
           });
         }
         break;
       }
       case "session_closed" /* SESSION_CLOSED */: {
-        this.inactiveSessions.delete(sessionId);
-        this.sessionLoadOptions.delete(sessionId);
         this.trackedChildSessionIds.delete(sessionId);
         this.childSessionAttachmentGeneration.delete(sessionId);
         this.clearPendingUserActionsForSession(sessionId);
@@ -16516,10 +16351,6 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
     });
     this.messageRouter.on("notification", ({ notification, sessionId }) => {
       const associatedPermissionSessionIds = notification.type === "permission_resolved" /* PERMISSION_RESOLVED */ ? this.permissionHandler.getPendingPermission(notification.requestId)?.associatedSessionIds.filter((id) => id !== sessionId) ?? [] : [];
-      const params = {
-        sessionId,
-        notification
-      };
       this.emit("sessionNotification" /* SessionNotification */, {
         sessionId,
         notification
@@ -16529,7 +16360,19 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
           notification.requestId
         );
       }
-      this.sessionStateManager.handleNotification(params);
+      const isInactiveNotification = notification.type === "session_inactivity" /* SESSION_INACTIVITY */ || notification.type === "session_process_exited" /* SESSION_PROCESS_EXITED */;
+      this.sessionStateManager.handleNotification(
+        {
+          sessionId,
+          notification: this.getEffectiveStateNotification(
+            notification,
+            sessionId
+          )
+        },
+        {
+          preserveWorkingStateOnInactive: isInactiveNotification && this.hasPendingUserActionForSession(sessionId)
+        }
+      );
       this.handleNotificationSideEffects(notification, sessionId);
       this.emitDroidEventForNotification(notification, sessionId);
       for (const associatedSessionId of associatedPermissionSessionIds) {
@@ -16573,7 +16416,7 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
         logInfo("[DaemonSessionController] Received permission request", {
           requestId,
           sessionId,
-          toolCount: request.params.toolUses.length
+          count: request.params.toolUses.length
         });
         if (!this.sessionStateManager.getSessionManager(sessionId)) {
           logWarn(
@@ -16608,7 +16451,11 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
         this.permissionHandler.handlePermissionRequest(
           requestWithAssociatedSessions,
           requestId,
-          sessionId
+          sessionId,
+          // Stamp the owning machine: this controller's daemon sent the
+          // request, so ownership filtering keeps working even when the
+          // session's manager binding is empty or later evicted.
+          { machineId: this.config.machineId }
         );
         this.markConcurrentPermissionSurfaces(
           /* @__PURE__ */ new Set([sessionId, ...associatedSessionIds])
@@ -16622,7 +16469,7 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
         logInfo("[DaemonSessionController] Received ask-user request", {
           requestId,
           sessionId,
-          questionCount: request.params.questions.length,
+          count: request.params.questions.length,
           toolCallId: request.params.toolCallId
         });
         if (!this.sessionStateManager.getSessionManager(sessionId)) {
@@ -16638,26 +16485,68 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
           sessionId,
           newState: "waiting_for_tool_confirmation" /* WaitingForToolConfirmation */
         });
-        this.askUserHandler.handleAskUserRequest(request, requestId, sessionId);
+        this.askUserHandler.handleAskUserRequest(
+          request,
+          requestId,
+          sessionId,
+          {
+            machineId: this.config.machineId
+          }
+        );
         void this.tryReplayBufferedAskUser(sessionId, requestId);
       }
     );
-    this.permissionHandler.on("permissionRequested", (permission) => {
+    const onPermissionRequested = (permission) => {
+      if (!this.machineOwnsPrompt(permission)) {
+        return;
+      }
       this.emit("permissionRequested" /* PermissionRequested */, permission);
       this.dispatchPermissionToSessionSubscribers(permission);
-    });
-    this.permissionHandler.on("permissionResolved", (id, option) => {
+    };
+    this.permissionHandler.on("permissionRequested", onPermissionRequested);
+    this.promptStoreUnsubscribes.push(
+      () => this.permissionHandler.off("permissionRequested", onPermissionRequested)
+    );
+    const onPermissionResolved = (id, option, context) => {
+      if (context && !this.machineOwnsPrompt(context)) {
+        return;
+      }
       this.emit("permissionResolved" /* PermissionResolved */, id, option);
-    });
-    this.permissionHandler.on("permissionTimeout", (id) => {
+    };
+    this.permissionHandler.on("permissionResolved", onPermissionResolved);
+    this.promptStoreUnsubscribes.push(
+      () => this.permissionHandler.off("permissionResolved", onPermissionResolved)
+    );
+    const onPermissionTimeout = (id, context) => {
+      if (context && !this.machineOwnsPrompt(context)) {
+        return;
+      }
       this.emit("permissionTimeout" /* PermissionTimeout */, id);
-    });
-    this.askUserHandler.on("askUserRequested", (req) => {
+    };
+    this.permissionHandler.on("permissionTimeout", onPermissionTimeout);
+    this.promptStoreUnsubscribes.push(
+      () => this.permissionHandler.off("permissionTimeout", onPermissionTimeout)
+    );
+    const onAskUserRequested = (req) => {
+      if (!this.machineOwnsPrompt(req)) {
+        return;
+      }
       this.emit("askUserRequested" /* AskUserRequested */, req);
-    });
-    this.askUserHandler.on("askUserResolved", (id, result) => {
+    };
+    this.askUserHandler.on("askUserRequested", onAskUserRequested);
+    this.promptStoreUnsubscribes.push(
+      () => this.askUserHandler.off("askUserRequested", onAskUserRequested)
+    );
+    const onAskUserResolved = (id, result, context) => {
+      if (context && !this.machineOwnsPrompt(context)) {
+        return;
+      }
       this.emit("askUserResolved" /* AskUserResolved */, id, result);
-    });
+    };
+    this.askUserHandler.on("askUserResolved", onAskUserResolved);
+    this.promptStoreUnsubscribes.push(
+      () => this.askUserHandler.off("askUserResolved", onAskUserResolved)
+    );
   }
   handleWebSocketMessage(data) {
     try {
@@ -16931,7 +16820,7 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
       token,
       ...options?.actAsGrant && { actAsGrant: options.actAsGrant },
       ...connectionId && { connectionId },
-      caller: this.isDesktopApp() ? "web-desktop" /* WebDesktop */ : "web-app" /* WebApp */,
+      caller: this.getFactoryClientType(),
       metadata: {
         tracing: {
           ...this.daemonClient.getTracingMetadata(),
@@ -16940,7 +16829,8 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
             connectAttemptId: this.connectAttemptContext.connectAttemptId,
             connectAttemptTrigger: this.connectAttemptContext.connectAttemptTrigger
           }
-        }
+        },
+        ...this.config.sdk && { sdk: this.config.sdk }
       }
     });
     try {
@@ -16962,7 +16852,7 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
     await this.daemonClient.logout();
     this._isAuthenticated = false;
     this.authenticationPromise = null;
-    this.permissionHandler.clearAllPermissions();
+    this.clearPromptsForOwnedSessions();
     this.emit("connectionStatusChanged" /* StatusChanged */, this.getConnectionStatus());
   }
   disconnect() {
@@ -16977,10 +16867,33 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
     this.isReconnecting = false;
     this._isAuthenticated = false;
     this.authenticationPromise = null;
-    this.permissionHandler.clearAllPermissions();
     this.daemonClient.destroy();
     this.emit("connectionStatusChanged" /* StatusChanged */, this.getConnectionStatus());
   }
+  /**
+   * Clear pending prompts owned by this controller's machine, leaving other
+   * machines' prompt state in the shared stores untouched.
+   *
+   * Ownership resolves from the machineId stamped on the record at intake,
+   * falling back to the session's manager binding when absent — the same
+   * identity the emission predicate uses, so a prompt this machine surfaced
+   * (including one taken in while its session was still `''`-bound optimistic
+   * or whose manager was since evicted) is cleared by this machine's logout.
+   */
+  clearPromptsForOwnedSessions() {
+    for (const permission of this.permissionHandler.getPendingPermissions()) {
+      if (this.getPromptOwnership(permission) === "owned") {
+        this.permissionHandler.clearPermission(permission.requestId, {
+          emitResolved: true
+        });
+      }
+    }
+    for (const request of this.askUserHandler.getPendingAskUserRequests()) {
+      if (this.getPromptOwnership(request) === "owned") {
+        this.askUserHandler.clearAskUser(request.requestId);
+      }
+    }
+  }
   /**
    * Send `initialize_session` to the daemon, transparently retrying on
    * RequestTimeoutError up to INITIALIZE_SESSION_MAX_ATTEMPTS. Other errors
@@ -17072,7 +16985,7 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
     if (callingToolUseId) {
       sessionManager?.getStore().setCallingToolUseId(callingToolUseId);
     }
-    this.sessionLoadOptions.set(
+    this.sessionStateManager.setSessionLoadOptions(
       result.sessionId,
       DaemonLoadSessionSpawnOptionsSchema.parse({
         disableInactivityTimeout: params.disableInactivityTimeout,
@@ -17168,7 +17081,7 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
     if (loadState !== "NOT_LOADED" /* NotLoaded */) {
       return;
     }
-    const stashed = this.sessionLoadOptions.get(sessionId) ?? {};
+    const stashed = this.sessionStateManager.getSessionLoadOptions(sessionId) ?? {};
     await this.loadSession({
       ...stashed,
       sessionId,
@@ -17204,7 +17117,7 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
     if (loadState === "LOADING" /* Loading */) {
       return;
     }
-    const stashed = this.sessionLoadOptions.get(sessionId) ?? {};
+    const stashed = this.sessionStateManager.getSessionLoadOptions(sessionId) ?? {};
     try {
       await this.loadSession({
         ...stashed,
@@ -17261,15 +17174,16 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
       params.sessionId,
       this.config.machineId
     );
+    const workingStateRevisionBeforeLoad = this.sessionStateManager.getSessionManager(params.sessionId)?.getWorkingStateRevision() ?? 0;
     const fetched = await this.config.getAccessToken();
     if (fetched === null) {
       throw new MetaError("No access token available for loadSession", {
         sessionId: params.sessionId
       });
     }
-    const currentSpawnOptions = this.sessionLoadOptions.get(params.sessionId) ?? {};
+    const stashedOptions = this.sessionStateManager.getSessionLoadOptions(params.sessionId) ?? {};
     const structuredOutputFormat = resolveStructuredOutputFormat(
-      currentSpawnOptions,
+      stashedOptions,
       params
     );
     const resolvedParams = {
@@ -17278,9 +17192,12 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
       token: fetched,
       loadAllMessages: this.getClientType() === "cli" ? params.loadAllMessages : true,
       messageLimit: params.messageLimit ?? this.config.defaultMessageLimit,
-      disableInactivityTimeout: params.disableInactivityTimeout ?? this.config.disableInactivityTimeout
+      disableInactivityTimeout: params.disableInactivityTimeout ?? stashedOptions.disableInactivityTimeout ?? this.config.disableInactivityTimeout,
+      disableBuiltinSkills: params.disableBuiltinSkills ?? stashedOptions.disableBuiltinSkills,
+      skipPermissionsUnsafe: params.skipPermissionsUnsafe ?? stashedOptions.skipPermissionsUnsafe,
+      runtimeSettingsPath: params.runtimeSettingsPath ?? stashedOptions.runtimeSettingsPath
     };
-    this.sessionLoadOptions.set(
+    this.sessionStateManager.setSessionLoadOptions(
       params.sessionId,
       DaemonLoadSessionSpawnOptionsSchema.parse({
         disableInactivityTimeout: resolvedParams.disableInactivityTimeout,
@@ -17291,10 +17208,18 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
       })
     );
     let result;
+    let reportedWorkingState;
+    let didHydrateReportedWorkingState = false;
     const loadPromise = this.daemonClient.loadSession(resolvedParams);
     this.daemonClient.setPendingSessionReady?.(params.sessionId, loadPromise);
     try {
       result = await loadPromise;
+      reportedWorkingState = result.workingState !== void 0 && result.workingState !== "idle" /* Idle */ ? result.workingState : result.isAgentLoopInProgress ? "streaming_assistant_message" /* StreamingAssistantMessage */ : "idle" /* Idle */;
+      const sessionManager2 = this.sessionStateManager.getSessionManager(
+        params.sessionId
+      );
+      const shouldHydrateReportedWorkingState = sessionManager2?.getWorkingStateRevision() === workingStateRevisionBeforeLoad;
+      didHydrateReportedWorkingState = shouldHydrateReportedWorkingState && sessionManager2?.getDroidWorkingState() !== reportedWorkingState;
       this.sessionStateManager.loadSession(
         params.sessionId,
         this.config.machineId,
@@ -17302,7 +17227,8 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
         {
           cwd: result.cwd ?? null,
           hasOlderMessages: result.hasOlderMessages ?? false,
-          loadedMessageLimit: resolvedParams.messageLimit ?? 0
+          loadedMessageLimit: resolvedParams.messageLimit ?? 0,
+          ...shouldHydrateReportedWorkingState ? { workingState: reportedWorkingState } : {}
         }
       );
       if (result.subagentInvocations && result.subagentInvocations.length > 0) {
@@ -17325,7 +17251,6 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
     const sessionManager = this.sessionStateManager.getSessionManager(
       params.sessionId
     );
-    const workingStateRevisionAtLoad = sessionManager?.getWorkingStateRevision() ?? 0;
     if (sessionManager && result.settings) {
       if (result.settings.modelId !== void 0) {
         sessionManager.getStore().setModelId(result.settings.modelId);
@@ -17427,7 +17352,7 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
             request.data,
             permissionRequest.requestId,
             params.sessionId,
-            { isRestored: true }
+            { isRestored: true, machineId: this.config.machineId }
           );
           surfacedPermissionCount += 1;
         }
@@ -17501,7 +17426,7 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
             request.data,
             askUserRequest.requestId,
             params.sessionId,
-            { isRestored: true }
+            { isRestored: true, machineId: this.config.machineId }
           );
         }
         logInfo(
@@ -17517,7 +17442,7 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
         );
       }
     } finally {
-      this.inactiveSessions.delete(params.sessionId);
+      this.sessionStateManager.markSessionActive(params.sessionId);
     }
     if (sessionManager) {
       await reconcileQueuedMessagesAfterLoad({
@@ -17528,9 +17453,8 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
       });
     }
     const hasAssociatedPendingPermission = this.permissionHandler.getPendingPermissionsForSession(params.sessionId).length > 0;
-    const reportedWorkingState = result.workingState !== void 0 && result.workingState !== "idle" /* Idle */ ? result.workingState : result.isAgentLoopInProgress ? "streaming_assistant_message" /* StreamingAssistantMessage */ : "idle" /* Idle */;
     const loadedWorkingState = hasAssociatedPendingPermission || hasPendingAskUserRequests ? "waiting_for_tool_confirmation" /* WaitingForToolConfirmation */ : reportedWorkingState;
-    if (sessionManager && sessionManager.getWorkingStateRevision() !== workingStateRevisionAtLoad) {
+    if (sessionManager && sessionManager.getWorkingStateRevision() !== workingStateRevisionBeforeLoad) {
       logInfo(
         "[DaemonSessionController] Skipping stale working state from load",
         {
@@ -17539,18 +17463,23 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
           state: sessionManager.getDroidWorkingState()
         }
       );
-    } else if (loadedWorkingState !== "idle" /* Idle */ || sessionManager && sessionManager.getDroidWorkingState() !== "idle" /* Idle */) {
-      sessionManager?.applyDroidWorkingState(loadedWorkingState);
-      this.emit("droidWorkingStateChanged" /* DroidWorkingStateChanged */, {
-        sessionId: params.sessionId,
-        newState: loadedWorkingState
-      });
-      logInfo("[DaemonSessionController] Restored working state on load", {
-        sessionId: params.sessionId,
-        value: loadedWorkingState,
-        pendingRequestCount: hasAssociatedPendingPermission ? 1 : 0,
-        questionCount: hasPendingAskUserRequests ? 1 : 0
-      });
+    } else if (sessionManager) {
+      const didApplyLoadedWorkingState = sessionManager.getDroidWorkingState() !== loadedWorkingState;
+      if (didApplyLoadedWorkingState) {
+        sessionManager.applyDroidWorkingState(loadedWorkingState);
+      }
+      if (loadedWorkingState !== "idle" /* Idle */ || didHydrateReportedWorkingState || didApplyLoadedWorkingState) {
+        this.emit("droidWorkingStateChanged" /* DroidWorkingStateChanged */, {
+          sessionId: params.sessionId,
+          newState: loadedWorkingState
+        });
+        logInfo("[DaemonSessionController] Restored working state on load", {
+          sessionId: params.sessionId,
+          value: loadedWorkingState,
+          pendingCount: hasAssociatedPendingPermission ? 1 : 0,
+          totalQuestions: hasPendingAskUserRequests ? 1 : 0
+        });
+      }
     }
     if (this.config.supportsTerminalRestoreOnLoad !== false) {
       await this.loadTerminals(params.sessionId);
@@ -17634,6 +17563,7 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
     const wasOptimisticallySubmittedWhileIdleBeforeRequest = sessionManager?.getDroidWorkingState() === "idle" /* Idle */ && sessionManager.getOptimisticMessage(requestId) !== void 0;
     const content = buildUserMessageContentBlocks2({
       text: params.text,
+      content: params.content,
       images: params.images,
       files: params.files
     });
@@ -17754,15 +17684,9 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
     const result = await this.daemonClient.interruptSession({
       sessionId
     });
-    const permissionsToClose = this.permissionHandler.getPendingPermissions().filter((p) => p.sessionId === sessionId);
-    this.permissionHandler.clearSessionPermissions(sessionId);
-    for (const permission of permissionsToClose) {
-      this.emit(
-        "permissionResolved" /* PermissionResolved */,
-        permission.requestId,
-        "cancel" /* Cancel */
-      );
-    }
+    this.permissionHandler.clearSessionPermissions(sessionId, {
+      emitResolved: true
+    });
     const askUserToClose = this.askUserHandler.getPendingAskUserRequests().filter((r) => r.sessionId === sessionId);
     for (const req of askUserToClose) {
       try {
@@ -17806,7 +17730,7 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
    */
   async closeSession(sessionId) {
     await this.daemonClient.closeSession({ sessionId });
-    this.sessionLoadOptions.delete(sessionId);
+    this.sessionStateManager.deleteSessionLoadOptions(sessionId);
     this.sessionLoadInFlight.delete(sessionId);
     this.trackedChildSessionIds.delete(sessionId);
     this.childSessionAttachmentGeneration.delete(sessionId);
@@ -17876,8 +17800,11 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
   async resolvePullRequestStatuses(params) {
     return await this.daemonClient.resolvePullRequestStatuses(params);
   }
-  async listGitBranches(cwd) {
-    return this.daemonClient.listGitBranches({ cwd });
+  async listGitBranches(cwd, options) {
+    return this.daemonClient.listGitBranches({
+      cwd,
+      ...options?.includeOriginBranches === true ? { includeOriginBranches: true } : {}
+    });
   }
   async checkoutGitBranch(params) {
     return this.daemonClient.checkoutGitBranch(params);
@@ -18445,7 +18372,7 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
   async runSelfResumeWithRetry(sessionId) {
     let lastError;
     for (let attempt = 1; attempt <= SELF_RESUME_MAX_ATTEMPTS; attempt++) {
-      const stashed = this.sessionLoadOptions.get(sessionId) ?? {};
+      const stashed = this.sessionStateManager.getSessionLoadOptions(sessionId) ?? {};
       try {
         await this.loadSession({
           sessionId,
@@ -18534,7 +18461,7 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
         }
       );
     }
-    if (this.inactiveSessions.has(executionSessionId)) {
+    if (this.sessionStateManager.isSessionInactive(executionSessionId)) {
       const toolUseId = permission.toolUses[0]?.toolUse.id;
       if (toolUseId) {
         this.pendingUserActionStore.savePermission({
@@ -18593,7 +18520,7 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
         requestId
       });
     }
-    if (this.inactiveSessions.has(sessionId)) {
+    if (this.sessionStateManager.isSessionInactive(sessionId)) {
       this.pendingUserActionStore.saveAskUser({
         kind: "askUser",
         sessionId,
@@ -18718,6 +18645,46 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
   getMachineId() {
     return this.config.machineId;
   }
+  /**
+   * Whether a prompt (or its resolution) involves this controller's machine.
+   *
+   * A prompt is owned by this machine when its stamped `machineId` (set at
+   * intake by the controller that received it) matches, or when any involved
+   * session's manager is bound to this machine (a relayed subagent prompt
+   * surfaces on the parent's machine via `associatedSessionIds`). Sessions
+   * with no registered manager (or no machine binding yet) don't count either
+   * way; if the prompt carries no stamp and none of the sessions has a known
+   * binding, this returns true so pre-registration edge cases keep the
+   * pre-shared-store behavior of emitting.
+   *
+   * Public so the CLI's TuiDaemonAdapter can dedupe the legacy remote relay
+   * against this controller's native shared-store fan-out.
+   */
+  machineOwnsPrompt(prompt) {
+    const sessionIds = /* @__PURE__ */ new Set([
+      prompt.sessionId,
+      ...prompt.associatedSessionIds ?? []
+    ]);
+    const ownerships = [...sessionIds].map(
+      (sessionId) => this.getPromptOwnership({
+        sessionId,
+        machineId: sessionId === prompt.sessionId ? prompt.machineId : void 0
+      })
+    );
+    return ownerships.includes("owned") || ownerships.every((ownership) => ownership === "unknown");
+  }
+  /**
+   * Resolve one prompt record or involved session against this controller.
+   * Emission treats an all-unknown prompt as visible. Logout clears only an
+   * exact owned record.
+   */
+  getPromptOwnership(prompt) {
+    const machineId = prompt.machineId || this.sessionStateManager.getSessionManager(prompt.sessionId)?.getMachineId();
+    if (!machineId) {
+      return "unknown";
+    }
+    return machineId === this.config.machineId ? "owned" : "foreign";
+  }
   /**
    * Get the machine type for this daemon client.
    */
@@ -18822,8 +18789,10 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
     this.disconnect();
     this.removeAllListeners();
     this.messageRouter.removeAllListeners();
-    this.permissionHandler.destroy();
-    this.askUserHandler.destroy();
+    for (const unsubscribe of this.promptStoreUnsubscribes) {
+      unsubscribe();
+    }
+    this.promptStoreUnsubscribes.length = 0;
     this.sessionPermissionSubscribers.clear();
     this.sessionLoadInFlight.clear();
     this.trackedChildSessionIds.clear();
@@ -18832,7 +18801,7 @@ var DaemonSessionController = class _DaemonSessionController extends EventEmitte
 };
 
 // ../daemon-sdk/src/session/ControllerEventAggregator.ts
-import { EventEmitter as EventEmitter7 } from "eventemitter3";
+import { EventEmitter as EventEmitter5 } from "eventemitter3";
 
 // ../daemon-sdk/src/session/mcpStatus.ts
 function deriveMcpStatusFromSummary(summary) {
@@ -19131,7 +19100,7 @@ var TOOL_DISPLAY_NAMES = {
   [TOOL_LLM_ID_TODO_WRITE]: "Plan",
   [TOOL_LLM_ID_ASK_USER]: "Ask User",
   [TOOL_LLM_ID_WEB_SEARCH]: "Web Search",
-  [TOOL_LLM_ID_FETCH_URL]: "Fetch URL",
+  [TOOL_LLM_ID_FETCH_URL]: "Web Fetch",
   [TOOL_LLM_ID_GENERATE_IMAGE]: "Generate Image",
   [TOOL_LLM_ID_GET_IDE_DIAGNOSTICS]: "Get IDE Diagnostics",
   [TOOL_LLM_ID_EXIT_SPEC_MODE]: "Propose Specification",
@@ -19140,7 +19109,7 @@ var TOOL_DISPLAY_NAMES = {
   [TOOL_LLM_ID_SELECT_FEATURE]: "Select Feature",
   [TOOL_LLM_ID_END_FEATURE_RUN]: "End Feature Run",
   [TOOL_LLM_ID_DISMISS_HANDOFF_ITEMS]: "Dismiss Handoff Items",
-  [TOOL_LLM_ID_TASK]: "Subagent",
+  [TOOL_LLM_ID_TASK]: "Task",
   [TOOL_LLM_ID_CONNECTOR_SEARCH]: "Connectors",
   [TOOL_LLM_ID_CONNECT_APP]: "Connect App"
 };
@@ -20967,7 +20936,7 @@ var SessionStateManager = class _SessionStateManager {
     }
     return void 0;
   }
-  completeStreamingContentBlocks() {
+  completeStreamingContentBlocks(options) {
     for (const message of this.store.getMessages()) {
       let didUpdateMessage = false;
       let thinkingBlockOrdinal = 0;
@@ -21001,10 +20970,14 @@ var SessionStateManager = class _SessionStateManager {
         return block;
       });
       if (didUpdateMessage) {
-        this.store.updateMessage(message.id, {
-          content,
-          updatedAt: Date.now()
-        });
+        this.store.updateMessage(
+          message.id,
+          {
+            content,
+            updatedAt: Date.now()
+          },
+          options
+        );
       }
     }
     this.streamingMessageIds.clear();
@@ -21259,9 +21232,9 @@ var SessionStateManager = class _SessionStateManager {
   /**
    * Set the load state of this session.
    */
-  setLoadState(state) {
+  setLoadState(state, options) {
     this.loadState = state;
-    if (state === "NOT_LOADED" /* NotLoaded */ && this.droidWorkingState !== "idle" /* Idle */) {
+    if (state === "NOT_LOADED" /* NotLoaded */ && options?.preserveWorkingState !== true && this.droidWorkingState !== "idle" /* Idle */) {
       this.stopStreaming();
     }
   }
@@ -21877,7 +21850,7 @@ var SessionStateManager = class _SessionStateManager {
    *
    * @param params - The notification parameters including sessionId and notification data
    */
-  handleNotification(params) {
+  handleNotification(params, options) {
     const { notification } = params;
     const isStreamingDelta = notification.type === "assistant_text_delta" /* ASSISTANT_TEXT_DELTA */ || notification.type === "thinking_text_delta" /* THINKING_TEXT_DELTA */;
     const isBlockComplete = notification.type === "assistant_text_complete" /* ASSISTANT_TEXT_COMPLETE */ || notification.type === "thinking_text_complete" /* THINKING_TEXT_COMPLETE */;
@@ -21961,8 +21934,7 @@ var SessionStateManager = class _SessionStateManager {
             sessionId: params.sessionId,
             type: notification.errorType,
             errorName: notification.error?.name,
-            message: notification.message,
-            cause: notification.error
+            message: notification.message
           });
         }
         this.stopStreaming();
@@ -21975,7 +21947,9 @@ var SessionStateManager = class _SessionStateManager {
           timestamp: notification.timestamp,
           timeout: notification.timeoutSeconds
         });
-        this.setLoadState("NOT_LOADED" /* NotLoaded */);
+        this.setLoadState("NOT_LOADED" /* NotLoaded */, {
+          preserveWorkingState: options?.preserveWorkingStateOnInactive === true
+        });
         break;
       }
       case "session_process_exited" /* SESSION_PROCESS_EXITED */: {
@@ -21984,7 +21958,9 @@ var SessionStateManager = class _SessionStateManager {
           message: notification.message,
           timestamp: notification.timestamp
         });
-        this.setLoadState("NOT_LOADED" /* NotLoaded */);
+        this.setLoadState("NOT_LOADED" /* NotLoaded */, {
+          preserveWorkingState: options?.preserveWorkingStateOnInactive === true
+        });
         break;
       }
       case "session_closed" /* SESSION_CLOSED */: {
@@ -22384,68 +22360,76 @@ var SessionStateManager = class _SessionStateManager {
     this.droidWorkingState = newState;
     this.droidWorkingStateChangedAtMs = Date.now();
   }
+  transitionDroidWorkingState(newState, options) {
+    const previousState = this.droidWorkingState;
+    const transition = () => {
+      if (newState !== "idle" /* Idle */) {
+        this.store.clearAgentTurnCompletionReason();
+      }
+      switch (newState) {
+        case "idle" /* Idle */:
+        case "executing_tool" /* ExecutingTool */:
+        case "waiting_for_tool_confirmation" /* WaitingForToolConfirmation */:
+          this.completeStreamingContentBlocks({
+            silent: options?.silent === true
+          });
+          break;
+        case "thinking" /* Thinking */:
+        case "streaming_assistant_message" /* StreamingAssistantMessage */:
+        case "compacting_conversation" /* CompactingConversation */:
+          break;
+        default: {
+          const exhaustiveCheck = newState;
+          logError("Unknown droid working state:", { value: exhaustiveCheck });
+          return;
+        }
+      }
+      this.updateDroidWorkingState(newState);
+    };
+    if (options?.silent === true) {
+      this.store.runWithStateEventsSuppressed(transition);
+    } else {
+      transition();
+    }
+    const didChange = previousState !== this.droidWorkingState;
+    if (didChange && options?.silent !== true) {
+      this.store.flushNotify("working_state_changed" /* WorkingStateChanged */);
+    }
+  }
   startStreaming() {
-    this.updateDroidWorkingState("streaming_assistant_message" /* StreamingAssistantMessage */);
-    this.store.clearAgentTurnCompletionReason();
-    this.store.flushNotify("working_state_changed" /* WorkingStateChanged */);
+    this.transitionDroidWorkingState(
+      "streaming_assistant_message" /* StreamingAssistantMessage */
+    );
   }
   stopStreaming() {
-    this.updateDroidWorkingState("idle" /* Idle */);
-    this.completeStreamingContentBlocks();
-    this.store.flushNotify("working_state_changed" /* WorkingStateChanged */);
+    this.transitionDroidWorkingState("idle" /* Idle */);
   }
   setWaitingForConfirmation() {
-    this.completeStreamingContentBlocks();
-    this.updateDroidWorkingState("waiting_for_tool_confirmation" /* WaitingForToolConfirmation */);
-    this.store.flushNotify("working_state_changed" /* WorkingStateChanged */);
+    this.transitionDroidWorkingState(
+      "waiting_for_tool_confirmation" /* WaitingForToolConfirmation */
+    );
   }
   setExecutingTool() {
-    this.completeStreamingContentBlocks();
-    this.updateDroidWorkingState("executing_tool" /* ExecutingTool */);
-    this.store.flushNotify("working_state_changed" /* WorkingStateChanged */);
+    this.transitionDroidWorkingState("executing_tool" /* ExecutingTool */);
   }
   setCompacting() {
-    this.updateDroidWorkingState("compacting_conversation" /* CompactingConversation */);
-    this.store.flushNotify("working_state_changed" /* WorkingStateChanged */);
+    this.transitionDroidWorkingState("compacting_conversation" /* CompactingConversation */);
   }
   setThinking() {
-    this.updateDroidWorkingState("thinking" /* Thinking */);
-    this.store.flushNotify("working_state_changed" /* WorkingStateChanged */);
+    this.transitionDroidWorkingState("thinking" /* Thinking */);
   }
   /**
-   * Apply a DroidWorkingState value to the local session state, routing to the
-   * matching setter. Used both by the working-state notification handler and by
-   * session load, where the load result reports the current state of an
-   * already-running session.
+   * Apply a live DroidWorkingState value and notify subscribers when it changes.
    */
   applyDroidWorkingState(newState) {
-    if (newState !== "idle" /* Idle */) {
-      this.store.clearAgentTurnCompletionReason();
-    }
-    switch (newState) {
-      case "idle" /* Idle */:
-        this.stopStreaming();
-        break;
-      case "thinking" /* Thinking */:
-        this.setThinking();
-        break;
-      case "streaming_assistant_message" /* StreamingAssistantMessage */:
-        this.startStreaming();
-        break;
-      case "executing_tool" /* ExecutingTool */:
-        this.setExecutingTool();
-        break;
-      case "waiting_for_tool_confirmation" /* WaitingForToolConfirmation */:
-        this.setWaitingForConfirmation();
-        break;
-      case "compacting_conversation" /* CompactingConversation */:
-        this.setCompacting();
-        break;
-      default: {
-        const exhaustiveCheck = newState;
-        logError("Unknown droid working state:", { value: exhaustiveCheck });
-      }
-    }
+    this.transitionDroidWorkingState(newState);
+  }
+  /**
+   * Hydrate a load-response working state before message publication without
+   * exposing an intermediate transcript/state pair to subscribers.
+   */
+  hydrateDroidWorkingState(newState) {
+    this.transitionDroidWorkingState(newState, { silent: true });
   }
   /**
    * Queue a user prompt in SSM for shared UI rendering and lifecycle handling.
@@ -22662,325 +22646,763 @@ var SessionStateManager = class _SessionStateManager {
     this.queuedMessages = pausedQueue;
     this.store.notify("queued_messages_updated" /* QueuedMessagesUpdated */);
   }
-  clearQueue() {
-    this.queuedMessages.clear();
-    this.store.notify("queued_messages_updated" /* QueuedMessagesUpdated */);
+  clearQueue() {
+    this.queuedMessages.clear();
+    this.store.notify("queued_messages_updated" /* QueuedMessagesUpdated */);
+  }
+  mergeOptimisticMessages(realMessages) {
+    const entries = Array.from(this.optimisticMessages.values()).sort(
+      (a, b) => (a.messages[0]?.createdAt ?? 0) - (b.messages[0]?.createdAt ?? 0)
+    );
+    const historicalSystemMessages = entries.filter(
+      (entry) => entry.messages[0]?.role === "system" /* System */ && entry.leadingOrder === void 0
+    ).flatMap((entry) => entry.messages);
+    const leadingMessages = entries.filter((entry) => entry.leadingOrder !== void 0).sort((a, b) => (a.leadingOrder ?? 0) - (b.leadingOrder ?? 0)).flatMap((entry) => entry.messages);
+    const pendingMessages = entries.filter(
+      (entry) => entry.messages[0]?.role !== "system" /* System */ && entry.leadingOrder === void 0
+    ).flatMap((entry) => entry.messages);
+    const leadingInsertIndex = leadingMessages.length === 0 ? 0 : this.findLeadingInsertIndex(realMessages);
+    return [
+      ...historicalSystemMessages,
+      ...realMessages.slice(0, leadingInsertIndex),
+      ...leadingMessages,
+      ...realMessages.slice(leadingInsertIndex),
+      ...pendingMessages
+    ];
+  }
+  /**
+   * Where the leading optimistic cards render: after the last real message
+   * that is one of their recorded siblings, or ahead of the transcript when
+   * none has been recorded yet.
+   */
+  findLeadingInsertIndex(realMessages) {
+    if (this.confirmedLeadingMessageIds.size === 0) {
+      return 0;
+    }
+    let insertIndex = 0;
+    realMessages.forEach((message, index) => {
+      if (this.confirmedLeadingMessageIds.has(message.id)) {
+        insertIndex = index + 1;
+      }
+    });
+    return insertIndex;
+  }
+  /**
+   * Note that `messageId` is the recorded form of a leading optimistic card,
+   * so `findLeadingInsertIndex` can keep the cards that have not been recorded
+   * yet below it. Ignores request ids that never staged a leading card.
+   */
+  rememberConfirmedLeadingMessage(requestId, messageId) {
+    if (this.optimisticMessages.get(requestId)?.leadingOrder === void 0) {
+      return;
+    }
+    this.confirmedLeadingMessageIds.add(messageId);
+  }
+  /**
+   * Get messages filtered for UI display.
+   * Uses the canonical filterMessagesForUI utility to ensure consistent filtering.
+   * Includes optimistic messages that are pending server confirmation.
+   */
+  getDisplayMessages() {
+    const sorted = this.mergeOptimisticMessages(
+      filterMessagesForUI2(this.store.getMessages())
+    );
+    if (this.renderLimit !== null && sorted.length > this.renderLimit) {
+      return sorted.slice(-this.renderLimit);
+    }
+    return sorted;
+  }
+  /**
+   * Add an optimistic message that will be shown until confirmed by server.
+   *
+   * `leadingOrder` renders the message above the transcript instead of among
+   * the pending turns, at the position that number gives it among the other
+   * leading messages. Session-launch steps use it so their cards sit where
+   * the daemon records the real ones: ahead of the first user message.
+   */
+  addOptimisticMessage(requestId, message, options) {
+    this.addOptimisticMessages(requestId, [message], options);
+  }
+  /**
+   * Replaces an optimistic exchange atomically so a tool result can settle
+   * its staged tool use without briefly removing or separating the pair.
+   */
+  addOptimisticMessages(requestId, messages, options) {
+    if (messages.length === 0) {
+      return;
+    }
+    this.optimisticMessages.set(requestId, {
+      messages,
+      ...options?.leadingOrder !== void 0 ? { leadingOrder: options.leadingOrder } : {}
+    });
+    this.store.notifyMessagesChanged();
+  }
+  /**
+   * Inspect a single optimistic message by requestId. Used by the
+   * post-load reconciliation pass in `MultiSessionStateManager` to
+   * match optimistic submits against the daemon-persisted user
+   * messages and confirm them when the originating CREATE_MESSAGE
+   * notification was lost.
+   */
+  getOptimisticMessage(requestId) {
+    return this.optimisticMessages.get(requestId)?.messages[0];
+  }
+  /** Keeps the unconfirmed half of a staged exchange until it arrives. */
+  confirmOptimisticMessages(requestId, messageId) {
+    const entry = this.optimisticMessages.get(requestId);
+    if (!entry) {
+      return;
+    }
+    const containsConfirmedMessage = entry.messages.some(
+      (message) => message.id === messageId
+    );
+    const remainingMessages = entry.messages.filter(
+      (message) => message.id !== messageId
+    );
+    if (containsConfirmedMessage && remainingMessages.length > 0) {
+      this.optimisticMessages.set(requestId, {
+        ...entry,
+        messages: remainingMessages
+      });
+      return;
+    }
+    this.optimisticMessages.delete(requestId);
+  }
+  /**
+   * Remove optimistic message when confirmed or on error
+   */
+  removeOptimisticMessage(requestId) {
+    if (this.optimisticMessages.delete(requestId)) {
+      this.store.notifyMessagesChanged();
+    }
+  }
+  /**
+   * Update session settings (model ID, reasoning effort, and autonomy level)
+   */
+  updateSessionSettings(params) {
+    if (params.modelId !== void 0) {
+      this.store.setModelId(params.modelId);
+    }
+    if (params.reasoningEffort !== void 0) {
+      this.store.setReasoningEffort(params.reasoningEffort);
+    }
+    this.applyInteractionSettings(params);
+    if (params.tags !== void 0) {
+      this.store.setTags(params.tags);
+    }
+  }
+  /**
+   * Resolve and apply interaction settings (interactionMode, autonomyLevel)
+   * to the session store.
+   */
+  applyInteractionSettings(settings) {
+    if (settings.interactionMode === void 0 && settings.autonomyLevel === void 0) {
+      return;
+    }
+    const nextInteractionSettings = resolveInteractionSettings({
+      interactionMode: settings.interactionMode,
+      autonomyLevel: settings.autonomyLevel,
+      fallback: {
+        interactionMode: this.store.getInteractionMode() ?? "auto" /* Auto */,
+        autonomyLevel: this.store.getAutonomyLevel() ?? "off" /* Off */
+      }
+    });
+    this.store.setInteractionMode(nextInteractionSettings.interactionMode);
+    this.store.setAutonomyLevel(nextInteractionSettings.autonomyLevel);
+  }
+  /**
+   * Get current interaction mode
+   */
+  getInteractionMode() {
+    return this.store.getInteractionMode();
+  }
+  /**
+   * Get current autonomy level
+   */
+  getAutonomyLevel() {
+    return this.store.getAutonomyLevel();
+  }
+  /**
+   * Get current model ID
+   */
+  getModelId() {
+    return this.store.getModelId();
+  }
+  /**
+   * Get current reasoning effort
+   */
+  getReasoningEffort() {
+    return this.store.getReasoningEffort();
+  }
+  /**
+   * Get spec mode model ID
+   */
+  getSpecModeModelId() {
+    return this.store.getSpecModeModelId();
+  }
+  /**
+   * Get spec mode reasoning effort
+   */
+  getSpecModeReasoningEffort() {
+    return this.store.getSpecModeReasoningEffort();
   }
-  mergeOptimisticMessages(realMessages) {
-    const entries = Array.from(this.optimisticMessages.values()).sort(
-      (a, b) => (a.messages[0]?.createdAt ?? 0) - (b.messages[0]?.createdAt ?? 0)
-    );
-    const historicalSystemMessages = entries.filter(
-      (entry) => entry.messages[0]?.role === "system" /* System */ && entry.leadingOrder === void 0
-    ).flatMap((entry) => entry.messages);
-    const leadingMessages = entries.filter((entry) => entry.leadingOrder !== void 0).sort((a, b) => (a.leadingOrder ?? 0) - (b.leadingOrder ?? 0)).flatMap((entry) => entry.messages);
-    const pendingMessages = entries.filter(
-      (entry) => entry.messages[0]?.role !== "system" /* System */ && entry.leadingOrder === void 0
-    ).flatMap((entry) => entry.messages);
-    const leadingInsertIndex = leadingMessages.length === 0 ? 0 : this.findLeadingInsertIndex(realMessages);
-    return [
-      ...historicalSystemMessages,
-      ...realMessages.slice(0, leadingInsertIndex),
-      ...leadingMessages,
-      ...realMessages.slice(leadingInsertIndex),
-      ...pendingMessages
-    ];
+  /**
+   * Get available models
+   */
+  getAvailableModels() {
+    return this.store.getAvailableModels();
   }
+  // ============ Terminal Registry Methods ============
   /**
-   * Where the leading optimistic cards render: after the last real message
-   * that is one of their recorded siblings, or ahead of the transcript when
-   * none has been recorded yet.
+   * Register a mounted terminal's write handler.
+   * Also flushes any buffered data that arrived while unmounted.
    */
-  findLeadingInsertIndex(realMessages) {
-    if (this.confirmedLeadingMessageIds.size === 0) {
-      return 0;
+  registerTerminal(terminalId, writeHandler) {
+    this.terminalWriteHandlers.set(terminalId, writeHandler);
+    const buffered = this.store.getTerminalBufferedData(terminalId);
+    if (buffered) {
+      logInfo("[SessionStateManager] Flushing buffered terminal data", {
+        terminalId
+      });
+      writeHandler(buffered);
+      this.store.clearTerminalBufferedData(terminalId);
     }
-    let insertIndex = 0;
-    realMessages.forEach((message, index) => {
-      if (this.confirmedLeadingMessageIds.has(message.id)) {
-        insertIndex = index + 1;
-      }
+  }
+  /**
+   * Unregister when terminal unmounts.
+   * Future DATA notifications will be buffered.
+   */
+  unregisterTerminal(terminalId) {
+    this.terminalWriteHandlers.delete(terminalId);
+    logInfo("[SessionStateManager] Terminal unregistered", { terminalId });
+  }
+  /**
+   * Store serialized terminal state (called on unmount)
+   */
+  storeTerminalState(terminalId, state) {
+    this.store.storeTerminalSerializedState(terminalId, state);
+    logInfo("[SessionStateManager] Terminal state serialized", {
+      terminalId
     });
-    return insertIndex;
   }
   /**
-   * Note that `messageId` is the recorded form of a leading optimistic card,
-   * so `findLeadingInsertIndex` can keep the cards that have not been recorded
-   * yet below it. Ignores request ids that never staged a leading card.
+   * Get serialized state for restoration
    */
-  rememberConfirmedLeadingMessage(requestId, messageId) {
-    if (this.optimisticMessages.get(requestId)?.leadingOrder === void 0) {
-      return;
-    }
-    this.confirmedLeadingMessageIds.add(messageId);
+  getTerminalSerializedState(terminalId) {
+    return this.store.getTerminalSerializedState(terminalId);
   }
   /**
-   * Get messages filtered for UI display.
-   * Uses the canonical filterMessagesForUI utility to ensure consistent filtering.
-   * Includes optimistic messages that are pending server confirmation.
+   * Get buffered data for restoration
    */
-  getDisplayMessages() {
-    const sorted = this.mergeOptimisticMessages(
-      filterMessagesForUI2(this.store.getMessages())
-    );
-    if (this.renderLimit !== null && sorted.length > this.renderLimit) {
-      return sorted.slice(-this.renderLimit);
-    }
-    return sorted;
+  getTerminalBufferedData(terminalId) {
+    return this.store.getTerminalBufferedData(terminalId);
   }
   /**
-   * Add an optimistic message that will be shown until confirmed by server.
-   *
-   * `leadingOrder` renders the message above the transcript instead of among
-   * the pending turns, at the position that number gives it among the other
-   * leading messages. Session-launch steps use it so their cards sit where
-   * the daemon records the real ones: ahead of the first user message.
+   * Clear only buffered data (called when daemon state is restored)
    */
-  addOptimisticMessage(requestId, message, options) {
-    this.addOptimisticMessages(requestId, [message], options);
+  clearTerminalBufferedData(terminalId) {
+    this.store.clearTerminalBufferedData(terminalId);
   }
   /**
-   * Replaces an optimistic exchange atomically so a tool result can settle
-   * its staged tool use without briefly removing or separating the pair.
+   * Clear restoration state after terminal is restored
    */
-  addOptimisticMessages(requestId, messages, options) {
-    if (messages.length === 0) {
-      return;
-    }
-    this.optimisticMessages.set(requestId, {
-      messages,
-      ...options?.leadingOrder !== void 0 ? { leadingOrder: options.leadingOrder } : {}
+  clearTerminalRestorationState(terminalId) {
+    this.store.clearTerminalRestorationState(terminalId);
+    logInfo("[SessionStateManager] Terminal restoration state cleared", {
+      terminalId
     });
-    this.store.notifyMessagesChanged();
   }
   /**
-   * Inspect a single optimistic message by requestId. Used by the
-   * post-load reconciliation pass in `MultiSessionStateManager` to
-   * match optimistic submits against the daemon-persisted user
-   * messages and confirm them when the originating CREATE_MESSAGE
-   * notification was lost.
+   * Get the machine ID for this session
    */
-  getOptimisticMessage(requestId) {
-    return this.optimisticMessages.get(requestId)?.messages[0];
+  getMachineId() {
+    return this.store.getMachineId();
   }
-  /** Keeps the unconfirmed half of a staged exchange until it arrives. */
-  confirmOptimisticMessages(requestId, messageId) {
-    const entry = this.optimisticMessages.get(requestId);
-    if (!entry) {
+  /**
+   * Set the machine ID for this session
+   */
+  setMachineId(machineId) {
+    this.store.setMachineId(machineId);
+  }
+  // ============ UI Render Cutoff ============
+  setUiRenderCutoff(messageId) {
+    this.store.setUiRenderCutoff(messageId);
+    if (messageId) {
+      logInfo("[SessionStateManager] UI render cutoff set", {
+        cutoffMessageId: messageId
+      });
+    }
+  }
+  getUiRenderCutoff() {
+    return this.store.getUiRenderCutoff();
+  }
+  getUiRenderHiddenMessageCount() {
+    return this.store.getUiRenderHiddenMessageCount();
+  }
+  /**
+   * Double the render limit (or expand fully if doubling exceeds total count).
+   * Returns true if there are still more messages to expand, false if fully
+   * expanded. No-op unless progressive UI rendering is enabled.
+   */
+  expandUiMessages() {
+    if (this.renderLimit === null) {
+      return false;
+    }
+    const displayCount = filterMessagesForUI2(this.store.getMessages()).length;
+    const nextLimit = this.renderLimit * 2;
+    if (nextLimit >= displayCount) {
+      this.renderLimit = null;
+    } else {
+      this.renderLimit = nextLimit;
+    }
+    this.store.notifyMessagesChanged();
+    return this.renderLimit !== null;
+  }
+  addMessage(message, options) {
+    this.applyTodoStateFromMessage(message);
+    this.store.addMessage(message, options);
+  }
+  // ============ Conversation State Queries ============
+  isConversationEmpty() {
+    return this.store.getMessageCount() === 0 && this.optimisticMessages.size === 0;
+  }
+};
+
+// ../daemon-sdk/src/session/handlers/AskUserRequestHandler.ts
+import { EventEmitter as EventEmitter6 } from "eventemitter3";
+var AskUserRequestHandler = class _AskUserRequestHandler extends EventEmitter6 {
+  pendingRequests = /* @__PURE__ */ new Map();
+  static buildResolutionContext(pending) {
+    return {
+      sessionId: pending.sessionId,
+      associatedSessionIds: [pending.sessionId],
+      ...pending.machineId ? { machineId: pending.machineId } : {}
+    };
+  }
+  handleAskUserRequest(request, id, sessionId, context) {
+    logInfo("[AskUserRequestHandler] Handling ask-user request", {
+      requestId: id,
+      sessionId,
+      toolCallId: request.params.toolCallId,
+      count: request.params.questions.length
+    });
+    const machineId = context?.machineId ?? this.pendingRequests.get(id)?.machineId;
+    const pending = {
+      requestId: id,
+      sessionId,
+      toolCallId: request.params.toolCallId,
+      questions: request.params.questions,
+      timestamp: Date.now(),
+      ...context?.isRestored ? { isRestored: true } : {},
+      ...machineId ? { machineId } : {}
+    };
+    const existingRequest = this.pendingRequests.get(id);
+    if (existingRequest) {
+      this.pendingRequests.set(id, pending);
+      logInfo("[AskUserRequestHandler] Duplicate ask-user request replay", {
+        requestId: id,
+        sessionId
+      });
       return;
     }
-    const containsConfirmedMessage = entry.messages.some(
-      (message) => message.id === messageId
+    this.pendingRequests.set(id, pending);
+    this.emit("askUserRequested", pending);
+  }
+  resolveAskUser(id, result) {
+    const pending = this.pendingRequests.get(id);
+    if (!pending) {
+      logWarn("[AskUserRequestHandler] No pending ask-user request found", {
+        requestId: id
+      });
+      return;
+    }
+    _AskUserRequestHandler.validateResult(pending, result);
+    this.pendingRequests.delete(id);
+    this.emit(
+      "askUserResolved",
+      id,
+      result,
+      _AskUserRequestHandler.buildResolutionContext(pending)
     );
-    const remainingMessages = entry.messages.filter(
-      (message) => message.id !== messageId
+  }
+  clearAskUser(id) {
+    const pending = this.pendingRequests.get(id);
+    if (!pending) {
+      logWarn(
+        "[AskUserRequestHandler] No pending ask-user request found to clear",
+        {
+          requestId: id
+        }
+      );
+      return;
+    }
+    this.pendingRequests.delete(id);
+    this.emit(
+      "askUserResolved",
+      id,
+      void 0,
+      _AskUserRequestHandler.buildResolutionContext(pending)
+    );
+  }
+  clearSessionAskUserRequests(sessionId) {
+    const requestsToRemove = Array.from(this.pendingRequests.values()).filter(
+      (request) => request.sessionId === sessionId
     );
-    if (containsConfirmedMessage && remainingMessages.length > 0) {
-      this.optimisticMessages.set(requestId, {
-        ...entry,
-        messages: remainingMessages
-      });
-      return;
+    for (const request of requestsToRemove) {
+      this.clearAskUser(request.requestId);
     }
-    this.optimisticMessages.delete(requestId);
   }
-  /**
-   * Remove optimistic message when confirmed or on error
-   */
-  removeOptimisticMessage(requestId) {
-    if (this.optimisticMessages.delete(requestId)) {
-      this.store.notifyMessagesChanged();
-    }
+  cancelAskUser(id) {
+    this.resolveAskUser(id, { cancelled: true, answers: [] });
   }
-  /**
-   * Update session settings (model ID, reasoning effort, and autonomy level)
-   */
-  updateSessionSettings(params) {
-    if (params.modelId !== void 0) {
-      this.store.setModelId(params.modelId);
+  getPendingAskUserRequests() {
+    return Array.from(this.pendingRequests.values());
+  }
+  getPendingAskUserRequest(id) {
+    return this.pendingRequests.get(id);
+  }
+  clearAll() {
+    this.pendingRequests.clear();
+  }
+  destroy() {
+    this.clearAll();
+    this.removeAllListeners();
+  }
+  static validateResult(pending, result) {
+    if (result.cancelled === true) {
+      return;
     }
-    if (params.reasoningEffort !== void 0) {
-      this.store.setReasoningEffort(params.reasoningEffort);
+    const questionsByIndex = new Map(
+      pending.questions.map((q) => [q.index, q])
+    );
+    const answered = /* @__PURE__ */ new Set();
+    for (const answer of result.answers) {
+      const question = questionsByIndex.get(answer.index);
+      if (!question) {
+        throw new MetaError("Answer references unknown question index", {
+          requestId: pending.requestId,
+          index: answer.index
+        });
+      }
+      if (answered.has(answer.index)) {
+        throw new MetaError("Duplicate answers for question index", {
+          requestId: pending.requestId,
+          index: answer.index
+        });
+      }
+      answered.add(answer.index);
     }
-    this.applyInteractionSettings(params);
-    if (params.tags !== void 0) {
-      this.store.setTags(params.tags);
+    const missing = pending.questions.map((q) => q.index).filter((idx) => !answered.has(idx));
+    if (missing.length > 0) {
+      throw new MetaError("Missing answers for some questions", {
+        requestId: pending.requestId,
+        missing: missing.map(String)
+      });
     }
   }
-  /**
-   * Resolve and apply interaction settings (interactionMode, autonomyLevel)
-   * to the session store.
-   */
-  applyInteractionSettings(settings) {
-    if (settings.interactionMode === void 0 && settings.autonomyLevel === void 0) {
-      return;
+};
+
+// ../daemon-sdk/src/session/handlers/PendingUserActionStore.ts
+var PendingUserActionStore = class {
+  permissionsByToolUseId = /* @__PURE__ */ new Map();
+  askUsersBySession = /* @__PURE__ */ new Map();
+  savePermission(action) {
+    this.permissionsByToolUseId.set(action.toolUseId, action);
+    logInfo("[PendingUserActionStore] Stored permission for later replay", {
+      sessionId: action.sessionId,
+      requestId: action.requestId,
+      toolUseId: action.toolUseId,
+      selectedOptionLabel: action.selectedOption
+    });
+  }
+  saveAskUser(action) {
+    let map = this.askUsersBySession.get(action.sessionId);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      this.askUsersBySession.set(action.sessionId, map);
     }
-    const nextInteractionSettings = resolveInteractionSettings({
-      interactionMode: settings.interactionMode,
-      autonomyLevel: settings.autonomyLevel,
-      fallback: {
-        interactionMode: this.store.getInteractionMode() ?? "auto" /* Auto */,
-        autonomyLevel: this.store.getAutonomyLevel() ?? "off" /* Off */
-      }
+    map.set(action.toolCallId, action);
+    logInfo("[PendingUserActionStore] Stored ask-user for later replay", {
+      sessionId: action.sessionId,
+      requestId: action.requestId,
+      toolCallId: action.toolCallId
     });
-    this.store.setInteractionMode(nextInteractionSettings.interactionMode);
-    this.store.setAutonomyLevel(nextInteractionSettings.autonomyLevel);
   }
-  /**
-   * Get current interaction mode
-   */
-  getInteractionMode() {
-    return this.store.getInteractionMode();
+  /** Peek a buffered permission response by its globally-unique tool-use id. */
+  getForToolUse(toolUseId) {
+    return this.permissionsByToolUseId.get(toolUseId);
   }
-  /**
-   * Get current autonomy level
-   */
-  getAutonomyLevel() {
-    return this.store.getAutonomyLevel();
+  getForToolCall(sessionId, toolCallId) {
+    return this.askUsersBySession.get(sessionId)?.get(toolCallId);
   }
-  /**
-   * Get current model ID
-   */
-  getModelId() {
-    return this.store.getModelId();
+  /** Remove and return a buffered permission response by tool-use id. */
+  takeForToolUse(toolUseId) {
+    const action = this.permissionsByToolUseId.get(toolUseId);
+    if (!action) return void 0;
+    this.permissionsByToolUseId.delete(toolUseId);
+    return action;
   }
-  /**
-   * Get current reasoning effort
-   */
-  getReasoningEffort() {
-    return this.store.getReasoningEffort();
+  takeForToolCall(sessionId, toolCallId) {
+    const map = this.askUsersBySession.get(sessionId);
+    if (!map) return void 0;
+    const action = map.get(toolCallId);
+    if (!action) return void 0;
+    map.delete(toolCallId);
+    if (map.size === 0) this.askUsersBySession.delete(sessionId);
+    return action;
   }
-  /**
-   * Get spec mode model ID
-   */
-  getSpecModeModelId() {
-    return this.store.getSpecModeModelId();
+  getPermissionsForSession(sessionId) {
+    return Array.from(this.permissionsByToolUseId.values()).filter(
+      (action) => action.sessionId === sessionId
+    );
   }
-  /**
-   * Get spec mode reasoning effort
-   */
-  getSpecModeReasoningEffort() {
-    return this.store.getSpecModeReasoningEffort();
+  getAskUsersForSession(sessionId) {
+    const map = this.askUsersBySession.get(sessionId);
+    return map ? Array.from(map.values()) : [];
+  }
+  clearSession(sessionId) {
+    let permCount = 0;
+    for (const [toolUseId, action] of this.permissionsByToolUseId) {
+      if (action.sessionId === sessionId) {
+        this.permissionsByToolUseId.delete(toolUseId);
+        permCount += 1;
+      }
+    }
+    const askCount = this.askUsersBySession.get(sessionId)?.size ?? 0;
+    this.askUsersBySession.delete(sessionId);
+    const total = permCount + askCount;
+    if (total > 0) {
+      logInfo("[PendingUserActionStore] Cleared session", {
+        sessionId,
+        pendingCount: permCount,
+        totalQuestions: askCount
+      });
+    }
+    return total;
+  }
+  clearAll() {
+    this.permissionsByToolUseId.clear();
+    this.askUsersBySession.clear();
+  }
+  destroy() {
+    this.clearAll();
   }
+};
+
+// ../daemon-sdk/src/session/handlers/PermissionRequestHandler.ts
+import { EventEmitter as EventEmitter7 } from "eventemitter3";
+function normalizeAssociatedSessionIds(sessionId, associatedSessionIds) {
+  return Array.from(/* @__PURE__ */ new Set([sessionId, ...associatedSessionIds ?? []]));
+}
+var PermissionRequestHandler = class _PermissionRequestHandler extends EventEmitter7 {
+  pendingPermissions = /* @__PURE__ */ new Map();
+  statistics = {
+    total: 0,
+    approved: 0,
+    denied: 0,
+    timedOut: 0
+  };
   /**
-   * Get available models
+   * Handle an incoming permission request
    */
-  getAvailableModels() {
-    return this.store.getAvailableModels();
+  static buildResolutionContext(pending) {
+    return {
+      sessionId: pending.sessionId,
+      associatedSessionIds: pending.associatedSessionIds,
+      ...pending.machineId ? { machineId: pending.machineId } : {}
+    };
+  }
+  handlePermissionRequest(request, id, sessionId, context) {
+    logInfo("[PermissionRequestHandler] Handling permission request", {
+      requestId: id,
+      sessionId,
+      count: request.params.toolUses.length,
+      options: request.params.options
+    });
+    const { options } = request.params;
+    const toolUses = request.params.toolUses.map((tool) => ({
+      ...tool,
+      toolUse: {
+        ...tool.toolUse,
+        input: getPermissionToolInputForDisplay2({
+          confirmationType: tool.confirmationType,
+          details: tool.details,
+          toolInput: tool.toolUse.input
+        })
+      }
+    }));
+    const requestAssociatedSessionIds = normalizeAssociatedSessionIds(
+      sessionId,
+      request.params.associatedSessionIds
+    );
+    const existingPermission = this.pendingPermissions.get(id);
+    const associatedSessionIds = existingPermission ? normalizeAssociatedSessionIds(sessionId, [
+      ...existingPermission.associatedSessionIds,
+      ...requestAssociatedSessionIds
+    ]) : requestAssociatedSessionIds;
+    const machineId = context?.machineId ?? existingPermission?.machineId;
+    const pendingPermission = {
+      requestId: id,
+      sessionId,
+      associatedSessionIds,
+      toolUses,
+      options,
+      timestamp: Date.now(),
+      ...context?.isRestored ? { isRestored: true } : {},
+      ...machineId ? { machineId } : {}
+    };
+    if (existingPermission) {
+      this.pendingPermissions.set(id, pendingPermission);
+      const addedSurface = associatedSessionIds.some(
+        (associatedSessionId) => !existingPermission.associatedSessionIds.includes(associatedSessionId)
+      );
+      logInfo(
+        "[PermissionRequestHandler] Duplicate permission request replay",
+        {
+          requestId: id,
+          sessionId
+        }
+      );
+      if (addedSurface) {
+        this.emit("permissionRequested", pendingPermission);
+      }
+      return;
+    }
+    const incomingToolUseIds = new Set(
+      toolUses.map((toolUse) => toolUse.toolUse.id)
+    );
+    for (const [pendingId, pending] of this.pendingPermissions.entries()) {
+      if (pending.machineId && machineId && pending.machineId !== machineId) {
+        continue;
+      }
+      if (pending.toolUses.some(
+        (toolUse) => incomingToolUseIds.has(toolUse.toolUse.id)
+      )) {
+        this.clearPermission(pendingId, { emitResolved: true });
+      }
+    }
+    this.pendingPermissions.set(id, pendingPermission);
+    this.statistics.total++;
+    logInfo("[PermissionRequestHandler] Stored pending permission", {
+      requestId: id,
+      count: this.pendingPermissions.size
+    });
+    logInfo("[PermissionRequestHandler] Emitting permissionRequested event", {
+      requestId: id
+    });
+    this.emit("permissionRequested", pendingPermission);
   }
-  // ============ Terminal Registry Methods ============
   /**
-   * Register a mounted terminal's write handler.
-   * Also flushes any buffered data that arrived while unmounted.
+   * Resolve a permission request with user's choice
    */
-  registerTerminal(terminalId, writeHandler) {
-    this.terminalWriteHandlers.set(terminalId, writeHandler);
-    const buffered = this.store.getTerminalBufferedData(terminalId);
-    if (buffered) {
-      logInfo("[SessionStateManager] Flushing buffered terminal data", {
-        terminalId
-      });
-      writeHandler(buffered);
-      this.store.clearTerminalBufferedData(terminalId);
+  resolvePermission(id, option) {
+    const pending = this.pendingPermissions.get(id);
+    if (!pending) {
+      throw new MetaError("No pending permission found", { requestId: id });
+    }
+    const isValidOption = pending.options.some((opt) => opt.value === option);
+    if (!isValidOption) {
+      const allowedOptions = pending.options.map((opt) => opt.value);
+      throw new MetaError(
+        `Invalid permission option: ${option}. Allowed: ${allowedOptions.join(", ")}`,
+        {
+          requestId: id
+        }
+      );
+    }
+    this.pendingPermissions.delete(id);
+    if (option !== "cancel" /* Cancel */) {
+      this.statistics.approved++;
+    } else {
+      this.statistics.denied++;
     }
+    this.emit(
+      "permissionResolved",
+      id,
+      option,
+      _PermissionRequestHandler.buildResolutionContext(pending)
+    );
   }
   /**
-   * Unregister when terminal unmounts.
-   * Future DATA notifications will be buffered.
+   * Clear a specific permission without an outcome.
    */
-  unregisterTerminal(terminalId) {
-    this.terminalWriteHandlers.delete(terminalId);
-    logInfo("[SessionStateManager] Terminal unregistered", { terminalId });
+  clearPermission(id, options) {
+    const pending = this.pendingPermissions.get(id);
+    this.pendingPermissions.delete(id);
+    if (options?.emitResolved) {
+      this.emit(
+        "permissionResolved",
+        id,
+        void 0,
+        pending ? _PermissionRequestHandler.buildResolutionContext(pending) : void 0
+      );
+    }
   }
   /**
-   * Store serialized terminal state (called on unmount)
+   * Clear all pending permissions for a specific session.
+   *
+   * With `preserveRelayed`, permissions surfaced on multiple sessions (a
+   * relayed subagent permission whose `associatedSessionIds` extend beyond this
+   * session) are kept. loadSession uses this so reloading the parent doesn't
+   * wipe a child's still-pending prompt that the daemon's parent-session load
+   * never returns.
    */
-  storeTerminalState(terminalId, state) {
-    this.store.storeTerminalSerializedState(terminalId, state);
-    logInfo("[SessionStateManager] Terminal state serialized", {
-      terminalId
+  clearSessionPermissions(sessionId, options) {
+    const permissionsToRemove = [];
+    for (const [id, permission] of this.pendingPermissions.entries()) {
+      if (permission.sessionId !== sessionId) {
+        continue;
+      }
+      if (options?.preserveRelayed && permission.associatedSessionIds.some(
+        (associatedId) => associatedId !== sessionId
+      )) {
+        continue;
+      }
+      permissionsToRemove.push(id);
+    }
+    for (const id of permissionsToRemove) {
+      this.clearPermission(id, options);
+    }
+    logInfo("[PermissionRequestHandler] Cleared permissions for session", {
+      sessionId,
+      count: permissionsToRemove.length
     });
   }
   /**
-   * Get serialized state for restoration
-   */
-  getTerminalSerializedState(terminalId) {
-    return this.store.getTerminalSerializedState(terminalId);
-  }
-  /**
-   * Get buffered data for restoration
+   * Clear all pending permissions
    */
-  getTerminalBufferedData(terminalId) {
-    return this.store.getTerminalBufferedData(terminalId);
+  clearAllPermissions() {
+    this.pendingPermissions.clear();
   }
   /**
-   * Clear only buffered data (called when daemon state is restored)
+   * Get all pending permissions
    */
-  clearTerminalBufferedData(terminalId) {
-    this.store.clearTerminalBufferedData(terminalId);
+  getPendingPermissions() {
+    return Array.from(this.pendingPermissions.values());
   }
-  /**
-   * Clear restoration state after terminal is restored
-   */
-  clearTerminalRestorationState(terminalId) {
-    this.store.clearTerminalRestorationState(terminalId);
-    logInfo("[SessionStateManager] Terminal restoration state cleared", {
-      terminalId
-    });
+  getPendingPermissionsForSession(sessionId) {
+    return this.getPendingPermissions().filter(
+      (permission) => permission.associatedSessionIds.includes(sessionId)
+    );
   }
   /**
-   * Get the machine ID for this session
+   * Get a specific pending permission
    */
-  getMachineId() {
-    return this.store.getMachineId();
+  getPendingPermission(id) {
+    return this.pendingPermissions.get(id);
   }
   /**
-   * Set the machine ID for this session
+   * Check if there are any pending permissions
    */
-  setMachineId(machineId) {
-    this.store.setMachineId(machineId);
-  }
-  // ============ UI Render Cutoff ============
-  setUiRenderCutoff(messageId) {
-    this.store.setUiRenderCutoff(messageId);
-    if (messageId) {
-      logInfo("[SessionStateManager] UI render cutoff set", {
-        cutoffMessageId: messageId
-      });
-    }
-  }
-  getUiRenderCutoff() {
-    return this.store.getUiRenderCutoff();
-  }
-  getUiRenderHiddenMessageCount() {
-    return this.store.getUiRenderHiddenMessageCount();
+  hasPendingPermissions() {
+    return this.pendingPermissions.size > 0;
   }
   /**
-   * Double the render limit (or expand fully if doubling exceeds total count).
-   * Returns true if there are still more messages to expand, false if fully
-   * expanded. No-op unless progressive UI rendering is enabled.
+   * Destroy and clean up
    */
-  expandUiMessages() {
-    if (this.renderLimit === null) {
-      return false;
-    }
-    const displayCount = filterMessagesForUI2(this.store.getMessages()).length;
-    const nextLimit = this.renderLimit * 2;
-    if (nextLimit >= displayCount) {
-      this.renderLimit = null;
-    } else {
-      this.renderLimit = nextLimit;
-    }
-    this.store.notifyMessagesChanged();
-    return this.renderLimit !== null;
-  }
-  addMessage(message, options) {
-    this.applyTodoStateFromMessage(message);
-    this.store.addMessage(message, options);
-  }
-  // ============ Conversation State Queries ============
-  isConversationEmpty() {
-    return this.store.getMessageCount() === 0 && this.optimisticMessages.size === 0;
+  destroy() {
+    this.clearAllPermissions();
+    this.removeAllListeners();
   }
 };
 
@@ -23006,6 +23428,43 @@ var MultiSessionStateManager = class _MultiSessionStateManager {
   subagentInvocationSummaries = /* @__PURE__ */ new Map();
   // Track sessions that have already had their initial prompt sent (persists across remounts)
   sentInitialPromptSessions = /* @__PURE__ */ new Set();
+  // Session-scoped prompt state, owned here (app lifetime) rather than by the
+  // per-connection DaemonSessionController: pending prompts and buffered
+  // answers must survive controller teardown/recreation (machine removal,
+  // act-as recreation, provider remount), which otherwise wiped them while
+  // loadState stayed Loaded and suppressed the daemon-side restore. Entries
+  // are keyed by globally unique request ids and carry their sessionId, so a
+  // single shared instance serves every machine's controller.
+  _askUserRequests = new AskUserRequestHandler();
+  _permissionRequests = new PermissionRequestHandler();
+  _pendingUserActions = new PendingUserActionStore();
+  // Narrowed public views: per-entry read/subscribe/mutate only. Whole-store
+  // teardown stays internal (see removeSession / clear).
+  get askUserRequests() {
+    return this._askUserRequests;
+  }
+  get permissionRequests() {
+    return this._permissionRequests;
+  }
+  get pendingUserActions() {
+    return this._pendingUserActions;
+  }
+  // Session-scoped state that describes the *session* rather than the
+  // connection, moved off the per-connection DaemonSessionController so a
+  // replacement controller (preconnect round-trip, reconnect, machine
+  // removal) does not lose it:
+  // - inactiveSessions: whether the daemon paused the session's worker; pairs
+  //   with the pendingUserActions buffering above so respondToPermission /
+  //   respondToAskUser keep taking the buffer-and-self-resume path.
+  // - sessionsWithConcurrentPrompts: bookkeeping over the prompt stores above;
+  //   must live and die with them so a rebuilt controller does not blanket
+  //   clear the surviving tail prompt of a concurrent batch.
+  // - sessionLoadOptions: spawn options replayed on any later
+  //   ensureSessionLoaded / self-resume so the session is not respawned with
+  //   the wrong flags.
+  inactiveSessions = /* @__PURE__ */ new Set();
+  sessionsWithConcurrentPrompts = /* @__PURE__ */ new Set();
+  sessionLoadOptions = /* @__PURE__ */ new Map();
   onToolProgressUpdate;
   isProgressiveUiRenderingEnabled;
   // Store for explicit setting changes made before a concrete session store
@@ -23053,19 +23512,21 @@ var MultiSessionStateManager = class _MultiSessionStateManager {
   emitSessionStateEvent = (event, payload) => {
     for (const listener of this.sessionStateEvents.listeners(event)) {
       try {
-        listener(payload);
+        Reflect.apply(listener, void 0, [payload]);
       } catch (error) {
         logWarn("[MultiSessionStateManager] Error in state event listener", {
           error
         });
       }
     }
+    if (event === "working_state_changed" /* WorkingStateChanged */ && this.sessions.size > this.maxCapacity && this.sessions.get(payload.sessionId)?.getDroidWorkingState() === "idle" /* Idle */) {
+      this.evictIfNeeded();
+    }
   };
   subscribeToSessionEvent(event, listener) {
-    const handler = listener;
-    this.sessionStateEvents.on(event, handler);
+    this.sessionStateEvents.on(event, listener);
     return () => {
-      this.sessionStateEvents.off(event, handler);
+      this.sessionStateEvents.off(event, listener);
     };
   }
   subscribeToSessionEvents(events, listener) {
@@ -23148,9 +23609,7 @@ var MultiSessionStateManager = class _MultiSessionStateManager {
         count: this.sessions.size,
         limit: this.maxCapacity
       });
-      this.removeSession(evictionTarget);
-      this.pendingNotifications.delete(evictionTarget);
-      this.lastAccessTime.delete(evictionTarget);
+      this.evictCachedSession(evictionTarget);
     }
   }
   /**
@@ -23235,7 +23694,7 @@ var MultiSessionStateManager = class _MultiSessionStateManager {
    * Drain any notifications that arrived for `sessionId` before its session
    * manager was registered, replaying them in arrival order.
    */
-  replayPendingNotifications(sessionId, manager, phase) {
+  replayPendingNotifications(sessionId, phase) {
     const queued = this.pendingNotifications.get(sessionId);
     if (!queued || queued.length === 0) return;
     logInfo(
@@ -23245,9 +23704,8 @@ var MultiSessionStateManager = class _MultiSessionStateManager {
         count: queued.length
       }
     );
-    queued.forEach((params) => {
-      manager.handleNotification(params);
-      this.maybeConfirmOptimisticSubmit(params);
+    queued.forEach(({ params, options }) => {
+      this.handleNotification(params, options);
     });
     this.pendingNotifications.delete(sessionId);
   }
@@ -23495,7 +23953,7 @@ var MultiSessionStateManager = class _MultiSessionStateManager {
       logInfo("[MultiSessionStateManager] Setting machineId for session", {
         sessionId,
         machineId,
-        previousState: manager.getMachineId() ?? ""
+        state: manager.getMachineId() ?? ""
       });
       manager.setMachineId(machineId);
       this.emitStateChange(sessionId, manager.getLoadState());
@@ -23520,7 +23978,7 @@ var MultiSessionStateManager = class _MultiSessionStateManager {
     if (previousState !== "LOADED" /* Loaded */) {
       this.emitStateChange(sessionId, "LOADED" /* Loaded */);
     }
-    this.replayPendingNotifications(sessionId, manager, "init");
+    this.replayPendingNotifications(sessionId, "init");
     if (this.sessions.size > this.maxCapacity) {
       this.evictIfNeeded();
     }
@@ -23531,16 +23989,17 @@ var MultiSessionStateManager = class _MultiSessionStateManager {
    */
   loadSession(sessionId, machineId, messages, options) {
     _MultiSessionStateManager.validateSessionId(sessionId);
-    const { manager, isNew } = this.getOrCreateSessionManager(
-      sessionId,
-      machineId
-    );
+    const { manager } = this.getOrCreateSessionManager(sessionId, machineId);
     const previousState = manager.getLoadState();
     const priorMessageIds = new Set(
       manager.getMessages().map((message) => message.id)
     );
     manager.setHasOlderMessages(options?.hasOlderMessages ?? false);
     manager.setLoadedMessageLimit(options?.loadedMessageLimit ?? 0);
+    const workingState = options?.workingState;
+    if (workingState !== void 0 && manager.getDroidWorkingState() !== workingState) {
+      manager.hydrateDroidWorkingState(workingState);
+    }
     manager.loadSession(sessionId, messages);
     if (options && "cwd" in options) {
       manager.getStore().setCwd(options.cwd ?? null);
@@ -23553,8 +24012,8 @@ var MultiSessionStateManager = class _MultiSessionStateManager {
       messages,
       priorMessageIds
     );
-    this.replayPendingNotifications(sessionId, manager, "load");
-    if (isNew) {
+    this.replayPendingNotifications(sessionId, "load");
+    if (this.sessions.size > this.maxCapacity) {
       this.evictIfNeeded();
     }
   }
@@ -23617,7 +24076,7 @@ var MultiSessionStateManager = class _MultiSessionStateManager {
     if (shouldSeedStreaming) {
       manager.startStreaming();
     }
-    this.replayPendingNotifications(childSessionId, manager, "load");
+    this.replayPendingNotifications(childSessionId, "load");
   }
   /**
    * Get the SessionStateManager for a specific session.
@@ -23822,10 +24281,42 @@ var MultiSessionStateManager = class _MultiSessionStateManager {
     return this.sessions.get(sessionId)?.getCurrentTodos() ?? null;
   }
   /**
-   * Remove a session from management.
+   * Remove a session from management when it is definitively gone (closed,
+   * not found).
+   *
+   * Pending prompts can never be answered, so they are cleared with
+   * resolution events; the durable session-scoped collections (inactive
+   * flag, concurrent-prompt marker, load options) go with them; and buffered
+   * answers in pendingUserActions are dropped too, because no future load or
+   * SESSION_CLOSED can confirm or drain them once the session is gone.
+   *
+   * Contrast {@link evictCachedSession}, which drops only the LRU cache
+   * entities while the daemon still holds the session.
    */
   removeSession(sessionId) {
     _MultiSessionStateManager.validateSessionId(sessionId);
+    this.evictCachedSession(sessionId);
+    this._askUserRequests.clearSessionAskUserRequests(sessionId);
+    this._permissionRequests.clearSessionPermissions(sessionId, {
+      emitResolved: true
+    });
+    this._pendingUserActions.clearSession(sessionId);
+    this.inactiveSessions.delete(sessionId);
+    this.sessionsWithConcurrentPrompts.delete(sessionId);
+    this.sessionLoadOptions.delete(sessionId);
+  }
+  /**
+   * Drop only the LRU cache entities for a session (render-cache manager,
+   * access time, queued notifications) under cache pressure, leaving the
+   * durable session-scoped state intact: pending prompts, the inactive flag,
+   * the concurrent-prompt marker, stashed load options, and buffered answers
+   * all survive.
+   *
+   * The daemon still holds an evicted session and may be blocked on a pending
+   * prompt, so a later re-open (or a response from another surface) still
+   * resolves it and a self-resume replays the real load flags.
+   */
+  evictCachedSession(sessionId) {
     const session = this.sessions.get(sessionId);
     if (session) {
       session.getStore().clearAll();
@@ -23853,6 +24344,12 @@ var MultiSessionStateManager = class _MultiSessionStateManager {
     this.lastAccessTime.clear();
     this.subagentInvocationSummaries.clear();
     this.preInitSessions.clear();
+    this._askUserRequests.clearAll();
+    this._permissionRequests.clearAllPermissions();
+    this._pendingUserActions.clearAll();
+    this.inactiveSessions.clear();
+    this.sessionsWithConcurrentPrompts.clear();
+    this.sessionLoadOptions.clear();
   }
   /**
    * Handle notifications and route them to the appropriate session.
@@ -23861,7 +24358,7 @@ var MultiSessionStateManager = class _MultiSessionStateManager {
    * race conditions where notifications arrive before initializeSession/loadSession.
    * Queued notifications are replayed after session initialization.
    */
-  handleNotification(params) {
+  handleNotification(params, options) {
     const { sessionId } = params;
     try {
       _MultiSessionStateManager.validateSessionId(sessionId);
@@ -23883,12 +24380,12 @@ var MultiSessionStateManager = class _MultiSessionStateManager {
       if (!this.pendingNotifications.has(sessionId)) {
         this.pendingNotifications.set(sessionId, []);
       }
-      this.pendingNotifications.get(sessionId).push(params);
+      this.pendingNotifications.get(sessionId).push({ params, options });
       return;
     }
     const previousState = manager.getLoadState();
     const previousWorkingState = params.notification.type === "droid_working_state_changed" /* DROID_WORKING_STATE_CHANGED */ ? manager.getDroidWorkingState() : void 0;
-    manager.handleNotification(params);
+    manager.handleNotification(params, options);
     this.maybeConfirmOptimisticSubmit(params);
     const newState = manager.getLoadState();
     if (previousState !== newState) {
@@ -24087,6 +24584,75 @@ var MultiSessionStateManager = class _MultiSessionStateManager {
     _MultiSessionStateManager.validateSessionId(sessionId);
     return this.sentInitialPromptSessions.has(sessionId);
   }
+  /**
+   * Mark a session's worker as paused (inactivity timeout / process exit).
+   * While inactive, prompt responses are buffered in pendingUserActions and
+   * the owning controller self-resumes instead of firing RPCs at a reaped
+   * worker.
+   */
+  markSessionInactive(sessionId) {
+    _MultiSessionStateManager.validateSessionId(sessionId);
+    this.inactiveSessions.add(sessionId);
+  }
+  /**
+   * Clear a session's inactive marker (a successful reload has resumed it).
+   */
+  markSessionActive(sessionId) {
+    _MultiSessionStateManager.validateSessionId(sessionId);
+    this.inactiveSessions.delete(sessionId);
+  }
+  /**
+   * Whether a session's worker is currently paused.
+   */
+  isSessionInactive(sessionId) {
+    _MultiSessionStateManager.validateSessionId(sessionId);
+    return this.inactiveSessions.has(sessionId);
+  }
+  /**
+   * Mark that a session is draining a batch of concurrent prompts, so a
+   * resume-driven auto-clear does not strand the surviving tail prompt.
+   */
+  markConcurrentPrompts(sessionId) {
+    _MultiSessionStateManager.validateSessionId(sessionId);
+    this.sessionsWithConcurrentPrompts.add(sessionId);
+  }
+  /**
+   * Forget a session's concurrent-prompt marker once its batch fully drains.
+   */
+  clearConcurrentPrompts(sessionId) {
+    _MultiSessionStateManager.validateSessionId(sessionId);
+    this.sessionsWithConcurrentPrompts.delete(sessionId);
+  }
+  /**
+   * Whether a session is mid-way through draining a concurrent prompt batch.
+   */
+  hasConcurrentPrompts(sessionId) {
+    _MultiSessionStateManager.validateSessionId(sessionId);
+    return this.sessionsWithConcurrentPrompts.has(sessionId);
+  }
+  /**
+   * Stash the spawn options used to load a session so they can be replayed on
+   * a later ensureSessionLoaded / self-resume by whichever controller loads
+   * the session next.
+   */
+  setSessionLoadOptions(sessionId, options) {
+    _MultiSessionStateManager.validateSessionId(sessionId);
+    this.sessionLoadOptions.set(sessionId, options);
+  }
+  /**
+   * Read the stashed spawn options for a session, if any.
+   */
+  getSessionLoadOptions(sessionId) {
+    _MultiSessionStateManager.validateSessionId(sessionId);
+    return this.sessionLoadOptions.get(sessionId);
+  }
+  /**
+   * Drop the stashed spawn options for a session (e.g. on close).
+   */
+  deleteSessionLoadOptions(sessionId) {
+    _MultiSessionStateManager.validateSessionId(sessionId);
+    this.sessionLoadOptions.delete(sessionId);
+  }
 };
 
 // ../daemon-sdk/src/session/DaemonConnectionManager.ts
@@ -24570,7 +25136,7 @@ var PublicResumeSessionParamsSchema = LoadSessionRequestParamsSchema2.pick({
 });
 function createSdkSessionAttribution(sessionId) {
   return {
-    sessionOriginHint: "api" /* Api */,
+    sessionOriginHint: "sdk" /* Sdk */,
     sessionSource: {
       platform: "api" /* Api */,
       delegationSessionId: sessionId
@@ -24812,7 +25378,7 @@ var ConnectedDroidSessionImpl = class {
       },
       addUserMessage: (params) => this.controller.addUserMessage(this.id, {
         ...params,
-        userMessageSource: "api" /* Api */
+        userMessageSource: "sdk" /* Sdk */
       }),
       interruptSession: () => this.controller.interruptSession(this.id)
     };
@@ -24917,7 +25483,7 @@ var SessionsResourceImpl = class {
         sessionId,
         machineId: LOCAL_MACHINE_ID,
         token: this.apiKey,
-        tags: [...tags ?? [], SDK_TAG],
+        tags: withSdkTag(tags),
         ...createSdkSessionAttribution(sessionId)
       });
       session.setMetadata(
@@ -25084,6 +25650,7 @@ async function connectToDaemon(options) {
       machineType: "local" /* Local */,
       url: options.url,
       clientType: "sdk",
+      sdk: SDK_CLIENT_METADATA,
       getAccessToken,
       onAuthenticationError: options.onAuthenticationError,
       connectionTimeoutMs: connectionConfig.connectionTimeoutMs,
@@ -25195,7 +25762,9 @@ async function factoryFetch(path, apiKey, baseUrl, options) {
   const method = options?.method ?? "GET";
   const headers = {
     Authorization: `Bearer ${apiKey}`,
-    Accept: "application/json"
+    Accept: "application/json",
+    [FACTORY_CLIENT_HEADER]: "sdk" /* SDK */,
+    [FACTORY_SDK_HEADER]: formatSdkClientMetadata(SDK_CLIENT_METADATA)
   };
   if (options?.body) {
     headers["Content-Type"] = "application/json";
@@ -25389,6 +25958,7 @@ export {
   SettingsLevel,
   SkillLocation,
   JSONRPC_VERSION,
+  formatSdkClientMetadata,
   TraceContextMetaSchema,
   JsonRpcEnvelopeSchema,
   JsonRpcErrorSchema,
@@ -25679,6 +26249,8 @@ export {
   FactoryDroidMessageRole,
   ServerRequestHandlerType,
   SDK_VERSION,
+  SDK_CLIENT_METADATA,
+  SDK_REQUEST_ATTRIBUTION,
   SDK_TAG,
   JSONRPC_VERSION3,
   LEGACY_FACTORY_API_VERSION3 as LEGACY_FACTORY_API_VERSION2,
@@ -25702,6 +26274,7 @@ export {
   InvalidSessionCwdError,
   ProcessExitError,
   mergeSessionSettings,
+  withSdkTag,
   unwrapResponseResult,
   SessionMetadataSchema,
   SessionStartDecompSessionTypeSchema,
@@ -25828,4 +26401,4 @@ react/cjs/react.development.js:
    * LICENSE file in the root directory of this source tree.
    *)
 */
-//# sourceMappingURL=chunk-ROFAQUG4.mjs.map
+//# sourceMappingURL=chunk-KXDG5ZWS.mjs.map