@slock-ai/daemon 0.57.3 → 0.57.5

package/dist/{chunk-H2QU4LAU.js → chunk-BGWXECWO.js}

@@ -1058,6 +1058,143 @@ function shortMessageId(value) {
   return value.slice(0, 8);
 }
 
+// ../shared/src/externalAgentIntegration.ts
+import { z as z2 } from "zod";
+var EXTERNAL_AGENT_COMMS_PROTOCOL_VERSION = "agent-comms-core.v1";
+var EXTERNAL_AGENT_PROOF_SCHEMA_VERSION = "agent-proof.v1";
+var EXTERNAL_RUNTIME_INTEGRATION_MANIFEST_SCHEMA = "slock-external-runtime-integration.v1";
+var EXTERNAL_AGENT_WAKE_EVENT_SCHEMA = "slock-external-agent-wake-event.v1";
+var externalAgentCommsModeValues = ["spawn-core", "attach-core", "import-core"];
+var externalAgentIntegrationPatternValues = ["external-harness-plugin", "integrated-runtime"];
+var externalAgentIsolationValues = ["profile-scoped", "session-scoped"];
+var externalAgentWakeAdapterKindValues = ["claude-code-channels", "hermes-in-process"];
+var externalAgentWakeProofLevelValues = [
+  "server_delivered",
+  "harness_accepted",
+  "wake_injected"
+];
+var externalAgentProofLevelValues = [
+  ...externalAgentWakeProofLevelValues,
+  "model_seen"
+];
+var externalAgentCommsLifecycleStateValues = [
+  "unbound",
+  "bound_stopped",
+  "starting",
+  "connected_replaying",
+  "listening_idle",
+  "handoff_pending",
+  "degraded_backoff",
+  "stopping",
+  "stopped",
+  "auth_revoked"
+];
+var externalAgentLifecycleSourceValues = ["server_core", "comms_core", "wake_adapter", "server"];
+var externalAgentLifecycleProvenanceValues = [
+  "slock_core",
+  "adapter_observed",
+  "agent_reported"
+];
+var externalAgentAdapterFailureValues = [
+  "no_session",
+  "busy",
+  "injection_failed",
+  "protocol_mismatch",
+  "auth_revoked"
+];
+var externalAgentServerApiModeValues = ["interim-agent-api-events", "agent-inbox-protocol"];
+var nonEmptyStringSchema = z2.string().min(1);
+var isoTimestampSchema = z2.string().refine((value) => !Number.isNaN(Date.parse(value)), {
+  message: "must be a parseable timestamp"
+});
+var externalRuntimeIntegrationManifestSchema = z2.object({
+  schema: z2.literal(EXTERNAL_RUNTIME_INTEGRATION_MANIFEST_SCHEMA),
+  runtimeId: nonEmptyStringSchema,
+  integrationPattern: z2.enum(externalAgentIntegrationPatternValues),
+  commsMode: z2.enum(externalAgentCommsModeValues),
+  commsProtocolVersion: z2.literal(EXTERNAL_AGENT_COMMS_PROTOCOL_VERSION),
+  proofSchemaVersion: z2.literal(EXTERNAL_AGENT_PROOF_SCHEMA_VERSION),
+  minSlockCliVersion: nonEmptyStringSchema,
+  multiplex: z2.boolean(),
+  agentIsolation: z2.enum(externalAgentIsolationValues),
+  bridgeLifecycle: z2.object({
+    explicitStartOnly: z2.literal(true),
+    oneShotCommandsBridgeIndependent: z2.literal(true),
+    requiresBridgeFailureCodes: z2.array(z2.enum(["BRIDGE_NOT_RUNNING", "NO_CORE_SESSION"])).min(1),
+    autoStartDefault: z2.literal(false)
+  }).strict(),
+  serverApi: z2.object({
+    mode: z2.enum(externalAgentServerApiModeValues),
+    deliveryOnly: z2.boolean(),
+    cursorAuthority: z2.literal("model_seen_only")
+  }).strict(),
+  wakeAdapter: z2.object({
+    kind: z2.enum(externalAgentWakeAdapterKindValues),
+    protocol: nonEmptyStringSchema,
+    requiresInteractiveSession: z2.boolean().optional()
+  }).strict()
+}).strict().superRefine((value, ctx) => {
+  if (!value.bridgeLifecycle.requiresBridgeFailureCodes.includes("BRIDGE_NOT_RUNNING")) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["bridgeLifecycle", "requiresBridgeFailureCodes"],
+      message: "bridge-dependent surfaces must include BRIDGE_NOT_RUNNING"
+    });
+  }
+  if (!value.bridgeLifecycle.requiresBridgeFailureCodes.includes("NO_CORE_SESSION")) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["bridgeLifecycle", "requiresBridgeFailureCodes"],
+      message: "bridge-dependent surfaces must include NO_CORE_SESSION"
+    });
+  }
+  if (value.serverApi.mode === "interim-agent-api-events" && value.serverApi.deliveryOnly !== true) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["serverApi", "deliveryOnly"],
+      message: "interim agent-api events mode must be delivery-only"
+    });
+  }
+});
+var externalAgentWakeEventBaseSchema = z2.object({
+  schema: z2.literal(EXTERNAL_AGENT_WAKE_EVENT_SCHEMA),
+  eventId: nonEmptyStringSchema,
+  attemptId: nonEmptyStringSchema,
+  messageId: nonEmptyStringSchema,
+  agentId: nonEmptyStringSchema,
+  profile: nonEmptyStringSchema,
+  coreSessionId: nonEmptyStringSchema,
+  adapterInstance: nonEmptyStringSchema,
+  runtimeSession: nonEmptyStringSchema.nullable(),
+  occurredAt: isoTimestampSchema,
+  lifecycleState: z2.enum(externalAgentCommsLifecycleStateValues),
+  authority: z2.object({
+    source: z2.enum(externalAgentLifecycleSourceValues),
+    provenance: z2.enum(externalAgentLifecycleProvenanceValues)
+  }).strict()
+}).strict();
+var externalAgentProofEventEnvelopeSchema = externalAgentWakeEventBaseSchema.extend({
+  kind: z2.literal("proof"),
+  proofLevel: z2.enum(externalAgentWakeProofLevelValues),
+  outcome: z2.literal("ok"),
+  failureMeta: z2.undefined().optional(),
+  reason: z2.string().optional()
+});
+var externalAgentFailedWakeEventEnvelopeSchema = externalAgentWakeEventBaseSchema.extend({
+  kind: z2.literal("wake_attempt"),
+  proofLevel: z2.undefined().optional(),
+  outcome: z2.literal("failed"),
+  failureMeta: z2.object({
+    failureClass: z2.enum(externalAgentAdapterFailureValues),
+    retryAfterMs: z2.number().int().positive().optional()
+  }).strict(),
+  reason: nonEmptyStringSchema
+});
+var externalAgentWakeEventEnvelopeSchema = z2.discriminatedUnion("kind", [
+  externalAgentProofEventEnvelopeSchema,
+  externalAgentFailedWakeEventEnvelopeSchema
+]);
+
 // ../shared/src/translationLanguages.ts
 var SUPPORTED_TRANSLATION_LANGUAGE_CODES = [
   "en",
@@ -1164,6 +1301,7 @@ var RUNTIME_MODELS = {
     { id: "claude-opus-4-8", label: "Claude Opus 4.8" },
     { id: "claude-opus-4-7", label: "Claude Opus 4.7" },
     { id: "claude-opus-4-6", label: "Claude Opus 4.6" },
+    { id: "fable", label: "Claude Fable" },
     { id: "sonnet", label: "Claude Sonnet" },
     { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6" },
     { id: "haiku", label: "Claude Haiku" },
@@ -6513,6 +6651,7 @@ import {
   VERSION as PI_SDK_VERSION
 } from "@earendil-works/pi-coding-agent";
 var PI_SESSION_DIR = ".pi-sessions";
+var PI_SDK_COMPACTION_ENABLED = true;
 var PI_PROVIDER_LABELS = {
   google: "Google",
   openai: "OpenAI",
@@ -6711,7 +6850,7 @@ async function createPiAgentSessionForContext(ctx, sessionId) {
   if (launchRuntimeFields.model && launchRuntimeFields.model !== "default" && !model) {
     throw new Error(`Pi model not found: ${launchRuntimeFields.model}`);
   }
-  const settingsManager = SettingsManager.inMemory({ compaction: { enabled: false } });
+  const settingsManager = SettingsManager.inMemory({ compaction: { enabled: PI_SDK_COMPACTION_ENABLED } });
   const resourceLoader = new DefaultResourceLoader({
     cwd: ctx.workingDirectory,
     agentDir,
@@ -8843,6 +8982,7 @@ var AgentProcessManager = class _AgentProcessManager {
   maxConcurrentAgentStarts;
   agentStartIntervalMs;
   startingInboxes = /* @__PURE__ */ new Map();
+  pendingStartRebinds = /* @__PURE__ */ new Map();
   /** Cached configs for agents whose process exited normally — enables auto-restart on next message */
   idleAgentConfigs = /* @__PURE__ */ new Map();
   slockCliPath;
@@ -9488,6 +9628,92 @@ var AgentProcessManager = class _AgentProcessManager {
       ...attrs
     };
   }
+  recordStartRebind(agentId, start, reason, previousLaunchId, nextLaunchId, sessionId) {
+    this.recordDaemonTrace("daemon.agent.start.rebound", {
+      ...this.startQueueTraceAttrs(
+        agentId,
+        start.config,
+        start.wakeMessage,
+        start.unreadSummary,
+        start.resumePrompt,
+        start.launchId,
+        start.wakeMessageTransient ?? false
+      ),
+      reason,
+      previous_launch_id_present: Boolean(previousLaunchId),
+      next_launch_id_present: Boolean(nextLaunchId),
+      session_id_present: Boolean(sessionId)
+    });
+  }
+  sameWakeMessage(left, right) {
+    if (!left || !right) return left === right;
+    if (left.message_id && right.message_id) return left.message_id === right.message_id;
+    return left === right;
+  }
+  rebindQueuedStart(agentId, start, reason) {
+    const item = this.queuedAgentStarts.get(agentId);
+    if (!item) {
+      return false;
+    }
+    const previousLaunchId = item.launchId || null;
+    const nextLaunchId = start.launchId || previousLaunchId;
+    const previousWakeMessage = item.wakeMessage;
+    if (previousWakeMessage && start.wakeMessage && !this.sameWakeMessage(previousWakeMessage, start.wakeMessage)) {
+      const pending = this.startingInboxes.get(agentId) || [];
+      pending.push(previousWakeMessage);
+      this.startingInboxes.set(agentId, pending);
+    }
+    item.config = start.config;
+    item.unreadSummary = start.unreadSummary;
+    item.resumePrompt = start.resumePrompt;
+    item.launchId = nextLaunchId || void 0;
+    if (start.wakeMessage) {
+      item.wakeMessage = start.wakeMessage;
+      item.wakeMessageTransient = start.wakeMessageTransient;
+    }
+    this.recordStartRebind(
+      agentId,
+      { ...start, launchId: nextLaunchId || void 0 },
+      reason,
+      previousLaunchId,
+      nextLaunchId,
+      null
+    );
+    return true;
+  }
+  rebindRunningStart(agentId, start, reason) {
+    const ap = this.agents.get(agentId);
+    if (!ap) {
+      this.pendingStartRebinds.set(agentId, start);
+      return false;
+    }
+    const previousLaunchId = ap.launchId;
+    const nextLaunchId = start.launchId || ap.launchId || null;
+    const nextSessionId = ap.sessionId || start.config.sessionId || null;
+    ap.launchId = nextLaunchId;
+    ap.sessionId = nextSessionId;
+    ap.config = {
+      ...start.config,
+      sessionId: nextSessionId
+    };
+    this.idleAgentConfigs.set(agentId, {
+      config: { ...stripManagedRunnerCredential(ap.config), sessionId: nextSessionId },
+      sessionId: nextSessionId,
+      launchId: nextLaunchId
+    });
+    this.recordStartRebind(agentId, start, reason, previousLaunchId, nextLaunchId, nextSessionId);
+    this.sendAgentStatus(agentId, "active", nextLaunchId);
+    if (nextSessionId) {
+      this.sendToServer({ type: "agent:session", agentId, sessionId: nextSessionId, launchId: nextLaunchId || void 0 });
+    }
+    if (start.wakeMessage) {
+      const accepted = this.deliverMessage(agentId, start.wakeMessage, { transient: start.wakeMessageTransient === true });
+      if (accepted instanceof Promise) {
+        accepted.catch((err) => logger.error(`[Agent ${agentId}] Failed to deliver wake message after start rebind`, err));
+      }
+    }
+    return true;
+  }
   async startAgent(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient = false) {
     this.recordDaemonTrace("daemon.agent.start.requested", this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient));
     if (this.agents.has(agentId)) {
@@ -9495,7 +9721,8 @@ var AgentProcessManager = class _AgentProcessManager {
         ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient),
         reason: "already_running"
       });
-      logger.info(`[Agent ${agentId}] Start ignored (already running)`);
+      this.rebindRunningStart(agentId, { config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient }, "already_running");
+      logger.info(`[Agent ${agentId}] Start rebound (already running)`);
       return;
     }
     if (this.agentsStarting.has(agentId)) {
@@ -9503,7 +9730,8 @@ var AgentProcessManager = class _AgentProcessManager {
         ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient),
         reason: "already_starting"
       });
-      logger.info(`[Agent ${agentId}] Start ignored (startup in progress)`);
+      this.pendingStartRebinds.set(agentId, { config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient });
+      logger.info(`[Agent ${agentId}] Start rebind deferred (startup in progress)`);
       return;
     }
     if (this.queuedAgentStarts.has(agentId)) {
@@ -9511,7 +9739,8 @@ var AgentProcessManager = class _AgentProcessManager {
         ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient),
         reason: "already_queued"
       });
-      logger.info(`[Agent ${agentId}] Start ignored (startup already queued)`);
+      this.rebindQueuedStart(agentId, { config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient }, "already_queued");
+      logger.info(`[Agent ${agentId}] Queued start rebound (startup already queued)`);
       return;
     }
     return new Promise((resolve, reject) => {
@@ -9570,6 +9799,11 @@ var AgentProcessManager = class _AgentProcessManager {
         ...this.startQueueTraceAttrs(item.agentId, item.config, item.wakeMessage, item.unreadSummary, item.resumePrompt, item.launchId, item.wakeMessageTransient),
         reason: "already_running_or_starting"
       });
+      if (this.agents.has(item.agentId)) {
+        this.rebindRunningStart(item.agentId, item, "already_running_or_starting");
+      } else {
+        this.pendingStartRebinds.set(item.agentId, item);
+      }
       logger.info(`[Agent ${item.agentId}] Queued start skipped (already running or starting)`);
       item.resolve();
       this.pumpAgentStartQueue();
@@ -9656,7 +9890,8 @@ var AgentProcessManager = class _AgentProcessManager {
         ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient),
         reason: "already_running"
       });
-      logger.info(`[Agent ${agentId}] Start ignored (already running)`);
+      this.rebindRunningStart(agentId, { config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient }, "already_running");
+      logger.info(`[Agent ${agentId}] Start rebound (already running)`);
       return;
     }
     if (this.agentsStarting.has(agentId)) {
@@ -9664,7 +9899,8 @@ var AgentProcessManager = class _AgentProcessManager {
         ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient),
         reason: "already_starting"
       });
-      logger.info(`[Agent ${agentId}] Start ignored (startup in progress)`);
+      this.pendingStartRebinds.set(agentId, { config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient });
+      logger.info(`[Agent ${agentId}] Start rebind deferred (startup in progress)`);
       return;
     }
     this.agentsStarting.add(agentId);
@@ -9792,7 +10028,12 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         nativeStandingPrompt: Boolean(driver.supportsNativeStandingPrompt)
       });
       const effectiveConfig = await this.buildSpawnConfig(agentId, runtimeConfig);
-      const canDeferEmptyStart = driver.deferSpawnUntilMessage === true && !wakeMessage && !runtimeConfig.runtimeProfileControl && (!unreadSummary || Object.keys(unreadSummary).length === 0);
+      const pendingStartRebind = this.pendingStartRebinds.get(agentId);
+      if (pendingStartRebind) {
+        this.pendingStartRebinds.delete(agentId);
+      }
+      const effectiveLaunchId = pendingStartRebind?.launchId || launchId || null;
+      const canDeferEmptyStart = driver.deferSpawnUntilMessage === true && !wakeMessage && !pendingStartRebind?.wakeMessage && !runtimeConfig.runtimeProfileControl && (!unreadSummary || Object.keys(unreadSummary).length === 0);
       if (canDeferEmptyStart) {
         const pendingMessages = this.startingInboxes.get(agentId) || [];
         this.startingInboxes.delete(agentId);
@@ -9800,12 +10041,12 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         this.idleAgentConfigs.set(agentId, {
           config: effectiveConfig,
           sessionId: effectiveConfig.sessionId || null,
-          launchId: launchId || null
+          launchId: effectiveLaunchId
         });
-        this.sendAgentStatus(agentId, "active", launchId || null);
+        this.sendAgentStatus(agentId, "active", effectiveLaunchId);
         this.broadcastActivity(agentId, "online", "Process idle");
         this.recordDaemonTrace("daemon.agent.spawn.deferred", {
-          ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient),
+          ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, effectiveLaunchId || void 0, wakeMessageTransient),
           pending_messages_count: pendingMessages.length,
           reason: "defer_until_concrete_message"
         });
@@ -9823,7 +10064,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         workingDirectory: agentDataDir,
         slockCliPath: this.slockCliPath,
         daemonApiKey: this.daemonApiKey,
-        launchId: launchId || null,
+        launchId: effectiveLaunchId,
         agentCredentialProxyInboxCoordinator: this.createAgentProxyInboxCoordinator(agentId),
         cliTransportTraceDir: this.cliTransportTraceDir
       };
@@ -9834,7 +10075,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         inbox: wakeMessageDeliveredAsInboxUpdate && wakeMessage ? [wakeMessage, ...startingInboxMessages] : startingInboxMessages,
         config: runtimeConfig,
         sessionId: runtimeConfig.sessionId || null,
-        launchId: launchId || null,
+        launchId: effectiveLaunchId,
         startupWakeMessage: wakeMessage,
         startupUnreadSummary: unreadSummary,
         startupResumePrompt: resumePrompt,
@@ -9870,8 +10111,11 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       this.idleAgentConfigs.set(agentId, {
         config: { ...effectiveConfig, sessionId: effectiveConfig.sessionId || null },
         sessionId: effectiveConfig.sessionId || null,
-        launchId: launchId || null
+        launchId: effectiveLaunchId
       });
+      if (pendingStartRebind) {
+        this.recordStartRebind(agentId, pendingStartRebind, "startup_registered", launchId || null, effectiveLaunchId, agentProcess.sessionId);
+      }
       this.startRuntimeTrace(agentId, agentProcess, "spawn", wakeMessage ? [wakeMessage] : void 0, runtimeInputTraceAttrs);
       this.agentsStarting.delete(agentId);
       if (runtimeConfig.runtimeProfileControl) {
@@ -10106,16 +10350,26 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         throw new Error(`Runtime session failed to start: ${startResult.reason}${startResult.error ? ` (${startResult.error})` : ""}`);
       }
       this.recordDaemonTrace("daemon.agent.spawn.created", {
-        ...this.startQueueTraceAttrs(agentId, effectiveConfig, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient),
+        ...this.startQueueTraceAttrs(agentId, effectiveConfig, wakeMessage, unreadSummary, resumePrompt, agentProcess.launchId || void 0, wakeMessageTransient),
         detached: false,
         new_session: false,
         process_pid_present: typeof runtime.pid === "number"
       });
-      this.sendAgentStatus(agentId, "active", launchId || null);
+      this.sendAgentStatus(agentId, "active", agentProcess.launchId);
+      if (pendingStartRebind && agentProcess.sessionId) {
+        this.sendToServer({ type: "agent:session", agentId, sessionId: agentProcess.sessionId, launchId: agentProcess.launchId || void 0 });
+      }
+      if (pendingStartRebind?.wakeMessage) {
+        const accepted = this.deliverMessage(agentId, pendingStartRebind.wakeMessage, { transient: pendingStartRebind.wakeMessageTransient === true });
+        if (accepted instanceof Promise) {
+          accepted.catch((err) => logger.error(`[Agent ${agentId}] Failed to deliver wake message after startup rebind`, err));
+        }
+      }
       this.broadcastActivity(agentId, "working", "Starting\u2026");
       this.startRuntimeStartupTimeout(agentId, agentProcess);
     } catch (err) {
       this.agentsStarting.delete(agentId);
+      this.pendingStartRebinds.delete(agentId);
       this.cleanupFailedRuntimeStart(agentId, agentProcess, err);
       throw err;
     }
@@ -10384,6 +10638,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   }
   async stopAgent(agentId, { wait = false, silent = false } = {}) {
     this.cancelQueuedAgentStart(agentId, "stop requested");
+    this.pendingStartRebinds.delete(agentId);
     this.idleAgentConfigs.delete(agentId);
     const ap = this.agents.get(agentId);
     if (!ap) {