@aiden-ade/sandbox-agent 0.1.82 → 0.1.83

package/dist/index.cjs

@@ -1477,30 +1477,30 @@ var require_permessage_deflate = __commonJS({
        */
       acceptAsServer(offers) {
         const opts = this._options;
-        const accepted = offers.find((params) => {
+        const accepted2 = offers.find((params) => {
           if (opts.serverNoContextTakeover === false && params.server_no_context_takeover || params.server_max_window_bits && (opts.serverMaxWindowBits === false || typeof opts.serverMaxWindowBits === "number" && opts.serverMaxWindowBits > params.server_max_window_bits) || typeof opts.clientMaxWindowBits === "number" && !params.client_max_window_bits) {
             return false;
           }
           return true;
         });
-        if (!accepted) {
+        if (!accepted2) {
           throw new Error("None of the extension offers can be accepted");
         }
         if (opts.serverNoContextTakeover) {
-          accepted.server_no_context_takeover = true;
+          accepted2.server_no_context_takeover = true;
         }
         if (opts.clientNoContextTakeover) {
-          accepted.client_no_context_takeover = true;
+          accepted2.client_no_context_takeover = true;
         }
         if (typeof opts.serverMaxWindowBits === "number") {
-          accepted.server_max_window_bits = opts.serverMaxWindowBits;
+          accepted2.server_max_window_bits = opts.serverMaxWindowBits;
         }
         if (typeof opts.clientMaxWindowBits === "number") {
-          accepted.client_max_window_bits = opts.clientMaxWindowBits;
-        } else if (accepted.client_max_window_bits === true || opts.clientMaxWindowBits === false) {
-          delete accepted.client_max_window_bits;
+          accepted2.client_max_window_bits = opts.clientMaxWindowBits;
+        } else if (accepted2.client_max_window_bits === true || opts.clientMaxWindowBits === false) {
+          delete accepted2.client_max_window_bits;
         }
-        return accepted;
+        return accepted2;
       }
       /**
        * Accept the extension negotiation response.
@@ -15240,7 +15240,7 @@ function describeError(error61) {
 }
 
 // src/version.ts
-var AGENT_VERSION = "0.1.82";
+var AGENT_VERSION = "0.1.83";
 
 // src/daemon-worktree.ts
 var import_node_child_process3 = require("child_process");
@@ -40308,7 +40308,7 @@ function resolveAntigravityParentTranscriptPath(conversationId, context) {
     "transcript.jsonl"
   );
 }
-function syncAntigravityParentThinkingFromTranscript(context, state) {
+function syncAntigravityParentTranscript(context, state) {
   const parent = state.antigravityParentTranscript;
   if (!parent?.transcriptPath) return 0;
   const lines = readAntigravityTranscriptLines(parent.transcriptPath);
@@ -40329,6 +40329,14 @@ function syncAntigravityParentThinkingFromTranscript(context, state) {
     }
     processedLineCount = lineIndex + 1;
     if (stringField2(entry, "source") !== "MODEL") continue;
+    const content = stringField2(entry, "content");
+    if (content?.includes("[diff_block_start]") && isAntigravityToolResultEntry(entry) && typeof entry.step_index === "number") {
+      emittedEventCount += 1;
+      void context.presenter.onToolResult?.(
+        liveStepId({ ...entry, conversation_id: parent.conversationId }),
+        stripAntigravityToolResultEnvelope(content)
+      );
+    }
     const thinking = stringField2(entry, "thinking") ?? stringField2(entry, "thinking_delta");
     if (!thinking) continue;
     emittedEventCount += 1;
@@ -40338,7 +40346,7 @@ function syncAntigravityParentThinkingFromTranscript(context, state) {
   return emittedEventCount;
 }
 function syncAntigravitySubagentEventsFromTranscripts(context, state) {
-  let emittedEventCount = syncAntigravityParentThinkingFromTranscript(context, state);
+  let emittedEventCount = syncAntigravityParentTranscript(context, state);
   for (const [launcherId, task] of state.antigravitySubagentTranscripts ?? []) {
     if (!task.transcriptPath) continue;
     const replay = syncAntigravitySubagentTranscript(
@@ -42958,10 +42966,7 @@ var parseCopilotStructuredLine = createStructuredLineParser(
 );
 function buildCopilotCliArgs(context, prompt, defaultArgs = []) {
   const args = [
-    "--autopilot",
     "--yolo",
-    "--max-autopilot-continues",
-    "20",
     "-s",
     "--stream",
     "on",
@@ -44771,36 +44776,6 @@ function createKimiCliBackend(command = "kimi-cli", defaultArgs = []) {
     }
   };
 }
-var AUTONOMOUS_OPENCODE_CONFIG_CONTENT = JSON.stringify({
-  $schema: "https://opencode.ai/config.json",
-  permission: "allow"
-});
-function buildAutonomousOpenCodeConfigContent(existing) {
-  if (!existing?.trim()) return AUTONOMOUS_OPENCODE_CONFIG_CONTENT;
-  try {
-    const parsed = JSON.parse(existing);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      return JSON.stringify({
-        ...parsed,
-        permission: "allow"
-      });
-    }
-  } catch {
-  }
-  return AUTONOMOUS_OPENCODE_CONFIG_CONTENT;
-}
-function withAutonomousOpenCodePermissions(context) {
-  if (shouldUseReadOnlyRuntimePermissions(context.config)) return context;
-  return {
-    ...context,
-    env: {
-      ...context.env,
-      OPENCODE_CONFIG_CONTENT: buildAutonomousOpenCodeConfigContent(
-        context.env.OPENCODE_CONFIG_CONTENT
-      )
-    }
-  };
-}
 function getRecord(value2) {
   return typeof value2 === "object" && value2 !== null ? value2 : null;
 }
@@ -45094,7 +45069,6 @@ function createOpencodeCliBackend(command = "opencode", defaultArgs = []) {
         context.cwd
       );
       try {
-        const runContext = withAutonomousOpenCodePermissions(context);
         return await createGenericCliBackend({
           kind: "opencode_cli",
           supportTier: "structured",
@@ -45103,7 +45077,7 @@ function createOpencodeCliBackend(command = "opencode", defaultArgs = []) {
           buildArgs: (ctx, prompt) => {
             const args = ["run", "--format", "json", "--thinking"];
             if (!shouldUseReadOnlyRuntimePermissions(ctx.config)) {
-              args.push("--dangerously-skip-permissions");
+              args.push("--auto");
             }
             const resumeId = ctx.config.runtimeSessionId?.trim() || ctx.config.providerSessionId?.trim();
             if (resumeId) args.push("--session", resumeId);
@@ -45124,7 +45098,7 @@ function createOpencodeCliBackend(command = "opencode", defaultArgs = []) {
             return ctx.config.mode === "plan" ? buildPlanModePrefix(base) : base;
           },
           parseStructuredLine: parseOpencodeStructuredLine
-        }).run(runContext);
+        }).run(context);
       } finally {
         cleanup();
         cleanupFiles();
@@ -45132,6 +45106,36 @@ function createOpencodeCliBackend(command = "opencode", defaultArgs = []) {
     }
   };
 }
+var AUTONOMOUS_OPENCODE_CONFIG_CONTENT = JSON.stringify({
+  $schema: "https://opencode.ai/config.json",
+  permission: "allow"
+});
+function buildAutonomousOpenCodeConfigContent(existing) {
+  if (!existing?.trim()) return AUTONOMOUS_OPENCODE_CONFIG_CONTENT;
+  try {
+    const parsed = JSON.parse(existing);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return JSON.stringify({
+        ...parsed,
+        permission: "allow"
+      });
+    }
+  } catch {
+  }
+  return AUTONOMOUS_OPENCODE_CONFIG_CONTENT;
+}
+function withAutonomousOpenCodePermissions(context) {
+  if (shouldUseReadOnlyRuntimePermissions(context.config)) return context;
+  return {
+    ...context,
+    env: {
+      ...context.env,
+      OPENCODE_CONFIG_CONTENT: buildAutonomousOpenCodeConfigContent(
+        context.env.OPENCODE_CONFIG_CONTENT
+      )
+    }
+  };
+}
 function parseSseEventBlock(block) {
   const dataLines = block.split("\n").map((line) => line.endsWith("\r") ? line.slice(0, -1) : line).filter((line) => line.startsWith("data:")).map((line) => line.slice("data:".length).replace(/^ /, ""));
   if (dataLines.length === 0) return null;
@@ -46077,7 +46081,7 @@ function defaultSelectedModelForBackend(backendKind) {
     case "droid_cli":
       return DROID_DEFAULT_MODEL;
     case "copilot_cli":
-      return "claude-sonnet-4.5";
+      return void 0;
     case "kimi_cli":
       return void 0;
     case "grok_cli":
@@ -46879,6 +46883,7 @@ ${output2.stderr}`;
 var import_node_crypto2 = require("crypto");
 var import_node_fs7 = require("fs");
 var import_node_path6 = require("path");
+var import_node_util = require("util");
 var OUTBOX_VERSION = 1;
 var MAX_INTERMEDIATE_EVENTS_PER_RUN = 200;
 var MAX_ENCRYPTED_OUTBOX_BYTES = 64 * 1024 * 1024;
@@ -47040,6 +47045,7 @@ var EncryptedEventOutbox = class _EncryptedEventOutbox {
   inFlightEventId = null;
   ackTimer = null;
   retryTimer = null;
+  acknowledgementWaiters = /* @__PURE__ */ new Map();
   /** Latch so a persistent disk failure logs once per streak, not per event. */
   persistFailureLogged = false;
   /**
@@ -47058,7 +47064,7 @@ var EncryptedEventOutbox = class _EncryptedEventOutbox {
   maxIntermediateEventsPerRun;
   enqueue(conversationId, runId, event) {
     const last = this.entries[this.entries.length - 1];
-    if (last && last.eventId !== this.inFlightEventId && !this.transmittedEventIds.has(last.eventId) && last.kind !== "condensation_marker" && last.conversationId === conversationId && last.runId === runId && canCoalesceEvents(last.event, event)) {
+    if (last && !last.explicitSource && last.eventId !== this.inFlightEventId && !this.transmittedEventIds.has(last.eventId) && last.kind !== "condensation_marker" && last.conversationId === conversationId && last.runId === runId && canCoalesceEvents(last.event, event)) {
       last.event = coalesceEvents(last.event, event);
       last.createdAtMs = Date.now();
       this.enforceCaps(runId);
@@ -47077,12 +47083,48 @@ var EncryptedEventOutbox = class _EncryptedEventOutbox {
     this.persist();
     return entry.eventId;
   }
+  /**
+   * Durably enqueue an event whose id is derived from an external source cursor.
+   * Identical retries are idempotent, while reusing an id for different content
+   * fails closed so the backend can never observe divergent payloads under one
+   * receipt key.
+   */
+  enqueueSource(conversationId, runId, eventId, event) {
+    if (!eventId.trim()) throw new Error("event outbox source event id must not be empty");
+    const existing = this.entries.find((entry) => entry.eventId === eventId);
+    if (existing) {
+      if (existing.explicitSource === true && existing.conversationId === conversationId && existing.runId === runId && (0, import_node_util.isDeepStrictEqual)(existing.event, event)) {
+        return eventId;
+      }
+      throw new Error(`event outbox source event id ${eventId} has divergent payload`);
+    }
+    this.entries.push({
+      eventId,
+      conversationId,
+      runId,
+      event,
+      createdAtMs: Date.now(),
+      explicitSource: true
+    });
+    this.enforceCaps(runId);
+    this.persist();
+    return eventId;
+  }
   hasTerminalEvent(runId) {
     return this.entries.some((entry) => entry.runId === runId && isTerminal(entry.event));
   }
   pendingCount() {
     return this.entries.length;
   }
+  /** Resolve only after the backend has durably acknowledged this queued event. */
+  waitForAcknowledgement(eventId) {
+    if (!this.entries.some((entry) => entry.eventId === eventId)) return Promise.resolve();
+    return new Promise((resolve15) => {
+      const waiters = this.acknowledgementWaiters.get(eventId) ?? [];
+      waiters.push(resolve15);
+      this.acknowledgementWaiters.set(eventId, waiters);
+    });
+  }
   disconnect() {
     this.clearAckTimer();
     this.clearRetryTimer();
@@ -47111,6 +47153,8 @@ var EncryptedEventOutbox = class _EncryptedEventOutbox {
           this.condensedRunIds.add(entry.runId);
         }
         this.persist();
+        for (const resolve15 of this.acknowledgementWaiters.get(entry.eventId) ?? []) resolve15();
+        this.acknowledgementWaiters.delete(entry.eventId);
         queueMicrotask(() => this.flush(socket));
         return;
       }
@@ -47130,7 +47174,7 @@ var EncryptedEventOutbox = class _EncryptedEventOutbox {
     );
   }
   isDroppable(entry) {
-    return entry.eventId !== this.inFlightEventId && entry.kind !== "condensation_marker" && !isTerminal(entry.event);
+    return entry.eventId !== this.inFlightEventId && !entry.explicitSource && entry.kind !== "condensation_marker" && !isTerminal(entry.event);
   }
   /**
    * Pick the next droppable entry to evict. Heartbeats are always evicted
@@ -47201,7 +47245,7 @@ var EncryptedEventOutbox = class _EncryptedEventOutbox {
         continue;
       }
       const terminal = this.entries.find(
-        (entry) => entry.eventId !== this.inFlightEventId && isTerminal(entry.event) && !entry.terminalCondensed
+        (entry) => entry.eventId !== this.inFlightEventId && !entry.explicitSource && isTerminal(entry.event) && !entry.terminalCondensed
       );
       if (!terminal) break;
       terminal.event = condenseTerminalEvent(terminal.event);
@@ -61692,10 +61736,10 @@ function isPlainObject2(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 function partitionInputResponses(inputResponses) {
-  const accepted = {};
+  const accepted2 = {};
   const droppedKeys = [];
   if (!isPlainObject2(inputResponses)) return {
-    accepted,
+    accepted: accepted2,
     droppedKeys
   };
   for (const [key, entry] of Object.entries(inputResponses)) {
@@ -61703,10 +61747,10 @@ function partitionInputResponses(inputResponses) {
       droppedKeys.push(key);
       continue;
     }
-    accepted[key] = entry;
+    accepted2[key] = entry;
   }
   return {
-    accepted,
+    accepted: accepted2,
     droppedKeys
   };
 }
@@ -73862,15 +73906,18 @@ async function drainNativeHookInbox(input2) {
   return input2.inbox.drain(async (envelope) => {
     const isStart = envelope.eventType === "session_start" || envelope.eventType === "subagent_start";
     const isTerminal2 = envelope.eventType === "stop" || envelope.eventType === "session_end" || envelope.eventType === "subagent_end";
+    let binding = envelope.eventType === "user_prompt" ? void 0 : input2.transcriptStreamer?.bindingFor?.(envelope);
     const streamTranscript = async () => {
       if (isStart || !input2.transcriptStreamer || !envelope.transcriptPath) {
         return "unavailable";
       }
       try {
-        const streamed = await input2.transcriptStreamer.stream(
-          envelope,
-          (event) => input2.sink.deliver(event)
-        );
+        const streamed = await input2.transcriptStreamer.stream(envelope, async (event) => {
+          if (binding && input2.sink.deliverCanonical) {
+            return input2.sink.deliverCanonical(binding, event);
+          }
+          return accepted(await input2.sink.deliver(event));
+        });
         return streamed.complete ? streamed.assistantOutputDelivered ? "replayed" : "unavailable" : "deferred";
       } catch (error61) {
         if (error61 instanceof PermanentNativeHookDeliveryError) throw error61;
@@ -73892,14 +73939,27 @@ async function drainNativeHookInbox(input2) {
     if (isTerminal2) {
       const transcriptReplay = await streamTranscript();
       if (transcriptReplay === "deferred") return false;
-      return input2.sink.deliver(
-        transcriptReplay === "replayed" ? { ...envelope, assistantOutputReplayed: true } : envelope
+      return accepted(
+        await input2.sink.deliver(
+          transcriptReplay === "replayed" ? { ...envelope, assistantOutputReplayed: true } : envelope
+        )
       );
     }
-    if (!await input2.sink.deliver(envelope)) return false;
+    const lifecycleDelivery = normalizeDelivery(await input2.sink.deliver(envelope));
+    if (!lifecycleDelivery.accepted) return false;
+    if (envelope.eventType === "user_prompt") {
+      binding = lifecycleDelivery.binding;
+      input2.transcriptStreamer?.setBinding?.(envelope, binding);
+    }
     return await streamTranscript() !== "deferred";
   }, input2.limit);
 }
+function normalizeDelivery(result) {
+  return typeof result === "boolean" ? { accepted: result } : result;
+}
+function accepted(result) {
+  return normalizeDelivery(result).accepted;
+}
 function isMissingTranscriptError(error61) {
   return error61.code === "ENOENT";
 }
@@ -74112,6 +74172,24 @@ var NativeTranscriptStreamer = class {
       throw new Error("native transcript maxReadBytes must be a positive integer");
     }
   }
+  bindingFor(hook) {
+    if (!hook.transcriptPath) return void 0;
+    return this.cursorStore.get(this.cursorKey(hook))?.binding;
+  }
+  setBinding(hook, binding) {
+    if (!hook.transcriptPath) return;
+    const key = this.cursorKey(hook);
+    const previous = this.cursorStore.get(key);
+    this.cursorStore.commit(key, {
+      offset: previous?.offset ?? 0,
+      generation: previous?.generation ?? 0,
+      device: previous?.device ?? 0,
+      inode: previous?.inode ?? 0,
+      assistantOutputSeen: previous?.assistantOutputSeen,
+      assistantOutputTurnId: previous?.assistantOutputTurnId,
+      ...binding ? { binding } : {}
+    });
+  }
   async stream(hook, deliver) {
     if (!hook.transcriptPath) {
       return {
@@ -74121,11 +74199,7 @@ var NativeTranscriptStreamer = class {
         assistantOutputDelivered: false
       };
     }
-    const key = nativeTranscriptCursorKey({
-      provider: hook.provider,
-      externalSessionId: hook.externalSessionId,
-      transcriptPath: hook.transcriptPath
-    });
+    const key = this.cursorKey(hook);
     let previous = this.cursorStore.get(key);
     if (hook.eventType === "user_prompt" && previous && previous.assistantOutputTurnId !== hook.eventId) {
       previous = {
@@ -74136,15 +74210,17 @@ var NativeTranscriptStreamer = class {
       this.cursorStore.commit(key, previous);
     }
     const file2 = (0, import_node_fs18.statSync)(hook.transcriptPath);
-    const replaced = Boolean(previous) && (previous.device !== file2.dev || previous.inode !== file2.ino);
+    const hasFileIdentity = Boolean(previous && (previous.device !== 0 || previous.inode !== 0));
+    const replaced = hasFileIdentity && (previous.device !== file2.dev || previous.inode !== file2.ino);
     const truncated = Boolean(previous) && file2.size < previous.offset;
-    const start = !previous || replaced || truncated ? {
+    const start = !previous || !hasFileIdentity || replaced || truncated ? {
       offset: 0,
-      generation: previous ? previous.generation + 1 : 0,
+      generation: previous ? previous.generation + (hasFileIdentity ? 1 : 0) : 0,
       device: file2.dev,
       inode: file2.ino,
       assistantOutputSeen: previous?.assistantOutputSeen ?? false,
-      assistantOutputTurnId: hook.eventType === "user_prompt" ? hook.eventId : previous?.assistantOutputTurnId
+      assistantOutputTurnId: hook.eventType === "user_prompt" ? hook.eventId : previous?.assistantOutputTurnId,
+      binding: previous?.binding
     } : previous;
     let assistantOutputSeen = start.assistantOutputSeen ?? false;
     if (file2.size <= start.offset) {
@@ -74197,9 +74273,10 @@ var NativeTranscriptStreamer = class {
       const events = parsed ? providerRecordToAgentEvents(hook.provider, parsed) : [];
       for (let index = 0; index < events.length; index += 1) {
         const deliveredEvent = events[index];
+        if (deliveredEvent.type === "start" && start.binding) continue;
         const sourceCursor = `${start.generation}:${recordEndOffset}:${index}`;
         const eventId = stableSourceEventId(hook, sourceCursor);
-        const accepted = await deliver({
+        const accepted2 = await deliver({
           schemaVersion: 1,
           eventId,
           provider: hook.provider,
@@ -74208,7 +74285,7 @@ var NativeTranscriptStreamer = class {
           observedAt: timestampOf(parsed) ?? hook.observedAt,
           event: deliveredEvent
         });
-        if (!accepted) {
+        if (!accepted2) {
           return {
             complete: false,
             recordsRead,
@@ -74238,6 +74315,14 @@ var NativeTranscriptStreamer = class {
       cursor: `${start.generation}:${committedOffset}`
     };
   }
+  cursorKey(hook) {
+    if (!hook.transcriptPath) throw new Error("native transcript hook has no transcript path");
+    return nativeTranscriptCursorKey({
+      provider: hook.provider,
+      externalSessionId: hook.externalSessionId,
+      transcriptPath: hook.transcriptPath
+    });
+  }
 };
 function stableSourceEventId(hook, sourceCursor) {
   const bytes = (0, import_node_crypto10.createHash)("sha256").update(`${hook.provider}\0${hook.externalSessionId}\0${hook.transcriptPath}\0${sourceCursor}`).digest().subarray(0, 16);
@@ -74257,8 +74342,19 @@ function parseJsonObject3(value2) {
 function providerRecordToAgentEvents(provider, record2) {
   if (provider === "codex") return codexRecordToAgentEvents(record2);
   if (provider === "copilot") return copilotRecordToAgentEvents(record2);
+  if (provider === "cursor") return cursorRecordToAgentEvents(record2);
   return claudeCompatibleRecordToAgentEvents(record2);
 }
+function cursorRecordToAgentEvents(record2) {
+  const message = isRecord2(record2.message) ? record2.message : record2;
+  const role = stringValue(message.role, record2.role);
+  if (role !== "user") return claudeCompatibleRecordToAgentEvents(record2);
+  const rawPrompt = extractText2(message.content).trim();
+  if (!rawPrompt) return [];
+  const wrappedPrompt = rawPrompt.match(/<user_query>\s*([\s\S]*?)\s*<\/user_query>/i)?.[1];
+  const prompt = (wrappedPrompt ?? rawPrompt).trim();
+  return prompt ? [{ type: "start", task: prompt, ts: Date.now() }] : [];
+}
 function copilotRecordToAgentEvents(record2) {
   if (typeof record2.type !== "string" || !isRecord2(record2.data)) return [];
   const timestamp = timestampOf(record2) ? Date.parse(timestampOf(record2)) : Date.now();
@@ -74684,9 +74780,9 @@ var import_yaml = __toESM(require_dist2(), 1);
 // ../shared/dist/skills/domain.js
 var SKILLS_PROTOCOL_VERSION = 1;
 var SKILL_PACKAGE_LIMITS = {
-  maxArchiveBytes: 10 * 1024 * 1024,
-  maxExpandedBytes: 25 * 1024 * 1024,
-  maxFileBytes: 25 * 1024 * 1024,
+  maxArchiveBytes: 20 * 1024 * 1024,
+  maxExpandedBytes: 20 * 1024 * 1024,
+  maxFileBytes: 20 * 1024 * 1024,
   maxSkillMarkdownBytes: 2 * 1024 * 1024,
   maxFiles: 1e3,
   maxPathBytes: 240,
@@ -74711,14 +74807,16 @@ var skillInvocationSchema = defineWireSchema()(external_exports.discriminatedUni
     kind: external_exports.literal("skill_version"),
     skillId: skillIdSchema,
     versionId: skillVersionIdSchema,
-    displayName: external_exports.string().trim().min(1).max(128)
+    displayName: external_exports.string().trim().min(1).max(128),
+    textOffset: external_exports.number().int().nonnegative().optional()
   }),
   external_exports.object({
     kind: external_exports.literal("local_skill"),
     runtimeId: runtimeIdSchema,
     localKey: external_exports.string().min(1).max(256),
     contentHash: sha256Schema,
-    displayName: external_exports.string().trim().min(1).max(128)
+    displayName: external_exports.string().trim().min(1).max(128),
+    textOffset: external_exports.number().int().nonnegative().optional()
   })
 ]));
 var runtimeUploadGrantSchema = external_exports.object({
@@ -74886,12 +74984,7 @@ var discoveredSkillCandidateSchema = external_exports.object({
       repositoryId: external_exports.string().min(1).max(128)
     })
   ]),
-  diagnostics: external_exports.array(skillPackageDiagnosticSchema).max(100),
-  publication: external_exports.object({
-    skillId: skillIdSchema,
-    versionId: skillVersionIdSchema,
-    contentHash: sha256Schema
-  }).optional()
+  diagnostics: external_exports.array(skillPackageDiagnosticSchema).max(100)
 });
 var skillScanOutcomeSchema = defineWireSchema()(external_exports.discriminatedUnion("status", [
   external_exports.object({
@@ -74925,6 +75018,19 @@ var desiredSkillManifestEntrySchema = external_exports.object({
   downloadUrl: external_exports.url(),
   downloadUrlExpiresAt: external_exports.iso.datetime()
 });
+var skillInstallConflictSchema = external_exports.object({
+  kind: external_exports.enum(["managed_destination", "compatibility_destination"]),
+  runtimeDirectory: external_exports.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/),
+  observedHash: sha256Schema,
+  observedName: external_exports.string().min(1).max(64).regex(SKILL_NAME_PATTERN, "Invalid")
+});
+var skillConflictResolutionSchema = external_exports.discriminatedUnion("kind", [
+  external_exports.object({
+    kind: external_exports.literal("rename_local"),
+    name: external_exports.string().min(1).max(64).regex(SKILL_NAME_PATTERN, "Invalid")
+  }),
+  external_exports.object({ kind: external_exports.literal("overwrite_local") })
+]);
 var desiredSkillManifestSchema = defineWireSchema()(external_exports.object({
   protocolVersion: external_exports.literal(SKILLS_PROTOCOL_VERSION),
   revision: sha256Schema,
@@ -74958,7 +75064,8 @@ var reconcileSkillResultSchema = external_exports.object({
   observedHash: sha256Schema.optional(),
   state: external_exports.enum(["applied", "conflict", "failed"]),
   errorCode: external_exports.string().max(128).optional(),
-  errorMessage: external_exports.string().max(2048).optional()
+  errorMessage: external_exports.string().max(2048).optional(),
+  conflict: skillInstallConflictSchema.optional()
 });
 var reconcileSkillsResultSchema = defineWireSchema()(external_exports.object({
   attemptId: external_exports.string().min(1).max(128),
@@ -74985,14 +75092,23 @@ var runtimeSkillCommandSchema = defineWireSchema()(external_exports.discriminate
     uploadGrant: runtimeUploadGrantSchema
   }),
   external_exports.object({
-    kind: external_exports.literal("bind_source"),
+    kind: external_exports.literal("resolve_conflict"),
     commandId: skillCommandIdSchema,
-    localKey: external_exports.string().min(1).max(256),
-    expectedContentHash: sha256Schema,
+    manifest: desiredSkillManifestSchema,
     skillId: skillIdSchema,
-    versionId: skillVersionIdSchema
+    versionId: skillVersionIdSchema,
+    expectedConflict: skillInstallConflictSchema,
+    resolution: skillConflictResolutionSchema
   })
 ]));
+var skillConflictResolutionResultSchema = defineWireSchema()(external_exports.object({
+  commandId: skillCommandIdSchema,
+  skillId: skillIdSchema,
+  versionId: skillVersionIdSchema,
+  state: external_exports.enum(["applied", "stale", "failed"]),
+  errorCode: external_exports.string().max(128).optional(),
+  errorMessage: external_exports.string().max(2048).optional()
+}));
 var publishSkillResultSchema = defineWireSchema()(external_exports.object({
   commandId: skillCommandIdSchema,
   previewId: skillPreviewIdSchema,
@@ -75012,6 +75128,7 @@ var runtimeSkillSyncRequestSchema = defineWireSchema()(external_exports.object({
   inventoryAttempt: skillScanOutcomeSchema.optional(),
   appliedResult: reconcileSkillsResultSchema.optional(),
   publishedPreviews: external_exports.array(publishSkillResultSchema).max(100).optional(),
+  resolvedConflicts: external_exports.array(skillConflictResolutionResultSchema).max(100).optional(),
   completedCommandIds: external_exports.array(skillCommandIdSchema).max(100).optional()
 }));
 var runtimeSkillSyncResponseSchema = defineWireSchema()(external_exports.object({
@@ -75535,7 +75652,6 @@ var DEFAULT_SKILL_CONFIG = `version = 1
 
 [skills]
 enabled = true
-publish_changes = "prompt"
 discover_repository_skills = true
 ignore = ["**/.git/**", "**/node_modules/**"]
 
@@ -75887,7 +76003,6 @@ function parseSkillSourceConfig(content, homeDirectory2) {
   }
   const skills = parsed.skills;
   const enabled = optionalBoolean(skills.enabled, true, "skills.enabled");
-  const publishChanges = optionalPublishChanges(skills.publish_changes);
   const discoverRepositorySkills = optionalBoolean(
     skills.discover_repository_skills,
     true,
@@ -75929,7 +76044,7 @@ function parseSkillSourceConfig(content, homeDirectory2) {
   if (duplicateId) {
     throw new Error(`skills.sources contains duplicate source id ${duplicateId.declarationId}`);
   }
-  return { enabled, publishChanges, discoverRepositorySkills, ignoredPaths, sources };
+  return { enabled, discoverRepositorySkills, ignoredPaths, sources };
 }
 function stableSourceDeclarationId(sourcePath) {
   const digest = (0, import_node_crypto12.createHash)("sha256").update("alan-skill-source-v1\0").update(sourcePath.normalize("NFC")).digest("hex").slice(0, 24);
@@ -75955,11 +76070,6 @@ function optionalBoolean(value2, fallback, field) {
   if (typeof value2 !== "boolean") throw new Error(`${field} must be true or false`);
   return value2;
 }
-function optionalPublishChanges(value2) {
-  if (value2 === void 0) return "prompt";
-  if (value2 === "prompt" || value2 === "automatic" || value2 === "never") return value2;
-  throw new Error('skills.publish_changes must be "prompt", "automatic", or "never"');
-}
 function optionalStringArray(value2, field) {
   if (value2 === void 0) return [];
   if (!Array.isArray(value2) || value2.some((item) => typeof item !== "string")) {
@@ -76068,6 +76178,7 @@ var RuntimeSkillCoordinator = class {
   pendingInventory;
   pendingApplied;
   pendingPublished = /* @__PURE__ */ new Map();
+  pendingResolvedConflicts = /* @__PURE__ */ new Map();
   completedCommandIds = /* @__PURE__ */ new Set();
   tail = Promise.resolve();
   lastScanInput;
@@ -76133,16 +76244,22 @@ var RuntimeSkillCoordinator = class {
             producedWork = true;
             break;
           }
-          case "bind_source":
-            await this.manager.bindSource({
-              localKey: command.localKey,
-              expectedContentHash: command.expectedContentHash,
+          case "resolve_conflict": {
+            const resolved = await this.manager.resolveConflict({
+              commandId: command.commandId,
+              manifest: command.manifest,
               skillId: command.skillId,
-              versionId: command.versionId
+              versionId: command.versionId,
+              expectedConflict: command.expectedConflict,
+              resolution: command.resolution
             });
-            this.completedCommandIds.add(command.commandId);
+            this.pendingResolvedConflicts.set(resolved.commandId, resolved);
+            if (resolved.state === "applied") {
+              this.pendingApplied = await this.manager.reconcile({ manifest: command.manifest });
+            }
             producedWork = true;
             break;
+          }
         }
       }
       if (!producedWork && !this.hasPendingReports()) return;
@@ -76157,6 +76274,7 @@ var RuntimeSkillCoordinator = class {
       ...this.pendingInventory ? { inventoryAttempt: this.pendingInventory } : {},
       ...this.pendingApplied ? { appliedResult: this.pendingApplied } : {},
       ...this.pendingPublished.size > 0 ? { publishedPreviews: [...this.pendingPublished.values()] } : {},
+      ...this.pendingResolvedConflicts.size > 0 ? { resolvedConflicts: [...this.pendingResolvedConflicts.values()] } : {},
       ...this.completedCommandIds.size > 0 ? { completedCommandIds: [...this.completedCommandIds] } : {}
     };
   }
@@ -76166,23 +76284,26 @@ var RuntimeSkillCoordinator = class {
     return this.manager.scan(prepared);
   }
   accept(attemptIds) {
-    const accepted = new Set(attemptIds);
-    if (this.pendingInventory && accepted.has(this.pendingInventory.attemptId)) {
+    const accepted2 = new Set(attemptIds);
+    if (this.pendingInventory && accepted2.has(this.pendingInventory.attemptId)) {
       this.pendingInventory = void 0;
     }
-    if (this.pendingApplied && accepted.has(this.pendingApplied.attemptId)) {
+    if (this.pendingApplied && accepted2.has(this.pendingApplied.attemptId)) {
       this.pendingApplied = void 0;
     }
     for (const commandId of this.pendingPublished.keys()) {
-      if (accepted.has(commandId)) this.pendingPublished.delete(commandId);
+      if (accepted2.has(commandId)) this.pendingPublished.delete(commandId);
+    }
+    for (const commandId of this.pendingResolvedConflicts.keys()) {
+      if (accepted2.has(commandId)) this.pendingResolvedConflicts.delete(commandId);
     }
     for (const commandId of this.completedCommandIds) {
-      if (accepted.has(commandId)) this.completedCommandIds.delete(commandId);
+      if (accepted2.has(commandId)) this.completedCommandIds.delete(commandId);
     }
   }
   hasPendingReports() {
     return Boolean(
-      this.pendingInventory || this.pendingApplied || this.pendingPublished.size > 0 || this.completedCommandIds.size > 0
+      this.pendingInventory || this.pendingApplied || this.pendingPublished.size > 0 || this.pendingResolvedConflicts.size > 0 || this.completedCommandIds.size > 0
     );
   }
   async runExclusively(work) {
@@ -76249,36 +76370,6 @@ var ManagedSkillStore = class _ManagedSkillStore {
   resolveSource(localKey) {
     return this.state.sources[localKey] ?? null;
   }
-  publicationFor(localKey, contentHash) {
-    const source = this.state.sources[localKey];
-    return source?.contentHash === contentHash && source.publication?.contentHash === contentHash ? source.publication : null;
-  }
-  sourceForPublication(projection) {
-    return Object.values(this.state.sources).find(
-      (source) => source.contentHash === projection.contentHash && source.publication?.skillId === projection.skillId && source.publication.versionId === projection.versionId && source.publication.contentHash === projection.contentHash
-    ) ?? null;
-  }
-  async bindSource(input2) {
-    const source = this.state.sources[input2.localKey];
-    if (!source || source.contentHash !== input2.expectedContentHash) {
-      throw new Error("Skill source changed before its publication binding was applied");
-    }
-    this.state = {
-      ...this.state,
-      sources: {
-        ...this.state.sources,
-        [input2.localKey]: {
-          ...source,
-          publication: {
-            skillId: input2.skillId,
-            versionId: input2.versionId,
-            contentHash: input2.expectedContentHash
-          }
-        }
-      }
-    };
-    await this.persist();
-  }
   appliedRevision() {
     return this.state.appliedRevision ?? null;
   }
@@ -76295,19 +76386,10 @@ var ManagedSkillStore = class _ManagedSkillStore {
   }
   async recordCompleteScan(input2) {
     const sources = Object.fromEntries(
-      input2.candidates.map((candidate) => {
-        const publication = this.publicationFor(candidate.localKey, candidate.contentHash) ?? Object.values(this.state.sources).find(
-          (source) => source.absolutePath === candidate.absolutePath && source.contentHash === candidate.contentHash && source.publication?.contentHash === candidate.contentHash
-        )?.publication;
-        return [
-          candidate.localKey,
-          {
-            absolutePath: candidate.absolutePath,
-            contentHash: candidate.contentHash,
-            ...publication ? { publication } : {}
-          }
-        ];
-      })
+      input2.candidates.map((candidate) => [
+        candidate.localKey,
+        { absolutePath: candidate.absolutePath, contentHash: candidate.contentHash }
+      ])
     );
     this.state = {
       ...this.state,
@@ -76355,11 +76437,9 @@ function parseState(value2) {
     if (!localKey.startsWith("local:") || !isRecord5(source) || typeof source.absolutePath !== "string" || !isSha256(source.contentHash)) {
       throw new Error("invalid Skill source state");
     }
-    const publication = parsePublication(source.publication, source.contentHash);
     sources[localKey] = {
       absolutePath: source.absolutePath,
-      contentHash: source.contentHash,
-      ...publication ? { publication } : {}
+      contentHash: source.contentHash
     };
   }
   const projections = {};
@@ -76383,17 +76463,6 @@ function parseState(value2) {
     projections
   };
 }
-function parsePublication(value2, sourceHash) {
-  if (value2 === void 0) return void 0;
-  if (!isRecord5(value2) || typeof value2.skillId !== "string" || typeof value2.versionId !== "string" || !isSha256(value2.contentHash) || value2.contentHash !== sourceHash) {
-    throw new Error("invalid Skill source publication state");
-  }
-  return {
-    skillId: value2.skillId,
-    versionId: value2.versionId,
-    contentHash: value2.contentHash
-  };
-}
 function optionalSha256(value2) {
   if (value2 === void 0) return void 0;
   if (!isSha256(value2)) throw new Error("invalid Skill state hash");
@@ -76417,8 +76486,8 @@ var import_node_path21 = require("path");
 var import_node_stream = require("stream");
 var import_node_zlib = require("zlib");
 var import_tar_stream = __toESM(require_tar_stream(), 1);
-async function createSkillBundle(packageRoot) {
-  const before = await inspectSkillPackage(packageRoot);
+async function createSkillBundle(packageRoot, options = {}) {
+  const before = await inspectSkillPackage(packageRoot, options);
   const archive = (0, import_tar_stream.pack)();
   const tarPromise = collectStream(archive);
   for (const file2 of before.files) {
@@ -76440,7 +76509,7 @@ async function createSkillBundle(packageRoot) {
   if (bytes.byteLength > SKILL_PACKAGE_LIMITS.maxArchiveBytes) {
     throw new Error(`Skill archive exceeds ${SKILL_PACKAGE_LIMITS.maxArchiveBytes} bytes`);
   }
-  const after = await inspectSkillPackage(packageRoot);
+  const after = await inspectSkillPackage(packageRoot, options);
   if (after.contentHash !== before.contentHash) {
     throw new Error("Skill source changed while its archive was being created");
   }
@@ -76637,17 +76706,7 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
     );
   }
   async scan(input2) {
-    const scanned = await this.localSource.scan(input2);
-    const outcome = scanned.status === "complete" ? {
-      ...scanned,
-      candidates: scanned.candidates.map((candidate) => {
-        const publication = this.store.publicationFor(
-          candidate.localKey,
-          candidate.contentHash
-        );
-        return publication ? { ...candidate, publication } : candidate;
-      })
-    } : scanned;
+    const outcome = await this.localSource.scan(input2);
     if (outcome.status === "complete") {
       await this.store.recordCompleteScan({
         revision: outcome.inventoryRevision,
@@ -76664,9 +76723,6 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
     }
     return outcome;
   }
-  async bindSource(input2) {
-    await this.store.bindSource(input2);
-  }
   async publish(input2) {
     const source = this.store.resolveSource(input2.localKey);
     if (!source) throw new Error("Skill source is not present in the last complete scan");
@@ -76754,6 +76810,11 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
       () => this.withMachineLock(() => this.reconcileUnlocked(input2.manifest))
     );
   }
+  async resolveConflict(input2) {
+    return this.runExclusively(
+      () => this.withMachineLock(() => this.resolveConflictUnlocked(input2))
+    );
+  }
   async inspect() {
     const status = this.store.inspect();
     return {
@@ -76815,11 +76876,7 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
         await this.adoptLegacyProjection(entry);
         await this.requireReplaceable(entry);
         const observedHash = await this.reuseCurrentProjection(entry);
-        const publishedSource = this.store.sourceForPublication(entry);
-        const appliedHash = observedHash ?? await this.project(
-          entry,
-          publishedSource && await packageMatches(publishedSource.absolutePath, entry.contentHash) ? publishedSource.absolutePath : await this.ensureCached(entry)
-        );
+        const appliedHash = observedHash ?? await this.project(entry, await this.ensureCached(entry));
         nextProjections[entry.runtimeDirectory] = {
           skillId: entry.skillId,
           versionId: entry.versionId,
@@ -76833,13 +76890,16 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
           state: "applied"
         });
       } catch (error61) {
+        const code = errorCode(error61);
+        const conflict = isUnmanagedConflict(error61) ? await this.observeConflict(entry, code).catch(() => null) : null;
         results.push({
           skillId: entry.skillId,
           versionId: entry.versionId,
           contentHash: entry.contentHash,
           state: isUnmanagedConflict(error61) ? "conflict" : "failed",
-          errorCode: errorCode(error61),
-          errorMessage: error61 instanceof Error ? error61.message : String(error61)
+          errorCode: code,
+          errorMessage: error61 instanceof Error ? error61.message : String(error61),
+          ...conflict ? { conflict } : {}
         });
       }
     }
@@ -76856,6 +76916,147 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
       skills: results
     };
   }
+  async resolveConflictUnlocked(input2) {
+    const manifest = desiredSkillManifestSchema.parse(input2.manifest);
+    const entry = manifest.skills.find(
+      (candidate) => candidate.skillId === input2.skillId && candidate.versionId === input2.versionId
+    );
+    if (!entry || entry.runtimeDirectory !== input2.expectedConflict.runtimeDirectory) {
+      return resolutionFailure(
+        input2,
+        "stale",
+        "SKILL_CONFLICT_STALE",
+        "The Skill conflict changed. Refresh and try again."
+      );
+    }
+    const current = await this.observeConflict(
+      entry,
+      input2.expectedConflict.kind === "managed_destination" ? "UNMANAGED_PATH_CONFLICT" : "COMPATIBILITY_PATH_CONFLICT"
+    ).catch(() => null);
+    if (!current || !sameConflict(current, input2.expectedConflict)) {
+      return resolutionFailure(
+        input2,
+        "stale",
+        "SKILL_CONFLICT_STALE",
+        "The local Skill changed. Refresh and try again."
+      );
+    }
+    try {
+      if (input2.resolution.kind === "rename_local") {
+        await this.renameLocalConflict(entry, current, input2.resolution.name);
+        const reconciled = await this.reconcileUnlocked(manifest);
+        return resolutionFromReconcile(input2, reconciled);
+      }
+      return await this.overwriteLocalConflict(input2, entry, current, manifest);
+    } catch (error61) {
+      return resolutionFailure(
+        input2,
+        errorCode(error61) === "SKILL_CONFLICT_STALE" ? "stale" : "failed",
+        errorCode(error61),
+        error61 instanceof Error ? error61.message : String(error61)
+      );
+    }
+  }
+  async observeConflict(entry, code) {
+    const kind = code === "COMPATIBILITY_PATH_CONFLICT" ? "compatibility_destination" : "managed_destination";
+    const directory = this.conflictDirectory(entry.runtimeDirectory, kind);
+    const inspected = await inspectSkillPackage(directory, { expectedName: null });
+    return {
+      kind,
+      runtimeDirectory: entry.runtimeDirectory,
+      observedHash: inspected.contentHash,
+      observedName: inspected.metadata.name
+    };
+  }
+  conflictDirectory(runtimeDirectory, kind) {
+    requireSafeRuntimeDirectory(runtimeDirectory);
+    return (0, import_node_path22.join)(
+      kind === "managed_destination" ? this.managedSkillsDirectory : this.compatibilitySkillsDirectory,
+      runtimeDirectory
+    );
+  }
+  async renameLocalConflict(entry, conflict, name) {
+    requirePortableSkillName(name);
+    const source = this.conflictDirectory(entry.runtimeDirectory, conflict.kind);
+    const destination = (0, import_node_path22.join)((0, import_node_path22.dirname)(source), name);
+    if (await pathExists2(destination)) {
+      throw Object.assign(new Error(`A local Skill named ${name} already exists`), {
+        code: "SKILL_LOCAL_NAME_CONFLICT"
+      });
+    }
+    const suffix = `${process.pid}-${(0, import_node_crypto15.randomBytes)(8).toString("hex")}`;
+    const backup = `${source}.rename-backup-${suffix}`;
+    const pending = `${source}.rename-pending-${suffix}`;
+    let sourceMoved = false;
+    let destinationInstalled = false;
+    try {
+      await (0, import_promises5.rename)(source, backup);
+      sourceMoved = true;
+      await (0, import_promises5.cp)(backup, pending, { recursive: true, errorOnExist: true, force: false });
+      const skillMarkdown = (0, import_node_path22.join)(pending, "SKILL.md");
+      await (0, import_promises5.writeFile)(
+        skillMarkdown,
+        rewriteSkillMarkdownName(await (0, import_promises5.readFile)(skillMarkdown, "utf8"), name),
+        {
+          encoding: "utf8",
+          mode: 420
+        }
+      );
+      await inspectSkillPackage(pending, { expectedName: name });
+      await (0, import_promises5.rename)(pending, destination);
+      destinationInstalled = true;
+      await (0, import_promises5.rm)(backup, { recursive: true, force: true });
+    } catch (error61) {
+      if (destinationInstalled) await (0, import_promises5.rm)(destination, { recursive: true, force: true });
+      if (sourceMoved && await pathExists2(backup) && !await pathExists2(source)) {
+        await (0, import_promises5.rename)(backup, source);
+      }
+      throw error61;
+    } finally {
+      await (0, import_promises5.rm)(pending, { recursive: true, force: true });
+      if (!sourceMoved || destinationInstalled) {
+        await (0, import_promises5.rm)(backup, { recursive: true, force: true });
+      }
+    }
+  }
+  async overwriteLocalConflict(input2, entry, conflict, manifest) {
+    const source = this.conflictDirectory(entry.runtimeDirectory, conflict.kind);
+    const backup = `${source}.overwrite-backup-${process.pid}-${(0, import_node_crypto15.randomBytes)(8).toString("hex")}`;
+    await (0, import_promises5.rename)(source, backup);
+    try {
+      const reconciled = await this.reconcileUnlocked(manifest);
+      const result = resolutionFromReconcile(input2, reconciled);
+      if (result.state !== "applied") {
+        await this.removeResolvedProjection(entry, conflict.kind);
+        await (0, import_promises5.rename)(backup, source);
+        return result;
+      }
+      await (0, import_promises5.rm)(backup, { recursive: true, force: true });
+      return result;
+    } catch (error61) {
+      await this.removeResolvedProjection(entry, conflict.kind).catch(() => void 0);
+      if (!await pathExists2(source) && await pathExists2(backup)) await (0, import_promises5.rename)(backup, source);
+      throw error61;
+    }
+  }
+  async removeResolvedProjection(entry, conflictKind) {
+    const destination = this.conflictDirectory(entry.runtimeDirectory, conflictKind);
+    if (!await pathExists2(destination)) return;
+    if (conflictKind === "managed_destination") {
+      const marker = await readMarker(destination);
+      if (marker?.skillId === entry.skillId && marker.versionId === entry.versionId && marker.contentHash === entry.contentHash) {
+        await (0, import_promises5.rm)(destination, { recursive: true, force: true });
+      }
+      return;
+    }
+    const canonical = (0, import_node_path22.join)(this.managedSkillsDirectory, entry.runtimeDirectory);
+    const projection = {
+      skillId: entry.skillId,
+      versionId: entry.versionId,
+      contentHash: entry.contentHash
+    };
+    await removeCompatibilityProjection(destination, canonical, projection);
+  }
   async reuseCurrentProjection(entry) {
     const destination = (0, import_node_path22.join)(this.managedSkillsDirectory, entry.runtimeDirectory);
     const marker = await readMarker(destination);
@@ -77233,6 +77434,66 @@ function requireSafeRuntimeDirectory(value2) {
     throw new Error(`Unsafe managed Skill directory: ${value2}`);
   }
 }
+function requirePortableSkillName(value2) {
+  if (!/^(?!-)(?!.*--)[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value2) || value2.length > 64) {
+    throw Object.assign(
+      new Error("Local Skill names use lowercase letters, numbers, and single hyphens"),
+      { code: "INVALID_SKILL_NAME" }
+    );
+  }
+}
+function rewriteSkillMarkdownName(markdown, name) {
+  const lineEnding = markdown.includes("\r\n") ? "\r\n" : "\n";
+  const lines = markdown.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") {
+    throw Object.assign(new Error("The local Skill has invalid SKILL.md frontmatter"), {
+      code: "INVALID_FRONTMATTER"
+    });
+  }
+  const end = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+  const nameIndex = lines.findIndex(
+    (line, index) => index > 0 && index < end && /^name\s*:/.test(line)
+  );
+  if (end < 0 || nameIndex < 0) {
+    throw Object.assign(new Error("The local Skill has invalid SKILL.md frontmatter"), {
+      code: "INVALID_FRONTMATTER"
+    });
+  }
+  lines[nameIndex] = `name: ${name}`;
+  return lines.join(lineEnding);
+}
+function sameConflict(left, right) {
+  return left.kind === right.kind && left.runtimeDirectory === right.runtimeDirectory && left.observedHash === right.observedHash && left.observedName === right.observedName;
+}
+function resolutionFromReconcile(input2, result) {
+  const resolved = result.skills.find(
+    (candidate) => candidate.skillId === input2.skillId && candidate.versionId === input2.versionId
+  );
+  if (resolved?.state === "applied") {
+    return {
+      commandId: input2.commandId,
+      skillId: input2.skillId,
+      versionId: input2.versionId,
+      state: "applied"
+    };
+  }
+  return resolutionFailure(
+    input2,
+    "failed",
+    resolved?.errorCode ?? "SKILL_RECONCILE_FAILED",
+    resolved?.errorMessage ?? "The Skill could not be installed after resolving the conflict"
+  );
+}
+function resolutionFailure(input2, state, errorCodeValue, errorMessage) {
+  return {
+    commandId: input2.commandId,
+    skillId: input2.skillId,
+    versionId: input2.versionId,
+    state,
+    errorCode: errorCodeValue,
+    errorMessage
+  };
+}
 function localRasterMediaType(path2) {
   const lower = path2.toLowerCase();
   if (lower.endsWith(".gif")) return "image/gif";
@@ -77556,12 +77817,13 @@ async function startDaemon(args) {
         transcriptStreamer: nativeTranscriptStreamer,
         sink: {
           deliver: (envelope) => new Promise((resolveDelivery, rejectDelivery) => {
+            const payload = "eventType" in envelope ? { ...envelope, canonicalSourceDelivery: true } : envelope;
             socket.timeout(5e3).emit(
               "native.session.event",
-              envelope,
+              payload,
               (error61, acknowledgement) => {
-                const accepted = !error61 && acknowledgement?.ok === true;
-                if (!accepted) {
+                const accepted2 = !error61 && acknowledgement?.ok === true;
+                if (!accepted2) {
                   pushLog(
                     `native-hook-delivery-deferred event=${envelope.eventId} provider=${envelope.provider} error=${error61?.message ?? "none"} ack=${acknowledgement?.ok ?? "missing"} retryable=${acknowledgement?.retryable ?? "missing"}`
                   );
@@ -77574,10 +77836,24 @@ async function startDaemon(args) {
                   );
                   return;
                 }
-                resolveDelivery(accepted);
+                resolveDelivery({
+                  accepted: accepted2,
+                  ...!error61 && acknowledgement?.binding ? { binding: acknowledgement.binding } : {}
+                });
               }
             );
-          })
+          }),
+          deliverCanonical: async (binding, source) => {
+            eventOutbox.enqueueSource(
+              binding.conversationId,
+              binding.runId,
+              source.eventId,
+              source.event
+            );
+            eventOutbox.flush(socket);
+            await eventOutbox.waitForAcknowledgement(source.eventId);
+            return true;
+          }
         },
         onTranscriptError: ({ envelope, error: error61 }) => pushLog(
           `native-transcript-unavailable event=${envelope.eventId} provider=${envelope.provider} error=${error61.message}`
@@ -80085,31 +80361,40 @@ function configFileContainsMarker(path2, marker) {
     return false;
   }
 }
-function inspectNativeHooksConfigured(providerKind, homeDir = (0, import_node_os14.homedir)()) {
+function inspectNativeHooksConfigured(providerKind, homeDir = (0, import_node_os14.homedir)(), expectedConfigPath) {
+  const matchesActiveProfile = (path2, marker) => {
+    if (!configFileContainsMarker(path2, marker)) return false;
+    if (!expectedConfigPath) return true;
+    try {
+      return extractNativeHookConfigPath((0, import_node_fs22.readFileSync)(path2, "utf8")) === expectedConfigPath;
+    } catch {
+      return false;
+    }
+  };
   switch (providerKind) {
     case "claude_cli":
-      return configFileContainsMarker((0, import_node_path25.join)(homeDir, ".claude", "settings.json"), ALAN_HOOK_MARKER);
+      return matchesActiveProfile((0, import_node_path25.join)(homeDir, ".claude", "settings.json"), ALAN_HOOK_MARKER);
     case "codex_app_server":
-      return configFileContainsMarker((0, import_node_path25.join)(homeDir, ".codex", "hooks.json"), ALAN_HOOK_MARKER);
+      return matchesActiveProfile((0, import_node_path25.join)(homeDir, ".codex", "hooks.json"), ALAN_HOOK_MARKER);
     case "copilot_cli":
-      return configFileContainsMarker(
+      return matchesActiveProfile(
         (0, import_node_path25.join)(homeDir, ".copilot", "hooks", "alan-native-session.json"),
         ALAN_HOOK_MARKER
       );
     case "cursor_agent_cli":
-      return configFileContainsMarker((0, import_node_path25.join)(homeDir, ".cursor", "hooks.json"), ALAN_HOOK_MARKER);
+      return matchesActiveProfile((0, import_node_path25.join)(homeDir, ".cursor", "hooks.json"), ALAN_HOOK_MARKER);
     case "kimi_cli":
-      return configFileContainsMarker(
+      return matchesActiveProfile(
         (0, import_node_path25.join)(homeDir, ".kimi-code", "config.toml"),
         ALAN_KIMI_HOOKS_START
       );
     case "grok_cli":
-      return configFileContainsMarker(
+      return matchesActiveProfile(
         (0, import_node_path25.join)(homeDir, ".grok", "hooks", "alan-native-session.json"),
         ALAN_HOOK_MARKER
       );
     case "opencode_cli":
-      return configFileContainsMarker(
+      return matchesActiveProfile(
         (0, import_node_path25.join)(homeDir, ".config", "opencode", "plugins", "alan-native-session.js"),
         ALAN_OPENCODE_PLUGIN_MARKER
       );
@@ -80117,6 +80402,24 @@ function inspectNativeHooksConfigured(providerKind, homeDir = (0, import_node_os
       return false;
   }
 }
+function extractNativeHookConfigPath(text) {
+  const jsonMatch = text.match(/"--config-path"\s*,\s*"((?:\\"|[^"])*)"/);
+  if (jsonMatch?.[1]) {
+    try {
+      return JSON.parse(`"${jsonMatch[1]}"`);
+    } catch {
+    }
+  }
+  const match = text.match(
+    /(?:['"])?--config-path(?:['"])?(?:=|\s+)('(?:\\'|[^'])*'|"(?:\\"|[^"])*"|[^\s#]+)/
+  );
+  if (!match?.[1]) return null;
+  const raw = match[1];
+  if (raw.startsWith("'") || raw.startsWith('"')) {
+    return raw.slice(1, -1).replaceAll(String.raw`\'`, "'").replaceAll(String.raw`\"`, '"');
+  }
+  return raw;
+}
 
 // src/integration-cli.ts
 function alanMcpServers(apiUrl) {
@@ -80733,13 +81036,14 @@ function runNativeHookCommand(args) {
 function collectNativeIntegrationStatus(args = []) {
   bindConfigPath(args);
   const config2 = readConfig();
+  const configPath = getConfigPath();
   const env = getDaemonCliEnvironment();
   const homeDir = (0, import_node_os15.homedir)();
   return NATIVE_SESSION_PROVIDER_CAPABILITIES.map((capability) => ({
     provider: capability.providerKind,
     command: capability.command,
     installed: resolveCliExecutable(capability.command, env) !== null,
-    hooksConfigured: inspectNativeHooksConfigured(capability.providerKind, homeDir),
+    hooksConfigured: inspectNativeHooksConfigured(capability.providerKind, homeDir, configPath),
     hookCoverage: capability.capabilities.lifecycleHooks ? "lifecycle" : capability.capabilities.state === "degraded" ? "notification" : "none",
     transcriptStreaming: capability.capabilities.transcriptDelta,
     inboxReady: Boolean(config2.eventSpoolKey)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiden-ade/sandbox-agent",
-  "version": "0.1.82",
+  "version": "0.1.83",
   "type": "module",
   "description": "Alan agent runtime — cloud sandbox and local daemon (alan-agent CLI)",
   "bin": {