thoth-agents 0.2.11 → 0.3.0

package/dist/cli/index.js

@@ -4,10 +4,10 @@ import {
   getOpenCodeVersion,
   isOpenCodeInstalled,
   opencodeAdapter
-} from "../chunk-6BNAV534.js";
+} from "../chunk-YUCGIJPP.js";
 import {
   CODEX_ROLE_NAMES,
-  RECOMMENDED_SKILLS,
+  REQUIRED_SKILLS,
   SUPPORTED_OPERATION_HARNESSES,
   applyClaudeCodePlan,
   applyClaudeCodeSetup,
@@ -38,21 +38,21 @@ import {
   getOpenCodeModelRoles,
   getOpenCodeStatus,
   getOperationHarness,
-  installRecommendedSkill,
+  getRequiredSkillInstallCommand,
+  installRequiredSkill,
   listOperationHarnesses,
   normalizeEffortSelection
-} from "../chunk-ASKXWU6E.js";
+} from "../chunk-2MZ5C2RN.js";
 import {
   ALL_AGENT_NAMES,
-  CUSTOM_SKILLS,
-  DEFAULT_MODELS,
   detectCurrentConfig,
   generateLiteConfig,
+  getDefaultOpenCodeModel,
+  getDefaultOpenCodeVariant,
   getExistingLiteConfigPath,
-  installCustomSkills,
   updateOpenCodeMainConfig,
   writeLiteConfig
-} from "../chunk-OZE7JVGS.js";
+} from "../chunk-XO74DXBZ.js";
 
 // src/cli/index.ts
 import { pathToFileURL } from "url";
@@ -72,6 +72,167 @@ function getHarnessAdapter(harness) {
 import { existsSync } from "fs";
 import { homedir } from "os";
 import { cwd } from "process";
+
+// src/cli/thoth-mem-install.ts
+import { spawnSync } from "child_process";
+var THOTH_MEM_SETUP_TIMEOUT_MS = 12e4;
+var STATUS_EXIT_CODE = {
+  complete: 0,
+  failed: 1,
+  partial: 2,
+  requires_user_action: 3
+};
+var SETUP_STATUSES = new Set(
+  Object.keys(STATUS_EXIT_CODE)
+);
+var STEP_OUTCOMES = /* @__PURE__ */ new Set([
+  "planned",
+  "skipped",
+  "confirmed",
+  "failed",
+  "unavailable"
+]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isSetupStep(value) {
+  return isRecord(value) && typeof value.name === "string" && value.name.length > 0 && typeof value.outcome === "string" && STEP_OUTCOMES.has(value.outcome);
+}
+function isProviderSetupResult(value, expectedHarness) {
+  return isRecord(value) && typeof value.status === "string" && SETUP_STATUSES.has(value.status) && typeof value.changed === "boolean" && value.harness === expectedHarness && value.scope === "global" && typeof value.target === "string" && value.target.length > 0 && Array.isArray(value.steps) && value.steps.every(isSetupStep) && isStringArray(value.diagnostics) && isStringArray(value.manual_actions) && (value.receipt === null || typeof value.receipt === "string");
+}
+function parseProviderSetupResult(stdout, expectedHarness) {
+  let value;
+  try {
+    value = JSON.parse(stdout.trim());
+  } catch {
+    return void 0;
+  }
+  return isProviderSetupResult(value, expectedHarness) ? value : void 0;
+}
+function defaultCommandExecutor(command, args, options) {
+  const result = spawnSync(command, [...args], {
+    cwd: options.cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: options.timeoutMs
+  });
+  return {
+    exitCode: result.status,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    error: result.error
+  };
+}
+function describeError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isTimeoutError(error) {
+  return isRecord(error) && error.code === "ETIMEDOUT";
+}
+function invalidResult(harness, command, args, exitCode, error) {
+  return {
+    success: false,
+    evidenceValid: false,
+    status: "invalid",
+    changed: false,
+    harness,
+    steps: [],
+    diagnostics: [],
+    manualActions: [],
+    receipt: null,
+    command,
+    args,
+    exitCode,
+    error
+  };
+}
+function getThothMemSetupCommand(harness, dryRun) {
+  return {
+    command: "npx",
+    args: [
+      "-y",
+      "thoth-mem@latest",
+      "setup",
+      harness,
+      "--scope",
+      "global",
+      ...dryRun ? ["--plan"] : [],
+      "--json"
+    ]
+  };
+}
+function runThothMemSetup(options) {
+  const { command, args } = getThothMemSetupCommand(
+    options.harness,
+    options.dryRun ?? false
+  );
+  const executor = options.commandExecutor ?? defaultCommandExecutor;
+  let commandResult;
+  try {
+    commandResult = executor(command, args, {
+      cwd: options.cwd,
+      timeoutMs: THOTH_MEM_SETUP_TIMEOUT_MS
+    });
+  } catch (error) {
+    return invalidResult(
+      options.harness,
+      command,
+      args,
+      null,
+      `Unable to launch thoth-mem setup: ${describeError(error)}`
+    );
+  }
+  if (commandResult.error) {
+    const stderr = commandResult.stderr.trim().slice(0, 2e3);
+    return invalidResult(
+      options.harness,
+      command,
+      args,
+      commandResult.exitCode,
+      isTimeoutError(commandResult.error) ? `thoth-mem setup timed out after ${THOTH_MEM_SETUP_TIMEOUT_MS} ms${stderr ? `: ${stderr}` : "."}` : `Unable to launch thoth-mem setup: ${describeError(commandResult.error)}`
+    );
+  }
+  const provider = parseProviderSetupResult(
+    commandResult.stdout,
+    options.harness
+  );
+  if (!provider) {
+    const stderr = commandResult.stderr.trim();
+    return invalidResult(
+      options.harness,
+      command,
+      args,
+      commandResult.exitCode,
+      stderr ? `thoth-mem returned invalid JSON evidence: ${stderr.slice(0, 2e3)}` : "thoth-mem returned invalid JSON evidence."
+    );
+  }
+  const expectedExitCode = STATUS_EXIT_CODE[provider.status];
+  const evidenceValid = commandResult.exitCode === expectedExitCode;
+  return {
+    success: evidenceValid && provider.status === "complete",
+    evidenceValid,
+    status: provider.status,
+    changed: provider.changed,
+    harness: provider.harness,
+    target: provider.target,
+    steps: provider.steps,
+    diagnostics: provider.diagnostics,
+    manualActions: provider.manual_actions,
+    receipt: provider.receipt,
+    command,
+    args,
+    exitCode: commandResult.exitCode,
+    ...!evidenceValid ? {
+      error: `thoth-mem exit code ${String(commandResult.exitCode)} contradicts reported status ${provider.status} (expected ${expectedExitCode}).`
+    } : {}
+  };
+}
+
+// src/cli/install.ts
 var GREEN = "\x1B[32m";
 var BLUE = "\x1B[34m";
 var YELLOW = "\x1B[33m";
@@ -106,14 +267,8 @@ function printError(message) {
 function printInfo(message) {
   console.log(`${SYMBOLS.info} ${message}`);
 }
-function formatCustomSkillReasons(report) {
-  if (report.updatedSkills.length === 0 && report.removedSkills.length === 0) {
-    return "all bundled skills already up to date";
-  }
-  return `${report.updatedSkills.length} updated, ${report.removedSkills.length} removed, ${report.skippedSkills.length} unchanged`;
-}
-function formatSkillReasons(reasons) {
-  return reasons.join(", ");
+function printWarning(message) {
+  console.log(`${SYMBOLS.warn} ${message}`);
 }
 async function checkOpenCodeInstalled() {
   const installed = await isOpenCodeInstalled();
@@ -146,29 +301,87 @@ function handleStepResult(result, successMsg) {
   );
   return true;
 }
-function formatConfigSummary() {
+function formatConfigSummary(dryRun) {
   const lines = [];
   lines.push(`${BOLD}Configuration Summary${RESET}`);
   lines.push("");
   lines.push(`  ${BOLD}Preset:${RESET} ${BLUE}openai${RESET}`);
-  lines.push(`  ${SYMBOLS.check} Seven-agent thoth-agents roster`);
+  lines.push(`  ${SYMBOLS.check} Seven-role adaptive thoth-agents roster`);
   lines.push(`  ${SYMBOLS.check} OpenAI models by default`);
-  lines.push(`  ${SYMBOLS.check} thoth-mem enabled for orchestrator memory`);
-  lines.push(`  ${SYMBOLS.check} Delegation results persisted to disk`);
-  lines.push(`  ${SYMBOLS.check} Bundled SDD skills ready for install`);
-  const seeDocs = "see docs/provider-configurations.md";
-  lines.push(`  ${DIM}\u25CB Kimi \u2014 ${seeDocs}${RESET}`);
-  lines.push(`  ${DIM}\u25CB GitHub Copilot \u2014 ${seeDocs}${RESET}`);
-  lines.push(`  ${DIM}\u25CB ZAI Coding Plan \u2014 ${seeDocs}${RESET}`);
+  lines.push(`  ${SYMBOLS.check} Direct, Accelerated, and Full SDD routing`);
+  lines.push(
+    `  ${SYMBOLS.check} ${dryRun ? "thoth-mem setup plan confirmed" : "thoth-mem setup completed through its provider-owned installer"}`
+  );
+  lines.push(
+    `  ${DIM}\u25CB thoth-mem remains the owner of hooks, MCP, skill, lifecycle, persistence, receipts, and recovery.${RESET}`
+  );
+  lines.push(`  ${SYMBOLS.check} Required external skills for this harness`);
   return lines.join("\n");
 }
-async function runInstall(config) {
+function installRequiredSkillsForHarness(harness, dryRun, homeDir = homedir()) {
+  if (dryRun) {
+    printInfo(`Dry run mode - required ${harness} skills:`);
+    for (const skill of REQUIRED_SKILLS) {
+      const { command, args } = getRequiredSkillInstallCommand(skill, harness);
+      printInfo(`  - ${skill.name}: ${command} ${args.join(" ")}`);
+    }
+    printSuccess(`Required external skills planned for ${harness}`);
+    return true;
+  }
+  let installed = 0;
+  let alreadyInstalled = 0;
+  for (const skill of REQUIRED_SKILLS) {
+    printInfo(`Installing required skill ${skill.name} for ${harness}...`);
+    const result = installRequiredSkill(skill, harness, { homeDir });
+    if (result.status === "failed") {
+      printError(`Failed to install required skill: ${skill.name}`);
+      return false;
+    }
+    if (result.status === "installed") {
+      installed += 1;
+      printSuccess(`Installed: ${skill.name}`);
+    } else {
+      alreadyInstalled += 1;
+      printInfo(`Skipped: ${skill.name} (already installed)`);
+    }
+  }
+  printSuccess(
+    `${installed} required skills installed, ${alreadyInstalled} already installed`
+  );
+  return true;
+}
+function printThothMemSetupResult(result, dryRun) {
+  printInfo(`Provider command: ${result.command} ${result.args.join(" ")}`);
+  for (const step of result.steps) {
+    printInfo(`thoth-mem: ${step.name} [${step.outcome}]`);
+  }
+  for (const diagnostic of result.diagnostics) printInfo(diagnostic);
+  if (result.receipt) printInfo(`thoth-mem receipt: ${result.receipt}`);
+  for (const action of result.manualActions) {
+    printWarning(`thoth-mem manual action: ${action}`);
+  }
+  if (!result.success) {
+    printError(`thoth-mem setup is incomplete: ${result.status}`);
+    if (result.error) printError(result.error);
+    return false;
+  }
+  printSuccess(
+    dryRun ? "thoth-mem setup plan confirmed" : "thoth-mem setup complete through its provider-owned installer"
+  );
+  return true;
+}
+function installThothMemForHarness(harness, dryRun, dependencies) {
+  const setup = dependencies.runThothMemSetup ?? runThothMemSetup;
+  return printThothMemSetupResult(
+    setup({ harness, dryRun, cwd: cwd() }),
+    dryRun
+  );
+}
+async function runInstall(config, dependencies) {
   const detected = detectCurrentConfig();
   const isUpdate = detected.isInstalled;
   printHeader(isUpdate);
-  let totalSteps = 3;
-  if (config.installSkills) totalSteps += 1;
-  if (config.installCustomSkills) totalSteps += 1;
+  const totalSteps = 5;
   let step = 1;
   printStep(step++, totalSteps, "Checking OpenCode installation...");
   if (config.dryRun) {
@@ -217,70 +430,14 @@ ${JSON.stringify(liteConfig, null, 2)}
         return 1;
     }
   }
-  if (config.installSkills) {
-    printStep(step++, totalSteps, "Installing recommended external skills...");
-    if (config.dryRun) {
-      printInfo("Dry run mode - would install skills:");
-      for (const skill of RECOMMENDED_SKILLS) {
-        printInfo(`  - ${skill.name}`);
-      }
-    } else {
-      let skillsInstalled = 0;
-      let skillsAlreadyInstalled = 0;
-      for (const skill of RECOMMENDED_SKILLS) {
-        printInfo(`Installing ${skill.name}...`);
-        const result = installRecommendedSkill(skill);
-        if (result.status === "installed") {
-          printSuccess(`Installed: ${skill.name}`);
-          skillsInstalled++;
-        } else if (result.status === "already-installed") {
-          printInfo(`Skipped: ${skill.name} (already installed)`);
-          skillsAlreadyInstalled++;
-        } else {
-          printError(`Failed to install recommended skill: ${skill.name}`);
-          return 1;
-        }
-      }
-      printSuccess(
-        `${skillsInstalled} installed, ${skillsAlreadyInstalled} already installed`
-      );
-    }
-  }
-  if (config.installCustomSkills) {
-    printStep(step++, totalSteps, "Installing bundled thoth-agents skills...");
-    if (config.dryRun) {
-      printInfo("Dry run mode - would install bundled skills:");
-      for (const skill of CUSTOM_SKILLS) {
-        printInfo(`  - ${skill.name}`);
-      }
-    } else {
-      const report = installCustomSkills();
-      for (const updatedSkill of report.updatedSkills) {
-        printSuccess(
-          `Installed: ${updatedSkill.skill.name} (${formatSkillReasons(updatedSkill.reasons)})`
-        );
-      }
-      for (const skippedSkill of report.skippedSkills) {
-        printInfo(`Up to date: ${skippedSkill.name}`);
-      }
-      for (const removedSkill of report.removedSkills) {
-        printInfo(`Removed obsolete skill: ${removedSkill}`);
-      }
-      for (const failedSkill of report.failedSkills) {
-        printError(
-          `Failed: ${failedSkill.skill.name} (${formatSkillReasons(failedSkill.reasons)})`
-        );
-      }
-      if (!report.success) {
-        return 1;
-      }
-      printSuccess(
-        `Bundled skills processed: ${formatCustomSkillReasons(report)}`
-      );
-    }
+  printStep(step++, totalSteps, "Installing required external skills...");
+  if (!installRequiredSkillsForHarness("opencode", config.dryRun)) return 1;
+  printStep(step++, totalSteps, "Configuring provider-owned thoth-mem...");
+  if (!installThothMemForHarness("opencode", config.dryRun, dependencies)) {
+    return 1;
   }
   console.log();
-  console.log(formatConfigSummary());
+  console.log(formatConfigSummary(config.dryRun));
   console.log();
   const statusMsg = isUpdate ? "thoth-agents updated!" : "thoth-agents installation complete!";
   console.log(`${SYMBOLS.star} ${BOLD}${GREEN}${statusMsg}${RESET}`);
@@ -290,32 +447,22 @@ ${JSON.stringify(liteConfig, null, 2)}
   console.log(`  1. Start OpenCode:`);
   console.log(`     ${BLUE}$ opencode${RESET}`);
   console.log();
-  const modelsInfo = "Default configuration uses OpenAI models (gpt-5.4 / gpt-5.4-mini).";
+  const modelsInfo = "Default configuration uses OpenAI models.";
   console.log(`${BOLD}${modelsInfo}${RESET}`);
   console.log(
-    `  ${DIM}Includes the seven-agent roster, thoth-mem memory defaults,${RESET}`
-  );
-  console.log(
-    `  ${DIM}native task delegation, and bundled SDD skills.${RESET}`
+    `  ${DIM}Includes the seven-role adaptive roster, native delegation, and Direct / Accelerated / Full SDD routing.${RESET}`
   );
-  const altProviders = "For alternative providers (Kimi, GitHub Copilot, ZAI Coding Plan)";
-  console.log(`${BOLD}${altProviders}, see:${RESET}`);
-  const docsUrl = "https://github.com/EremesNG/thoth-agents/blob/master/docs/provider-configurations.md";
-  console.log(`  ${BLUE}${docsUrl}${RESET}`);
-  console.log();
   return 0;
 }
 function createInstallConfig(args) {
   return {
     agent: args.agent ?? "opencode",
     hasTmux: args.tmux === "yes",
-    installSkills: args.skills === "yes",
-    installCustomSkills: true,
     dryRun: args.dryRun,
     reset: args.reset ?? false
   };
 }
-async function install(args) {
+async function install(args, dependencies = {}) {
   const config = createInstallConfig(args);
   if (config.agent === "codex") {
     const plan = buildCodexSetupPlan({
@@ -332,6 +479,10 @@ async function install(args) {
       printError(`Codex install failed: ${result.error}`);
       return 1;
     }
+    if (!installRequiredSkillsForHarness("codex", config.dryRun)) return 1;
+    if (!installThothMemForHarness("codex", config.dryRun, dependencies)) {
+      return 1;
+    }
     printSuccess(
       config.dryRun ? "Codex dry-run complete; no files written" : "Codex agent-pack setup complete"
     );
@@ -342,8 +493,7 @@ async function install(args) {
       dryRun: config.dryRun,
       reset: config.reset,
       scope: "user",
-      projectRoot: cwd(),
-      homeDir: homedir()
+      projectRoot: cwd()
     });
     console.log(formatClaudeCodeSetupPlan(plan));
     const result = applyClaudeCodeSetup(plan);
@@ -352,12 +502,16 @@ async function install(args) {
       printError(`Claude Code install failed: ${result.error}`);
       return 1;
     }
+    if (!installRequiredSkillsForHarness("claude", config.dryRun)) return 1;
+    if (!installThothMemForHarness("claude", config.dryRun, dependencies)) {
+      return 1;
+    }
     printSuccess(
-      config.dryRun ? "Claude Code dry-run complete; no files written" : "Claude Code plugin installed as thoth-agents@skills-dir (restart Claude Code or run /reload-plugins to activate)"
+      config.dryRun ? "Claude Code dry-run complete; no files written" : "Claude Code plugin installed as thoth-agents@thoth-agents through the native manager (restart Claude Code or run /reload-plugins to activate)"
     );
     return 0;
   }
-  return runInstall(config);
+  return runInstall(config, dependencies);
 }
 
 // src/cli/commands.ts
@@ -408,6 +562,12 @@ function formatHarnessStatusReport(reports) {
       `${report.displayName ?? getOperationHarness(report.harness).displayName} (${report.harness})`,
       `State: ${report.state}`,
       `Summary: ${report.summary}`,
+      ...report.providerCapability ? [
+        "Provider evidence:",
+        `Provider capability: ${report.providerCapability.state}`,
+        `Evidence source: ${report.providerCapability.source}`,
+        `Evidence basis: ${report.providerCapability.basis.length > 0 ? report.providerCapability.basis.join("; ") : "none supplied"}`
+      ] : [],
       ...report.targets.length > 0 ? ["Targets:", ...report.targets.map(formatTarget)] : [],
       ...report.diagnostics.length > 0 ? ["Warnings:", ...formatWarnings(report.diagnostics)] : [],
       ...report.disclaimers && report.disclaimers.length > 0 ? ["Disclaimers:", ...formatDisclaimers(report.disclaimers)] : [],
@@ -504,7 +664,6 @@ Commands:
 
 Options:
   --tmux=yes|no          Enable tmux integration (yes/no)
-  --skills=yes|no        Install recommended external skills
   --no-tui               Non-interactive mode
   --dry-run              Simulate install without writing files
   --reset                Repair managed installer-owned targets
@@ -526,14 +685,14 @@ OpenCode loads the plugin with config such as:
 That plugin entry does not create a global thoth-agents command.
 Run this CLI through a global install, npx, or pnpm dlx.
 
-OpenCode install configures the seven-agent roster, thoth-mem defaults,
-native task delegation, and bundled SDD skills for OpenCode.
+OpenCode install configures the adaptive seven-role roster and native task delegation.
+Provider capability is external and reported only from caller-supplied evidence.
 
-Bundled thoth-agents skills are always installed.
-Use --skills=no to skip only recommended external skills.
+External required skills are installed for every harness:
+  simplify, tdd, progressive-context-router, and architectural-grilling.
+Their installation is mandatory and cannot be skipped.
 
-The generated config uses OpenAI by default.
-For alternative providers, see docs/provider-configurations.md.
+The generated OpenCode config supports the built-in OpenAI preset only.
 
 Examples:
   thoth-agents
@@ -544,7 +703,7 @@ Examples:
   pnpm dlx thoth-agents@latest install --agent=codex --dry-run
   pnpm dlx thoth-agents@latest install --agent=claude
   pnpm dlx thoth-agents@latest install --agent=claude --dry-run
-  pnpm dlx thoth-agents install --no-tui --tmux=no --skills=yes
+  pnpm dlx thoth-agents install --no-tui --tmux=no
   pnpm dlx thoth-agents install --dry-run
   pnpm dlx thoth-agents install --reset
   pnpm dlx thoth-agents generate --harness=codex --dry-run
@@ -589,7 +748,8 @@ function defaultModelRoles(harness) {
   }
   return ALL_AGENT_NAMES.map((role) => ({
     role,
-    model: DEFAULT_MODELS[role] ?? "openai/gpt-5.4"
+    model: getDefaultOpenCodeModel(role),
+    effort: { kind: "effort", value: getDefaultOpenCodeVariant(role) }
   }));
 }
 function resolveCliModelRoles(harness, roles, resolution) {
@@ -891,8 +1051,6 @@ function parseInstallArgs(args) {
       result.tui = false;
     } else if (arg.startsWith("--tmux=")) {
       result.tmux = parseBooleanArg("--tmux", arg.split("=")[1] ?? "");
-    } else if (arg.startsWith("--skills=")) {
-      result.skills = parseBooleanArg("--skills", arg.split("=")[1] ?? "");
     } else if (arg === "--dry-run") {
       result.dryRun = true;
     } else if (arg === "--reset") {
@@ -907,6 +1065,8 @@ function parseInstallArgs(args) {
       result.agent = agent;
     } else if (arg === "-h" || arg === "--help") {
       throw new Error("help");
+    } else {
+      throw new Error(`Unsupported install option: ${arg}`);
     }
   }
   return result;

package/dist/cli/install.d.ts

@@ -1,3 +1,7 @@
+import { type ThothMemSetupOptions, type ThothMemSetupResult } from './thoth-mem-install';
 import type { InstallArgs, InstallConfig } from './types';
+export interface InstallDependencies {
+    runThothMemSetup?: (options: ThothMemSetupOptions) => ThothMemSetupResult;
+}
 export declare function createInstallConfig(args: InstallArgs): InstallConfig;
-export declare function install(args: InstallArgs): Promise<number>;
+export declare function install(args: InstallArgs, dependencies?: InstallDependencies): Promise<number>;

package/dist/cli/model-catalog/cache.d.ts

@@ -11,8 +11,8 @@ export declare const modelsDevCacheSchema: z.ZodObject<{
             provider: z.ZodString;
             efforts: z.ZodArray<z.ZodString>;
             source: z.ZodEnum<{
-                manual: "manual";
                 remote: "remote";
+                manual: "manual";
                 lkg: "lkg";
             }>;
         }, z.core.$loose>>;

package/dist/cli/operations/claude-code.d.ts

@@ -1,9 +1,12 @@
+import type { ProviderEvidenceInput } from '../../harness/types';
+import { type ClaudeCommandExecutor } from '../claude-code-install';
 import type { ClaudeCodeInstallScope } from '../claude-code-paths';
 import type { HarnessAction, HarnessStatusReport, ModelConfigInput, ModelRoleInput, OperationApplyResult, OperationContext, OperationPlan } from './types';
 export interface ClaudeCodeOperationContext extends OperationContext {
     scope?: ClaudeCodeInstallScope;
     homeDir?: string;
     packageRoot?: string;
+    commandExecutor?: ClaudeCommandExecutor;
 }
 export type ClaudeCodeEffortResolution = {
     ok: true;
@@ -18,13 +21,13 @@ export declare const claudeCodeOperationAdapter: {
     readonly id: "claude";
     readonly displayName: "Claude Code";
     readonly available: true;
-    readonly description: "Claude Code plugin package and managed subagent surfaces.";
+    readonly description: "Native Claude Code marketplace plugin and required skills.";
     readonly actions: HarnessAction[];
 };
-export declare function getClaudeCodeStatus(context?: ClaudeCodeOperationContext): HarnessStatusReport;
+export declare function getClaudeCodeStatus(context?: ClaudeCodeOperationContext, evidence?: ProviderEvidenceInput): HarnessStatusReport;
 export declare function buildClaudeCodeInstallPlan(context?: ClaudeCodeOperationContext): OperationPlan;
 export declare function buildClaudeCodeUpdatePlan(context?: ClaudeCodeOperationContext): OperationPlan;
 export declare function buildClaudeCodeSyncPlan(context?: ClaudeCodeOperationContext): OperationPlan;
-export declare function buildClaudeCodeModelPlan(input: ModelConfigInput, context?: ClaudeCodeOperationContext): OperationPlan;
+export declare function buildClaudeCodeModelPlan(input: ModelConfigInput, _context?: ClaudeCodeOperationContext): OperationPlan;
 export declare function applyClaudeCodePlan(plan: OperationPlan): OperationApplyResult;
 export declare function defaultClaudeCodeModelRoles(): ModelRoleInput[];

package/dist/cli/operations/codex.d.ts

@@ -1,3 +1,4 @@
+import type { ProviderEvidenceInput } from '../../harness/types';
 import type { CodexInstallScope } from '../codex-paths';
 import type { HarnessAction, HarnessStatusReport, ModelConfigInput, ModelRoleInput, OperationApplyResult, OperationContext, OperationPlan } from './types';
 export interface CodexOperationContext extends OperationContext {
@@ -14,7 +15,7 @@ export declare const codexOperationAdapter: {
     readonly description: "Codex agent-pack and managed subagent surfaces.";
     readonly actions: HarnessAction[];
 };
-export declare function getCodexStatus(context?: CodexOperationContext): HarnessStatusReport;
+export declare function getCodexStatus(context?: CodexOperationContext, evidence?: ProviderEvidenceInput): HarnessStatusReport;
 export declare function buildCodexUpdatePlan(context?: CodexOperationContext): OperationPlan;
 export declare function buildCodexSyncPlan(context?: CodexOperationContext): OperationPlan;
 export declare function buildCodexInstallPlan(context?: CodexOperationContext): OperationPlan;

package/dist/cli/operations/opencode.d.ts

@@ -1,3 +1,4 @@
+import type { ProviderEvidenceInput } from '../../harness/types';
 import type { HarnessAction, HarnessStatusReport, ModelConfigInput, OperationApplyResult, OperationContext, OperationPlan } from './types';
 export declare const opencodeOperationAdapter: {
     readonly id: "opencode";
@@ -6,7 +7,7 @@ export declare const opencodeOperationAdapter: {
     readonly description: "OpenCode plugin and configuration surfaces.";
     readonly actions: HarnessAction[];
 };
-export declare function getOpenCodeStatus(context?: OperationContext): HarnessStatusReport;
+export declare function getOpenCodeStatus(context?: OperationContext, evidence?: ProviderEvidenceInput): HarnessStatusReport;
 export declare function buildOpenCodeUpdatePlan(_context?: OperationContext): OperationPlan;
 export declare function buildOpenCodeSyncPlan(_context?: OperationContext): OperationPlan;
 export declare function buildOpenCodeInstallPlan(_context?: OperationContext): OperationPlan;

package/dist/cli/operations/types.d.ts

@@ -1,4 +1,4 @@
-import type { HarnessId } from '../../harness/types';
+import type { HarnessId, ProviderCapabilityEvidence, ProviderEvidenceInput } from '../../harness/types';
 import type { EffortSelection } from '../model-effort';
 export type ManagedState = 'installed' | 'missing' | 'drift' | 'outdated' | 'unknown';
 export type OperationActionKind = 'status' | 'list' | 'install' | 'update' | 'sync' | 'repair' | 'model-config';
@@ -53,8 +53,16 @@ export interface HarnessStatusReport {
     targets: ManagedTarget[];
     diagnostics: OperationWarning[];
     actions: HarnessAction[];
+    /** Ephemeral provider evidence, kept separate from consumer-managed state. */
+    providerCapability?: ProviderCapabilityEvidence;
     disclaimers?: OperationDisclaimer[];
 }
+/**
+ * Classifies only evidence explicitly supplied by the caller. This function is
+ * intentionally pure: it performs no discovery, probing, persistence, setup,
+ * health checking, acquisition, migration, or fallback.
+ */
+export declare function classifyProviderCapabilityEvidence(input?: ProviderEvidenceInput): ProviderCapabilityEvidence;
 export type BackupStrategy = 'none' | 'managed-backup-file' | 'existing-helper' | 'external';
 export interface BackupExpectation {
     required: boolean;

package/dist/cli/package-root.d.ts

@@ -0,0 +1 @@
+export declare function findPackageRoot(startDir: string): string | null;