agentbox-sdk 0.1.516 → 0.1.518

package/README.md

@@ -133,6 +133,32 @@ a 15s grace as a compatibility fallback. A final
 default 30 minutes, `0` settles at the first turn end as before, `Infinity`
 waits forever. On expiry the tasks are stopped best-effort and the run
 completes with the last turn's text.
+
+### Harness commands
+
+A run whose input starts with `/name args` carries the harness's own slash
+command. `resolveHarnessCommand(provider, input)` keeps the text as typed and
+returns `command: { name, args }` for `AgentRunConfig.command`; `/plan`,
+`/agent`, and `/goal` stay harness modes as before. Each adapter dispatches
+what its CLI supports headlessly:
+
+- Claude Code parses slash commands from the user message itself (`/compact`,
+  `/context`, `/init`, skills, custom commands, plugin commands).
+- Codex maps `/compact` to `thread/compact/start`, `/review [instructions]` to
+  `review/start`, `/init` to the TUI's AGENTS.md prompt, and an installed skill
+  to its `$name` mention.
+- OpenCode maps `/compact` to `POST /session/:id/summarize`, a configured
+  command to `POST /session/:id/command`, and an installed skill to a
+  directive the model follows. Configured command calls preserve file and
+  image attachments. They reject a per-run `systemPrompt` because OpenCode's
+  command endpoint cannot accept it; use a normal prompt or the setup-time
+  `OpenCodeAgentOptions.systemPrompt` instead. This also applies to the runtime
+  system appendix generated from configured MCPs, skills, sub-agents, or commands.
+
+Anything the harness does not know is sent as plain text. Each run emits one
+`harness.commands` event listing what it can run (`HarnessCommandDescriptor[]`:
+name, description, argument hint, source), so a host can build its `/` menu;
+`builtinHarnessCommands(provider)` gives the static list before a run exists.
 Tasks marked ambient by Claude (such as live-update watchers) do not keep the
 run waiting. The SDK's full task snapshots take precedence over task start and
 finish events, whose ordering relative to those snapshots is unspecified.
@@ -687,6 +713,15 @@ array containing each `questionId` and its selected or custom `values`, or use
 Question answers cannot modify unrelated tool arguments. Ordinary tool requests
 use the same API without `answers`.
 
+Codex can also ask without pausing (`request_user_input_async`): the app-server
+accepts the call itself and the turn keeps working. That ask is not a permission
+request; it arrives as a `message.completed` event carrying `questions` (same
+`AgentUserQuestion` shape, bare-string options become labels) next to the text
+Codex rendered for it. Nothing is pending, so there is nothing to respond to:
+relay the user's choice as a follow-up message (`run.sendMessage()` while the
+run is live, otherwise the next run of the session). Claude Code and OpenCode
+have no non-blocking ask; their questions always pause as `permission.requested`.
+
 Native runtimes own a POSIX process group by default. Termination is bounded and
 escalates to SIGKILL if the process ignores SIGTERM. A supervisor that launches
 each run in its own process group can set `processGroup: "inherited"`; that

package/dist/agents/index.d.ts

@@ -1,5 +1,5 @@
-import { o as AgentProviderName, h as AgentOptions, t as AgentRunConfig, s as AgentRun, r as AgentResult, a9 as RawAgentEvent, b as AgentAttachRequest, B as AttachedRun, ag as SetupLayout, am as UserContent } from '../types-BKvKgRMY.js';
-export { a as AgentApprovalMode, c as AgentCommandConfig, d as AgentCostData, e as AgentExecutionRequest, f as AgentLocalMcpConfig, g as AgentMcpConfig, i as AgentOptionsBase, j as AgentOptionsMap, k as AgentPermissionDecision, l as AgentPermissionKind, m as AgentPermissionResponse, n as AgentProviderAdapter, p as AgentReasoningEffort, q as AgentRemoteMcpConfig, u as AgentRunSink, v as AgentSetupRequest, w as AgentSkillConfig, x as AgentSubAgentConfig, y as AgentUserAnswer, z as AgentUserQuestion, E as ClaudeCodeAgentOptions, F as ClaudeCodeHookConfig, G as ClaudeCodeHookEvent, H as ClaudeCodeHookHandler, I as ClaudeCodeHookMatcherGroup, J as ClaudeCodeHooksConfig, K as ClaudeCodeProviderOptions, L as CodexAgentOptions, M as CodexCommandHook, N as CodexHookEvent, O as CodexHookMatcherGroup, P as CodexHooksConfig, Q as CodexModelProviderConfig, R as CodexProviderOptions, S as DataContent, T as EmbeddedSkillConfig, U as FilePart, V as ImagePart, a1 as OpenCodeAgentOptions, a2 as OpenCodePluginConfig, a3 as OpenCodePluginEvent, a4 as OpenCodePluginHookConfig, a5 as OpenCodeProviderOptions, a6 as OpenRouterPlugin, ab as RepoSkillConfig, ai as TextPart, an as UserContentPart } from '../types-BKvKgRMY.js';
+import { o as AgentProviderName, h as AgentOptions, t as AgentRunConfig, s as AgentRun, r as AgentResult, ak as RawAgentEvent, b as AgentAttachRequest, B as AttachedRun, ar as SetupLayout, ax as UserContent } from '../types-DjHP7dFq.js';
+export { a as AgentApprovalMode, c as AgentCommandConfig, d as AgentCostData, e as AgentExecutionRequest, f as AgentLocalMcpConfig, g as AgentMcpConfig, i as AgentOptionsBase, j as AgentOptionsMap, k as AgentPermissionDecision, l as AgentPermissionKind, m as AgentPermissionResponse, n as AgentProviderAdapter, p as AgentReasoningEffort, q as AgentRemoteMcpConfig, u as AgentRunSink, v as AgentSetupRequest, w as AgentSkillConfig, x as AgentSubAgentConfig, y as AgentUserAnswer, z as AgentUserQuestion, E as ClaudeCodeAgentOptions, F as ClaudeCodeHookConfig, G as ClaudeCodeHookEvent, H as ClaudeCodeHookHandler, I as ClaudeCodeHookMatcherGroup, J as ClaudeCodeHooksConfig, K as ClaudeCodeProviderOptions, L as CodexAgentOptions, M as CodexCommandHook, N as CodexHookEvent, O as CodexHookMatcherGroup, P as CodexHooksConfig, Q as CodexModelProviderConfig, R as CodexProviderOptions, S as CodexSkillEntry, T as DataContent, U as EmbeddedSkillConfig, V as FilePart, W as HarnessCommandDescriptor, X as HarnessCommandInvocation, Y as HarnessCommandSource, _ as ImagePart, $ as MAX_HARNESS_COMMANDS, a0 as MAX_HARNESS_COMMAND_ARGUMENT_HINT, a1 as MAX_HARNESS_COMMAND_DESCRIPTION, a2 as MAX_HARNESS_COMMAND_NAME, aa as OpenCodeAgentOptions, ab as OpenCodeCommandEntry, ac as OpenCodePluginConfig, ad as OpenCodePluginEvent, ae as OpenCodePluginHookConfig, af as OpenCodeProviderOptions, ag as OpenCodeSkillEntry, ah as OpenRouterPlugin, am as RepoSkillConfig, at as TextPart, ay as UserContentPart, az as builtinHarnessCommands, aA as claudeHarnessCommands, aB as codexHarnessCommands, aC as codexSkillMention, aF as openCodeHarnessCommands, aG as parseHarnessCommandInvocation, aH as skillDirective } from '../types-DjHP7dFq.js';
 import { S as Sandbox } from '../Sandbox-DcKAU-E3.js';
 export { AgentProvider } from '../enums.js';
 import 'e2b';
@@ -133,6 +133,12 @@ interface HarnessCapabilities {
 }
 /** Adapter capabilities. Runtime adapters additionally validate commands against the live harness. */
 declare function harnessCapabilities(provider: AgentProviderName): HarnessCapabilities;
-declare function resolveHarnessCommand(provider: AgentProviderName, input: UserContent): Pick<AgentRunConfig, "input" | "mode" | "goal">;
+/**
+ * Resolve a leading slash token. `/plan`, `/agent`, and `/goal` are harness
+ * modes handled here; any other `/name args` is a harness command left in the
+ * input verbatim (Claude Code dispatches it itself) and described by
+ * `command` so Codex and OpenCode adapters can map it to their native calls.
+ */
+declare function resolveHarnessCommand(provider: AgentProviderName, input: UserContent): Pick<AgentRunConfig, "input" | "mode" | "goal" | "command">;
 
 export { AGENT_RESERVED_PORTS, Agent, AgentAttachRequest, AgentOptions, AgentProviderName, AgentResult, AgentRun, AgentRunConfig, AttachedRun, type HarnessCapabilities, type HarnessCommand, SetupLayout, UserContent, agentboxRoot, collectAllAgentReservedPorts, getAgentLayout, harnessCapabilities, resolveHarnessCommand };

package/dist/agents/index.js

@@ -1,10 +1,21 @@
 import {
   Agent,
+  MAX_HARNESS_COMMANDS,
+  MAX_HARNESS_COMMAND_ARGUMENT_HINT,
+  MAX_HARNESS_COMMAND_DESCRIPTION,
+  MAX_HARNESS_COMMAND_NAME,
   agentboxRoot,
+  builtinHarnessCommands,
+  claudeHarnessCommands,
+  codexHarnessCommands,
+  codexSkillMention,
   getAgentLayout,
   harnessCapabilities,
-  resolveHarnessCommand
-} from "../chunk-SERVEWIE.js";
+  openCodeHarnessCommands,
+  parseHarnessCommandInvocation,
+  resolveHarnessCommand,
+  skillDirective
+} from "../chunk-YV3DQS6Z.js";
 import "../chunk-V4M4LPPT.js";
 import {
   AGENT_RESERVED_PORTS,
@@ -18,9 +29,20 @@ export {
   AGENT_RESERVED_PORTS,
   Agent,
   AgentProvider,
+  MAX_HARNESS_COMMANDS,
+  MAX_HARNESS_COMMAND_ARGUMENT_HINT,
+  MAX_HARNESS_COMMAND_DESCRIPTION,
+  MAX_HARNESS_COMMAND_NAME,
   agentboxRoot,
+  builtinHarnessCommands,
+  claudeHarnessCommands,
+  codexHarnessCommands,
+  codexSkillMention,
   collectAllAgentReservedPorts,
   getAgentLayout,
   harnessCapabilities,
-  resolveHarnessCommand
+  openCodeHarnessCommands,
+  parseHarnessCommandInvocation,
+  resolveHarnessCommand,
+  skillDirective
 };

package/dist/{chunk-SERVEWIE.js → chunk-YV3DQS6Z.js}

@@ -103,6 +103,258 @@ async function* linesFromNodeStream(stream) {
 // src/agents/providers/claude-code.ts
 import path8 from "path";
 
+// src/agents/harness-commands.ts
+var MAX_HARNESS_COMMANDS = 500;
+var MAX_HARNESS_COMMAND_NAME = 200;
+var MAX_HARNESS_COMMAND_DESCRIPTION = 500;
+var MAX_HARNESS_COMMAND_ARGUMENT_HINT = 200;
+var HARNESS_COMMAND_NAME_PATTERN = /^[A-Za-z0-9][\w:.-]*$/;
+function harnessCommandName(raw) {
+  const name = raw?.trim();
+  if (!name || name.length > MAX_HARNESS_COMMAND_NAME) return void 0;
+  return HARNESS_COMMAND_NAME_PATTERN.test(name) ? name : void 0;
+}
+function harnessCommandText(raw, max) {
+  const text2 = raw?.trim();
+  return text2 ? text2.slice(0, max) : void 0;
+}
+var CLAUDE_BUILTINS = [
+  {
+    name: "compact",
+    description: "Free up context by summarizing the conversation so far",
+    argumentHint: "<optional summarization instructions>",
+    source: "builtin"
+  },
+  {
+    name: "context",
+    description: "Show what is using the context window",
+    source: "builtin"
+  },
+  {
+    name: "usage",
+    description: "Show token usage and cost for this session",
+    source: "builtin"
+  },
+  {
+    name: "recap",
+    description: "Summarize what has happened in this session",
+    source: "builtin"
+  },
+  {
+    name: "init",
+    description: "Create a CLAUDE.md guide for this repository",
+    source: "builtin"
+  },
+  {
+    name: "security-review",
+    description: "Review pending changes for security issues",
+    source: "builtin"
+  },
+  {
+    name: "mcp",
+    description: "Show configured MCP servers and their status",
+    source: "builtin"
+  }
+];
+var CODEX_BUILTINS = [
+  {
+    name: "compact",
+    description: "Summarize the conversation to free up context",
+    source: "builtin"
+  },
+  {
+    name: "review",
+    description: "Review the uncommitted changes in the workspace",
+    argumentHint: "<optional review instructions>",
+    source: "builtin"
+  },
+  {
+    name: "init",
+    description: "Create an AGENTS.md contributor guide for this repository",
+    argumentHint: "<optional focus>",
+    source: "builtin"
+  }
+];
+var OPENCODE_BUILTINS = [
+  {
+    name: "compact",
+    description: "Summarize the session to free up context",
+    source: "builtin"
+  },
+  {
+    name: "init",
+    description: "Create an AGENTS.md guide for this repository",
+    argumentHint: "<optional focus>",
+    source: "builtin"
+  },
+  {
+    name: "review",
+    description: "Review the current changes",
+    argumentHint: "<optional focus>",
+    source: "builtin"
+  }
+];
+function builtinHarnessCommands(provider) {
+  switch (provider) {
+    case "claude-code":
+      return CLAUDE_BUILTINS.map((command) => ({ ...command }));
+    case "codex":
+      return CODEX_BUILTINS.map((command) => ({ ...command }));
+    case "open-code":
+      return OPENCODE_BUILTINS.map((command) => ({ ...command }));
+    default:
+      return [];
+  }
+}
+function parseHarnessCommandInvocation(text2) {
+  const match = text2.match(/^\s*\/([A-Za-z0-9][\w:.-]*)(?:\s+([\s\S]*))?$/);
+  const name = match?.[1];
+  if (!name) return void 0;
+  return { name, args: (match[2] ?? "").trim() };
+}
+var CLAUDE_HIDDEN_BUILTINS = /* @__PURE__ */ new Set([
+  "agents",
+  "list-agents",
+  "advisor",
+  "auto-mode-setup",
+  "autocompact",
+  "clear",
+  "reset",
+  "new",
+  "color",
+  "config",
+  "design-consent",
+  "design-revoke",
+  "doctor",
+  "effort",
+  "exit",
+  "quit",
+  "extra-usage",
+  "fast",
+  "goal",
+  "heapdump",
+  "import",
+  "insights",
+  "model",
+  "output-style",
+  "plan",
+  "reload-plugins",
+  "reload-skills",
+  "rename",
+  "name",
+  "skill-doctor",
+  "team-onboarding",
+  "ultrareview",
+  "usage-credits",
+  "workflow-launch-exec",
+  "add-dir",
+  "stop"
+]);
+var CLAUDE_BUILTIN_DESCRIPTIONS = new Map(
+  CLAUDE_BUILTINS.map((command) => [command.name, command])
+);
+function claudeHarnessCommands(init) {
+  const skills = new Set(init.skills ?? []);
+  const terminal = new Set(init.terminal_slash_commands ?? []);
+  const plugins = new Set((init.plugins ?? []).map((plugin) => plugin.name));
+  const seen = /* @__PURE__ */ new Set();
+  const commands = [];
+  for (const raw of init.slash_commands ?? []) {
+    const name = harnessCommandName(raw.replace(/^\//, ""));
+    if (!name || seen.has(name) || name.startsWith("__")) continue;
+    if (terminal.has(name) || CLAUDE_HIDDEN_BUILTINS.has(name)) continue;
+    seen.add(name);
+    const known = CLAUDE_BUILTIN_DESCRIPTIONS.get(name);
+    const prefix = name.includes(":") ? name.slice(0, name.indexOf(":")) : "";
+    const source = known ? "builtin" : prefix && plugins.has(prefix) ? "plugin" : skills.has(name) ? "skill" : "custom";
+    commands.push({
+      name,
+      ...known?.description ? { description: known.description } : {},
+      ...known?.argumentHint ? { argumentHint: known.argumentHint } : {},
+      source
+    });
+  }
+  return commands.slice(0, MAX_HARNESS_COMMANDS);
+}
+function codexHarnessCommands(list) {
+  const commands = builtinHarnessCommands("codex");
+  const seen = new Set(commands.map((command) => command.name));
+  for (const group of list.data ?? []) {
+    for (const skill of group.skills ?? []) {
+      const name = harnessCommandName(skill.name);
+      if (!name || skill.enabled === false || seen.has(name)) continue;
+      seen.add(name);
+      const description = harnessCommandText(
+        skill.interface?.shortDescription ?? skill.description ?? void 0,
+        MAX_HARNESS_COMMAND_DESCRIPTION
+      );
+      commands.push({
+        name,
+        ...description ? { description } : {},
+        source: skill.pluginId ? "plugin" : "skill"
+      });
+    }
+  }
+  return commands.slice(0, MAX_HARNESS_COMMANDS);
+}
+function codexSkillMention(name) {
+  const index = name.lastIndexOf(":");
+  return `$${index === -1 ? name : name.slice(index + 1)}`;
+}
+var OPENCODE_BUILTIN_DESCRIPTIONS = new Map(
+  OPENCODE_BUILTINS.map((command) => [command.name, command])
+);
+var OPENCODE_PLACEHOLDER_HINT = /^\$(?:\d+|ARGUMENTS)$/;
+function openCodeArgumentHint(hints) {
+  const named = (hints ?? []).map((hint) => hint.trim()).filter((hint) => hint.length > 0 && !OPENCODE_PLACEHOLDER_HINT.test(hint));
+  if (named.length > 0) return named.map((hint) => `<${hint}>`).join(" ");
+  return hints?.length ? "<arguments>" : void 0;
+}
+function openCodeHarnessCommands(commands, skills = []) {
+  const result = [
+    { ...OPENCODE_BUILTIN_DESCRIPTIONS.get("compact") }
+  ];
+  const seen = new Set(result.map((command) => command.name));
+  for (const command of commands) {
+    const name = harnessCommandName(command.name);
+    if (!name || seen.has(name)) continue;
+    seen.add(name);
+    const known = OPENCODE_BUILTIN_DESCRIPTIONS.get(name);
+    const description = harnessCommandText(
+      command.description ?? known?.description,
+      MAX_HARNESS_COMMAND_DESCRIPTION
+    );
+    const hint = harnessCommandText(
+      known?.argumentHint ?? openCodeArgumentHint(command.hints),
+      MAX_HARNESS_COMMAND_ARGUMENT_HINT
+    );
+    result.push({
+      name,
+      ...description ? { description } : {},
+      ...hint ? { argumentHint: hint } : {},
+      source: command.mcp ? "mcp" : command.source === "command" || known ? "builtin" : "custom"
+    });
+  }
+  for (const skill of skills) {
+    const name = harnessCommandName(skill.name);
+    if (!name || seen.has(name)) continue;
+    seen.add(name);
+    const description = harnessCommandText(
+      skill.description,
+      MAX_HARNESS_COMMAND_DESCRIPTION
+    );
+    result.push({
+      name,
+      ...description ? { description } : {},
+      source: "skill"
+    });
+  }
+  return result.slice(0, MAX_HARNESS_COMMANDS);
+}
+function skillDirective(name, args) {
+  return args ? `Use the "${name}" skill for this: ${args}` : `Use the "${name}" skill.`;
+}
+
 // src/agents/approval.ts
 function getApprovalMode(options) {
   return options.approvalMode ?? "auto";
@@ -153,6 +405,34 @@ function normalizeUserQuestions(provider, input) {
     return result;
   });
 }
+function normalizeAsyncUserQuestions(provider, questions) {
+  if (!Array.isArray(questions) || !questions.length || questions.length > 10) return void 0;
+  try {
+    return questions.map((value, index) => {
+      const item = record(value);
+      if (item.isSecret === true) throw new Error("Secret questions cannot be relayed");
+      const options = item.options ?? [];
+      if (!Array.isArray(options) || options.length > 30) throw new Error("Unsupported agent question options");
+      const result = {
+        id: String(index),
+        question: text(item.title ?? item.question, 1e4),
+        ...item.header ? { header: text(item.header, 200) } : {},
+        // Codex async options are bare strings; blocking shapes use {label, description}.
+        options: options.map((value2) => {
+          if (typeof value2 === "string") return { label: text(value2, 1e3) };
+          const option = record(value2);
+          return { label: text(option.label, 1e3), ...option.description ? { description: text(option.description, 1e4) } : {} };
+        }),
+        multiple: provider === "claude-code" ? item.multiSelect === true : provider === "open-code" && item.multiple === true,
+        allowCustom: provider === "open-code" ? item.custom !== false : true
+      };
+      if (new Set(result.options.map((option) => option.label)).size !== result.options.length) throw new Error("Duplicate agent question options");
+      return result;
+    });
+  } catch {
+    return void 0;
+  }
+}
 function validateUserAnswers(questions, answers) {
   if (!questions?.length || !answers || answers.length !== questions.length || new Set(answers.map((answer) => answer.questionId)).size !== answers.length) throw new Error("Answer each agent question once");
   return questions.map((question) => {
@@ -3566,6 +3846,13 @@ async function consumeClaudeMessages(request, sink, messages, executeStartedAt,
               "This Claude Code installation does not expose the native /goal command."
             );
           }
+          sink.emitEvent(
+            createNormalizedEvent(
+              "harness.commands",
+              { provider: request.provider, runId: request.runId },
+              { commands: claudeHarnessCommands(sys) }
+            )
+          );
           if (sys.session_id) {
             debugClaude(
               "\u2605 session.init session_id=%s (%dms)",
@@ -4285,6 +4572,9 @@ function compactEnv(values) {
 function buildCodexSandboxMode(options) {
   return options.fullAccess ? "danger-full-access" : options.provider?.sandboxMode ?? (options.configuration === "native" ? void 0 : options.sandbox ? "workspace-write" : "read-only");
 }
+function buildCodexThreadConfig(request) {
+  return request.run.reasoning ? { config: { model_reasoning_effort: request.run.reasoning } } : {};
+}
 function buildThreadParams(cwd, options, request) {
   return {
     cwd,
@@ -4292,6 +4582,7 @@ function buildThreadParams(cwd, options, request) {
     ...request.options.provider?.serviceTier !== void 0 ? { serviceTier: request.options.provider.serviceTier } : {},
     ...options.provider?.approvalPolicy ? { approvalPolicy: options.provider.approvalPolicy } : options.configuration === "native" && !options.fullAccess ? {} : { approvalPolicy: !options.fullAccess && isInteractiveApproval(options) ? "untrusted" : "never" },
     sandbox: buildCodexSandboxMode(options),
+    ...buildCodexThreadConfig(request),
     serviceName: "agentbox",
     // Persist the rollout on disk so follow-up runs can call `thread/resume`.
     // `ephemeral: true` threads have no rollout file and resume fails with
@@ -4308,6 +4599,7 @@ function buildResumeParams(cwd, options, request) {
     ...request.options.provider?.serviceTier !== void 0 ? { serviceTier: request.options.provider.serviceTier } : {},
     ...options.provider?.approvalPolicy ? { approvalPolicy: options.provider.approvalPolicy } : options.configuration === "native" && !options.fullAccess ? {} : { approvalPolicy: !options.fullAccess && isInteractiveApproval(options) ? "untrusted" : "never" },
     sandbox: buildCodexSandboxMode(options),
+    ...buildCodexThreadConfig(request),
     ...request.run.systemPrompt ? { developerInstructions: request.run.systemPrompt } : options.configuration === "native" ? {} : { developerInstructions: null },
     // We only need the thread id back; we never read `thread.turns`.
     // Without this Codex hydrates the full history into the response and
@@ -4325,6 +4617,7 @@ function buildForkParams(cwd, options, request) {
     ...request.options.provider?.serviceTier !== void 0 ? { serviceTier: request.options.provider.serviceTier } : {},
     ...options.provider?.approvalPolicy ? { approvalPolicy: options.provider.approvalPolicy } : options.configuration === "native" && !options.fullAccess ? {} : { approvalPolicy: !options.fullAccess && isInteractiveApproval(options) ? "untrusted" : "never" },
     sandbox: buildCodexSandboxMode(options),
+    ...buildCodexThreadConfig(request),
     ...request.run.systemPrompt ? { developerInstructions: request.run.systemPrompt } : options.configuration === "native" ? {} : { developerInstructions: null },
     excludeTurns: true
   };
@@ -4372,6 +4665,51 @@ function buildCodexTurnStartParams(params) {
   };
 }
 var CODEX_CANCEL_TURN_TEXT = "Run cancelled by the host.";
+var CODEX_INIT_PROMPT = "Generate a file named AGENTS.md that serves as a contributor guide for this repository.";
+var CODEX_BUILTIN_COMMAND_NAMES = new Set(
+  builtinHarnessCommands("codex").map((command) => command.name)
+);
+function replaceCodexPromptText(inputItems, text2) {
+  let replaced = false;
+  const next = inputItems.map((item) => {
+    if (item.type !== "text" || replaced) return item;
+    replaced = true;
+    return { ...item, text: text2 };
+  });
+  return replaced ? next : [{ type: "text", text: text2, text_elements: [] }, ...next];
+}
+function resolveCodexCommandDispatch(command, inputItems, skillNames) {
+  if (!command) return { kind: "turn", inputItems };
+  const args = command.args;
+  switch (command.name) {
+    case "compact":
+      return { kind: "compact" };
+    case "review":
+      return {
+        kind: "review",
+        target: args ? { type: "custom", instructions: args } : { type: "uncommittedChanges" }
+      };
+    case "init":
+      return { kind: "turn", inputItems: replaceCodexPromptText(inputItems, args ? `${CODEX_INIT_PROMPT} ${args}` : CODEX_INIT_PROMPT) };
+    default:
+      if (skillNames.has(command.name)) {
+        const mention = codexSkillMention(command.name);
+        return { kind: "turn", inputItems: replaceCodexPromptText(inputItems, args ? `${mention} ${args}` : mention) };
+      }
+      return { kind: "turn", inputItems };
+  }
+}
+var HARNESS_COMMANDS_SETTLE_GRACE_MS = 500;
+async function listCodexHarnessCommands(client, cwd) {
+  try {
+    const list = await withTimeout(client.request("skills/list", { cwds: [cwd] }), 5e3);
+    if (!list) throw new Error("skills/list timed out");
+    return codexHarnessCommands(list);
+  } catch (error) {
+    debugCodex("skills/list unavailable; reporting built-in commands only: %o", error);
+    return builtinHarnessCommands("codex");
+  }
+}
 async function terminateBackgroundTerminals(client, threadId) {
   await withTimeout((async () => {
     try {
@@ -4442,8 +4780,12 @@ function toNormalizedCodexEvents(runId, notification) {
       return [];
     }
     if (item.type === "agentMessage" && typeof item.text === "string") {
+      const questions = normalizeAsyncUserQuestions(AgentProvider.Codex, item.questions);
       return [
-        createNormalizedEvent("message.completed", base, { text: item.text })
+        createNormalizedEvent("message.completed", base, {
+          text: item.text,
+          ...questions ? { questions } : {}
+        })
       ];
     }
     if (item.type === "reasoning" && item.summary) {
@@ -5070,19 +5412,9 @@ async function createRuntime(request, inputParts) {
   };
 }
 async function buildCodexInputItems(options, inputParts) {
-  const textPrompt = joinTextParts(
-    inputParts.filter(
-      (part) => part.type === "text"
-    )
+  const inputItems = inputParts.flatMap(
+    (part) => part.type === "text" && part.text.trim().length > 0 ? [{ type: "text", text: part.text, text_elements: [] }] : []
   );
-  const inputItems = [];
-  if (textPrompt.trim().length > 0) {
-    inputItems.push({
-      type: "text",
-      text: textPrompt,
-      text_elements: []
-    });
-  }
   inputItems.push(
     ...await mapToCodexPromptParts(
       inputParts,
@@ -5484,17 +5816,40 @@ var CodexAgentAdapter = class {
         const modes = await client.request("collaborationMode/list", {});
         if (!modes.data.some((mode) => mode.mode === request.run.mode)) throw new Error("This Codex installation does not support the requested planning mode.");
       }
+      const emitHarnessCommands = (commands) => sink.emitEvent(
+        createNormalizedEvent(
+          "harness.commands",
+          { provider: request.provider, runId: request.runId },
+          { commands }
+        )
+      );
+      const inventory = listCodexHarnessCommands(client, cwd).then((commands) => {
+        emitHarnessCommands(commands);
+        return commands;
+      });
+      inventory.catch(() => void 0);
       if (request.run.goal) {
         await client.request("thread/goal/set", { threadId: threadResponse.thread.id, objective: request.run.goal, status: "active" });
       }
-      await client.request(
-        "turn/start",
-        buildCodexTurnStartParams({
-          threadId: threadResponse.thread.id,
-          inputItems: runtime.inputItems,
-          request
-        })
+      const command = request.run.command;
+      const skillNames = new Set(
+        command && !CODEX_BUILTIN_COMMAND_NAMES.has(command.name) ? (await inventory).filter((entry) => entry.source !== "builtin").map((entry) => entry.name) : []
       );
+      const dispatch = resolveCodexCommandDispatch(command, runtime.inputItems, skillNames);
+      if (dispatch.kind === "compact") {
+        await client.request("thread/compact/start", { threadId: threadResponse.thread.id });
+      } else if (dispatch.kind === "review") {
+        await client.request("review/start", { threadId: threadResponse.thread.id, target: dispatch.target, delivery: "inline" });
+      } else {
+        await client.request(
+          "turn/start",
+          buildCodexTurnStartParams({
+            threadId: threadResponse.thread.id,
+            inputItems: dispatch.inputItems,
+            request
+          })
+        );
+      }
       let completionResult;
       let completionError;
       try {
@@ -5502,6 +5857,10 @@ var CodexAgentAdapter = class {
       } catch (err) {
         completionError = err;
       }
+      await withTimeout(
+        inventory.catch(() => void 0),
+        HARNESS_COMMANDS_SETTLE_GRACE_MS
+      );
       endWait();
       if (completionError !== void 0) {
         if (abortInvoked) {
@@ -5724,6 +6083,60 @@ function toRawEvent3(runId, payload, type) {
 function injectedTaskResultChild(text2) {
   return /<task id="?([^"\s>]+)"? state="?(?:completed|error)"?>/.exec(text2)?.[1];
 }
+function resolveOpenCodeCommandDispatch(command, harnessCommands) {
+  if (!command) return { kind: "prompt" };
+  if (command.name === "compact") return { kind: "summarize" };
+  const known = harnessCommands.find((entry) => entry.name === command.name);
+  if (!known) return { kind: "prompt" };
+  if (known.source === "skill")
+    return { kind: "prompt", text: skillDirective(command.name, command.args) };
+  return { kind: "command", command: command.name, arguments: command.args };
+}
+function replaceOpenCodePromptText(parts, text2) {
+  let replaced = false;
+  const next = parts.map((part) => {
+    if (part.type !== "text" || replaced) return part;
+    replaced = true;
+    return { ...part, text: text2 };
+  });
+  return replaced ? next : [{ type: "text", text: text2 }, ...next];
+}
+var OPENCODE_COMMAND_DISCOVERY_TIMEOUT_MS = 5e3;
+async function listOpenCodeHarnessCommands(runtime) {
+  const init = {
+    headers: runtime.previewHeaders,
+    signal: AbortSignal.timeout(OPENCODE_COMMAND_DISCOVERY_TIMEOUT_MS)
+  };
+  try {
+    const listed = await withTimeout(
+      Promise.all([
+        fetchJson(`${runtime.baseUrl}/command`, init),
+        fetchJson(`${runtime.baseUrl}/skill`, init).catch(
+          () => []
+        )
+      ]),
+      OPENCODE_COMMAND_DISCOVERY_TIMEOUT_MS
+    );
+    if (!listed) {
+      debugOpencode(
+        "GET /command did not answer within %dms; reporting built-in commands only",
+        OPENCODE_COMMAND_DISCOVERY_TIMEOUT_MS
+      );
+      return builtinHarnessCommands("open-code");
+    }
+    const [commands, skills] = listed;
+    return openCodeHarnessCommands(
+      Array.isArray(commands) ? commands : [],
+      Array.isArray(skills) ? skills : []
+    );
+  } catch (error) {
+    debugOpencode(
+      "GET /command unavailable; reporting built-in commands only: %o",
+      error
+    );
+    return builtinHarnessCommands("open-code");
+  }
+}
 function toOpenCodeModel(model) {
   if (!model) {
     return void 0;
@@ -6748,6 +7161,32 @@ var OpenCodeAgentAdapter = class {
         const name = request.run.mode === "plan" ? "plan" : "build";
         if (!agents.some((agent) => agent.name === name)) throw new Error(`This OpenCode installation does not expose the ${name} agent.`);
       }
+      const harnessCommands = await listOpenCodeHarnessCommands(runtime);
+      sink.emitEvent(
+        createNormalizedEvent(
+          "harness.commands",
+          { provider: request.provider, runId: request.runId },
+          { commands: harnessCommands }
+        )
+      );
+      const commandDispatch = resolveOpenCodeCommandDispatch(request.run.command, harnessCommands);
+      if (commandDispatch.kind === "command" && request.run.systemPrompt) {
+        throw new Error(
+          "OpenCode commands do not support a per-run systemPrompt. Use a normal prompt, or configure the systemPrompt on the Agent at setup time."
+        );
+      }
+      const dispatchBlocking = (endpoint, body) => {
+        void fetch(`${runtime.baseUrl}/session/${sessionId}/${endpoint}`, {
+          method: "POST",
+          headers: { "content-type": "application/json", ...runtime.previewHeaders },
+          body: JSON.stringify(body)
+        }).then((response) => {
+          if (!response.ok) throw new Error(`POST /session/${sessionId}/${endpoint} returned ${response.status}`);
+        }).catch((error) => {
+          if (!dispatchError) dispatchError = error;
+          resolveSessionTerminal();
+        });
+      };
       const dispatchPrompt = async (parts) => {
         const body = JSON.stringify({
           ...request.run.model ? { model: toOpenCodeModel(request.run.model) } : {},
@@ -6816,7 +7255,24 @@ var OpenCodeAgentAdapter = class {
         sendToSession(queued);
       }
       try {
-        await dispatchPrompt(mapToOpenCodeParts(inputParts));
+        if (commandDispatch.kind === "summarize") {
+          const model = toOpenCodeModel(request.run.model);
+          if (!model?.providerID) throw new Error("OpenCode compaction needs a provider-qualified model id.");
+          dispatchBlocking("summarize", { providerID: model.providerID, modelID: model.modelID });
+        } else if (commandDispatch.kind === "command") {
+          dispatchBlocking("command", {
+            command: commandDispatch.command,
+            arguments: commandDispatch.arguments,
+            parts: mapToOpenCodeParts(inputParts).filter((part) => part.type === "file"),
+            ...request.run.model?.includes("/") ? { model: request.run.model } : {},
+            ...request.run.mode ? { agent: request.run.mode === "plan" ? "plan" : "build" } : request.options.configuration === "native" ? {} : { agent: agentSlug }
+          });
+        } else {
+          const parts = mapToOpenCodeParts(inputParts);
+          await dispatchPrompt(
+            commandDispatch.text === void 0 ? parts : replaceOpenCodePromptText(parts, commandDispatch.text)
+          );
+        }
       } catch (error) {
         if (!dispatchError) {
           dispatchError = error;
@@ -7574,7 +8030,10 @@ function harnessCapabilities(provider) {
 function resolveHarnessCommand(provider, input) {
   const first = typeof input === "string" ? input : input.find((part) => part.type === "text")?.text;
   const match = first?.match(/^\s*\/(plan|agent|goal)(?:\s+([\s\S]*))?$/);
-  if (!match) return { input };
+  if (!match) {
+    const invocation = first ? parseHarnessCommandInvocation(first) : void 0;
+    return invocation ? { input, command: invocation } : { input };
+  }
   const command = match[1];
   if (!harnessCapabilities(provider).commands.includes(command)) throw new Error(`/${command} is not supported by ${provider}.`);
   const body = match[2]?.trim() ?? "";
@@ -7591,6 +8050,17 @@ function resolveHarnessCommand(provider, input) {
 }
 
 export {
+  MAX_HARNESS_COMMANDS,
+  MAX_HARNESS_COMMAND_NAME,
+  MAX_HARNESS_COMMAND_DESCRIPTION,
+  MAX_HARNESS_COMMAND_ARGUMENT_HINT,
+  builtinHarnessCommands,
+  parseHarnessCommandInvocation,
+  claudeHarnessCommands,
+  codexHarnessCommands,
+  codexSkillMention,
+  openCodeHarnessCommands,
+  skillDirective,
   agentboxRoot,
   getAgentLayout,
   Agent,

package/dist/events/index.d.ts

@@ -1,4 +1,4 @@
-export { A as AISDKEvent, C as BackgroundTask, D as BackgroundTasksEvent, W as MessageCompletedEvent, X as MessageInjectedEvent, Y as MessageStartedEvent, Z as NativePlanEvent, _ as NormalizedAgentEvent, $ as NormalizedAgentEventBase, a0 as NormalizedAgentEventType, a7 as PermissionRequestedEvent, a8 as PermissionResolvedEvent, a9 as RawAgentEvent, aa as ReasoningDeltaEvent, ac as RunCancelledEvent, ad as RunCompletedEvent, ae as RunErrorEvent, af as RunStartedEvent, ah as TextDeltaEvent, aj as ToolCallCompletedEvent, ak as ToolCallDeltaEvent, al as ToolCallStartedEvent, ao as createNormalizedEvent, ap as normalizeRawAgentEvent, aq as toAISDKEvent, ar as toAISDKStream } from '../types-BKvKgRMY.js';
+export { A as AISDKEvent, C as BackgroundTask, D as BackgroundTasksEvent, Z as HarnessCommandsEvent, a3 as MessageCompletedEvent, a4 as MessageInjectedEvent, a5 as MessageStartedEvent, a6 as NativePlanEvent, a7 as NormalizedAgentEvent, a8 as NormalizedAgentEventBase, a9 as NormalizedAgentEventType, ai as PermissionRequestedEvent, aj as PermissionResolvedEvent, ak as RawAgentEvent, al as ReasoningDeltaEvent, an as RunCancelledEvent, ao as RunCompletedEvent, ap as RunErrorEvent, aq as RunStartedEvent, as as TextDeltaEvent, au as ToolCallCompletedEvent, av as ToolCallDeltaEvent, aw as ToolCallStartedEvent, aD as createNormalizedEvent, aE as normalizeRawAgentEvent, aI as toAISDKEvent, aJ as toAISDKStream } from '../types-DjHP7dFq.js';
 import { AgentProvider } from '../enums.js';
 import '../Sandbox-DcKAU-E3.js';
 import 'e2b';

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { A as AISDKEvent, a as AgentApprovalMode, b as AgentAttachRequest, c as AgentCommandConfig, d as AgentCostData, e as AgentExecutionRequest, f as AgentLocalMcpConfig, g as AgentMcpConfig, h as AgentOptions, i as AgentOptionsBase, j as AgentOptionsMap, k as AgentPermissionDecision, l as AgentPermissionKind, m as AgentPermissionResponse, n as AgentProviderAdapter, o as AgentProviderName, p as AgentReasoningEffort, q as AgentRemoteMcpConfig, r as AgentResult, s as AgentRun, t as AgentRunConfig, u as AgentRunSink, v as AgentSetupRequest, w as AgentSkillConfig, x as AgentSubAgentConfig, y as AgentUserAnswer, z as AgentUserQuestion, B as AttachedRun, C as BackgroundTask, D as BackgroundTasksEvent, E as ClaudeCodeAgentOptions, F as ClaudeCodeHookConfig, G as ClaudeCodeHookEvent, H as ClaudeCodeHookHandler, I as ClaudeCodeHookMatcherGroup, J as ClaudeCodeHooksConfig, K as ClaudeCodeProviderOptions, L as CodexAgentOptions, M as CodexCommandHook, N as CodexHookEvent, O as CodexHookMatcherGroup, P as CodexHooksConfig, Q as CodexModelProviderConfig, R as CodexProviderOptions, S as DataContent, T as EmbeddedSkillConfig, U as FilePart, V as ImagePart, W as MessageCompletedEvent, X as MessageInjectedEvent, Y as MessageStartedEvent, Z as NativePlanEvent, _ as NormalizedAgentEvent, $ as NormalizedAgentEventBase, a0 as NormalizedAgentEventType, a1 as OpenCodeAgentOptions, a2 as OpenCodePluginConfig, a3 as OpenCodePluginEvent, a4 as OpenCodePluginHookConfig, a5 as OpenCodeProviderOptions, a6 as OpenRouterPlugin, a7 as PermissionRequestedEvent, a8 as PermissionResolvedEvent, a9 as RawAgentEvent, aa as ReasoningDeltaEvent, ab as RepoSkillConfig, ac as RunCancelledEvent, ad as RunCompletedEvent, ae as RunErrorEvent, af as RunStartedEvent, ag as SetupLayout, ah as TextDeltaEvent, ai as TextPart, aj as ToolCallCompletedEvent, ak as ToolCallDeltaEvent, al as ToolCallStartedEvent, am as UserContent, an as UserContentPart, ao as createNormalizedEvent, ap as normalizeRawAgentEvent, aq as toAISDKEvent, ar as toAISDKStream } from './types-BKvKgRMY.js';
+export { A as AISDKEvent, a as AgentApprovalMode, b as AgentAttachRequest, c as AgentCommandConfig, d as AgentCostData, e as AgentExecutionRequest, f as AgentLocalMcpConfig, g as AgentMcpConfig, h as AgentOptions, i as AgentOptionsBase, j as AgentOptionsMap, k as AgentPermissionDecision, l as AgentPermissionKind, m as AgentPermissionResponse, n as AgentProviderAdapter, o as AgentProviderName, p as AgentReasoningEffort, q as AgentRemoteMcpConfig, r as AgentResult, s as AgentRun, t as AgentRunConfig, u as AgentRunSink, v as AgentSetupRequest, w as AgentSkillConfig, x as AgentSubAgentConfig, y as AgentUserAnswer, z as AgentUserQuestion, B as AttachedRun, C as BackgroundTask, D as BackgroundTasksEvent, E as ClaudeCodeAgentOptions, F as ClaudeCodeHookConfig, G as ClaudeCodeHookEvent, H as ClaudeCodeHookHandler, I as ClaudeCodeHookMatcherGroup, J as ClaudeCodeHooksConfig, K as ClaudeCodeProviderOptions, L as CodexAgentOptions, M as CodexCommandHook, N as CodexHookEvent, O as CodexHookMatcherGroup, P as CodexHooksConfig, Q as CodexModelProviderConfig, R as CodexProviderOptions, S as CodexSkillEntry, T as DataContent, U as EmbeddedSkillConfig, V as FilePart, W as HarnessCommandDescriptor, X as HarnessCommandInvocation, Y as HarnessCommandSource, Z as HarnessCommandsEvent, _ as ImagePart, $ as MAX_HARNESS_COMMANDS, a0 as MAX_HARNESS_COMMAND_ARGUMENT_HINT, a1 as MAX_HARNESS_COMMAND_DESCRIPTION, a2 as MAX_HARNESS_COMMAND_NAME, a3 as MessageCompletedEvent, a4 as MessageInjectedEvent, a5 as MessageStartedEvent, a6 as NativePlanEvent, a7 as NormalizedAgentEvent, a8 as NormalizedAgentEventBase, a9 as NormalizedAgentEventType, aa as OpenCodeAgentOptions, ab as OpenCodeCommandEntry, ac as OpenCodePluginConfig, ad as OpenCodePluginEvent, ae as OpenCodePluginHookConfig, af as OpenCodeProviderOptions, ag as OpenCodeSkillEntry, ah as OpenRouterPlugin, ai as PermissionRequestedEvent, aj as PermissionResolvedEvent, ak as RawAgentEvent, al as ReasoningDeltaEvent, am as RepoSkillConfig, an as RunCancelledEvent, ao as RunCompletedEvent, ap as RunErrorEvent, aq as RunStartedEvent, ar as SetupLayout, as as TextDeltaEvent, at as TextPart, au as ToolCallCompletedEvent, av as ToolCallDeltaEvent, aw as ToolCallStartedEvent, ax as UserContent, ay as UserContentPart, az as builtinHarnessCommands, aA as claudeHarnessCommands, aB as codexHarnessCommands, aC as codexSkillMention, aD as createNormalizedEvent, aE as normalizeRawAgentEvent, aF as openCodeHarnessCommands, aG as parseHarnessCommandInvocation, aH as skillDirective, aI as toAISDKEvent, aJ as toAISDKStream } from './types-DjHP7dFq.js';
 export { AGENT_RESERVED_PORTS, Agent, HarnessCapabilities, HarnessCommand, agentboxRoot, collectAllAgentReservedPorts, getAgentLayout, harnessCapabilities, resolveHarnessCommand } from './agents/index.js';
 export { A as AsyncCommandHandle, C as CommandEvent, a as CommandOptions, b as CommandResult, D as DaytonaProviderOptions, c as DaytonaSandboxOptions, E as E2bProviderOptions, d as E2bSandboxOptions, G as GitCloneOptions, L as LocalDockerProviderOptions, e as LocalDockerSandboxOptions, M as ModalProviderOptions, f as ModalSandboxOptions, S as Sandbox, g as SandboxDescriptor, h as SandboxListOptions, i as SandboxOptions, j as SandboxOptionsBase, k as SandboxOptionsMap, l as SandboxProviderName, m as SandboxRaw, n as SandboxRawMap, o as SandboxResourceSpec, T as TarballEntry, V as VercelGitSource, p as VercelProviderOptions, q as VercelSandboxOptions } from './Sandbox-DcKAU-E3.js';
 export { SandboxAdapter, buildGitCloneCommand } from './sandboxes/index.js';

package/dist/index.js

@@ -1,10 +1,21 @@
 import {
   Agent,
+  MAX_HARNESS_COMMANDS,
+  MAX_HARNESS_COMMAND_ARGUMENT_HINT,
+  MAX_HARNESS_COMMAND_DESCRIPTION,
+  MAX_HARNESS_COMMAND_NAME,
   agentboxRoot,
+  builtinHarnessCommands,
+  claudeHarnessCommands,
+  codexHarnessCommands,
+  codexSkillMention,
   getAgentLayout,
   harnessCapabilities,
-  resolveHarnessCommand
-} from "./chunk-SERVEWIE.js";
+  openCodeHarnessCommands,
+  parseHarnessCommandInvocation,
+  resolveHarnessCommand,
+  skillDirective
+} from "./chunk-YV3DQS6Z.js";
 import {
   ProviderLogAssembler,
   createNormalizedEvent,
@@ -30,18 +41,29 @@ export {
   AGENT_RESERVED_PORTS,
   Agent,
   AgentProvider,
+  MAX_HARNESS_COMMANDS,
+  MAX_HARNESS_COMMAND_ARGUMENT_HINT,
+  MAX_HARNESS_COMMAND_DESCRIPTION,
+  MAX_HARNESS_COMMAND_NAME,
   ProviderLogAssembler,
   Sandbox,
   SandboxAdapter,
   SandboxProvider,
   agentboxRoot,
   buildGitCloneCommand,
+  builtinHarnessCommands,
+  claudeHarnessCommands,
+  codexHarnessCommands,
+  codexSkillMention,
   collectAllAgentReservedPorts,
   createNormalizedEvent,
   getAgentLayout,
   harnessCapabilities,
   normalizeRawAgentEvent,
+  openCodeHarnessCommands,
+  parseHarnessCommandInvocation,
   resolveHarnessCommand,
+  skillDirective,
   toAISDKEvent,
   toAISDKStream
 };

package/dist/{types-BKvKgRMY.d.ts → types-DjHP7dFq.d.ts}

@@ -9,7 +9,92 @@ interface RawAgentEvent<TPayload = unknown> {
     payload: TPayload;
 }
 
-type NormalizedAgentEventType = "plan.completed" | "run.started" | "message.started" | "message.injected" | "text.delta" | "reasoning.delta" | "tool.call.started" | "tool.call.delta" | "tool.call.completed" | "permission.requested" | "permission.resolved" | "message.completed" | "background.tasks" | "run.completed" | "run.cancelled" | "run.error";
+/**
+ * Where a harness command comes from. `builtin` commands ship with the CLI;
+ * `skill`, `custom`, `plugin`, and `mcp` commands are discovered from the
+ * environment the harness runs in and can differ per project.
+ */
+type HarnessCommandSource = "builtin" | "skill" | "custom" | "plugin" | "mcp";
+/** A slash command the harness can run, as shown in a host's `/` palette. */
+interface HarnessCommandDescriptor {
+    /** Name as typed after the slash, e.g. `compact` or `posthog:signals`. */
+    name: string;
+    description?: string;
+    /** Free-text hint for what follows the name, e.g. `<optional instructions>`. */
+    argumentHint?: string;
+    source: HarnessCommandSource;
+}
+/** A leading `/name args` token from user input, resolved by each adapter. */
+interface HarnessCommandInvocation {
+    name: string;
+    /** Text after the command name, trimmed. Empty when none was given. */
+    args: string;
+}
+declare const MAX_HARNESS_COMMANDS = 500;
+declare const MAX_HARNESS_COMMAND_NAME = 200;
+declare const MAX_HARNESS_COMMAND_DESCRIPTION = 500;
+declare const MAX_HARNESS_COMMAND_ARGUMENT_HINT = 200;
+/**
+ * Commands known to work for every installation of the harness when driven
+ * headlessly. A live run replaces this list with what the harness reports.
+ */
+declare function builtinHarnessCommands(provider: AgentProviderName): HarnessCommandDescriptor[];
+/**
+ * Parse a leading `/name args` token. Only a bare name qualifies: a path such
+ * as `/src/app.ts` or a name followed by punctuation is prose, not a command.
+ */
+declare function parseHarnessCommandInvocation(text: string): HarnessCommandInvocation | undefined;
+/**
+ * Turn Claude Code's `system/init` command inventory into descriptors. The
+ * headless CLI already omits commands that need an interactive terminal; this
+ * additionally hides host-owned settings, internal commands, and the
+ * commands flagged as bound to the local terminal.
+ */
+declare function claudeHarnessCommands(init: {
+    slash_commands?: string[];
+    skills?: string[];
+    terminal_slash_commands?: string[];
+    plugins?: Array<{
+        name: string;
+    }>;
+}): HarnessCommandDescriptor[];
+/** One entry of Codex's `skills/list` response. */
+interface CodexSkillEntry {
+    name: string;
+    description?: string;
+    enabled?: boolean;
+    pluginId?: string | null;
+    interface?: {
+        shortDescription?: string;
+        displayName?: string;
+    } | null;
+}
+/** Codex `skills/list` groups skills per working directory. */
+declare function codexHarnessCommands(list: {
+    data?: Array<{
+        skills?: CodexSkillEntry[];
+    }>;
+}): HarnessCommandDescriptor[];
+/** Skill mention Codex resolves from prompt text (`$name`). */
+declare function codexSkillMention(name: string): string;
+/** One entry of OpenCode's `GET /command` response. */
+interface OpenCodeCommandEntry {
+    name: string;
+    description?: string;
+    mcp?: boolean;
+    hints?: string[];
+    source?: string;
+}
+/** One entry of OpenCode's `GET /skill` response. */
+interface OpenCodeSkillEntry {
+    name: string;
+    description?: string;
+}
+declare function openCodeHarnessCommands(commands: OpenCodeCommandEntry[], skills?: OpenCodeSkillEntry[]): HarnessCommandDescriptor[];
+/** Natural-language directive for harnesses whose skills the model invokes. */
+declare function skillDirective(name: string, args: string): string;
+
+type NormalizedAgentEventType = "plan.completed" | "harness.commands" | "run.started" | "message.started" | "message.injected" | "text.delta" | "reasoning.delta" | "tool.call.started" | "tool.call.delta" | "tool.call.completed" | "permission.requested" | "permission.resolved" | "message.completed" | "background.tasks" | "run.completed" | "run.cancelled" | "run.error";
 interface NormalizedAgentEventBase {
     provider: string;
     runId: string;
@@ -95,6 +180,15 @@ interface MessageCompletedEvent extends NormalizedAgentEventBase {
      * the assistant turn rather than the user one.
      */
     messageId?: string;
+    /**
+     * Questions the harness asked without pausing the turn (Codex
+     * `request_user_input_async`: an `agentMessage` item with
+     * `delivery: "async"`). Nothing is pending and the run keeps working;
+     * an answer, if any, is a follow-up user message (`AgentRun.sendMessage`
+     * while the run is live, or the next run). Blocking questions never use
+     * this field: they arrive as `permission.requested` with `kind: "question"`.
+     */
+    questions?: AgentUserQuestion[];
 }
 /** Work the harness left running past its turn (background shell, monitor,
  * background subagent, scheduled wakeup). */
@@ -132,7 +226,17 @@ interface NativePlanEvent extends NormalizedAgentEventBase {
     type: "plan.completed";
     text: string;
 }
-type NormalizedAgentEvent = NativePlanEvent | RunStartedEvent | MessageStartedEvent | MessageInjectedEvent | TextDeltaEvent | ReasoningDeltaEvent | ToolCallStartedEvent | ToolCallDeltaEvent | ToolCallCompletedEvent | PermissionRequestedEvent | PermissionResolvedEvent | MessageCompletedEvent | BackgroundTasksEvent | RunCompletedEvent | RunCancelledEvent | RunErrorEvent;
+/**
+ * Slash commands the harness reports for this session: built-ins usable
+ * headlessly plus the skills, custom commands, plugin commands, and MCP
+ * prompts discovered in its environment. Emitted once a run knows them
+ * (Claude Code `system/init`, Codex `skills/list`, OpenCode `GET /command`).
+ */
+interface HarnessCommandsEvent extends NormalizedAgentEventBase {
+    type: "harness.commands";
+    commands: HarnessCommandDescriptor[];
+}
+type NormalizedAgentEvent = NativePlanEvent | HarnessCommandsEvent | RunStartedEvent | MessageStartedEvent | MessageInjectedEvent | TextDeltaEvent | ReasoningDeltaEvent | ToolCallStartedEvent | ToolCallDeltaEvent | ToolCallCompletedEvent | PermissionRequestedEvent | PermissionResolvedEvent | MessageCompletedEvent | BackgroundTasksEvent | RunCompletedEvent | RunCancelledEvent | RunErrorEvent;
 declare function createNormalizedEvent<TType extends NormalizedAgentEventType>(type: TType, base: Omit<NormalizedAgentEventBase, "type" | "timestamp"> & {
     timestamp?: string;
 }, extra?: Record<string, unknown>): NormalizedAgentEvent;
@@ -421,6 +525,14 @@ interface AgentRunConfig {
     mode?: "plan" | "default";
     /** Native goal objective. Unsupported harnesses reject it. */
     goal?: string;
+    /**
+     * Leading `/name args` token of {@link input}, as parsed by
+     * `resolveHarnessCommand`. The input keeps the raw text: Claude Code
+     * dispatches slash commands itself, while the Codex and OpenCode adapters
+     * map known names to native calls (compaction, review, commands, skills)
+     * and send unknown ones as plain text.
+     */
+    command?: HarnessCommandInvocation;
 }
 type AgentApprovalMode = "auto" | "interactive";
 type AgentPermissionKind = "bash" | "edit" | "tool" | "network" | "file-change" | "question" | "plan" | "unknown";
@@ -872,4 +984,4 @@ interface AgentProviderAdapter<P extends AgentProviderName = AgentProviderName>
     attachSendMessage(request: AgentAttachRequest<P>, content: UserContent): Promise<void>;
 }
 
-export { type NormalizedAgentEventBase as $, type AISDKEvent as A, type AttachedRun as B, type BackgroundTask as C, type BackgroundTasksEvent as D, type ClaudeCodeAgentOptions as E, type ClaudeCodeHookConfig as F, type ClaudeCodeHookEvent as G, type ClaudeCodeHookHandler as H, type ClaudeCodeHookMatcherGroup as I, type ClaudeCodeHooksConfig as J, type ClaudeCodeProviderOptions as K, type CodexAgentOptions as L, type CodexCommandHook as M, type CodexHookEvent as N, type CodexHookMatcherGroup as O, type CodexHooksConfig as P, type CodexModelProviderConfig as Q, type CodexProviderOptions as R, type DataContent as S, type EmbeddedSkillConfig as T, type FilePart as U, type ImagePart as V, type MessageCompletedEvent as W, type MessageInjectedEvent as X, type MessageStartedEvent as Y, type NativePlanEvent as Z, type NormalizedAgentEvent as _, type AgentApprovalMode as a, type NormalizedAgentEventType as a0, type OpenCodeAgentOptions as a1, type OpenCodePluginConfig as a2, type OpenCodePluginEvent as a3, type OpenCodePluginHookConfig as a4, type OpenCodeProviderOptions as a5, type OpenRouterPlugin as a6, type PermissionRequestedEvent as a7, type PermissionResolvedEvent as a8, type RawAgentEvent as a9, type ReasoningDeltaEvent as aa, type RepoSkillConfig as ab, type RunCancelledEvent as ac, type RunCompletedEvent as ad, type RunErrorEvent as ae, type RunStartedEvent as af, type SetupLayout as ag, type TextDeltaEvent as ah, type TextPart as ai, type ToolCallCompletedEvent as aj, type ToolCallDeltaEvent as ak, type ToolCallStartedEvent as al, type UserContent as am, type UserContentPart as an, createNormalizedEvent as ao, normalizeRawAgentEvent as ap, toAISDKEvent as aq, toAISDKStream as ar, type AgentAttachRequest as b, type AgentCommandConfig as c, type AgentCostData as d, type AgentExecutionRequest as e, type AgentLocalMcpConfig as f, type AgentMcpConfig as g, type AgentOptions as h, type AgentOptionsBase as i, type AgentOptionsMap as j, type AgentPermissionDecision as k, type AgentPermissionKind as l, type AgentPermissionResponse as m, type AgentProviderAdapter as n, type AgentProviderName as o, type AgentReasoningEffort as p, type AgentRemoteMcpConfig as q, type AgentResult as r, type AgentRun as s, type AgentRunConfig as t, type AgentRunSink as u, type AgentSetupRequest as v, type AgentSkillConfig as w, type AgentSubAgentConfig as x, type AgentUserAnswer as y, type AgentUserQuestion as z };
+export { MAX_HARNESS_COMMANDS as $, type AISDKEvent as A, type AttachedRun as B, type BackgroundTask as C, type BackgroundTasksEvent as D, type ClaudeCodeAgentOptions as E, type ClaudeCodeHookConfig as F, type ClaudeCodeHookEvent as G, type ClaudeCodeHookHandler as H, type ClaudeCodeHookMatcherGroup as I, type ClaudeCodeHooksConfig as J, type ClaudeCodeProviderOptions as K, type CodexAgentOptions as L, type CodexCommandHook as M, type CodexHookEvent as N, type CodexHookMatcherGroup as O, type CodexHooksConfig as P, type CodexModelProviderConfig as Q, type CodexProviderOptions as R, type CodexSkillEntry as S, type DataContent as T, type EmbeddedSkillConfig as U, type FilePart as V, type HarnessCommandDescriptor as W, type HarnessCommandInvocation as X, type HarnessCommandSource as Y, type HarnessCommandsEvent as Z, type ImagePart as _, type AgentApprovalMode as a, MAX_HARNESS_COMMAND_ARGUMENT_HINT as a0, MAX_HARNESS_COMMAND_DESCRIPTION as a1, MAX_HARNESS_COMMAND_NAME as a2, type MessageCompletedEvent as a3, type MessageInjectedEvent as a4, type MessageStartedEvent as a5, type NativePlanEvent as a6, type NormalizedAgentEvent as a7, type NormalizedAgentEventBase as a8, type NormalizedAgentEventType as a9, claudeHarnessCommands as aA, codexHarnessCommands as aB, codexSkillMention as aC, createNormalizedEvent as aD, normalizeRawAgentEvent as aE, openCodeHarnessCommands as aF, parseHarnessCommandInvocation as aG, skillDirective as aH, toAISDKEvent as aI, toAISDKStream as aJ, type OpenCodeAgentOptions as aa, type OpenCodeCommandEntry as ab, type OpenCodePluginConfig as ac, type OpenCodePluginEvent as ad, type OpenCodePluginHookConfig as ae, type OpenCodeProviderOptions as af, type OpenCodeSkillEntry as ag, type OpenRouterPlugin as ah, type PermissionRequestedEvent as ai, type PermissionResolvedEvent as aj, type RawAgentEvent as ak, type ReasoningDeltaEvent as al, type RepoSkillConfig as am, type RunCancelledEvent as an, type RunCompletedEvent as ao, type RunErrorEvent as ap, type RunStartedEvent as aq, type SetupLayout as ar, type TextDeltaEvent as as, type TextPart as at, type ToolCallCompletedEvent as au, type ToolCallDeltaEvent as av, type ToolCallStartedEvent as aw, type UserContent as ax, type UserContentPart as ay, builtinHarnessCommands as az, type AgentAttachRequest as b, type AgentCommandConfig as c, type AgentCostData as d, type AgentExecutionRequest as e, type AgentLocalMcpConfig as f, type AgentMcpConfig as g, type AgentOptions as h, type AgentOptionsBase as i, type AgentOptionsMap as j, type AgentPermissionDecision as k, type AgentPermissionKind as l, type AgentPermissionResponse as m, type AgentProviderAdapter as n, type AgentProviderName as o, type AgentReasoningEffort as p, type AgentRemoteMcpConfig as q, type AgentResult as r, type AgentRun as s, type AgentRunConfig as t, type AgentRunSink as u, type AgentSetupRequest as v, type AgentSkillConfig as w, type AgentSubAgentConfig as x, type AgentUserAnswer as y, type AgentUserQuestion as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentbox-sdk",
-  "version": "0.1.516",
+  "version": "0.1.518",
   "description": "Swappable coding agents and sandbox providers for Bun and TypeScript.",
   "license": "MIT",
   "repository": {