@elench/testkit 0.1.98 → 0.1.99

package/lib/cli/assistant/context-pack.mjs

@@ -2,6 +2,13 @@ import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
 import { readContextContent, buildContextSelection } from "../../results/context.mjs";
+import {
+  ASSISTANT_COMMAND_ID_ENV,
+  ASSISTANT_COMMAND_LOG_ENV,
+  ASSISTANT_RESULT_DIR_ENV,
+  ASSISTANT_SESSION_ENV,
+  ASSISTANT_WRAPPER_LOGGED_ENV,
+} from "./command-results.mjs";
 
 export function prepareAssistantContextPack({
   productDir,
@@ -9,7 +16,11 @@ export function prepareAssistantContextPack({
 } = {}) {
   const contextDir = path.join(productDir, ".testkit", "assistant");
   const binDir = path.join(contextDir, "bin");
+  const resultDir = path.join(contextDir, "command-results");
+  const sessionId = `session-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
   fs.mkdirSync(binDir, { recursive: true });
+  fs.rmSync(resultDir, { recursive: true, force: true });
+  fs.mkdirSync(resultDir, { recursive: true });
 
   const commandLogPath = path.join(contextDir, "commands.jsonl");
   const contextPath = path.join(contextDir, "context.md");
@@ -55,7 +66,7 @@ export function prepareAssistantContextPack({
       }),
       "utf8"
     );
-    fs.writeFileSync(wrapperPath, buildWrapperScript({ cliPath: resolveCliPath() }), {
+    fs.writeFileSync(wrapperPath, buildWrapperScript({ cliPath: resolveCliPath(), sessionId, resultDir, commandLogPath }), {
       encoding: "utf8",
       mode: 0o755,
     });
@@ -71,12 +82,23 @@ export function prepareAssistantContextPack({
     selectionPath,
     commandsPath,
     commandLogPath,
+    resultDir,
+    sessionId,
     focusedDetailPath,
     focusedLogsPath,
     focusedArtifactsPath,
     focusedSetupPath,
     binDir,
     wrapperPath,
+    providerEnv(baseEnv = process.env) {
+      return {
+        ...baseEnv,
+        PATH: [binDir, baseEnv?.PATH, process.env.PATH].filter(Boolean).join(path.delimiter),
+        [ASSISTANT_SESSION_ENV]: sessionId,
+        [ASSISTANT_RESULT_DIR_ENV]: resultDir,
+        [ASSISTANT_COMMAND_LOG_ENV]: commandLogPath,
+      };
+    },
     refresh,
     appendCommandLog(event) {
       if (!event || typeof event !== "object") return;
@@ -97,15 +119,36 @@ function resolveCliPath() {
   return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "bin", "testkit.mjs");
 }
 
-function buildWrapperScript({ cliPath } = {}) {
+function buildWrapperScript({ cliPath, sessionId, resultDir, commandLogPath } = {}) {
   return `#!/usr/bin/env node
 import { spawnSync } from "child_process";
+import fs from "fs";
+import path from "path";
+
+const commandId = process.env.${ASSISTANT_COMMAND_ID_ENV} || \`cmd-\${Date.now()}-\${Math.random().toString(36).slice(2, 10)}\`;
+const commandLogPath = process.env.${ASSISTANT_COMMAND_LOG_ENV} || ${JSON.stringify(commandLogPath)};
+const sessionId = process.env.${ASSISTANT_SESSION_ENV} || ${JSON.stringify(sessionId)};
+const argv = process.argv.slice(2);
+
+appendCommandLog({
+  type: "command_start",
+  commandId,
+  command: "testkit",
+  kind: inferKind(argv),
+  argv,
+  cwd: process.cwd(),
+});
 
 const result = spawnSync(process.execPath, [${JSON.stringify(cliPath)}, ...process.argv.slice(2)], {
   cwd: process.cwd(),
   env: {
     ...process.env,
     TESTKIT_NO_ASSISTANT_DEFAULT: "1",
+    ${ASSISTANT_SESSION_ENV}: sessionId,
+    ${ASSISTANT_RESULT_DIR_ENV}: process.env.${ASSISTANT_RESULT_DIR_ENV} || ${JSON.stringify(resultDir)},
+    ${ASSISTANT_COMMAND_LOG_ENV}: commandLogPath,
+    ${ASSISTANT_COMMAND_ID_ENV}: commandId,
+    ${ASSISTANT_WRAPPER_LOGGED_ENV}: "1",
   },
   stdio: "inherit",
 });
@@ -113,7 +156,30 @@ const result = spawnSync(process.execPath, [${JSON.stringify(cliPath)}, ...proce
 if (result.error) {
   throw result.error;
 }
+appendCommandLog({
+  type: "command_exit",
+  commandId,
+  command: "testkit",
+  kind: inferKind(argv),
+  argv,
+  cwd: process.cwd(),
+  code: result.status ?? 0,
+  signal: result.signal ?? null,
+});
 process.exit(result.status ?? 0);
+
+function appendCommandLog(event) {
+  try {
+    fs.mkdirSync(path.dirname(commandLogPath), { recursive: true });
+    fs.appendFileSync(commandLogPath, \`\${JSON.stringify({ timestamp: new Date().toISOString(), sessionId, ...event })}\\n\`, "utf8");
+  } catch {
+    // Command observation must not affect command execution.
+  }
+}
+
+function inferKind(args) {
+  return args.find((arg) => !String(arg).startsWith("-")) || "run";
+}
 `;
 }
 
@@ -160,7 +226,8 @@ function buildContextMarkdown(productDir, snapshot, paths) {
   lines.push(
     "",
     "## Guidance",
-    "- Use dedicated testkit tools for run/discover/status/doctor/typecheck actions before falling back to generic shell commands.",
+    "- Work normally in the repository and run real commands. Testkit observes recognized Testkit commands and renders them in the assistant UI.",
+    "- Prefer `testkit ...` commands when using Testkit directly; `npx testkit ...` and project scripts are also valid.",
     "- Do not reinterpret CLI syntax after an execution failure unless `testkit run --help` confirms a syntax problem.",
     "- Use the command log and focused context files before rereading artifacts manually.",
     "- Prefer repo-local commands over guessing project-specific wrappers.",

package/lib/cli/assistant/prompt-builder.mjs

@@ -1,12 +1,11 @@
 import { readContextContent } from "../../results/context.mjs";
-import { buildAssistantResponseContract } from "./protocol.mjs";
 
 export function buildAssistantPrompt({
   productDir,
   snapshot,
   transcript = [],
-  tools = [],
   userMessage,
+  commandLog = null,
 } = {}) {
   const selectionSummary = buildSelectionSummary(snapshot);
   const focusPreview = buildFocusPreview(productDir, snapshot);
@@ -14,11 +13,19 @@ export function buildAssistantPrompt({
 
   return [
     "You are Testkit Assistant.",
-    "You help users run tests, inspect failures, read logs and artifacts, and navigate the current local test state.",
-    "All user natural-language requests must be handled through your own reasoning plus the available tools.",
-    "Use the dedicated testkit tools for run/discover/status/doctor/typecheck actions; use shell_exec only for arbitrary repository commands outside those actions.",
-    "Use read_context before repeating artifact/log inspection work, and use read_file/search_repo when you need codebase context.",
-    buildAssistantResponseContract({ tools }),
+    "You are running as a coding agent inside the user's repository.",
+    "Work normally: inspect files, edit files, run real shell commands, and iterate until the user's request is handled.",
+    "When using Testkit, run real commands such as `testkit discover`, `testkit run int`, `npx testkit run int`, or the repository's package scripts.",
+    "Testkit observes recognized Testkit commands and renders rich assistant UI from the real command output, sidecars, and artifacts.",
+    "Do not respond with a JSON tool envelope. Give the user a normal final answer when you are done.",
+    "",
+    "Assistant context files:",
+    ...(commandLog ? [
+      `- Context: ${commandLog.contextPath}`,
+      `- Command reference: ${commandLog.commandsPath}`,
+      `- Command log: ${commandLog.commandLogPath}`,
+      `- Current selection: ${commandLog.selectionPath}`,
+    ] : ["- No assistant context pack is available."]),
     "",
     "Current run summary:",
     ...(summaryRows.length > 0 ? summaryRows.map(([label, value]) => `- ${label}: ${value}`) : ["- No run artifact is currently loaded."]),

package/lib/cli/assistant/providers/claude.mjs

@@ -16,6 +16,7 @@ export function startClaudeHostedSession({
   model = null,
   effort = null,
   providerArgs = [],
+  env = process.env,
 } = {}) {
   const args = [
     "-p",
@@ -25,9 +26,6 @@ export function startClaudeHostedSession({
     "--include-partial-messages",
   ];
 
-  if (purpose === "assistant") {
-    args.push("--permission-mode", "plan");
-  }
   if (model) {
     args.push("--model", String(model));
   }
@@ -44,6 +42,7 @@ export function startClaudeHostedSession({
     stdout: "pipe",
     stderr: "pipe",
     reject: false,
+    env,
   });
 
   return createHostedSessionRunner({

package/lib/cli/assistant/providers/codex.mjs

@@ -19,6 +19,7 @@ export function startCodexHostedSession({
   purpose = "assistant",
   model = null,
   providerArgs = [],
+  env = process.env,
 } = {}) {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-codex-"));
   const outputFile = path.join(tempDir, "final-message.txt");
@@ -28,7 +29,6 @@ export function startCodexHostedSession({
     model,
     providerArgs,
     prompt,
-    sandbox: process.env.TESTKIT_CODEX_SANDBOX,
   });
 
   const child = execa(command, args, {
@@ -37,6 +37,7 @@ export function startCodexHostedSession({
     stdout: "pipe",
     stderr: "pipe",
     reject: false,
+    env,
   });
 
   const session = createHostedSessionRunner({
@@ -64,18 +65,13 @@ export function startCodexHostedSession({
 
 export function buildCodexArgs({
   outputFile,
-  purpose = "assistant",
   model = null,
   providerArgs = [],
   prompt = "",
-  sandbox = null,
 } = {}) {
   const args = ["exec", "--json"];
   if (outputFile) args.push("-o", outputFile);
 
-  if (purpose === "assistant") {
-    args.push("-s", String(sandbox || "workspace-write"));
-  }
   if (model) {
     args.push("--model", String(model));
   }

package/lib/cli/assistant/providers/index.mjs

@@ -69,7 +69,7 @@ export function startProviderSession({
   const resolvedProvider = resolvePreferredProvider(provider, env);
   const command = resolveProviderBinary(resolvedProvider, env);
   if (resolvedProvider === "claude") {
-    return startClaudeHostedSession({ command, cwd, prompt, onEvent, purpose, model, effort, providerArgs });
+    return startClaudeHostedSession({ command, cwd, prompt, onEvent, purpose, model, effort, providerArgs, env });
   }
-  return startCodexHostedSession({ command, cwd, prompt, onEvent, purpose, model, providerArgs });
+  return startCodexHostedSession({ command, cwd, prompt, onEvent, purpose, model, providerArgs, env });
 }

package/lib/cli/assistant/session.mjs

@@ -1,7 +1,6 @@
 import { startProviderSession, resolvePreferredProvider } from "./providers/index.mjs";
 import { buildAssistantPrompt } from "./prompt-builder.mjs";
-import { listAssistantTools, executeAssistantTool } from "./tool-registry.mjs";
-import { parseAssistantEnvelope } from "./protocol.mjs";
+import { createAssistantCommandObserver } from "./command-observer.mjs";
 
 export async function runAssistantConversationTurn({
   productDir,
@@ -18,40 +17,36 @@ export async function runAssistantConversationTurn({
   onResolvedProvider,
   onPrompt,
 } = {}) {
-  const tools = listAssistantTools();
-  const toolContext = {
+  const observer = createAssistantCommandObserver({
     productDir,
     runState,
-    configs,
-    env,
     commandLog,
     onEvent: onToolEvent,
-  };
+  });
 
-  let currentTranscript = [...(transcript || []), { role: "user", text: userMessage }];
-  const emitted = [];
+  const snapshot = runState.getSnapshot();
+  const prompt = buildAssistantPrompt({
+    productDir,
+    snapshot,
+    transcript: [...(transcript || []), { role: "user", text: userMessage }],
+    userMessage,
+    commandLog,
+  });
 
-  for (let attempt = 0; attempt < 6; attempt += 1) {
-    const snapshot = runState.getSnapshot();
-    const prompt = buildAssistantPrompt({
-      productDir,
-      snapshot,
-      transcript: currentTranscript,
-      tools,
-      userMessage,
-    });
+  const runtimeSettings = settings || { provider };
+  const resolvedProvider = resolvePreferredProvider(runtimeSettings.provider || provider, env);
+  const providerEnv = commandLog?.providerEnv?.(env) || env;
+  onResolvedProvider?.(resolvedProvider);
+  onPrompt?.({
+    prompt,
+    provider: resolvedProvider,
+    model: runtimeSettings.model || null,
+    effort: runtimeSettings.effort || null,
+  });
+  onStatus?.(`Thinking with ${resolvedProvider}...`);
 
-    const runtimeSettings = settings || { provider };
-    const resolvedProvider = resolvePreferredProvider(runtimeSettings.provider || provider, env);
-    onResolvedProvider?.(resolvedProvider);
-    onPrompt?.({
-      prompt,
-      provider: resolvedProvider,
-      model: runtimeSettings.model || null,
-      effort: runtimeSettings.effort || null,
-    });
-    onStatus?.(`Thinking with ${resolvedProvider}...`);
-    const events = [];
+  observer.start();
+  try {
     const session = startProviderSession({
       provider: runtimeSettings.provider || provider,
       model: runtimeSettings.model || null,
@@ -60,74 +55,21 @@ export async function runAssistantConversationTurn({
       cwd: productDir,
       prompt,
       purpose: "assistant",
-      env,
+      env: providerEnv,
       onEvent(event) {
-        events.push(event);
         if (event.type === "status" || event.type === "tool") onStatus?.(formatProviderEvent(event));
       },
     });
     const result = await session.completion;
-    const envelope = parseAssistantEnvelope(result.finalText || "");
-
-    if (envelope.type === "tool") {
-      if (envelope.commentary) {
-        emitted.push({ role: "assistant", text: envelope.commentary });
-        currentTranscript.push({ role: "assistant", text: envelope.commentary });
-      }
-      let toolResult;
-      try {
-        toolResult = await executeAssistantTool(envelope.tool, envelope.arguments, toolContext);
-      } catch (error) {
-        const toolText = formatToolError(envelope.tool, error);
-        emitted.push({
-          role: "tool",
-          text: toolText,
-          toolName: envelope.tool,
-          title: `${envelope.tool} error`,
-          data: { ok: false, error: toolText },
-        });
-        currentTranscript.push({
-          role: "tool",
-          text: `${envelope.tool}: ${toolText}`,
-        });
-        continue;
-      }
-      const toolText = toolResult.text || `${envelope.tool} completed`;
-      emitted.push({
-        role: "tool",
-        text: toolText,
-        toolName: envelope.tool,
-        title: toolResult.title || envelope.tool,
-        data: toolResult.data || null,
-      });
-      currentTranscript.push({
-        role: "tool",
-        text: `${envelope.tool}: ${toolText}`,
-      });
-      onToolEvent?.({ type: "tool-result", tool: envelope.tool, text: toolText });
-      continue;
-    }
-
-    emitted.push({
+    observer.scan();
+    commandLog?.refresh?.();
+    return [{
       role: "assistant",
-      text: envelope.message || result.finalText || "",
-    });
-    return emitted;
-  }
-
-  emitted.push({
-    role: "assistant",
-    text: "I hit the assistant tool-call limit before reaching a final answer.",
-  });
-  return emitted;
-}
-
-export function formatToolError(tool, error) {
-  const message = error instanceof Error ? error.message : String(error);
-  if (tool === "shell_exec" && /command string/.test(message)) {
-    return "The assistant requested shell_exec without a command. Retry with arguments.command set to the exact shell command.";
+      text: result.finalText || "",
+    }];
+  } finally {
+    observer.stop();
   }
-  return `Tool failed: ${message}`;
 }
 
 function formatProviderEvent(event) {

package/lib/cli/assistant/state.mjs

@@ -10,7 +10,7 @@ import { createRunState } from "../state/run/state.mjs";
 import { buildContextSelection } from "../../results/context.mjs";
 import { isProviderInstalled } from "./providers/index.mjs";
 import { parseSlashCommand, formatSlashHelpLines } from "./slash-commands.mjs";
-import { executeAssistantTool } from "./tool-registry.mjs";
+import { executeAssistantAction } from "./actions.mjs";
 import { runAssistantConversationTurn } from "./session.mjs";
 import { prepareAssistantContextPack } from "./context-pack.mjs";
 import {
@@ -598,6 +598,27 @@ function handleAssistantToolEvent(state, event, appendMessage) {
   }
   if (event.type === "run-session-end") {
     state.completeRunSession(event.session);
+    return;
+  }
+  if (event.type === "observed-run-artifact") {
+    const observedSession = {
+      productDir: state.getSnapshot().productDir,
+      runState: state.runState,
+      getSnapshot() {
+        return state.runState.getSnapshot();
+      },
+    };
+    state.attachRunSession(observedSession, { active: false });
+    return;
+  }
+  if (event.type === "observed-testkit-command") {
+    appendMessage({
+      role: "tool",
+      toolName: event.command?.kind || "testkit",
+      title: formatObservedCommandTitle(event.command),
+      text: formatObservedCommandText(event.command),
+      data: event.command || null,
+    });
   }
 }
 
@@ -613,34 +634,7 @@ function formatSettings(snapshot) {
 }
 
 async function executeSlashTool(slash, context) {
-  switch (slash.type) {
-    case "inspect":
-      return executeAssistantTool(
-        "read_context",
-        { file: slash.file || null, mode: "detail" },
-        context
-      );
-    case "logs":
-      return executeAssistantTool("read_context", { service: slash.service || null, mode: "logs" }, context);
-    case "artifacts":
-      return executeAssistantTool("read_context", { file: slash.file || null, mode: "artifacts" }, context);
-    case "setup":
-      return executeAssistantTool("read_context", { service: slash.service || null, mode: "setup" }, context);
-    case "file":
-      return executeAssistantTool("read_file", { path: slash.file }, context);
-    case "service":
-      return executeAssistantTool("read_context", { service: slash.service, mode: "detail" }, context);
-    case "status":
-      return executeAssistantTool("show_status", {}, context);
-    case "discover":
-      return executeAssistantTool("discover_tests", {}, context);
-    case "doctor":
-      return executeAssistantTool("run_doctor", {}, context);
-    case "run":
-      return executeAssistantTool("run_tests", slash.options, context);
-    default:
-      throw new Error(`Unsupported slash command "${slash.type}"`);
-  }
+  return executeAssistantAction(slash.type, slash, context);
 }
 
 function parseSlashCommandSafe(input) {
@@ -692,3 +686,23 @@ function serializeRunSession(session) {
     snapshot: session.getSnapshot(),
   };
 }
+
+function formatObservedCommandTitle(command) {
+  const kind = command?.kind || "command";
+  return `testkit ${kind}`;
+}
+
+function formatObservedCommandText(command) {
+  if (!command) return "Observed Testkit command.";
+  const lines = [];
+  lines.push(`$ testkit ${command.argv?.join(" ") || command.kind || ""}`.trim());
+  if (Number.isInteger(command.exitCode)) lines.push(`exit code: ${command.exitCode}`);
+  const rows = command.result?.runSession?.summaryData?.rows || command.result?.summaryRows || command.result?.runArtifact?.summaryRows || null;
+  if (Array.isArray(rows) && rows.length > 0) {
+    for (const [label, value] of rows) lines.push(`${label}: ${value}`);
+  } else if (command.kind === "run" && command.result?.runArtifact?.summary?.files) {
+    const files = command.result.runArtifact.summary.files;
+    lines.push(`Files: ${files.total || 0} total, ${files.passed || 0} passed, ${files.failed || 0} failed, ${files.skipped || 0} skipped`);
+  }
+  return lines.join("\n");
+}

package/lib/cli/commands/assistant.mjs

@@ -1,7 +1,7 @@
 import { Command, Flags } from "@oclif/core";
 import { loadManagedConfigs } from "../../app/configs.mjs";
 import { loadLatestRunArtifact, resolveFileSubject } from "../../results/artifacts.mjs";
-import { sharedFlags } from "./flags.mjs";
+import { sharedFlags } from "../command-flags.mjs";
 import { createAssistantState } from "../assistant/state.mjs";
 import { runInteractiveAssistant } from "../assistant/interactive.mjs";
 

package/lib/cli/commands/cleanup.mjs

@@ -1,5 +1,5 @@
 import { Command } from "@oclif/core";
-import { sharedFlags } from "./flags.mjs";
+import { sharedFlags } from "../command-flags.mjs";
 import { executeCleanupOperation } from "../operations/cleanup/operation.mjs";
 import { renderCleanupResult } from "../renderers/cleanup/text.mjs";
 

package/lib/cli/commands/db/snapshot/capture.mjs

@@ -1,5 +1,5 @@
 import { Command, Flags } from "@oclif/core";
-import { sharedFlags } from "../../flags.mjs";
+import { sharedFlags } from "../../../command-flags.mjs";
 import { executeDatabaseSnapshotCaptureOperation } from "../../../operations/db/snapshot/capture/operation.mjs";
 import { renderDatabaseSnapshotCaptureResult } from "../../../renderers/db-snapshot-capture/text.mjs";
 

package/lib/cli/commands/destroy.mjs

@@ -1,5 +1,5 @@
 import { Command } from "@oclif/core";
-import { sharedFlags } from "./flags.mjs";
+import { sharedFlags } from "../command-flags.mjs";
 import { executeDestroyOperation } from "../operations/destroy/operation.mjs";
 import { renderDestroyResult } from "../renderers/destroy/text.mjs";
 

package/lib/cli/commands/discover.mjs

@@ -1,7 +1,8 @@
 import { Command, Flags } from "@oclif/core";
 import { executeDiscoverOperation } from "../operations/discover/operation.mjs";
 import { renderDiscoverResult } from "../renderers/discover/text.mjs";
-import { sharedFlags } from "./flags.mjs";
+import { sharedFlags } from "../command-flags.mjs";
+import { withAssistantCommandResult } from "../assistant/command-results.mjs";
 
 export default class DiscoverCommand extends Command {
   static summary = "Discover managed tests and report their metadata";
@@ -44,15 +45,17 @@ export default class DiscoverCommand extends Command {
   };
 
   async run() {
-    const { flags } = await this.parse(DiscoverCommand);
-    const result = await executeDiscoverOperation(flags, process.cwd());
+    return withAssistantCommandResult("discover", async () => {
+      const { flags } = await this.parse(DiscoverCommand);
+      const result = await executeDiscoverOperation(flags, process.cwd());
 
-    if (!this.jsonEnabled()) {
-      for (const line of renderDiscoverResult(result, { outputMode: flags["output-mode"] })) {
-        this.log(line);
+      if (!this.jsonEnabled()) {
+        for (const line of renderDiscoverResult(result, { outputMode: flags["output-mode"] })) {
+          this.log(line);
+        }
       }
-    }
 
-    return result;
+      return result;
+    });
   }
 }

package/lib/cli/commands/doctor.mjs

@@ -1,6 +1,7 @@
 import { Command, Flags } from "@oclif/core";
 import { executeDoctorOperation } from "../operations/doctor/operation.mjs";
 import { renderDoctorResult } from "../renderers/doctor/text.mjs";
+import { withAssistantCommandResult } from "../assistant/command-results.mjs";
 
 export default class DoctorCommand extends Command {
   static summary = "Run built-in config, discovery, and hygiene checks";
@@ -19,21 +20,23 @@ export default class DoctorCommand extends Command {
   };
 
   async run() {
-    const { flags } = await this.parse(DoctorCommand);
-    const result = await executeDoctorOperation(flags);
+    return withAssistantCommandResult("doctor", async () => {
+      const { flags } = await this.parse(DoctorCommand);
+      const result = await executeDoctorOperation(flags);
 
-    if (!this.jsonEnabled()) {
-      for (const line of renderDoctorResult(result)) {
-        this.log(line);
+      if (!this.jsonEnabled()) {
+        for (const line of renderDoctorResult(result)) {
+          this.log(line);
+        }
       }
-    }
 
-    if (!result.ok) {
-      const error = new Error("testkit doctor failed");
-      error.result = result;
-      throw error;
-    }
+      if (!result.ok) {
+        const error = new Error("testkit doctor failed");
+        error.result = result;
+        throw error;
+      }
 
-    return result;
+      return result;
+    });
   }
 }

package/lib/cli/commands/run.mjs

@@ -1,7 +1,8 @@
 import { Args, Command } from "@oclif/core";
-import { runFlags } from "./flags.mjs";
+import { runFlags } from "../command-flags.mjs";
 import { buildRunRequest, executeRunRequest } from "../operations/run/operation.mjs";
 import { resolveTerminalCapabilities } from "../terminal/capabilities.mjs";
+import { withAssistantCommandResult } from "../assistant/command-results.mjs";
 
 export default class RunCommand extends Command {
   static summary = "Run test suites";
@@ -19,13 +20,15 @@ export default class RunCommand extends Command {
   static flags = runFlags;
 
   async run() {
-    const { args, flags } = await this.parse(RunCommand);
-    const request = await buildRunRequest(flags, args.type || null, process.cwd(), process.cwd());
-    return executeRunRequest(request, {
-      outputMode: flags["output-mode"] || "compact",
-      json: this.jsonEnabled(),
-      debug: flags.debug,
-      terminal: resolveTerminalCapabilities(),
+    return withAssistantCommandResult("run", async () => {
+      const { args, flags } = await this.parse(RunCommand);
+      const request = await buildRunRequest(flags, args.type || null, process.cwd(), process.cwd());
+      return executeRunRequest(request, {
+        outputMode: flags["output-mode"] || "compact",
+        json: this.jsonEnabled(),
+        debug: flags.debug,
+        terminal: resolveTerminalCapabilities(),
+      });
     });
   }
 }