thoth-agents 0.3.2 → 0.3.4

package/dist/cli/index.js

@@ -4,7 +4,7 @@ import {
   getOpenCodeVersion,
   isOpenCodeInstalled,
   opencodeAdapter
-} from "../chunk-YUCGIJPP.js";
+} from "../chunk-6GQYMWWT.js";
 import {
   CODEX_ROLE_NAMES,
   REQUIRED_SKILLS,
@@ -43,7 +43,7 @@ import {
   installRequiredSkill,
   listOperationHarnesses,
   normalizeEffortSelection
-} from "../chunk-NUSODNWE.js";
+} from "../chunk-W5GCMYA3.js";
 import {
   ALL_AGENT_NAMES,
   detectCurrentConfig,
@@ -53,7 +53,7 @@ import {
   getExistingLiteConfigPath,
   updateOpenCodeMainConfig,
   writeLiteConfig
-} from "../chunk-XO74DXBZ.js";
+} from "../chunk-F2K4CS5J.js";
 
 // src/cli/index.ts
 import { pathToFileURL } from "url";
@@ -74,8 +74,243 @@ import { existsSync } from "fs";
 import { homedir } from "os";
 import { cwd } from "process";
 
-// src/cli/thoth-mem-install.ts
+// src/cli/codex-plugin-install.ts
 import { spawnSync } from "child_process";
+var MARKETPLACE_NAME = "thoth-agents";
+var MARKETPLACE_SOURCE = "EremesNG/thoth-agents";
+var PLUGIN_ID = "thoth-agents@thoth-agents";
+var MARKETPLACE_TARGET = "codex://marketplaces/thoth-agents";
+var PLUGIN_TARGET = "codex://plugins/thoth-agents@thoth-agents";
+function getCodexCommand(args, options = {}) {
+  if ((options.platform ?? process.platform) !== "win32") {
+    return { command: "codex", args: [...args] };
+  }
+  return {
+    command: options.commandShell ?? process.env.ComSpec ?? "cmd.exe",
+    args: ["/d", "/s", "/c", "codex.cmd", ...args]
+  };
+}
+function defaultCommandExecutor(command, args, options) {
+  const invocation = command === "codex" ? getCodexCommand(args) : { command, args: [...args] };
+  const result = spawnSync(invocation.command, invocation.args, {
+    cwd: options.cwd,
+    encoding: "utf8",
+    shell: false,
+    windowsHide: true
+  });
+  return {
+    exitCode: result.status ?? (result.error ? 1 : 0),
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? result.error?.message ?? ""
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseRecordArray(value) {
+  return Array.isArray(value) && value.every(isRecord) ? value : null;
+}
+function parseManagerRecord(content) {
+  try {
+    const parsed = JSON.parse(content);
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function normalizeMarketplaceSource(value) {
+  return value.trim().replace(/^git@github\.com:/i, "").replace(/^(?:https?|ssh):\/\/(?:git@)?github\.com\//i, "").replace(/^github\.com\//i, "").replace(/\/?\.git\/?$/i, "").replace(/\/$/, "").toLowerCase();
+}
+function marketplaceSources(entry) {
+  const sources = [entry.repo, entry.source];
+  if (isRecord(entry.marketplaceSource)) {
+    sources.push(entry.marketplaceSource.repo, entry.marketplaceSource.source);
+  }
+  return sources.filter(
+    (source) => typeof source === "string"
+  );
+}
+function isCanonicalMarketplace(entry) {
+  if (entry.name !== MARKETPLACE_NAME) return false;
+  const canonical = MARKETPLACE_SOURCE.toLowerCase();
+  return marketplaceSources(entry).some(
+    (source) => normalizeMarketplaceSource(source) === canonical
+  );
+}
+function inspectCodexManager(executor, cwd2) {
+  const marketplaceResult = executor(
+    "codex",
+    ["plugin", "marketplace", "list", "--json"],
+    { cwd: cwd2 }
+  );
+  const pluginResult = executor(
+    "codex",
+    ["plugin", "list", "--available", "--json"],
+    { cwd: cwd2 }
+  );
+  const diagnostics = [];
+  if (marketplaceResult.exitCode !== 0 || pluginResult.exitCode !== 0) {
+    diagnostics.push(
+      "Codex native plugin state could not be inspected; no manager mutation will be attempted."
+    );
+    return {
+      ready: false,
+      marketplace: "unknown",
+      plugin: "unknown",
+      diagnostics
+    };
+  }
+  const marketplaceRecord = parseManagerRecord(marketplaceResult.stdout);
+  const pluginRecord = parseManagerRecord(pluginResult.stdout);
+  const marketplaces = marketplaceRecord ? parseRecordArray(marketplaceRecord.marketplaces) : null;
+  const installedPlugins = pluginRecord ? parseRecordArray(pluginRecord.installed) : null;
+  if (!marketplaces || !installedPlugins) {
+    diagnostics.push(
+      "Codex returned unparseable plugin manager JSON; no manager mutation will be attempted."
+    );
+    return {
+      ready: false,
+      marketplace: "unknown",
+      plugin: "unknown",
+      diagnostics
+    };
+  }
+  const namedMarketplaces = marketplaces.filter(
+    (entry) => entry.name === MARKETPLACE_NAME
+  );
+  let marketplace = "absent";
+  if (namedMarketplaces.length > 0) {
+    marketplace = namedMarketplaces.every(isCanonicalMarketplace) ? "installed" : "conflict";
+  }
+  if (marketplace === "conflict") {
+    diagnostics.push(
+      "A Codex marketplace named thoth-agents is registered from a different source; resolve it through Codex before retrying."
+    );
+  }
+  const matchingPlugins = installedPlugins.filter(
+    (entry) => entry.pluginId === PLUGIN_ID
+  );
+  let plugin = "absent";
+  if (matchingPlugins.some((entry) => entry.enabled === true)) {
+    plugin = "installed";
+  } else if (matchingPlugins.length > 0) {
+    plugin = "disabled";
+  }
+  return {
+    ready: marketplace !== "conflict",
+    marketplace,
+    plugin,
+    diagnostics
+  };
+}
+function commandItem(action, projectRoot) {
+  if (action === "register-marketplace") {
+    return {
+      action,
+      targetPath: MARKETPLACE_TARGET,
+      description: "Register the package-owned thoth-agents Codex marketplace.",
+      command: {
+        executable: "codex",
+        args: ["plugin", "marketplace", "add", MARKETPLACE_SOURCE, "--json"],
+        cwd: projectRoot
+      }
+    };
+  }
+  return {
+    action,
+    targetPath: PLUGIN_TARGET,
+    description: "Install and enable the thoth-agents Codex plugin from its native marketplace.",
+    command: {
+      executable: "codex",
+      args: ["plugin", "add", PLUGIN_ID, "--json"],
+      cwd: projectRoot
+    }
+  };
+}
+function buildCodexPluginSetupPlan(config) {
+  const commandExecutor = config.commandExecutor ?? defaultCommandExecutor;
+  const inspection = inspectCodexManager(commandExecutor, config.projectRoot);
+  const items = [];
+  if (inspection.ready) {
+    if (inspection.marketplace === "absent") {
+      items.push(commandItem("register-marketplace", config.projectRoot));
+    }
+    if (inspection.plugin === "absent" || inspection.plugin === "disabled") {
+      items.push(commandItem("install-plugin", config.projectRoot));
+    }
+  }
+  return {
+    dryRun: config.dryRun === true,
+    items,
+    ready: inspection.ready,
+    projectRoot: config.projectRoot,
+    commandExecutor,
+    diagnostics: [
+      ...inspection.diagnostics,
+      "Codex installs thoth-agents from EremesNG/thoth-agents through its native plugin manager and owns the cached plugin files.",
+      "Restart Codex after installation; use /plugins to inspect marketplace and plugin state."
+    ]
+  };
+}
+function uniqueMessages(messages) {
+  return [...new Set(messages)];
+}
+function boundedCommandFailure(item, result) {
+  const detail = result.stderr.trim().replace(/\s+/g, " ").slice(0, 240);
+  return `${item.description} Codex exited with code ${result.exitCode}${detail ? `: ${detail}` : "."}`;
+}
+function applyCodexPluginSetup(plan) {
+  const changed = [];
+  const diagnostics = uniqueMessages(plan.diagnostics);
+  if (!plan.ready) {
+    return {
+      success: false,
+      changed,
+      diagnostics,
+      error: "Codex native plugin manager state is not safe to mutate."
+    };
+  }
+  if (plan.dryRun) return { success: true, changed, diagnostics };
+  for (const item of plan.items) {
+    const result = plan.commandExecutor(
+      item.command.executable,
+      item.command.args,
+      { cwd: item.command.cwd }
+    );
+    if (result.exitCode !== 0) {
+      return {
+        success: false,
+        changed,
+        diagnostics,
+        error: boundedCommandFailure(item, result)
+      };
+    }
+    changed.push(item.targetPath);
+  }
+  const inspection = inspectCodexManager(
+    plan.commandExecutor,
+    plan.projectRoot
+  );
+  diagnostics.push(...inspection.diagnostics);
+  if (inspection.marketplace !== "installed" || inspection.plugin !== "installed") {
+    return {
+      success: false,
+      changed,
+      diagnostics: uniqueMessages(diagnostics),
+      error: "Codex did not verify the expected marketplace and enabled plugin after mutation."
+    };
+  }
+  return { success: true, changed, diagnostics: uniqueMessages(diagnostics) };
+}
+function formatCodexPluginSetupPlan(plan) {
+  const lines = plan.items.map(
+    (item) => `- ${item.action}: ${item.command.executable} ${item.command.args.join(" ")}`
+  );
+  return ["Codex plugin setup plan:", ...lines].join("\n");
+}
+
+// src/cli/thoth-mem-install.ts
+import { spawnSync as spawnSync2 } from "child_process";
 var THOTH_MEM_SETUP_TIMEOUT_MS = 12e4;
 var STATUS_EXIT_CODE = {
   complete: 0,
@@ -93,17 +328,17 @@ var STEP_OUTCOMES = /* @__PURE__ */ new Set([
   "failed",
   "unavailable"
 ]);
-function isRecord(value) {
+function isRecord2(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);
+  return isRecord2(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");
+  return isRecord2(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;
@@ -114,8 +349,8 @@ function parseProviderSetupResult(stdout, expectedHarness) {
   }
   return isProviderSetupResult(value, expectedHarness) ? value : void 0;
 }
-function defaultCommandExecutor(command, args, options) {
-  const result = spawnSync(command, [...args], {
+function defaultCommandExecutor2(command, args, options) {
+  const result = spawnSync2(command, [...args], {
     cwd: options.cwd,
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"],
@@ -132,7 +367,7 @@ function describeError(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function isTimeoutError(error) {
-  return isRecord(error) && error.code === "ETIMEDOUT";
+  return isRecord2(error) && error.code === "ETIMEDOUT";
 }
 function invalidResult(harness, command, args, exitCode, error) {
   return {
@@ -171,7 +406,7 @@ function runThothMemSetup(options) {
     options.harness,
     options.dryRun ?? false
   );
-  const executor = options.commandExecutor ?? defaultCommandExecutor;
+  const executor = options.commandExecutor ?? defaultCommandExecutor2;
   let commandResult;
   try {
     commandResult = executor(command, args, {
@@ -466,11 +701,23 @@ function createInstallConfig(args) {
 async function install(args, dependencies = {}) {
   const config = createInstallConfig(args);
   if (config.agent === "codex") {
+    const projectRoot = cwd();
+    const pluginPlan = buildCodexPluginSetupPlan({
+      dryRun: config.dryRun,
+      projectRoot
+    });
+    console.log(formatCodexPluginSetupPlan(pluginPlan));
+    const pluginResult = applyCodexPluginSetup(pluginPlan);
+    for (const diagnostic of pluginResult.diagnostics) printInfo(diagnostic);
+    if (!pluginResult.success) {
+      printError(`Codex plugin install failed: ${pluginResult.error}`);
+      return 1;
+    }
     const plan = buildCodexSetupPlan({
       dryRun: config.dryRun,
       reset: config.reset,
       scope: "user",
-      projectRoot: cwd(),
+      projectRoot,
       homeDir: homedir()
     });
     console.log(formatCodexSetupPlan(plan));
@@ -485,7 +732,7 @@ async function install(args, dependencies = {}) {
       return 1;
     }
     printSuccess(
-      config.dryRun ? "Codex dry-run complete; no files written" : "Codex agent-pack setup complete"
+      config.dryRun ? "Codex dry-run complete; no files written" : "Codex plugin installed as thoth-agents@thoth-agents and agent-pack setup complete (restart Codex to activate)"
     );
     return 0;
   }

package/dist/cli/skills.d.ts

@@ -19,7 +19,9 @@ interface InstallRequiredSkillOptions extends NpxCommandOptions {
     homeDir?: string;
 }
 export declare const REQUIRED_SKILLS: readonly RequiredSkill[];
+export declare function getRequiredSkillPaths(skill: RequiredSkill, harness: SkillInstallHarness, homeDir?: string): string[];
 export declare function getRequiredSkillPath(skill: RequiredSkill, harness: SkillInstallHarness, homeDir?: string): string;
+export declare function getInstalledRequiredSkillPath(skill: RequiredSkill, harness: SkillInstallHarness, homeDir?: string): string | undefined;
 export declare function isRequiredSkillInstalled(skill: RequiredSkill, harness: SkillInstallHarness, options?: InstallRequiredSkillOptions): boolean;
 export declare function getRequiredSkillInstallCommand(skill: RequiredSkill, harness: SkillInstallHarness, options?: NpxCommandOptions): NpxCommand;
 /** Install one mandatory skill into the selected harness's global skill root. */

package/dist/cli/tui/index.js

@@ -2,8 +2,8 @@ import {
   defaultTuiOperations,
   effortChoicesForModel,
   listOperationHarnesses
-} from "../../chunk-NUSODNWE.js";
-import "../../chunk-XO74DXBZ.js";
+} from "../../chunk-W5GCMYA3.js";
+import "../../chunk-F2K4CS5J.js";
 
 // src/cli/tui/index.tsx
 import { render } from "ink";

package/dist/harness/core/agent-pack.d.ts

@@ -32,7 +32,7 @@ export declare const AGENT_ROLES: readonly [{
     readonly scope: "requirements, SDD coordination, routing, bounded direct work, decisions, and synthesis";
     readonly responsibility: "Keep the task coherent, own sequential specification, planning, task, convergence, and archive coordination, act directly when work is clear and bounded, and delegate only for net gain.";
     readonly toolGovernance: ["may inspect and edit bounded direct work, but every verification is delegated to oracle", "loads the matching thoth-sdd phase contract on demand instead of carrying every phase protocol in its prompt", "owns governed coordination writes under openspec/ and uses append-only tasks.md updates during convergence", "delegates independent or specialist work only when it produces a net gain", "keeps requirements, decisions, and final synthesis in the root thread"];
-    readonly verification: ["delegates analyze and every verify phase to oracle, including Direct and Accelerated routes", "consolidates summarized evidence returned by child agents"];
+    readonly verification: ["delegates selected plan-review and every verify phase to oracle; plan review stays optional and final verification stays mandatory", "consolidates summarized evidence returned by child agents"];
 }, {
     readonly name: "explorer";
     readonly mode: "read-only";
@@ -56,8 +56,8 @@ export declare const AGENT_ROLES: readonly [{
     readonly mode: "read-only";
     readonly dispatch: "synchronous-task-only";
     readonly canMutateWorkspace: false;
-    readonly scope: "diagnosis, architecture, analysis, and independent verification";
-    readonly responsibility: "Independently analyze plans and perform every implementation verification, exposing correctness risks and judging whether results satisfy their contracts.";
+    readonly scope: "diagnosis, architecture, optional plan review, and independent verification";
+    readonly responsibility: "Independently review plans when the user requests it and perform every implementation verification, exposing correctness risks and judging whether results satisfy their contracts.";
     readonly toolGovernance: ["performs read-only analysis and independent review and is never the implementer of the work it judges", "does not implement, persist artifacts, or delegate further"];
     readonly verification: ["separates observations, risks, and recommendations"];
 }, {

package/dist/harness/core/sdd.d.ts

@@ -22,7 +22,7 @@ export interface SddRoutingDecision {
     requiresUserInput: boolean;
     reasons: string[];
 }
-export type SddPhaseId = 'explore' | 'specify' | 'clarify' | 'plan' | 'checklist' | 'tasks' | 'analyze' | 'implement' | 'verify' | 'converge' | 'archive';
+export type SddPhaseId = 'explore' | 'specify' | 'clarify' | 'plan' | 'checklist' | 'tasks' | 'plan-review' | 'implement' | 'verify' | 'converge' | 'archive';
 export type SddPhaseActivation = 'required' | 'conditional';
 export interface SddPhaseContract {
     id: SddPhaseId;
@@ -58,7 +58,7 @@ export interface SddPhaseDispatchInput {
     verification?: string[];
     memory: MemoryDispatchContract;
 }
-export type SddArtifactId = 'spec' | 'plan' | 'tasks' | 'requirements-checklist' | 'research' | 'data-model' | 'contracts' | 'quickstart' | 'verify-report' | 'archive-report';
+export type SddArtifactId = 'spec' | 'plan' | 'tasks' | 'requirements-checklist' | 'research' | 'data-model' | 'contracts' | 'quickstart' | 'plan-review' | 'verify-report' | 'archive-report';
 export interface SddArtifactContract {
     id: SddArtifactId;
     path: string;
@@ -151,23 +151,24 @@ export declare const SDD_PHASES: readonly [{
     readonly eligibleAgentRoles: ["orchestrator"];
     readonly reason: "Produce dependency-ordered implementation slices with verification.";
 }, {
-    readonly id: "analyze";
+    readonly id: "plan-review";
     readonly order: 6;
-    readonly availableFor: ["full"];
-    readonly requiredFor: ["full"];
-    readonly activation: "required";
-    readonly prerequisites: ["specify", "plan", "tasks"];
-    readonly producesArtifact: false;
+    readonly availableFor: ["accelerated", "full"];
+    readonly requiredFor: [];
+    readonly activation: "conditional";
+    readonly prerequisites: ["tasks"];
+    readonly producesArtifact: true;
     readonly defaultAgentRole: "oracle";
     readonly eligibleAgentRoles: ["oracle"];
-    readonly reason: "Independently check cross-artifact consistency before high-risk implementation.";
+    readonly reason: "Offer independent blocker-only plan review when the user selects it after planning passes ready.";
+    readonly condition: "Activate only after ready when the user chooses Review plan with Oracle (Recommended).";
 }, {
     readonly id: "implement";
     readonly order: 7;
     readonly availableFor: ["direct", "accelerated", "full"];
     readonly requiredFor: ["direct", "accelerated", "full"];
     readonly activation: "required";
-    readonly prerequisites: ["tasks", "analyze"];
+    readonly prerequisites: ["tasks"];
     readonly producesArtifact: false;
     readonly defaultAgentRole: "orchestrator";
     readonly eligibleAgentRoles: ["orchestrator", "designer", "quick", "deep"];
@@ -255,6 +256,12 @@ export declare const SDD_ARTIFACT_GRAPH: readonly [{
     readonly producedBy: "plan";
     readonly consumes: ["spec", "plan"];
     readonly requiredFor: [];
+}, {
+    readonly id: "plan-review";
+    readonly path: "plan-review.md";
+    readonly producedBy: "plan-review";
+    readonly consumes: ["spec", "plan", "tasks"];
+    readonly requiredFor: [];
 }, {
     readonly id: "verify-report";
     readonly path: "verify-report.md";
@@ -280,14 +287,14 @@ export declare const SDD_ROUTE_EXECUTION_POLICIES: readonly [{
     readonly planningMode: "fast-forward";
     readonly validationGates: ["specify", "ready", "closeout"];
     readonly optionalArtifactsByDefault: false;
-    readonly routineUserPauses: false;
+    readonly routineUserPauses: true;
     readonly artifactRevisionPolicy: "revalidate-affected-downstream";
 }, {
     readonly route: "full";
     readonly planningMode: "gated";
     readonly validationGates: ["specify", "plan", "tasks", "ready", "closeout"];
     readonly optionalArtifactsByDefault: false;
-    readonly routineUserPauses: false;
+    readonly routineUserPauses: true;
     readonly artifactRevisionPolicy: "revalidate-affected-downstream";
 }];
 export declare const SDD_PHASE_PROTOCOLS: readonly [{
@@ -349,17 +356,17 @@ export declare const SDD_PHASE_PROTOCOLS: readonly [{
     readonly outputSchema: ["tasks.md path", "requirement coverage", "dependency order"];
     readonly doneWhen: ["Every FR and buildable SC has executable task coverage and every task has a verification step."];
     readonly blockingConditions: ["A task requires an unresolved requirement, architecture choice, or hidden prerequisite."];
-    readonly handoff: ["Pass spec.md, plan.md, tasks.md, dependencies, and verification commands to analyze or implement."];
-}, {
-    readonly id: "analyze";
-    readonly objective: "Perform read-only cross-artifact consistency and readiness analysis before full SDD implementation.";
-    readonly requiredInputs: ["spec.md", "plan.md", "tasks.md", "Project constitution"];
-    readonly instructions: ["Detect contradictions, ambiguity, duplication, scope drift, orphan tasks, and uncovered requirements.", "Challenge artifact completeness, requirement correctness, and cross-artifact coherence as separate review dimensions.", "Require task coverage for every FR and buildable SC; assess outcome SC as measurable verification targets without manufacturing implementation tasks.", "Report requirement coverage as a percentage and classify findings as CRITICAL, HIGH, MEDIUM, or LOW.", "Treat constitution violations and baseline requirements with zero task coverage as blocking."];
-    readonly allowedWrites: ["None; analysis is read-only and returns its report in-session."];
-    readonly outputSchema: ["findings table with stable IDs and severity", "requirement coverage percentage", "constitution alignment", "readiness verdict: ready | blocked"];
-    readonly doneWhen: ["Every high-signal cross-artifact inconsistency has a severity and remediation anchor."];
-    readonly blockingConditions: ["Any unresolved CRITICAL finding or constitution violation blocks implementation."];
-    readonly handoff: ["On ready, pass the reviewed artifact set and cautions to implement; on blocked, return findings to the owning coordination phase."];
+    readonly handoff: ["After ready, pass spec.md, plan.md, tasks.md, dependencies, and verification commands to the user-selected plan-review path or implement."];
+}, {
+    readonly id: "plan-review";
+    readonly objective: "Perform the user-selected read-only blocker review before Accelerated or Full implementation.";
+    readonly requiredInputs: ["spec.md", "plan.md", "tasks.md", "Optional active requirements checklist", "Project constitution", "Explicit user choice to review after the ready gate"];
+    readonly instructions: ["Load the bundled plan-reviewer skill and review executability, completeness, correctness, and coherence without redesigning the plan.", "Require task coverage for every FR and buildable SC; assess outcome SC as measurable verification targets without manufacturing implementation tasks.", "Return exact [OKAY] or [REJECT] semantics, default to [OKAY], and report at most three true blockers with the smallest fixes.", "Provide the reviewed artifact set so root can persist plan-review.md with SHA-256 freshness evidence; Oracle never writes it.", "Keep plan-review approval separate from implementation confirmation and mandatory final verify."];
+    readonly allowedWrites: ["None; Oracle is read-only. Root persists plan-review.md when review runs."];
+    readonly outputSchema: ["status: [OKAY] or [REJECT]", "zero to three blocker findings with smallest fixes", "non-blocking cautions", "requirement coverage percentage", "constitution alignment", "reviewed artifact freshness manifest input"];
+    readonly doneWhen: ["Oracle has returned an exact status and every true blocker has a concrete remediation anchor."];
+    readonly blockingConditions: ["[REJECT] blocks the review path until root repairs planning blockers, the user explicitly proceeds without review, or an explicit override is recorded."];
+    readonly handoff: ["On [OKAY], root persists review evidence, presents the approved-plan overview, and asks whether to implement or stop.", "A plan-review result never satisfies mandatory final verify."];
 }, {
     readonly id: "implement";
     readonly objective: "Execute the accepted task slice with one writer and focused verification.";

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   renderOpenCodeAgentConfigs,
   spawn,
   spawnSync
-} from "./chunk-YUCGIJPP.js";
+} from "./chunk-6GQYMWWT.js";
 import {
   POLL_INTERVAL_BACKGROUND_MS,
   context7,
@@ -12,7 +12,7 @@ import {
   grep_app,
   loadPluginConfig,
   stripJsonComments
-} from "./chunk-XO74DXBZ.js";
+} from "./chunk-F2K4CS5J.js";
 
 // src/index.ts
 import { fileURLToPath as fileURLToPath3 } from "url";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thoth-agents",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Adaptive multi-harness orchestration with seven roles, runtime-autonomous Spec Kit-compatible SDD routes, and external provider boundaries.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/plugin/.claude-plugin/.thoth-agents-plugin-assets.json

@@ -29,12 +29,12 @@
     {
       "path": "agents/oracle.md",
       "kind": "agent-config",
-      "sha256": "sha256:93b9744b95bf657d8902f0108d24904ab504249fd47308f66271978010501a13"
+      "sha256": "sha256:b5a2334cc0b52fb95281cb46fb9c2a6fc1df9f87faefe0e47838df270992bfe0"
     },
     {
       "path": "agents/orchestrator.md",
       "kind": "agent-config",
-      "sha256": "sha256:bac6c6c2abda0352f785fec16debde1361d2bfbd17acdf3a75b326c6c4d0a992"
+      "sha256": "sha256:b39b6cb996d5dcb38dc66bb83bfd7d6dacbb75d9e1de9097ce2416e64d630b9e"
     },
     {
       "path": "agents/quick.md",

package/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "thoth-agents",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Adaptive multi-harness agent pack with seven roles and a runtime-autonomous Spec Kit-compatible SDD bundle for Claude Code.",
   "author": {
     "name": "thoth-agents"

package/plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "thoth-agents",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Bundled Spec Kit-compatible SDD skills and MCP configuration; the seven-role global Codex layer requires thoth-agents CLI setup.",
   "skills": "./skills/",
   "mcpServers": "./codex.mcp.json"

package/plugin/agents/oracle.md

@@ -1,6 +1,6 @@
 ---
 name: oracle
-description: "Independently analyze plans and perform every implementation verification, exposing correctness risks and judging whether results satisfy their contracts."
+description: "Independently review plans when the user requests it and perform every implementation verification, exposing correctness risks and judging whether results satisfy their contracts."
 model: opus
 disallowedTools: "Write, Edit"
 ---
@@ -12,11 +12,11 @@ You are oracle.
 <mode>
 - Mode: read-only
 - Dispatch: synchronous Agent only
-- Scope: diagnosis, architecture, analysis, and independent verification
+- Scope: diagnosis, architecture, optional plan review, and independent verification
 </mode>
 
 <responsibility>
-Independently analyze plans and perform every implementation verification, exposing correctness risks and judging whether results satisfy their contracts.
+Independently review plans when the user requests it and perform every implementation verification, exposing correctness risks and judging whether results satisfy their contracts.
 </responsibility>
 
 <reasoning-discipline>
@@ -30,7 +30,7 @@ Independently analyze plans and perform every implementation verification, expos
 - Do not create coordination artifacts.
 - Separate observations, risks, and recommendations.
 - Review against stated requirements and contracts; do not invent implementation scope.
-- For analyze or verify, load the matching bundled thoth-sdd reference and remain read-only.
+- For plan-review, load the bundled plan-reviewer skill; for verify, load the matching bundled thoth-sdd reference and remain read-only.
 - Reject self-review: the implementing root or writer cannot substitute for independent oracle judgment.
 - Ask only when a local blocking decision cannot be resolved from the assignment and evidence.
 </rules>
@@ -64,8 +64,8 @@ Be concise. Return distilled evidence and outcomes, not raw logs or full-file du
 <role-operational-contract>
 - Role: oracle
 - Mode: read-only
-- Scope: diagnosis, architecture, analysis, and independent verification
-- Responsibility: Independently analyze plans and perform every implementation verification, exposing correctness risks and judging whether results satisfy their contracts.
+- Scope: diagnosis, architecture, optional plan review, and independent verification
+- Responsibility: Independently review plans when the user requests it and perform every implementation verification, exposing correctness risks and judging whether results satisfy their contracts.
 - Use AskUserQuestion for local blocking decisions.
 - oracle runs as an auto-discovered Claude Code plugin subagent invoked via Agent(subagent_type: thoth-agents:oracle); plugin subagents are namespaced with the plugin name. The orchestrator is the main Claude Code session.
 - Write and Edit are denied in frontmatter while all other inherited tools, including MCP tools, remain available.