@codexhost/cli-darwin-x64 0.9.2 → 0.10.1

package/app/plugins/omp/plugin.mjs

@@ -527,6 +527,7 @@ function splitLines(text) {
 
 // dist/omp-adapter.js
 import { randomUUID as randomUUID2 } from "node:crypto";
+import { realpath as realpath2, stat } from "node:fs/promises";
 import path4 from "node:path";
 
 // ../../../node_modules/zod/v4/classic/external.js
@@ -15801,10 +15802,21 @@ var harnessCommandDescriptorSchema = external_exports.object({
   invocation: commandInvocationSchema,
   label: commandLabelSchema,
   description: commandDescriptionSchema.optional(),
-  argumentMode: external_exports.enum(["none", "text"])
+  argumentMode: external_exports.enum(["none", "text"]),
+  /**
+   * Native distinction reported by the Harness. Omitted when the Harness does
+   * not tell skills and commands apart; consumers treat that as "command".
+   */
+  kind: external_exports.enum(["command", "skill"]).optional()
 }).strict();
 var harnessCommandCatalogSchema = external_exports.object({
-  commands: external_exports.array(harnessCommandDescriptorSchema)
+  commands: external_exports.array(harnessCommandDescriptorSchema),
+  /**
+   * `live` when the catalog includes what a native Session reports for its
+   * workspace (custom commands, skills); `static` for Adapter built-ins only.
+   * Omitted by Adapters; set by the Host on inspection results.
+   */
+  source: external_exports.enum(["live", "static"]).optional()
 }).strict().superRefine((catalog, context) => {
   const ids = /* @__PURE__ */ new Set();
   for (const [index, command] of catalog.commands.entries()) {
@@ -15818,7 +15830,11 @@ var harnessCommandCatalogSchema = external_exports.object({
     ids.add(command.id);
   }
 });
-var harnessCommandsInspectParamsSchema = external_exports.object({ harnessId: harnessIdSchema }).strict();
+var harnessCommandsInspectParamsSchema = external_exports.object({
+  harnessId: harnessIdSchema,
+  /** Workspace of a draft without a Thread, for its live catalog when known. */
+  cwd: external_exports.string().min(1).optional()
+}).strict();
 var threadCommandsInspectParamsSchema = external_exports.object({
   threadId: hostThreadIdSchema
 }).strict();
@@ -16157,6 +16173,155 @@ function parseHostUsage(value) {
   return { ...value };
 }
 
+// ../../harness-adapter/dist/live-command-catalog.js
+var COMMON_EXCLUDED_LIVE_COMMANDS = /* @__PURE__ */ new Set([
+  // Session lifecycle
+  "branch",
+  "clear",
+  "exit",
+  "fork",
+  "fresh",
+  "new",
+  "quit",
+  "rename",
+  "rename-chat",
+  "reset",
+  "resume",
+  "rewind",
+  "session",
+  "sessions",
+  // Desktop-owned configuration
+  "autocompact",
+  "color",
+  "config",
+  "effort",
+  "fast",
+  "keybindings",
+  "model",
+  "models",
+  "output-style",
+  "permissions",
+  "settings",
+  "statusline",
+  "terminal-setup",
+  "theme",
+  "vim",
+  // Trust and approval policy
+  "always-approve",
+  "auto-mode-setup",
+  // Native login
+  "login",
+  "logout",
+  // Work outliving the Turn
+  "autopilot",
+  "background",
+  "bg",
+  "goal",
+  "jobs",
+  "loop",
+  "multitask",
+  "queue",
+  "remote-control",
+  "schedule",
+  "steer",
+  // Native terminal UI
+  "copy",
+  "debug",
+  "feedback",
+  "heapdump",
+  "share",
+  "shell",
+  // Plugin and MCP management
+  "marketplace",
+  "mcp",
+  "plugins",
+  "reload-plugins"
+]);
+var COMMON_EXCLUDED_LIVE_COMMAND_PREFIXES = ["__", "hooks-"];
+function isExcludedLiveCommand(name, kind, extra = {}) {
+  const normalized = name.trim().replace(/^\//u, "");
+  if (new Set(extra.names ?? []).has(normalized))
+    return true;
+  if (extra.prefixes?.some((prefix) => normalized.startsWith(prefix)))
+    return true;
+  if (kind === "skill")
+    return false;
+  return COMMON_EXCLUDED_LIVE_COMMANDS.has(normalized) || COMMON_EXCLUDED_LIVE_COMMAND_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+}
+function liveHarnessCommandPrompt(catalog, idPrefix, commandId, argumentText) {
+  if (!commandId.startsWith(idPrefix))
+    return null;
+  const descriptor = catalog.commands.find(({ id }) => id === commandId);
+  if (!descriptor)
+    return null;
+  const text = typeof argumentText === "string" ? argumentText.trim() : "";
+  return text ? `${descriptor.invocation} ${text}` : descriptor.invocation;
+}
+function mergeLiveHarnessCommands(builtIns, idPrefix, live, exclusions = {}) {
+  if (!live)
+    return builtIns;
+  const invocations = new Set(builtIns.commands.map(({ invocation }) => invocation));
+  const ids = new Set(builtIns.commands.map(({ id }) => id));
+  const dynamic = [];
+  for (const command of live) {
+    const name = command.name.trim().replace(/^\//u, "");
+    if (!name || /\s/u.test(name))
+      continue;
+    if (isExcludedLiveCommand(name, command.kind, exclusions))
+      continue;
+    const invocation = `/${name}`;
+    const id = `${idPrefix}${name.replace(/[^A-Za-z0-9._:-]/gu, "-")}`.slice(0, 128);
+    if (invocations.has(invocation) || ids.has(id))
+      continue;
+    const description = command.description?.trim().slice(0, 512);
+    const parsed = harnessCommandDescriptorSchema.safeParse({
+      id,
+      invocation,
+      label: name.slice(0, 128),
+      ...description ? { description } : {},
+      argumentMode: "text",
+      kind: command.kind
+    });
+    if (!parsed.success)
+      continue;
+    invocations.add(invocation);
+    ids.add(id);
+    dynamic.push(parsed.data);
+  }
+  return harnessCommandCatalogSchema.parse({ commands: [...builtIns.commands, ...dynamic] });
+}
+
+// dist/omp-slash-commands.js
+var OMP_LIVE_COMMAND_ID_PREFIX = "omp.slash.";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseOmpAvailableCommands(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.flatMap((entry) => {
+    if (!isRecord2(entry))
+      return [];
+    const name = typeof entry.name === "string" ? entry.name.trim().replace(/^\//u, "") : "";
+    if (!name)
+      return [];
+    return [
+      {
+        name,
+        description: typeof entry.description === "string" ? entry.description : "",
+        source: typeof entry.source === "string" ? entry.source : null
+      }
+    ];
+  });
+}
+function ompLiveCommands(native) {
+  return native.filter(({ source }) => source !== "builtin").map((command) => ({
+    name: command.name,
+    description: command.description,
+    kind: command.source === "skill" ? "skill" : "command"
+  }));
+}
+
 // dist/omp-model-catalog.js
 var OMP_MODEL_REF_PREFIX = "omp-model-v1.";
 var OMP_DRAFT_THINKING_OPTION_IDS = [
@@ -16272,11 +16437,11 @@ function normalizeOmpModelCatalog(nativeModels, effectiveModel, thinkingLevels,
 }
 
 // dist/omp-tool-presentation.js
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stringField(value, key) {
-  return isRecord2(value) && typeof value[key] === "string" ? value[key] : void 0;
+  return isRecord3(value) && typeof value[key] === "string" ? value[key] : void 0;
 }
 function toolCommand(toolName, argumentsValue) {
   if (toolName === "bash") {
@@ -16298,7 +16463,7 @@ function projectOmpToolItem(input) {
 
 // dist/omp-history.js
 var ompHarnessId = harnessIdSchema.parse("omp");
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function textContent(value) {
@@ -16306,12 +16471,12 @@ function textContent(value) {
     return value;
   if (!Array.isArray(value))
     return "";
-  return value.filter((part) => isRecord3(part) && part.type === "text" && typeof part.text === "string").map((part) => part.text).join("");
+  return value.filter((part) => isRecord4(part) && part.type === "text" && typeof part.text === "string").map((part) => part.text).join("");
 }
 function thinkingContent(value) {
   if (!Array.isArray(value))
     return "";
-  return value.filter((part) => isRecord3(part) && part.type === "thinking" && typeof part.thinking === "string").map((part) => part.thinking).join("");
+  return value.filter((part) => isRecord4(part) && part.type === "thinking" && typeof part.thinking === "string").map((part) => part.thinking).join("");
 }
 function validatedEntry(value) {
   if (typeof value.id !== "string" || value.id.length === 0 || value.parentId !== null && typeof value.parentId !== "string" || typeof value.type !== "string") {
@@ -16342,7 +16507,7 @@ function activeOmpEntries(history) {
   return reversed.reverse();
 }
 function message(entry) {
-  return entry.type === "message" && isRecord3(entry.message) ? entry.message : null;
+  return entry.type === "message" && isRecord4(entry.message) ? entry.message : null;
 }
 function messageRole(entry) {
   const value = message(entry)?.role;
@@ -16404,7 +16569,7 @@ function snapshotItems(entries, outcome) {
       let projectedText = false;
       let projectedReasoning = false;
       for (const [ordinal, part] of content.entries()) {
-        if (!isRecord3(part))
+        if (!isRecord4(part))
           continue;
         if (part.type === "thinking" && !projectedReasoning && reasoning.length > 0) {
           const item2 = {
@@ -16542,6 +16707,100 @@ function resolveOmpForkBoundary(history, checkpointId) {
   };
 }
 
+// dist/omp-session-file.js
+import { createReadStream } from "node:fs";
+import { open, realpath } from "node:fs/promises";
+import readline from "node:readline";
+var MAX_SESSION_HEADER_BYTES = 64 * 1024;
+var utf8Decoder = new TextDecoder("utf-8", { fatal: true });
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function historyEntry(value) {
+  if (!isRecord5(value) || value.type === "title" || value.type === "session" || typeof value.id !== "string" || value.id.length === 0 || value.parentId !== null && typeof value.parentId !== "string" || typeof value.type !== "string") {
+    return null;
+  }
+  return value;
+}
+async function readOmpSessionHistory(sessionFile, maxBytes) {
+  const entries = [];
+  let leafId = null;
+  const lines = readline.createInterface({
+    input: createReadStream(sessionFile, {
+      encoding: "utf8",
+      ...maxBytes === void 0 ? {} : { end: maxBytes - 1 }
+    }),
+    crlfDelay: Number.POSITIVE_INFINITY
+  });
+  try {
+    for await (const line of lines) {
+      if (line.length === 0)
+        continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const entry = historyEntry(parsed);
+      if (!entry)
+        continue;
+      entries.push(entry);
+      leafId = entry.id;
+    }
+  } finally {
+    lines.close();
+  }
+  return { entries, leafId };
+}
+async function readOmpSessionHeader(sessionFile) {
+  const handle = await open(sessionFile, "r");
+  try {
+    const buffer = Buffer.allocUnsafe(MAX_SESSION_HEADER_BYTES);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    const contents = buffer.subarray(0, bytesRead);
+    const newline = contents.indexOf(10);
+    if (newline < 0 && bytesRead === buffer.length) {
+      throw new Error("Omp Session header exceeds the supported size");
+    }
+    const contentsText = utf8Decoder.decode(contents);
+    for (const line of contentsText.split("\n")) {
+      if (line.length === 0)
+        continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (!isRecord5(parsed) || parsed.type !== "session")
+        continue;
+      if (typeof parsed.id !== "string" || parsed.id.length === 0 || typeof parsed.cwd !== "string" || parsed.cwd.length === 0) {
+        throw new Error("Omp Session header is invalid");
+      }
+      return { type: "session", id: parsed.id, cwd: parsed.cwd };
+    }
+    throw new Error("Omp Session header is invalid");
+  } finally {
+    await handle.close();
+  }
+}
+async function verifyOmpSessionCwd(input) {
+  if (!input.sessionFile)
+    throw new Error("Omp Fork Session has no persisted Session file");
+  const header = await readOmpSessionHeader(input.sessionFile);
+  if (header.id !== input.sessionId) {
+    throw new Error("Omp Fork Session header identity does not match RPC state");
+  }
+  const [actualCwd, expectedCwd] = await Promise.all([
+    realpath(header.cwd),
+    realpath(input.expectedCwd)
+  ]);
+  if (actualCwd !== expectedCwd) {
+    throw new Error("Omp Fork Session did not bind the requested cwd");
+  }
+}
+
 // dist/omp-last-turn-rollback.js
 function modelFromState(state) {
   if (state.provider === null && state.modelId === null)
@@ -16849,14 +17108,14 @@ function resolveOmpExecutable(input, dependencies = {}) {
 }
 
 // dist/omp-usage.js
-function isRecord4(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonNegativeSafeInteger(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
 }
 function optionalOmpCacheHitRatePercent(value) {
-  if (!isRecord4(value) || value.role !== "assistant" || !isRecord4(value.usage))
+  if (!isRecord6(value) || value.role !== "assistant" || !isRecord6(value.usage))
     return null;
   const input = nonNegativeSafeInteger(value.usage.input);
   const cacheRead = nonNegativeSafeInteger(value.usage.cacheRead);
@@ -16869,20 +17128,20 @@ function optionalOmpCacheHitRatePercent(value) {
 function latestOmpCacheHitRatePercent(history) {
   let latest = null;
   for (const entry of activeOmpEntries(history)) {
-    if (entry.type === "message" && isRecord4(entry.message) && entry.message.role === "assistant") {
+    if (entry.type === "message" && isRecord6(entry.message) && entry.message.role === "assistant") {
       latest = optionalOmpCacheHitRatePercent(entry.message);
     }
   }
   return latest;
 }
 function responseData(response, operation) {
-  if (!isRecord4(response.data)) {
+  if (!isRecord6(response.data)) {
     throw new Error(`Omp RPC ${operation} response has no data`);
   }
   return response.data;
 }
 function contextUsage(value) {
-  if (!isRecord4(value))
+  if (!isRecord6(value))
     throw new Error("Omp RPC context Usage is invalid");
   return parseHostUsage({
     contextUsedTokens: value.tokens,
@@ -16892,15 +17151,15 @@ function contextUsage(value) {
 function parseOmpSessionUsage(response) {
   const data = responseData(response, "Session stats");
   const tokens = data.tokens;
-  if (tokens !== void 0 && !isRecord4(tokens)) {
+  if (tokens !== void 0 && !isRecord6(tokens)) {
     throw new Error("Omp RPC Session stats tokens are invalid");
   }
   return parseHostUsage({
-    ...isRecord4(tokens) && tokens.input !== void 0 ? { inputTokens: tokens.input } : {},
-    ...isRecord4(tokens) && tokens.cacheRead !== void 0 ? { cachedInputTokens: tokens.cacheRead } : {},
-    ...isRecord4(tokens) && tokens.cacheWrite !== void 0 ? { cacheWriteInputTokens: tokens.cacheWrite } : {},
-    ...isRecord4(tokens) && tokens.output !== void 0 ? { outputTokens: tokens.output } : {},
-    ...isRecord4(tokens) && tokens.total !== void 0 ? { totalTokens: tokens.total } : {},
+    ...isRecord6(tokens) && tokens.input !== void 0 ? { inputTokens: tokens.input } : {},
+    ...isRecord6(tokens) && tokens.cacheRead !== void 0 ? { cachedInputTokens: tokens.cacheRead } : {},
+    ...isRecord6(tokens) && tokens.cacheWrite !== void 0 ? { cacheWriteInputTokens: tokens.cacheWrite } : {},
+    ...isRecord6(tokens) && tokens.output !== void 0 ? { outputTokens: tokens.output } : {},
+    ...isRecord6(tokens) && tokens.total !== void 0 ? { totalTokens: tokens.total } : {},
     ...data.cost !== void 0 ? { totalCostUsd: data.cost } : {},
     ...data.contextUsage !== void 0 ? contextUsage(data.contextUsage) : {}
   });
@@ -16919,97 +17178,6 @@ function optionalOmpStateContextUsage(value) {
   }
 }
 
-// dist/omp-session-file.js
-import { createReadStream } from "node:fs";
-import { open, realpath } from "node:fs/promises";
-import readline from "node:readline";
-var MAX_SESSION_HEADER_BYTES = 64 * 1024;
-var utf8Decoder = new TextDecoder("utf-8", { fatal: true });
-function isRecord5(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function historyEntry(value) {
-  if (!isRecord5(value) || value.type === "title" || value.type === "session" || typeof value.id !== "string" || value.id.length === 0 || value.parentId !== null && typeof value.parentId !== "string" || typeof value.type !== "string") {
-    return null;
-  }
-  return value;
-}
-async function readOmpSessionHistory(sessionFile) {
-  const entries = [];
-  let leafId = null;
-  const lines = readline.createInterface({
-    input: createReadStream(sessionFile, { encoding: "utf8" }),
-    crlfDelay: Number.POSITIVE_INFINITY
-  });
-  try {
-    for await (const line of lines) {
-      if (line.length === 0)
-        continue;
-      let parsed;
-      try {
-        parsed = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      const entry = historyEntry(parsed);
-      if (!entry)
-        continue;
-      entries.push(entry);
-      leafId = entry.id;
-    }
-  } finally {
-    lines.close();
-  }
-  return { entries, leafId };
-}
-async function readOmpSessionHeader(sessionFile) {
-  const handle = await open(sessionFile, "r");
-  try {
-    const buffer = Buffer.allocUnsafe(MAX_SESSION_HEADER_BYTES);
-    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
-    const contents = buffer.subarray(0, bytesRead);
-    const newline = contents.indexOf(10);
-    if (newline < 0 && bytesRead === buffer.length) {
-      throw new Error("Omp Session header exceeds the supported size");
-    }
-    const contentsText = utf8Decoder.decode(contents);
-    for (const line of contentsText.split("\n")) {
-      if (line.length === 0)
-        continue;
-      let parsed;
-      try {
-        parsed = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      if (!isRecord5(parsed) || parsed.type !== "session")
-        continue;
-      if (typeof parsed.id !== "string" || parsed.id.length === 0 || typeof parsed.cwd !== "string" || parsed.cwd.length === 0) {
-        throw new Error("Omp Session header is invalid");
-      }
-      return { type: "session", id: parsed.id, cwd: parsed.cwd };
-    }
-    throw new Error("Omp Session header is invalid");
-  } finally {
-    await handle.close();
-  }
-}
-async function verifyOmpSessionCwd(input) {
-  if (!input.sessionFile)
-    throw new Error("Omp Fork Session has no persisted Session file");
-  const header = await readOmpSessionHeader(input.sessionFile);
-  if (header.id !== input.sessionId) {
-    throw new Error("Omp Fork Session header identity does not match RPC state");
-  }
-  const [actualCwd, expectedCwd] = await Promise.all([
-    realpath(header.cwd),
-    realpath(input.expectedCwd)
-  ]);
-  if (actualCwd !== expectedCwd) {
-    throw new Error("Omp Fork Session did not bind the requested cwd");
-  }
-}
-
 // dist/omp-protocol.js
 var MAX_FRAME_BYTES = 1024 * 1024;
 var MAX_REASSEMBLED_BYTES = 64 * 1024 * 1024;
@@ -17106,7 +17274,7 @@ var OmpRpcUnsupportedCommandError = class extends Error {
   }
 };
 var textDecoder = new TextDecoder("utf-8", { fatal: true });
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function message2(value) {
@@ -17118,13 +17286,13 @@ function nonBlankString(value) {
 function parseNativeModel(value, context) {
   if (value === null || value === void 0)
     return null;
-  if (!isRecord6(value) || !nonBlankString(value.provider) || !nonBlankString(value.id)) {
+  if (!isRecord7(value) || !nonBlankString(value.provider) || !nonBlankString(value.id)) {
     throw new OmpRpcFaultError("protocolError", `Omp RPC returned an invalid ${context} Model`);
   }
   return { provider: value.provider, id: value.id };
 }
 function sessionStateData(response) {
-  const data = isRecord6(response.data) ? response.data : null;
+  const data = isRecord7(response.data) ? response.data : null;
   if (!data)
     throw new OmpRpcFaultError("protocolError", "Omp RPC state response has no data");
   return data;
@@ -17139,7 +17307,7 @@ function parseSessionState(response) {
   if (thinkingLevel !== null && !thinkingLevel.success) {
     throw new OmpRpcFaultError("protocolError", "Omp RPC state has an invalid Thinking level");
   }
-  const thinking = isRecord6(data.model) && isRecord6(data.model.thinking) ? data.model.thinking : null;
+  const thinking = isRecord7(data.model) && isRecord7(data.model.thinking) ? data.model.thinking : null;
   const availableThinkingLevels = thinking && Array.isArray(thinking.efforts) ? thinking.efforts.flatMap((level) => {
     const parsed = harnessThinkingOptionIdSchema.safeParse(level);
     return parsed.success ? [parsed.data] : [];
@@ -17162,25 +17330,25 @@ function parseSessionStreaming(response) {
   return isStreaming;
 }
 function parseAvailableModels(response) {
-  const data = isRecord6(response.data) ? response.data : null;
+  const data = isRecord7(response.data) ? response.data : null;
   if (!data || !Array.isArray(data.models)) {
     throw new OmpRpcFaultError("protocolError", "Omp RPC Model catalog response has no models");
   }
   return data.models.map((model) => {
     const parsed = parseNativeModel(model, "catalog");
-    if (!parsed || !isRecord6(model) || typeof model.reasoning !== "boolean") {
+    if (!parsed || !isRecord7(model) || typeof model.reasoning !== "boolean") {
       throw new OmpRpcFaultError("protocolError", "Omp RPC catalog contains a Model without reasoning capability");
     }
     return { ...parsed, reasoning: model.reasoning };
   });
 }
 function parseSubagentMessages(response) {
-  const data = isRecord6(response.data) ? response.data : null;
+  const data = isRecord7(response.data) ? response.data : null;
   if (!data || !nonBlankString(data.sessionFile) || !Number.isSafeInteger(data.fromByte) || !Number.isSafeInteger(data.nextByte) || data.fromByte < 0 || data.nextByte < data.fromByte || typeof data.reset !== "boolean" || !Array.isArray(data.entries) || !Array.isArray(data.messages)) {
     throw new OmpRpcFaultError("protocolError", "Omp RPC Subagent transcript response is invalid");
   }
-  const entries = data.entries.flatMap((value) => isRecord6(value) ? [value] : []);
-  const messages = data.messages.flatMap((value) => isRecord6(value) ? [value] : []);
+  const entries = data.entries.flatMap((value) => isRecord7(value) ? [value] : []);
+  const messages = data.messages.flatMap((value) => isRecord7(value) ? [value] : []);
   if (entries.length !== data.entries.length || messages.length !== data.messages.length) {
     throw new OmpRpcFaultError("protocolError", "Omp RPC Subagent transcript contains invalid data");
   }
@@ -17201,17 +17369,17 @@ function subagentStatus(value) {
   throw new OmpRpcFaultError("protocolError", "Omp RPC Subagent status is invalid");
 }
 function assistantText(value) {
-  if (!isRecord6(value) || value.role !== "assistant" || !Array.isArray(value.content))
+  if (!isRecord7(value) || value.role !== "assistant" || !Array.isArray(value.content))
     return null;
-  return value.content.filter((content) => isRecord6(content) && content.type === "text" && typeof content.text === "string").map((content) => content.text).join("");
+  return value.content.filter((content) => isRecord7(content) && content.type === "text" && typeof content.text === "string").map((content) => content.text).join("");
 }
 function assistantMessageId(value) {
-  if (!isRecord6(value) || value.role !== "assistant")
+  if (!isRecord7(value) || value.role !== "assistant")
     return null;
   return nonBlankString(value.responseId) ? value.responseId : null;
 }
 function extractReasoningText(content) {
-  if (!isRecord6(content))
+  if (!isRecord7(content))
     return null;
   const type = String(content.type ?? "");
   if (type === "thinking" || type === "reasoning" || type === "thought") {
@@ -17221,12 +17389,12 @@ function extractReasoningText(content) {
   return null;
 }
 function assistantReasoning(value) {
-  if (!isRecord6(value) || value.role !== "assistant" || !Array.isArray(value.content))
+  if (!isRecord7(value) || value.role !== "assistant" || !Array.isArray(value.content))
     return null;
   return value.content.map(extractReasoningText).filter((text) => typeof text === "string").join("");
 }
 function assistantFailure(value) {
-  if (!isRecord6(value) || value.role !== "assistant")
+  if (!isRecord7(value) || value.role !== "assistant")
     return void 0;
   if (value.stopReason !== "error" && value.stopReason !== "aborted")
     return null;
@@ -17246,7 +17414,7 @@ function signalProcessTree(child, signal) {
   try {
     process.kill(-child.pid, signal);
   } catch (error51) {
-    if (!isRecord6(error51) || error51.code !== "ESRCH")
+    if (!isRecord7(error51) || error51.code !== "ESRCH")
       throw error51;
   }
 }
@@ -17323,6 +17491,7 @@ var OmpRpcSession = class {
   #failed = false;
   #pending = /* @__PURE__ */ new Map();
   #state = null;
+  #availableCommands = null;
   #latestCacheHitRatePercent;
   #manualCompaction = null;
   #stderrTail = "";
@@ -17383,7 +17552,7 @@ var OmpRpcSession = class {
       this.#stderrTail = sanitizeDiagnosticTail(`${this.#stderrTail}${chunk.toString()}`);
     });
     child.once("error", (error51) => {
-      const kind = isRecord6(error51) && error51.code === "ENOENT" ? "notInstalled" : "unavailable";
+      const kind = isRecord7(error51) && error51.code === "ENOENT" ? "notInstalled" : "unavailable";
       this.#fail(new OmpRpcFaultError(kind, `Omp RPC failed to start: ${error51.message}`, this.stderrTail));
     });
     child.once("exit", (code, signal) => {
@@ -17403,6 +17572,9 @@ var OmpRpcSession = class {
       new Promise((_resolve, reject) => setTimeout(() => reject(new Error("Omp RPC ready signal timed out")), this.#options.commandTimeoutMs))
     ]);
     await this.#send("negotiate_protocol", { protocolVersion: 2 }).catch(() => void 0);
+    if (this.#options.subscribeSubagentEvents !== false) {
+      await this.#send("set_subagent_subscription", { level: "events" }).catch(() => void 0);
+    }
     try {
       this.#state = parseSessionState(await this.#send("get_state", {}));
     } catch (error51) {
@@ -17418,17 +17590,17 @@ var OmpRpcSession = class {
         return await readOmpSessionHistory(this.state.sessionFile);
       }
       const response = await this.#send("get_messages", {});
-      const data = isRecord6(response.data) ? response.data : null;
+      const data = isRecord7(response.data) ? response.data : null;
       if (!data || !Array.isArray(data.messages)) {
         throw new OmpRpcFaultError("protocolError", "Omp RPC messages response has no messages");
       }
       let branchEntryIds = null;
       try {
         const branchResponse = await this.#send("get_branch_messages", {});
-        const branchData = isRecord6(branchResponse.data) ? branchResponse.data : null;
+        const branchData = isRecord7(branchResponse.data) ? branchResponse.data : null;
         if (branchData && Array.isArray(branchData.messages)) {
           const parsed = branchData.messages.flatMap((entry) => {
-            if (!isRecord6(entry) || !nonBlankString(entry.entryId))
+            if (!isRecord7(entry) || !nonBlankString(entry.entryId))
               return [];
             return [entry.entryId];
           });
@@ -17442,11 +17614,11 @@ var OmpRpcSession = class {
       let userIndex = 0;
       let parentId = null;
       const entries = data.messages.map((nativeMessage, index) => {
-        const role = isRecord6(nativeMessage) ? nativeMessage.role : void 0;
+        const role = isRecord7(nativeMessage) ? nativeMessage.role : void 0;
         const branchId = role === "user" ? branchEntryIds?.[userIndex] : void 0;
         if (branchId)
           userIndex += 1;
-        const id = branchId ?? (isRecord6(nativeMessage) && nonBlankString(nativeMessage.id) ? nativeMessage.id : `omp-message-${index}`);
+        const id = branchId ?? (isRecord7(nativeMessage) && nonBlankString(nativeMessage.id) ? nativeMessage.id : `omp-message-${index}`);
         const entry = { id, parentId, type: "message", message: nativeMessage };
         parentId = id;
         return entry;
@@ -17526,7 +17698,7 @@ var OmpRpcSession = class {
       throw new Error("Omp RPC Fork requires an Entry identity");
     try {
       const response = await this.#send("branch", { entryId });
-      const data = isRecord6(response.data) ? response.data : null;
+      const data = isRecord7(response.data) ? response.data : null;
       if (!data || data.cancelled === true) {
         throw new OmpRpcFaultError("unavailable", "Omp RPC Fork was cancelled");
       }
@@ -17719,7 +17891,7 @@ var OmpRpcSession = class {
           continue;
         }
         const value = decoded;
-        if (!isRecord6(value) || typeof value.type !== "string") {
+        if (!isRecord7(value) || typeof value.type !== "string") {
           throw new OmpRpcFaultError("protocolError", "Omp RPC returned an invalid envelope");
         }
         this.#handle(value);
@@ -17729,9 +17901,17 @@ var OmpRpcSession = class {
       newline = this.#buffer.indexOf(10);
     }
   }
+  /** Latest `available_commands_update` of the running process, if any. */
+  get availableCommands() {
+    return this.#availableCommands;
+  }
   #handle(value) {
     if (this.#closed || this.#failed)
       return;
+    if (value.type === "available_commands_update") {
+      this.#availableCommands = parseOmpAvailableCommands(value.commands);
+      return;
+    }
     if (value.type === "ready") {
       this.#readyResolve?.();
       this.#readyResolve = null;
@@ -17770,7 +17950,7 @@ var OmpRpcSession = class {
           this.#armCommandTimeout(id, pending);
         }
       }
-      const outcome = value.aborted === true ? "cancelled" : isRecord6(value.result) ? "succeeded" : "failed";
+      const outcome = value.aborted === true ? "cancelled" : isRecord7(value.result) ? "succeeded" : "failed";
       const event = {
         type: "compaction.completed",
         outcome,
@@ -17803,12 +17983,12 @@ var OmpRpcSession = class {
       this.#startAssistantMessage(active, value.message);
       return;
     }
-    if (value.type === "message_update" && isRecord6(value.assistantMessageEvent)) {
+    if (value.type === "message_update" && isRecord7(value.assistantMessageEvent)) {
       const event = value.assistantMessageEvent;
       const eventType = String(event.type ?? "");
       const isThinking = eventType === "thinking_delta" || eventType === "reasoning_delta" || eventType === "thought_delta" || eventType === "thinking" || eventType === "reasoning";
       const isText = eventType === "text_delta" || eventType === "text" || eventType === "content_block_delta";
-      const delta = typeof event.delta === "string" ? event.delta : typeof event.thinking === "string" ? event.thinking : typeof event.reasoning === "string" ? event.reasoning : typeof event.text === "string" ? event.text : isRecord6(event.delta) && typeof event.delta.thinking === "string" ? event.delta.thinking : isRecord6(event.delta) && typeof event.delta.text === "string" ? event.delta.text : null;
+      const delta = typeof event.delta === "string" ? event.delta : typeof event.thinking === "string" ? event.thinking : typeof event.reasoning === "string" ? event.reasoning : typeof event.text === "string" ? event.text : isRecord7(event.delta) && typeof event.delta.thinking === "string" ? event.delta.thinking : isRecord7(event.delta) && typeof event.delta.text === "string" ? event.delta.text : null;
       if (isThinking && delta !== null && delta.length > 0) {
         const messageId = this.#ensureAssistantMessage(active, value.message);
         active.reasoningMessageOpen = true;
@@ -17848,7 +18028,7 @@ var OmpRpcSession = class {
     if (value.type === "agent_end" && Array.isArray(value.messages)) {
       for (let index = value.messages.length - 1; index >= 0; index -= 1) {
         const message3 = value.messages[index];
-        if (!isRecord6(message3) || message3.role !== "assistant")
+        if (!isRecord7(message3) || message3.role !== "assistant")
           continue;
         this.#finalizeAssistantMessage(active, message3);
         break;
@@ -17865,8 +18045,8 @@ var OmpRpcSession = class {
     if (value.type !== "subagent_lifecycle" && value.type !== "subagent_progress" && value.type !== "subagent_event") {
       return false;
     }
-    const payload = isRecord6(value.payload) ? value.payload : null;
-    const progressPayload = value.type === "subagent_progress" && payload && isRecord6(payload.progress) ? payload.progress : null;
+    const payload = isRecord7(value.payload) ? value.payload : null;
+    const progressPayload = value.type === "subagent_progress" && payload && isRecord7(payload.progress) ? payload.progress : null;
     const nativeIdValue = progressPayload?.id ?? payload?.id;
     if (!payload || !nonBlankString(nativeIdValue)) {
       throw new OmpRpcFaultError("protocolError", "Omp RPC Subagent frame has no stable ID");
@@ -18443,7 +18623,7 @@ var ompCommandCatalog = harnessCommandCatalogSchema.parse({
   ]
 });
 var DEFAULT_TOOL_OUTPUT_LIMIT = 64e3;
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function errorMessage(error51) {
@@ -18458,7 +18638,7 @@ var OmpAdapterFaultError = class extends Error {
   }
 };
 function normalizedError(error51, fallbackCode) {
-  if (isRecord7(error51) && error51.code === "ENOENT") {
+  if (isRecord8(error51) && error51.code === "ENOENT") {
     return { code: "notInstalled", message: errorMessage(error51), retryable: false };
   }
   if (error51 instanceof OmpAdapterFaultError)
@@ -18535,11 +18715,51 @@ function nativeModelForHistory(state) {
   return nativeModelFromState(state);
 }
 function sessionFileFromRef(ref) {
-  if (ref.harnessId !== ompHarnessId2 || !isRecord7(ref.locator) || typeof ref.locator.sessionFile !== "string" || ref.locator.sessionFile.length === 0) {
+  if (ref.harnessId !== ompHarnessId2 || !isRecord8(ref.locator) || typeof ref.locator.sessionFile !== "string" || ref.locator.sessionFile.length === 0) {
     throw new Error("Omp Native Session Ref has no resumable Session file");
   }
   return ref.locator.sessionFile;
 }
+var MAX_SUBAGENT_TRANSCRIPT_BYTES = 8 * 1024 * 1024;
+function subagentTranscriptPath(parentSessionFile, nativeSubagentId) {
+  if (nativeSubagentId.includes("/") || nativeSubagentId.includes("\\") || nativeSubagentId.includes("\0") || nativeSubagentId === "." || nativeSubagentId === "..") {
+    throw new Error("Omp Subagent ID is not a plain transcript file name");
+  }
+  if (!parentSessionFile.endsWith(".jsonl") || !path4.isAbsolute(parentSessionFile)) {
+    return null;
+  }
+  return `${parentSessionFile.slice(0, -".jsonl".length)}/${nativeSubagentId}.jsonl`;
+}
+async function readSubagentTranscriptFile(parentSessionFile, nativeSubagentId) {
+  const transcriptFile = subagentTranscriptPath(parentSessionFile, nativeSubagentId);
+  if (transcriptFile === null)
+    return { status: "missing" };
+  const parentDirectory = path4.dirname(transcriptFile);
+  let metadata;
+  try {
+    metadata = await stat(transcriptFile);
+  } catch (error51) {
+    if (error51.code === "ENOENT")
+      return { status: "missing" };
+    throw error51;
+  }
+  if (!metadata.isFile())
+    return { status: "missing" };
+  if (metadata.size > MAX_SUBAGENT_TRANSCRIPT_BYTES) {
+    throw new Error("Omp Subagent transcript exceeds the supported size");
+  }
+  const [resolvedTranscript, resolvedParentDirectory] = await Promise.all([
+    realpath2(transcriptFile),
+    realpath2(parentDirectory)
+  ]);
+  if (path4.dirname(resolvedTranscript) !== resolvedParentDirectory) {
+    throw new Error("Omp Subagent transcript resolves outside its parent Session directory");
+  }
+  return {
+    status: "read",
+    history: await readOmpSessionHistory(transcriptFile, MAX_SUBAGENT_TRANSCRIPT_BYTES)
+  };
+}
 function toolFailure(toolName) {
   return {
     code: "nativeFailure",
@@ -18550,9 +18770,9 @@ function toolFailure(toolName) {
 function nativeText(value) {
   if (typeof value === "string")
     return value;
-  if (!isRecord7(value) || !Array.isArray(value.content))
+  if (!isRecord8(value) || !Array.isArray(value.content))
     return "";
-  return value.content.filter((content) => isRecord7(content) && content.type === "text" && typeof content.text === "string").map(({ text }) => text).join("");
+  return value.content.filter((content) => isRecord8(content) && content.type === "text" && typeof content.text === "string").map(({ text }) => text).join("");
 }
 function boundedOutput(value, limit) {
   const text = nativeText(value);
@@ -18568,17 +18788,17 @@ function outputText(output) {
   return output?.content.filter((content) => content.type === "text").map(({ text }) => text).join("") ?? "";
 }
 function stringField2(value, key) {
-  if (!isRecord7(value))
+  if (!isRecord8(value))
     return void 0;
   const field = value[key];
   if (typeof field === "string" && field.length > 0)
     return field;
-  if (isRecord7(value.input)) {
+  if (isRecord8(value.input)) {
     const nested = value.input[key];
     if (typeof nested === "string" && nested.length > 0)
       return nested;
   }
-  if (isRecord7(value.arguments)) {
+  if (isRecord8(value.arguments)) {
     const nested = value.arguments[key];
     if (typeof nested === "string" && nested.length > 0)
       return nested;
@@ -18586,7 +18806,7 @@ function stringField2(value, key) {
   return void 0;
 }
 function numberField(value, key) {
-  if (!isRecord7(value))
+  if (!isRecord8(value))
     return void 0;
   const field = value[key];
   return typeof field === "number" || field === null ? field : void 0;
@@ -18625,7 +18845,7 @@ function fileMutatingKind(toolName) {
   return null;
 }
 function nestedToolString(value, keys) {
-  if (!isRecord7(value))
+  if (!isRecord8(value))
     return void 0;
   for (const key of keys) {
     const field = value[key];
@@ -18640,14 +18860,14 @@ function nestedToolString(value, keys) {
   return void 0;
 }
 function patchFromResult(result) {
-  if (!isRecord7(result))
+  if (!isRecord8(result))
     return void 0;
   for (const key of ["patch", "diff", "unifiedDiff"]) {
     const field = result[key];
     if (typeof field === "string" && field.length > 0)
       return field;
   }
-  if (isRecord7(result.details)) {
+  if (isRecord8(result.details)) {
     for (const key of ["patch", "diff", "unifiedDiff"]) {
       const field = result.details[key];
       if (typeof field === "string" && field.length > 0)
@@ -18798,7 +19018,7 @@ var OmpHarnessSession = class {
       subagents: { observe: true, readTranscript: true }
     };
     this.commands = {
-      list: async () => ({ ok: true, value: ompCommandCatalog }),
+      list: async () => ({ ok: true, value: this.#liveCommandCatalog() }),
       execute: (command) => this.#executeHarnessCommand(command)
     };
     this.#transport = options.startedTransport ?? null;
@@ -19446,7 +19666,24 @@ var OmpHarnessSession = class {
       return { ok: false, error: normalized };
     }
   }
+  /**
+   * Built-ins plus the skills and extension commands of the running process.
+   * Never starts the process just to list commands.
+   */
+  #liveCommandCatalog() {
+    const native = this.#transport?.availableCommands ?? null;
+    return mergeLiveHarnessCommands(ompCommandCatalog, OMP_LIVE_COMMAND_ID_PREFIX, native ? ompLiveCommands(native) : null);
+  }
   async #executeHarnessCommand(command) {
+    const livePrompt = liveHarnessCommandPrompt(this.#liveCommandCatalog(), OMP_LIVE_COMMAND_ID_PREFIX, command.commandId, command.arguments?.text);
+    if (livePrompt !== null) {
+      const started = await this.execute({
+        type: "turn.start",
+        turnId: command.turnId,
+        input: [{ type: "text", text: livePrompt }]
+      });
+      return started.ok ? { ok: true, value: { turnId: command.turnId } } : started;
+    }
     if (command.commandId !== "omp.compact") {
       return {
         ok: false,
@@ -20110,6 +20347,7 @@ var OmpHarnessSession = class {
 };
 var OmpAdapter = class {
   commandCatalog = ompCommandCatalog;
+  liveCommandCatalog = true;
   harnessId = ompHarnessId2;
   subagents = {
     readSnapshot: async (input) => {
@@ -20125,9 +20363,18 @@ var OmpAdapter = class {
       }
       let transport;
       try {
+        const transcriptFile = await readSubagentTranscriptFile(sessionFileFromRef(input.parent), input.nativeSubagentId);
+        if (transcriptFile.status === "read") {
+          const snapshot2 = mapOmpSnapshot(transcriptFile.history, {
+            sessionId: input.parent.nativeSessionId,
+            model: null
+          });
+          return { ok: true, value: snapshot2 };
+        }
         transport = this.#createTransport({
           cwd: input.cwd,
           sessionFile: sessionFileFromRef(input.parent),
+          subscribeSubagentEvents: false,
           onFault: () => void 0
         });
         await transport.start();
@@ -20199,7 +20446,11 @@ var OmpAdapter = class {
   async #inspectCwd(cwd) {
     const startedAt = Date.now();
     let stage = "spawn";
-    const transport = this.#createTransport({ cwd, onFault: () => void 0 });
+    const transport = this.#createTransport({
+      cwd,
+      subscribeSubagentEvents: false,
+      onFault: () => void 0
+    });
     this.#inspections.add(transport);
     try {
       stage = "startup";