thoth-agents 0.3.8 → 0.3.10

package/dist/{chunk-F2K4CS5J.js → chunk-M2WF46BP.js}

@@ -5,20 +5,135 @@ import * as path from "path";
 // src/cli/config-io.ts
 import {
   copyFileSync,
-  existsSync as existsSync2,
-  readFileSync,
+  existsSync as existsSync3,
+  readFileSync as readFileSync2,
   renameSync,
   statSync,
   writeFileSync
 } from "fs";
 
+// src/cli/package-version.ts
+import { readFileSync } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+import { fileURLToPath } from "url";
+
+// src/cli/package-root.ts
+import { existsSync } from "fs";
+import { dirname, join, parse } from "path";
+function findPackageRoot(startDir) {
+  let currentDir = startDir;
+  const filesystemRoot = parse(startDir).root;
+  while (true) {
+    if (existsSync(join(currentDir, "package.json"))) {
+      return currentDir;
+    }
+    if (currentDir === filesystemRoot) {
+      return null;
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+
+// src/cli/package-version.ts
+var EXPECTED_PACKAGE_NAME = "thoth-agents";
+var SEMVER_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/;
+function isValidPackageVersion(version) {
+  return typeof version === "string" && SEMVER_PATTERN.test(version);
+}
+function resolveExecutingPackageVersion(options = {}) {
+  const moduleUrl = options.moduleUrl ?? import.meta.url;
+  const packageRoot = findPackageRoot(dirname2(fileURLToPath(moduleUrl)));
+  if (!packageRoot) {
+    return {
+      ok: false,
+      error: {
+        code: "package-root-not-found",
+        message: "Could not locate the executing thoth-agents package root."
+      }
+    };
+  }
+  const packageJsonPath = join2(packageRoot, "package.json");
+  let serializedMetadata;
+  try {
+    serializedMetadata = readFileSync(packageJsonPath, "utf8");
+  } catch (error) {
+    return {
+      ok: false,
+      error: {
+        code: "package-metadata-unreadable",
+        message: `Could not read executing package metadata: ${error}`,
+        packageJsonPath
+      }
+    };
+  }
+  let metadata;
+  try {
+    metadata = JSON.parse(serializedMetadata);
+  } catch (error) {
+    return {
+      ok: false,
+      error: {
+        code: "package-metadata-malformed",
+        message: `Could not parse executing package metadata: ${error}`,
+        packageJsonPath
+      }
+    };
+  }
+  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
+    return {
+      ok: false,
+      error: {
+        code: "package-metadata-malformed",
+        message: "Executing package metadata must be a JSON object.",
+        packageJsonPath
+      }
+    };
+  }
+  const { name, version } = metadata;
+  if (typeof name !== "string" || name.length === 0) {
+    return {
+      ok: false,
+      error: {
+        code: "package-metadata-malformed",
+        message: "Executing package metadata has no valid package name.",
+        packageJsonPath
+      }
+    };
+  }
+  if (name !== EXPECTED_PACKAGE_NAME) {
+    return {
+      ok: false,
+      error: {
+        code: "package-name-mismatch",
+        message: `Expected package ${EXPECTED_PACKAGE_NAME}, received ${name}.`,
+        packageJsonPath
+      }
+    };
+  }
+  if (!isValidPackageVersion(version)) {
+    return {
+      ok: false,
+      error: {
+        code: "package-version-invalid",
+        message: "Executing package metadata has no valid semantic version.",
+        packageJsonPath
+      }
+    };
+  }
+  return { ok: true, version, packageRoot };
+}
+
 // src/cli/paths.ts
-import { existsSync, mkdirSync } from "fs";
+import { existsSync as existsSync2, mkdirSync } from "fs";
 import { homedir } from "os";
-import { dirname, join } from "path";
+import { dirname as dirname3, join as join3 } from "path";
 function getDefaultOpenCodeConfigDir() {
-  const userConfigDir = process.env.XDG_CONFIG_HOME ? process.env.XDG_CONFIG_HOME : join(homedir(), ".config");
-  return join(userConfigDir, "opencode");
+  const userConfigDir = process.env.XDG_CONFIG_HOME ? process.env.XDG_CONFIG_HOME : join3(homedir(), ".config");
+  return join3(userConfigDir, "opencode");
 }
 function getCustomOpenCodeConfigDir() {
   const configDir = process.env.OPENCODE_CONFIG_DIR?.trim();
@@ -33,7 +148,7 @@ function getConfigDir() {
 }
 function getOpenCodeConfigPaths() {
   const configDir = getDefaultOpenCodeConfigDir();
-  return [join(configDir, "opencode.json"), join(configDir, "opencode.jsonc")];
+  return [join3(configDir, "opencode.json"), join3(configDir, "opencode.jsonc")];
 }
 function getConfigJson() {
   return getOpenCodeConfigPaths()[0];
@@ -42,37 +157,37 @@ function getConfigJsonc() {
   return getOpenCodeConfigPaths()[1];
 }
 function getLiteConfig() {
-  return join(getConfigDir(), "thoth-agents.json");
+  return join3(getConfigDir(), "thoth-agents.json");
 }
 function getLiteConfigJsonc() {
-  return join(getConfigDir(), "thoth-agents.jsonc");
+  return join3(getConfigDir(), "thoth-agents.jsonc");
 }
 function getOpenCodeManagedModelStatePath() {
-  return join(getConfigDir(), ".thoth-agents-managed-models.json");
+  return join3(getConfigDir(), ".thoth-agents-managed-models.json");
 }
 function getExistingLiteConfigPath() {
   const jsonPath = getLiteConfig();
-  if (existsSync(jsonPath)) return jsonPath;
+  if (existsSync2(jsonPath)) return jsonPath;
   const jsoncPath = getLiteConfigJsonc();
-  if (existsSync(jsoncPath)) return jsoncPath;
+  if (existsSync2(jsoncPath)) return jsoncPath;
   return jsonPath;
 }
 function getExistingConfigPath() {
   const jsonPath = getConfigJson();
-  if (existsSync(jsonPath)) return jsonPath;
+  if (existsSync2(jsonPath)) return jsonPath;
   const jsoncPath = getConfigJsonc();
-  if (existsSync(jsoncPath)) return jsoncPath;
+  if (existsSync2(jsoncPath)) return jsoncPath;
   return jsonPath;
 }
 function ensureConfigDir() {
   const configDir = getConfigDir();
-  if (!existsSync(configDir)) {
+  if (!existsSync2(configDir)) {
     mkdirSync(configDir, { recursive: true });
   }
 }
 function ensureOpenCodeConfigDir() {
-  const configDir = dirname(getConfigJson());
-  if (!existsSync(configDir)) {
+  const configDir = dirname3(getConfigJson());
+  if (!existsSync2(configDir)) {
     mkdirSync(configDir, { recursive: true });
   }
 }
@@ -349,10 +464,10 @@ function stripJsonComments(json) {
 }
 function parseConfigFile(path2) {
   try {
-    if (!existsSync2(path2)) return { config: null };
+    if (!existsSync3(path2)) return { config: null };
     const stat = statSync(path2);
     if (stat.size === 0) return { config: null };
-    const content = readFileSync(path2, "utf-8");
+    const content = readFileSync2(path2, "utf-8");
     if (content.trim().length === 0) return { config: null };
     return { config: JSON.parse(stripJsonComments(content)) };
   } catch (err) {
@@ -378,7 +493,7 @@ function writeConfig(configPath, config) {
   const bakPath = `${configPath}.bak`;
   const content = `${JSON.stringify(config, null, 2)}
 `;
-  if (existsSync2(configPath)) {
+  if (existsSync3(configPath)) {
     copyFileSync(configPath, bakPath);
   }
   writeFileSync(tmpPath, content);
@@ -391,7 +506,7 @@ function mergeOpenCodeMainConfig(config, update) {
       ...plugins.filter(
         (plugin) => plugin !== PACKAGE_NAME && !plugin.startsWith(`${PACKAGE_NAME}@`)
       ),
-      `${PACKAGE_NAME}@latest`
+      `${PACKAGE_NAME}@${update.pluginVersion}`
     ];
   }
   if (update.disableDefaults) {
@@ -406,6 +521,13 @@ function mergeOpenCodeMainConfig(config, update) {
 }
 function updateOpenCodeMainConfig(update) {
   const configPath = getExistingConfigPath();
+  if (update.ensurePlugin && !isValidPackageVersion(update.pluginVersion)) {
+    return {
+      success: false,
+      configPath,
+      error: "An approved plugin version is required."
+    };
+  }
   try {
     ensureOpenCodeConfigDir();
   } catch (err) {
@@ -446,7 +568,7 @@ function writeLiteConfig(installConfig, targetPath) {
     const bakPath = `${configPath}.bak`;
     const content = `${JSON.stringify(config, null, 2)}
 `;
-    if (existsSync2(configPath)) {
+    if (existsSync3(configPath)) {
       copyFileSync(configPath, bakPath);
     }
     writeFileSync(tmpPath, content);
@@ -680,6 +802,9 @@ var OPENCODE_PROMPT_DIALECT = {
     progressTool: "todowrite",
     hostStatusSurface: "task_status",
     lifecycle: {
+      freshDelegation: "`task` without `task_id`",
+      sameAssignmentContinuation: "`task` with the prior `task_id`",
+      independentContext: "omitting `task_id` creates an isolated child session",
       statusAction: "wait, poll, and collect",
       terminalState: "terminal task_status result",
       nonterminalState: "nonterminal task_status result",
@@ -713,6 +838,9 @@ var CODEX_PROMPT_DIALECT = {
     progressTool: "functions.update_plan",
     hostStatusSurface: "collaboration.list_agents",
     lifecycle: {
+      freshDelegation: '`collaboration.spawn_agent` with `fork_turns="none"`',
+      sameAssignmentContinuation: "`collaboration.followup_task` for the existing agent",
+      independentContext: '`fork_turns="none"` prevents parent-history inheritance',
       statusAction: "wait and inspect status",
       terminalState: "terminal mailbox completion or failure update",
       nonterminalState: "collaboration.wait_agent timeout or silence",
@@ -753,6 +881,9 @@ var CLAUDE_CODE_PROMPT_DIALECT = {
     progressTool: "TodoWrite",
     hostStatusSurface: "TodoWrite",
     lifecycle: {
+      freshDelegation: "a normal `Agent` invocation",
+      sameAssignmentContinuation: "`SendMessage` to the prior agent ID",
+      independentContext: "do not use `fork` for independent work",
       statusAction: "wait, inspect, and collect",
       terminalState: "terminal TaskOutput result",
       nonterminalState: "nonterminal TaskOutput result",
@@ -891,6 +1022,10 @@ var ORCHESTRATION_POLICY = {
     "Delegate only when specialization, context isolation, or independent parallel work creates a net gain.",
     "Prefer child agents for read-heavy exploration, research, analysis, and verification.",
     "Use one writer for each mutable surface and never parallelize overlapping writes.",
+    "A fresh subagent instance is the default when the objective, SDD phase, mutable surface, or independent judgment changes.",
+    "Continue an existing subagent only to steer, complete, or clarify the same bounded assignment; completed agents are not a reusable role pool.",
+    "Every Oracle plan review, verification round, and approval or PASS judgment uses a fresh Oracle instance; reuse is limited to clarifying current findings.",
+    "Wait and status operations collect only the active nonterminal assignment and do not authorize later reuse.",
     "Child agents return distilled evidence instead of raw logs or file dumps."
   ]
 };
@@ -1079,85 +1214,6 @@ var SDD_PHASES = [
     reason: "Transactionally sync declared durable deltas and close verified work with a dated audit trail."
   }
 ];
-var SDD_ARTIFACT_GRAPH = [
-  {
-    id: "spec",
-    path: "spec.md",
-    producedBy: "specify",
-    consumes: [],
-    requiredFor: ["accelerated", "full"]
-  },
-  {
-    id: "plan",
-    path: "plan.md",
-    producedBy: "plan",
-    consumes: ["spec"],
-    requiredFor: ["accelerated", "full"]
-  },
-  {
-    id: "tasks",
-    path: "tasks.md",
-    producedBy: "tasks",
-    consumes: ["spec", "plan"],
-    requiredFor: ["accelerated", "full"]
-  },
-  {
-    id: "requirements-checklist",
-    path: "checklists/requirements.md",
-    producedBy: "checklist",
-    consumes: ["spec"],
-    requiredFor: []
-  },
-  {
-    id: "research",
-    path: "research.md",
-    producedBy: "plan",
-    consumes: ["spec"],
-    requiredFor: []
-  },
-  {
-    id: "data-model",
-    path: "data-model.md",
-    producedBy: "plan",
-    consumes: ["spec"],
-    requiredFor: []
-  },
-  {
-    id: "contracts",
-    path: "contracts/",
-    producedBy: "plan",
-    consumes: ["spec"],
-    requiredFor: []
-  },
-  {
-    id: "quickstart",
-    path: "quickstart.md",
-    producedBy: "plan",
-    consumes: ["spec", "plan"],
-    requiredFor: []
-  },
-  {
-    id: "plan-review",
-    path: "plan-review.md",
-    producedBy: "plan-review",
-    consumes: ["spec", "plan", "tasks"],
-    requiredFor: []
-  },
-  {
-    id: "verify-report",
-    path: "verify-report.md",
-    producedBy: "verify",
-    consumes: ["spec", "plan", "tasks"],
-    requiredFor: ["accelerated", "full"]
-  },
-  {
-    id: "archive-report",
-    path: "archive-report.md",
-    producedBy: "archive",
-    consumes: ["spec", "plan", "tasks", "verify-report"],
-    requiredFor: ["accelerated", "full"]
-  }
-];
 var SDD_ROUTE_EXECUTION_POLICIES = [
   {
     route: "direct",
@@ -1250,13 +1306,6 @@ function getSddRouteExecutionPolicy(route) {
     validationGates: [...policy.validationGates]
   };
 }
-function getSddArtifactGraph() {
-  return SDD_ARTIFACT_GRAPH.map((artifact) => ({
-    ...artifact,
-    consumes: [...artifact.consumes],
-    requiredFor: [...artifact.requiredFor]
-  }));
-}
 function getSddPhase(id) {
   const phase = SDD_PHASES.find((candidate) => candidate.id === id);
   if (!phase) {
@@ -1364,9 +1413,6 @@ function renderSddRoute(route) {
 function renderRoleDirectory() {
   return getAgentPackContract().roles.filter((role) => role.name !== "orchestrator").map((role) => `- ${roleTemplate(role.name)}: ${role.responsibility}`).join("\n");
 }
-function renderArtifactSummary() {
-  return getSddArtifactGraph().filter((artifact) => artifact.requiredFor.length === 0).map((artifact) => artifact.path).join(", ");
-}
 function createOrchestratorPromptSections() {
   const workflow = getSddWorkflowContract();
   const policy = getAgentPackContract().orchestrationPolicy;
@@ -1382,10 +1428,19 @@ You are the adaptive root for thoth-agents. Keep requirements, decisions, execut
 - Delegate only for net gain from specialization, context isolation, review, or safe parallelism. The maximum delegation depth is ${policy.maxDelegationDepth}; children never delegate.
 - Maintain one writer for each mutable surface. Parallelize only independent work with no overlapping writes.
 - Keep prompts bounded; request distilled evidence, not raw logs or full files.
+- Preserve unrelated changes; report changed files, evidence, risks, and capability gaps.
 - Use \`{{userQuestionTool}}\` only when a material unresolved choice changes the result. Continue all safe non-blocked work first.
 - Use \`{{progressTool}}\` only when the work genuinely has multiple dependent steps.
 </operating-model>
 
+<delegation-lifecycle>
+- A new objective, SDD phase, mutable surface, or independent judgment is a work boundary: start a fresh specialist using {{lifecycleFreshDelegation}}. Never treat completed agents as a reusable role pool.
+- Independent context: {{lifecycleIndependentContext}}.
+- Continue with {{lifecycleSameAssignmentContinuation}} only to steer, complete, or clarify the same bounded assignment; never to cross a work boundary.
+- {{lifecycleSameSessionProbe}} only collects the active nonterminal assignment and does not authorize later reuse.
+- Every Oracle plan review, verification round, and approval or PASS judgment uses a fresh Oracle instance. An existing Oracle session may only clarify its current findings.
+</delegation-lifecycle>
+
 <routing>
 ${renderRoleDirectory()}
 </routing>
@@ -1419,29 +1474,20 @@ ${renderRoleDirectory()}
 </external-skills>
 
 <memory>
-- Load the installed \`thoth-mem\` skill for resume or prior work and provider-backed memory; never invent its protocol.
-- Preserve a durable decision, root cause, convention, or discovery only when reusable. Root owns the stable root session ID, project, lifecycle, real-user intent, and authorization; never invent identity or confirmed effects.
-- Follow the skill at verified compaction and a meaningful semantic boundary. Children receive only bounded MEMORY dispatch and never own root lifecycle.
-- \`openspec/\` remains canonical; do not mirror SDD phase artifacts into provider memory. A memory failure degrades memory only and does not block unrelated implementation or verification.
+- Load the installed \`thoth-mem\` skill for resume or prior work; never invent its protocol.
+- Preserve a durable decision, root cause, convention, or discovery only when reusable. Root owns the stable root session ID, project, lifecycle, real-user intent, and authorization.
+- Follow the skill at verified compaction or a meaningful semantic boundary; children receive only bounded MEMORY and never own root lifecycle.
+- \`openspec/\` remains canonical; do not mirror SDD phase artifacts. A memory failure does not block unrelated work.
 </memory>
 
 <artifacts>
-- Preserve Spec Kit semantics inside ${workflow.artifactRoot}.
-- Accelerated and Full require spec.md, plan.md, tasks.md, verify-report.md, and archive-report.md; optional when useful: ${renderArtifactSummary()}.
-- Root owns openspec/ coordination and thoth-sdd gates; product work has one writer, and root alone moves [~] -> [x] after evidence.
-- ${roleTemplate("oracle")} returns read-only findings. Root persists verification; after PASS, archive syncs declared durable deltas and moves the change to openspec/changes/archive/YYYY-MM-DD-<feature>/.
+- In ${workflow.artifactRoot}, Accelerated and Full require spec.md, plan.md, tasks.md, verify-report.md, and archive-report.md.
+- Root owns openspec/ gates and task state, moves [~] -> [x] after evidence, and keeps one product writer.
+- ${roleTemplate("oracle")} returns read-only findings; root persists verification and archives declared durable deltas after PASS.
 </artifacts>
 
-<execution>
-- Validate contracts and tests first; use test-first work for behavior. Root or one writer implements; do not delegate merely because an agent exists.
-- ${roleTemplate("oracle")} owns selected plan review and every verification; root and writers never self-approve.
-- Preserve unrelated working-tree changes. Never instruct an agent to discard them.
-- Report changed files, evidence, risks, and capability gaps truthfully.
-</execution>
-
 <delegation>
-- Dispatch through \`{{delegationTool}}\` with this envelope; use the same boundaries for non-SDD work.
-- Parallelize only independent work and await requested results before synthesis.
+- Use this envelope for all \`{{delegationTool}}\` delegation; parallelize only independent work and await results.
 - Child return fields: conclusion, evidence, verification, risks, openQuestions, nextAction.
 
 ${renderSddPhaseDispatchTemplate()}
@@ -1619,6 +1665,15 @@ function renderRoleText(section, dialect) {
   ).replaceAll("{{userQuestionTool}}", dialect.tools.userQuestionTool).replaceAll("{{progressTool}}", dialect.tools.progressTool).replaceAll(
     "{{lifecycleStatusAction}}",
     dialect.tools.lifecycle.statusAction
+  ).replaceAll(
+    "{{lifecycleFreshDelegation}}",
+    dialect.tools.lifecycle.freshDelegation
+  ).replaceAll(
+    "{{lifecycleIndependentContext}}",
+    dialect.tools.lifecycle.independentContext
+  ).replaceAll(
+    "{{lifecycleSameAssignmentContinuation}}",
+    dialect.tools.lifecycle.sameAssignmentContinuation
   ).replaceAll(
     "{{lifecycleTerminalState}}",
     dialect.tools.lifecycle.terminalState
@@ -1748,6 +1803,9 @@ export {
   getDefaultOpenCodeModel,
   getDefaultOpenCodeVariant,
   POLL_INTERVAL_BACKGROUND_MS,
+  findPackageRoot,
+  isValidPackageVersion,
+  resolveExecutingPackageVersion,
   getOpenCodeConfigPaths,
   getOpenCodeManagedModelStatePath,
   getExistingLiteConfigPath,

package/dist/{chunk-6GQYMWWT.js → chunk-TKIDBRM3.js}

@@ -14,7 +14,7 @@ import {
   getStepBudgetPromptSection,
   loadAgentPrompt,
   renderRolePrompt
-} from "./chunk-F2K4CS5J.js";
+} from "./chunk-M2WF46BP.js";
 
 // src/agents/deep.ts
 var DEEP_PROMPT = renderRolePrompt(

package/dist/cli/commands.d.ts

@@ -14,6 +14,7 @@ export interface CliModelCommandServices {
     operationContext(): OperationContext;
     modelRoles(harness: OperationHarnessArg): ModelRoleInput[];
     modelOptions(harness: OperationHarnessArg): Promise<ModelOption[]>;
+    applyOperationPlan?(plan: OperationPlan): OperationApplyResult;
 }
 export declare function printHarnessGeneration(args: GenerateArgs): number;
 export declare function runCliCommand(parsed: CliParseResult, modelServices?: CliModelCommandServices): Promise<number>;

package/dist/cli/config-io.d.ts

@@ -15,9 +15,10 @@ export declare function parseConfig(path: string): {
  * Write config to file atomically.
  */
 export declare function writeConfig(configPath: string, config: OpenCodeConfig): void;
-export declare function addPluginToOpenCodeConfig(): Promise<ConfigMergeResult>;
+export declare function addPluginToOpenCodeConfig(pluginVersion: string): Promise<ConfigMergeResult>;
 export interface OpenCodeMainConfigUpdate {
     ensurePlugin?: boolean;
+    pluginVersion?: string;
     disableDefaults?: boolean;
 }
 export declare function updateOpenCodeMainConfig(update: OpenCodeMainConfigUpdate): ConfigMergeResult;