thoth-agents 0.3.7 → 0.3.9

package/dist/cli/install-completion.d.ts

@@ -0,0 +1,34 @@
+import { type InstallHarnessId, type InstallLedgerOptions, type RecordCompletedInstallResult, recordCompletedInstall } from './install-ledger';
+import { type ThothMemSetupOptions, type ThothMemSetupResult } from './thoth-mem-install';
+export type InstallCompletionLedgerResult = {
+    status: 'planned';
+    path: string;
+} | {
+    status: 'not-attempted';
+    path: string;
+} | {
+    status: 'recorded';
+    path: string;
+    repairedInvalidState: boolean;
+    backupPath?: string;
+} | {
+    status: 'failed';
+    path: string;
+    error: string;
+};
+export interface HarnessInstallCompletionResult {
+    success: boolean;
+    provider: ThothMemSetupResult;
+    ledger: InstallCompletionLedgerResult;
+    error?: string;
+}
+export interface FinalizeHarnessInstallOptions {
+    harness: InstallHarnessId;
+    version: string;
+    dryRun?: boolean;
+    cwd: string;
+    runThothMemSetup?: (options: ThothMemSetupOptions) => ThothMemSetupResult;
+    recordCompletedInstall?: (options: Parameters<typeof recordCompletedInstall>[0]) => RecordCompletedInstallResult;
+    ledgerOptions?: InstallLedgerOptions;
+}
+export declare function finalizeHarnessInstall(options: FinalizeHarnessInstallOptions): HarnessInstallCompletionResult;

package/dist/cli/install-ledger.d.ts

@@ -0,0 +1,44 @@
+export declare const INSTALL_LEDGER_SCHEMA_VERSION: 1;
+export type InstallHarnessId = 'opencode' | 'codex' | 'claude';
+export interface InstallLedger {
+    schemaVersion: typeof INSTALL_LEDGER_SCHEMA_VERSION;
+    harnesses: Partial<Record<InstallHarnessId, {
+        version: string;
+    }>>;
+}
+export interface InstallLedgerOptions {
+    configRoot?: string;
+    env?: Readonly<Record<string, string | undefined>>;
+    homeDir?: string;
+    renameFile?: (source: string, destination: string) => void;
+}
+export type InstallLedgerReadResult = {
+    status: 'missing';
+    path: string;
+} | {
+    status: 'valid';
+    path: string;
+    ledger: InstallLedger;
+} | {
+    status: 'invalid';
+    path: string;
+    error: string;
+};
+export type RecordCompletedInstallResult = {
+    success: true;
+    path: string;
+    ledger: InstallLedger;
+    repairedInvalidState: boolean;
+    backupPath?: string;
+} | {
+    success: false;
+    path: string;
+    error: string;
+};
+export interface RecordCompletedInstallOptions extends InstallLedgerOptions {
+    harness: InstallHarnessId;
+    version: string;
+}
+export declare function getInstallLedgerPath(options?: InstallLedgerOptions): string;
+export declare function readInstallLedger(options?: InstallLedgerOptions): InstallLedgerReadResult;
+export declare function recordCompletedInstall(options: RecordCompletedInstallOptions): RecordCompletedInstallResult;

package/dist/cli/install.d.ts

@@ -1,9 +1,17 @@
-import { type ThothMemSetupOptions, type ThothMemSetupResult } from './thoth-mem-install';
+import { updateOpenCodeMainConfig } from './config-manager';
+import { finalizeHarnessInstall } from './install-completion';
+import type { InstallLedgerOptions } from './install-ledger';
+import { type ExecutingPackageVersionResult } from './package-version';
+import type { ThothMemSetupOptions, ThothMemSetupResult } from './thoth-mem-install';
 import type { InstallArgs, InstallConfig } from './types';
 export interface InstallDependencies {
     homeDir?: string;
     opencodeOwnedSkillPackageRoot?: string;
     runThothMemSetup?: (options: ThothMemSetupOptions) => ThothMemSetupResult;
+    resolveExecutingPackageVersion?: () => ExecutingPackageVersionResult;
+    updateOpenCodeMainConfig?: typeof updateOpenCodeMainConfig;
+    finalizeHarnessInstall?: typeof finalizeHarnessInstall;
+    installLedgerOptions?: InstallLedgerOptions;
 }
 export declare function createInstallConfig(args: InstallArgs): InstallConfig;
 export declare function install(args: InstallArgs, dependencies?: InstallDependencies): Promise<number>;

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

@@ -1,12 +1,23 @@
 import type { ProviderEvidenceInput } from '../../harness/types';
-import { type ClaudeCommandExecutor } from '../claude-code-install';
+import { applyClaudeCodeSetup, buildClaudeCodeSetupPlan, type ClaudeCommandExecutor } from '../claude-code-install';
 import type { ClaudeCodeInstallScope } from '../claude-code-paths';
+import { type FinalizeHarnessInstallOptions, finalizeHarnessInstall } from '../install-completion';
+import { type InstallLedgerOptions } from '../install-ledger';
+import { type ExecutingPackageVersionResult } from '../package-version';
+import { installRequiredSkill } from '../skills';
 import type { HarnessAction, HarnessStatusReport, ModelConfigInput, ModelRoleInput, OperationApplyResult, OperationContext, OperationPlan } from './types';
 export interface ClaudeCodeOperationContext extends OperationContext {
     scope?: ClaudeCodeInstallScope;
     homeDir?: string;
     packageRoot?: string;
     commandExecutor?: ClaudeCommandExecutor;
+    resolveExecutingPackageVersion?: () => ExecutingPackageVersionResult;
+    buildClaudeCodeSetupPlan?: typeof buildClaudeCodeSetupPlan;
+    applyClaudeCodeSetup?: typeof applyClaudeCodeSetup;
+    installRequiredSkill?: typeof installRequiredSkill;
+    finalizeHarnessInstall?: (options: FinalizeHarnessInstallOptions) => ReturnType<typeof finalizeHarnessInstall>;
+    runThothMemSetup?: FinalizeHarnessInstallOptions['runThothMemSetup'];
+    installLedgerOptions?: InstallLedgerOptions;
 }
 export type ClaudeCodeEffortResolution = {
     ok: true;

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

@@ -1,5 +1,11 @@
 import type { ProviderEvidenceInput } from '../../harness/types';
+import { applyCodexSetup, buildCodexSetupPlan } from '../codex-install';
 import type { CodexInstallScope } from '../codex-paths';
+import { applyCodexPluginSetup, buildCodexPluginSetupPlan, type CodexCommandExecutor } from '../codex-plugin-install';
+import { type FinalizeHarnessInstallOptions, finalizeHarnessInstall } from '../install-completion';
+import { type InstallLedgerOptions } from '../install-ledger';
+import { type ExecutingPackageVersionResult } from '../package-version';
+import { installRequiredSkill } from '../skills';
 import type { HarnessAction, HarnessStatusReport, ModelConfigInput, ModelRoleInput, OperationApplyResult, OperationContext, OperationPlan } from './types';
 export interface CodexOperationContext extends OperationContext {
     scope?: CodexInstallScope;
@@ -7,6 +13,16 @@ export interface CodexOperationContext extends OperationContext {
     codexHome?: string;
     packageRoot?: string;
     pluginId?: string;
+    resolveExecutingPackageVersion?: () => ExecutingPackageVersionResult;
+    codexPluginCommandExecutor?: CodexCommandExecutor;
+    buildCodexPluginSetupPlan?: typeof buildCodexPluginSetupPlan;
+    applyCodexPluginSetup?: typeof applyCodexPluginSetup;
+    buildCodexSetupPlan?: typeof buildCodexSetupPlan;
+    applyCodexSetup?: typeof applyCodexSetup;
+    installRequiredSkill?: typeof installRequiredSkill;
+    finalizeHarnessInstall?: (options: FinalizeHarnessInstallOptions) => ReturnType<typeof finalizeHarnessInstall>;
+    runThothMemSetup?: FinalizeHarnessInstallOptions['runThothMemSetup'];
+    installLedgerOptions?: InstallLedgerOptions;
 }
 export declare const codexOperationAdapter: {
     readonly id: "codex";

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

@@ -1,5 +1,22 @@
 import type { ProviderEvidenceInput } from '../../harness/types';
+import { type OpenCodeMainConfigUpdate, writeLiteConfig } from '../config-io';
+import { type FinalizeHarnessInstallOptions, finalizeHarnessInstall } from '../install-completion';
+import { type InstallLedgerOptions } from '../install-ledger';
+import { type OpenCodeOwnedSkillSyncOptions, type OpenCodeOwnedSkillSyncResult } from '../owned-skills';
+import { type ExecutingPackageVersionResult } from '../package-version';
+import { installRequiredSkill } from '../skills';
+import type { ConfigMergeResult } from '../types';
 import type { HarnessAction, HarnessStatusReport, ModelConfigInput, OperationApplyResult, OperationContext, OperationPlan } from './types';
+export interface OpenCodeOperationContext extends OperationContext {
+    resolveExecutingPackageVersion?: () => ExecutingPackageVersionResult;
+    updateOpenCodeMainConfig?: (update: OpenCodeMainConfigUpdate) => ConfigMergeResult;
+    writeLiteConfig?: typeof writeLiteConfig;
+    syncOpenCodeOwnedSkills?: (options: OpenCodeOwnedSkillSyncOptions) => OpenCodeOwnedSkillSyncResult;
+    installRequiredSkill?: typeof installRequiredSkill;
+    finalizeHarnessInstall?: (options: FinalizeHarnessInstallOptions) => ReturnType<typeof finalizeHarnessInstall>;
+    runThothMemSetup?: FinalizeHarnessInstallOptions['runThothMemSetup'];
+    installLedgerOptions?: InstallLedgerOptions;
+}
 export declare const opencodeOperationAdapter: {
     readonly id: "opencode";
     readonly displayName: "OpenCode";
@@ -8,8 +25,8 @@ export declare const opencodeOperationAdapter: {
     readonly actions: HarnessAction[];
 };
 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;
+export declare function buildOpenCodeUpdatePlan(context?: OpenCodeOperationContext): OperationPlan;
+export declare function buildOpenCodeSyncPlan(context?: OpenCodeOperationContext): OperationPlan;
+export declare function buildOpenCodeInstallPlan(context?: OpenCodeOperationContext): OperationPlan;
 export declare function buildOpenCodeModelPlan(input: ModelConfigInput, _context?: OperationContext): OperationPlan;
 export declare function applyOpenCodePlan(plan: OperationPlan): OperationApplyResult;

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

@@ -1,4 +1,6 @@
 import type { HarnessId, ProviderCapabilityEvidence, ProviderEvidenceInput } from '../../harness/types';
+import type { HarnessInstallCompletionResult } from '../install-completion';
+import { type InstallHarnessId } from '../install-ledger';
 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';
@@ -26,6 +28,17 @@ export interface ManagedTarget {
     observed?: string;
     description?: string;
 }
+export declare function getInstallCompletionEvidence(completion: HarnessInstallCompletionResult, options: {
+    codePrefix: string;
+    version: string;
+    fallbackError: string;
+}): {
+    targets: ManagedTarget[];
+    warnings: OperationWarning[];
+};
+export declare function getCliManagedInstallVersionTarget(harness: InstallHarnessId, context?: Pick<OperationContext, 'env'> & {
+    homeDir?: string;
+}): ManagedTarget;
 export interface ManagedSurface {
     id: string;
     label: string;

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

@@ -0,0 +1,19 @@
+export type PackageVersionErrorCode = 'package-root-not-found' | 'package-metadata-unreadable' | 'package-metadata-malformed' | 'package-name-mismatch' | 'package-version-invalid';
+export interface PackageVersionError {
+    code: PackageVersionErrorCode;
+    message: string;
+    packageJsonPath?: string;
+}
+export type ExecutingPackageVersionResult = {
+    ok: true;
+    version: string;
+    packageRoot: string;
+} | {
+    ok: false;
+    error: PackageVersionError;
+};
+export interface ResolveExecutingPackageVersionOptions {
+    moduleUrl?: string | URL;
+}
+export declare function isValidPackageVersion(version: unknown): version is string;
+export declare function resolveExecutingPackageVersion(options?: ResolveExecutingPackageVersionOptions): ExecutingPackageVersionResult;

package/dist/cli/tui/index.js

@@ -2,8 +2,8 @@ import {
   defaultTuiOperations,
   effortChoicesForModel,
   listOperationHarnesses
-} from "../../chunk-HIXSRHEG.js";
-import "../../chunk-F2K4CS5J.js";
+} from "../../chunk-XEEYNMPC.js";
+import "../../chunk-2TLT6WWY.js";
 
 // src/cli/tui/index.tsx
 import { render } from "ink";
@@ -309,6 +309,7 @@ function countByState(report) {
   );
 }
 var categoryOrder = [
+  "CLI-managed version",
   "Agents",
   "Skills",
   "Plugin/MCP",
@@ -345,6 +346,20 @@ function categorizeTarget(target) {
   const detail = target.state !== "installed" ? target.observed : void 0;
   const agent = path.match(/thoth-agents-([a-z0-9_-]+)\.toml$/i);
   const skill = path.match(/skills\/([^/]+)\/SKILL\.md$/i);
+  if (/CLI-managed install version/i.test(label)) {
+    const executing = target.expected?.replace(/^executing\s+/i, "") ?? "unknown";
+    const recorded = target.observed?.replace(/^recorded\s+/i, "") ?? "unknown";
+    return {
+      category: "CLI-managed version",
+      label: "Last complete install",
+      state: target.state,
+      detail: `Executing: ${executing} \xB7 Recorded: ${recorded}`,
+      notes: [
+        "Recorded is the last complete CLI-managed version.",
+        "Codex/Claude native marketplace versions are independent."
+      ]
+    };
+  }
   if (agent?.[1]) {
     return {
       category: "Agents",
@@ -483,19 +498,32 @@ function StatusView({
       const hidden = targets.length - visible.length;
       return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", children: [
         /* @__PURE__ */ jsx6(Text6, { color: theme.accent, children: category }),
-        visible.map((target) => /* @__PURE__ */ jsxs5(Text6, { children: [
-          "- ",
-          target.label,
-          target.state ? /* @__PURE__ */ jsxs5(Text6, { color: stateColor(target.state), children: [
-            ": [",
-            target.state,
-            "]"
-          ] }) : null,
-          target.detail ? /* @__PURE__ */ jsxs5(Text6, { color: theme.dim, children: [
-            " - ",
-            target.detail
-          ] }) : null
-        ] }, `${category}-${target.label}-${target.state}`)),
+        visible.map((target) => /* @__PURE__ */ jsxs5(
+          Box6,
+          {
+            flexDirection: "column",
+            children: [
+              /* @__PURE__ */ jsxs5(Text6, { children: [
+                "- ",
+                target.label,
+                target.state ? /* @__PURE__ */ jsxs5(Text6, { color: stateColor(target.state), children: [
+                  ": [",
+                  target.state,
+                  "]"
+                ] }) : null,
+                target.detail ? /* @__PURE__ */ jsxs5(Text6, { color: theme.dim, children: [
+                  " - ",
+                  target.detail
+                ] }) : null
+              ] }),
+              target.notes?.map((note) => /* @__PURE__ */ jsxs5(Text6, { color: theme.dim, children: [
+                " ",
+                note
+              ] }, note))
+            ]
+          },
+          `${category}-${target.label}-${target.state}`
+        )),
         hidden > 0 ? /* @__PURE__ */ jsxs5(Text6, { color: theme.dim, children: [
           " +",
           hidden,
@@ -555,6 +583,8 @@ function PlanPreview({
 }) {
   const blockerTargets = plan.blockerTargets ?? [];
   const providerEvidence = providerEvidenceFor(result ?? plan);
+  const completeOperation = plan.action === "update" ? "refresh" : plan.action === "install" ? "install" : void 0;
+  const applyLabel = completeOperation ? `Apply complete ${completeOperation}` : "Apply";
   return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", children: [
     /* @__PURE__ */ jsx7(Text7, { bold: true, children: plan.title }),
     /* @__PURE__ */ jsx7(Text7, { children: plan.summary }),
@@ -571,6 +601,14 @@ function PlanPreview({
       "Can apply: ",
       plan.canApply ? "yes" : "no"
     ] }),
+    completeOperation ? /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs6(Text7, { color: theme.accent, children: [
+        "Complete CLI-managed ",
+        completeOperation
+      ] }),
+      /* @__PURE__ */ jsx7(Text7, { color: theme.dim, children: "The selected harness changes only after explicit confirmation." }),
+      /* @__PURE__ */ jsx7(Text7, { color: theme.dim, children: "Codex and Claude native marketplace versions remain independent." })
+    ] }) : null,
     providerEvidence ? /* @__PURE__ */ jsx7(ProviderCapabilityView, { evidence: providerEvidence }) : null,
     !plan.canApply && blockerTargets.length > 0 ? /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", children: [
       /* @__PURE__ */ jsx7(Text7, { color: theme.warning, children: "Blocker targets" }),
@@ -624,16 +662,17 @@ function PlanPreview({
       disclaimer.message
     ] }, disclaimer.code ?? disclaimer.message)),
     /* @__PURE__ */ jsxs6(Box7, { marginTop: 1, children: [
-      /* @__PURE__ */ jsx7(Text7, { color: selectedAction === "apply" ? theme.accent : void 0, children: "[Apply]" }),
+      /* @__PURE__ */ jsxs6(Text7, { color: selectedAction === "apply" ? theme.accent : void 0, children: [
+        "[",
+        applyLabel,
+        "]"
+      ] }),
       /* @__PURE__ */ jsx7(Text7, { children: " " }),
       /* @__PURE__ */ jsx7(Text7, { color: selectedAction === "cancel" ? theme.accent : void 0, children: "[Cancel]" })
     ] }),
     /* @__PURE__ */ jsx7(Text7, { color: theme.dim, children: "Enter selects. a applies. c cancels." }),
     result ? /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxs6(Text7, { color: result.applied ? theme.ok : theme.warning, children: [
-        "Consumer result: ",
-        result.summary
-      ] }),
+      /* @__PURE__ */ jsx7(Text7, { color: result.applied ? theme.ok : theme.warning, children: completeOperation ? `Complete CLI ${completeOperation} result: ${result.applied ? "completed" : "failed"} \u2014 ${result.summary}` : `Consumer result: ${result.summary}` }),
       !result.applied && ((result.diagnosticTargets?.length ?? 0) > 0 || result.warnings.length > 0) ? /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", children: [
         /* @__PURE__ */ jsx7(Text7, { color: theme.warning, children: "Apply diagnostics" }),
         result.diagnosticTargets?.map((target, index) => /* @__PURE__ */ jsxs6(
@@ -681,7 +720,7 @@ var rootItems = [
     id: "sync",
     action: "sync",
     label: "Sync / Update",
-    detail: "Preview managed setup changes"
+    detail: "Preview sync or a complete CLI-managed refresh"
   },
   {
     id: "exit",
@@ -695,7 +734,7 @@ var actionItems = [
     id: "update",
     action: "update",
     label: "Update",
-    detail: "Refresh managed plugin/setup entries"
+    detail: "Preview a complete CLI-managed refresh"
   },
   {
     id: "sync",
@@ -710,7 +749,7 @@ var installManageItems = [
     id: "install",
     action: "install",
     label: "Install",
-    detail: "Preview managed setup install"
+    detail: "Preview the complete CLI-managed install"
   },
   { id: "back", action: "back", label: "Back", detail: "Choose harness" }
 ];
@@ -725,7 +764,7 @@ var manageItems = [
     id: "update",
     action: "update",
     label: "Update preview",
-    detail: "Preview managed plugin/setup refresh"
+    detail: "Preview a complete CLI-managed refresh"
   },
   {
     id: "sync",

package/dist/hooks/auto-update-checker/checker.d.ts

@@ -17,11 +17,6 @@ export declare function findPluginEntry(directory: string): PluginEntryInfo | nu
  * Resolves the installed version from node_modules, with memoization.
  */
 export declare function getCachedVersion(): string | null;
-/**
- * Safely updates a pinned version in the configuration file.
- * It attempts to replace the exact plugin string to preserve comments and formatting.
- */
-export declare function updatePinnedVersion(configPath: string, oldEntry: string, newVersion: string): boolean;
 /**
  * Fetches the latest version for a specific channel from the NPM registry.
  */

package/dist/hooks/auto-update-checker/index.d.ts

@@ -4,10 +4,9 @@ import type { AutoUpdateCheckerOptions } from './types';
  * Creates an OpenCode hook that checks for plugin updates when a new session is created.
  * @param ctx The plugin input context.
  * @param options Configuration options for the update checker.
- * @param shell The shell instance for running commands.
  * @returns A hook object for the session.created event.
  */
-export declare function createAutoUpdateCheckerHook(ctx: PluginInput, options: AutoUpdateCheckerOptions | undefined, shell: PluginInput['$']): {
+export declare function createAutoUpdateCheckerHook(ctx: PluginInput, options?: AutoUpdateCheckerOptions): {
     event: ({ event }: {
         event: {
             type: string;

package/dist/hooks/auto-update-checker/types.d.ts

@@ -13,7 +13,6 @@ export interface PackageJson {
 }
 export interface AutoUpdateCheckerOptions {
     showStartupToast?: boolean;
-    autoUpdate?: boolean;
 }
 export interface PluginEntryInfo {
     entry: string;