thoth-agents 0.2.11 → 0.3.1

package/dist/config/schema.d.ts

@@ -101,11 +101,11 @@ export declare const PresetSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
 }, z.core.$strip>>;
 export type Preset = z.infer<typeof PresetSchema>;
 export declare const AgentNameSchema: z.ZodEnum<{
-    explorer: "explorer";
-    designer: "designer";
     orchestrator: "orchestrator";
+    explorer: "explorer";
     librarian: "librarian";
     oracle: "oracle";
+    designer: "designer";
     quick: "quick";
     deep: "deep";
 }>;
@@ -113,30 +113,8 @@ export declare const McpNameSchema: z.ZodEnum<{
     exa: "exa";
     context7: "context7";
     grep_app: "grep_app";
-    thoth_mem: "thoth_mem";
 }>;
 export type McpName = string;
-export declare const ThothConfigSchema: z.ZodObject<{
-    command: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    data_dir: z.ZodOptional<z.ZodString>;
-    environment: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    timeout: z.ZodOptional<z.ZodNumber>;
-    http_port: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export type ThothConfig = z.infer<typeof ThothConfigSchema>;
-export declare const ArtifactStoreModeSchema: z.ZodEnum<{
-    "thoth-mem": "thoth-mem";
-    openspec: "openspec";
-    hybrid: "hybrid";
-}>;
-export declare const ArtifactStoreConfigSchema: z.ZodObject<{
-    mode: z.ZodDefault<z.ZodEnum<{
-        "thoth-mem": "thoth-mem";
-        openspec: "openspec";
-        hybrid: "hybrid";
-    }>>;
-}, z.core.$strip>;
-export type ArtifactStoreConfig = z.infer<typeof ArtifactStoreConfigSchema>;
 export declare const CodexGenerationConfigSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     outputRoot: z.ZodOptional<z.ZodString>;
@@ -262,20 +240,6 @@ export declare const PluginConfigSchema: z.ZodObject<{
             deep: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$catchall<z.ZodArray<z.ZodString>>>>;
     }, z.core.$strip>>;
-    thoth: z.ZodOptional<z.ZodObject<{
-        command: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        data_dir: z.ZodOptional<z.ZodString>;
-        environment: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        timeout: z.ZodOptional<z.ZodNumber>;
-        http_port: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    artifactStore: z.ZodOptional<z.ZodObject<{
-        mode: z.ZodDefault<z.ZodEnum<{
-            "thoth-mem": "thoth-mem";
-            openspec: "openspec";
-            hybrid: "hybrid";
-        }>>;
-    }, z.core.$strip>>;
     codex: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         outputRoot: z.ZodOptional<z.ZodString>;

package/dist/config/utils.d.ts

@@ -1,7 +1,6 @@
 import type { AgentOverrideConfig, PluginConfig } from './schema';
 /**
- * Get agent override config by name, supporting backward-compatible aliases.
- * Checks both the current name and any legacy alias names.
+ * Get an agent override by its canonical v0.3 role name.
  *
  * @param config - The plugin configuration
  * @param name - The current agent name

package/dist/harness/adapters/codex-surfaces.d.ts

@@ -151,10 +151,10 @@ export declare const CODEX_SURFACES: readonly [{
     readonly target: "mcp-config";
     readonly status: "validated";
     readonly artifactKind: "mcp-config";
-    readonly path: ".codex-plugin/.mcp.json";
-    readonly fields: ["mcpServers", "./.mcp.json"];
+    readonly path: ".codex-plugin/codex.mcp.json";
+    readonly fields: ["mcpServers", "./codex.mcp.json"];
     readonly diagnosticCode: "codex.surface.plugin_mcp_json.validated";
-    readonly summary: "Codex plugin packages can bundle MCP server definitions in plugin-root .mcp.json.";
+    readonly summary: "Codex plugin packages can reference bundled MCP server definitions from the plugin root.";
     readonly evidence: "OpenAI Codex plugin docs describe bundled .mcp.json server definitions referenced from plugin.json using plugin-root relative paths.";
 }, {
     readonly id: "inline-hooks";

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

@@ -1,5 +1,5 @@
 export type AgentRoleName = 'orchestrator' | 'explorer' | 'librarian' | 'oracle' | 'designer' | 'quick' | 'deep';
-export type AgentMutationMode = 'primary-non-mutating' | 'read-only' | 'write-capable';
+export type AgentMutationMode = 'adaptive-root' | 'read-only' | 'write-capable';
 export type AgentDispatchMethod = 'root-coordinator' | 'task' | 'synchronous-task-only';
 export interface AgentRoleContract {
     name: AgentRoleName;
@@ -8,50 +8,57 @@ export interface AgentRoleContract {
     canMutateWorkspace: boolean;
     scope: string;
     responsibility: string;
+    writeScope?: string[];
     toolGovernance: string[];
     verification: string[];
 }
+export interface OrchestrationPolicy {
+    maxDelegationDepth: number;
+    singleWriter: boolean;
+    rules: string[];
+}
 export interface AgentPackContract {
     roles: AgentRoleContract[];
-    delegateFirstRules: string[];
+    orchestrationPolicy: OrchestrationPolicy;
+    returnContract: string[];
     verificationProtocol: string[];
 }
 export declare const AGENT_ROLE_NAMES: readonly ["orchestrator", "explorer", "librarian", "oracle", "designer", "quick", "deep"];
 export declare const AGENT_ROLES: readonly [{
     readonly name: "orchestrator";
-    readonly mode: "primary-non-mutating";
+    readonly mode: "adaptive-root";
     readonly dispatch: "root-coordinator";
-    readonly canMutateWorkspace: false;
-    readonly scope: "coordination, routing, decisions, progress, and root memory";
-    readonly responsibility: "Delegate-first coordinator for SDD workflow, specialist dispatch, and root-session memory ownership.";
-    readonly toolGovernance: ["delegates inspection, writing, debugging, and verification", "owns question prompts and root-session memory", "does not perform inline workspace implementation"];
-    readonly verification: ["routes verification to specialists", "summarizes evidence from changed files, diagnostics, and tests"];
+    readonly canMutateWorkspace: true;
+    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 name: "explorer";
     readonly mode: "read-only";
     readonly dispatch: "task";
     readonly canMutateWorkspace: false;
     readonly scope: "local repository discovery";
-    readonly responsibility: "Find workspace facts fast and return paths, lines, symbols, constraints, edit targets, and conclusions.";
-    readonly toolGovernance: ["read/search/code-navigation tools only", "no durable memory writes", "no task delegation or progress ownership"];
-    readonly verification: ["reports confidence, anchors, unchecked areas, and gaps"];
+    readonly responsibility: "Resolve broad or uncertain repository questions and return distilled evidence.";
+    readonly toolGovernance: ["uses read, search, and code-navigation tools only", "does not mutate files or delegate further"];
+    readonly verification: ["reports inspected paths, confidence, and remaining gaps"];
 }, {
     readonly name: "librarian";
     readonly mode: "read-only";
     readonly dispatch: "task";
     readonly canMutateWorkspace: false;
-    readonly scope: "external research plus local confirmation when needed";
-    readonly responsibility: "Gather authoritative external evidence and distinguish official docs from examples.";
-    readonly toolGovernance: ["research and read-only local confirmation tools", "no workspace mutation", "no durable memory writes"];
-    readonly verification: ["sources every substantive external claim with a URL"];
+    readonly scope: "authoritative external research with local confirmation when needed";
+    readonly responsibility: "Gather current authoritative evidence and separate documented facts from inference.";
+    readonly toolGovernance: ["uses research and read-only local tools", "does not mutate files or delegate further"];
+    readonly verification: ["provides direct sources for substantive external claims"];
 }, {
     readonly name: "oracle";
     readonly mode: "read-only";
     readonly dispatch: "synchronous-task-only";
     readonly canMutateWorkspace: false;
-    readonly scope: "advice, diagnosis, architecture, code review, and plan review";
-    readonly responsibility: "Provide strategic technical guidance anchored to evidence and review SDD plans.";
-    readonly toolGovernance: ["read-only analysis and review", "no implementation; may perform read-only SDD plan review and verification review, but does not persist artifacts", "no task delegation"];
+    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 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"];
 }, {
     readonly name: "designer";
@@ -59,30 +66,31 @@ export declare const AGENT_ROLES: readonly [{
     readonly dispatch: "synchronous-task-only";
     readonly canMutateWorkspace: true;
     readonly scope: "UI/UX decisions, implementation, and visual verification";
-    readonly responsibility: "Own user-facing implementation choices and visual QA for UI work.";
-    readonly toolGovernance: ["may edit focused UI/UX files", "owns screenshots and visual QA", "does not delegate or own SDD progress"];
-    readonly verification: ["includes visual verification status when applicable"];
+    readonly responsibility: "Own user-facing implementation choices and visual quality for UI work.";
+    readonly toolGovernance: ["may edit focused UI/UX files", "owns screenshots and visual QA", "does not delegate further"];
+    readonly verification: ["includes visual verification when applicable"];
 }, {
     readonly name: "quick";
     readonly mode: "write-capable";
     readonly dispatch: "synchronous-task-only";
     readonly canMutateWorkspace: true;
     readonly scope: "fast bounded implementation";
-    readonly responsibility: "Implement well-defined narrow or mechanical changes with focused verification.";
-    readonly toolGovernance: ["may edit bounded targets", "does not perform broad rediscovery", "does not delegate or own SDD progress"];
+    readonly responsibility: "Implement narrow, clear, low-risk changes within an explicitly bounded surface.";
+    readonly toolGovernance: ["edits only bounded targets", "escalates when discovery or correctness risk exceeds the assignment", "does not delegate further"];
     readonly verification: ["runs the smallest sufficient focused check"];
 }, {
     readonly name: "deep";
     readonly mode: "write-capable";
     readonly dispatch: "synchronous-task-only";
     readonly canMutateWorkspace: true;
-    readonly scope: "thorough implementation and verification";
-    readonly responsibility: "Handle correctness-critical, multi-file, or edge-case-heavy changes with full local context analysis.";
-    readonly toolGovernance: ["may edit implementation and tests", "validates shared behavior against related code and call sites", "does not delegate or own SDD progress"];
-    readonly verification: ["does not skip verification and reports edge-case evidence"];
+    readonly scope: "correctness-critical implementation and verification";
+    readonly responsibility: "Handle multi-file, edge-case-heavy, or high-risk implementation with full local context.";
+    readonly toolGovernance: ["may edit implementation and tests within the assigned surface", "validates shared behavior against related code and call sites", "does not delegate further"];
+    readonly verification: ["reports focused checks and relevant edge-case evidence"];
 }];
-export declare const DELEGATE_FIRST_RULES: readonly ["The orchestrator coordinates, decides, asks blocking questions, and delegates evidence or action.", "Explorer, librarian, and oracle remain read-only specialists.", "Designer, quick, and deep are write-capable leaf agents with synchronous task dispatch.", "Subagents return findings, diffs, verification, and blockers rather than raw file dumps.", "No leaf agent owns SDD progress checkboxes or orchestrator-only memory."];
-export declare const VERIFICATION_PROTOCOL: readonly ["Completion reports include changed files and verification evidence.", "Behavior changes require the smallest sufficient automated check or an explicitly documented check.", "Visual changes require designer-owned visual QA when feasible."];
+export declare const ORCHESTRATION_POLICY: OrchestrationPolicy;
+export declare const AGENT_RETURN_CONTRACT: readonly ["conclusion", "evidence", "verification", "risks", "openQuestions", "nextAction"];
+export declare const VERIFICATION_PROTOCOL: readonly ["Completion reports identify changed files and verification evidence.", "Behavior changes receive the smallest sufficient automated check or a declared manual check.", "Visual changes receive designer-owned visual QA when applicable."];
 export declare const AGENT_PACK_CONTRACT: AgentPackContract;
 export declare function getAgentRole(name: AgentRoleName): AgentRoleContract;
 export declare function getAgentPackContract(): AgentPackContract;

package/dist/harness/core/memory-governance.d.ts

@@ -1,67 +1,43 @@
 import type { HarnessPromptDialect } from '../../agents/prompt-dialects';
 import type { HarnessCapabilityStatus, HarnessDiagnostic } from '../types';
 import type { AgentRoleContract, AgentRoleName } from './agent-pack';
-export type MemoryToolName = 'mem_save' | 'mem_recall' | 'mem_context' | 'mem_get' | 'mem_project' | 'mem_session';
-export type MemSaveKind = 'observation' | 'prompt' | 'session_summary' | 'passive_learnings';
-export type MemSessionAction = 'start' | 'checkpoint' | 'summary';
-export type MemRecallMode = 'compact' | 'context';
-export type MemProjectAction = 'list' | 'summary' | 'graph' | 'topics' | 'topic';
-export type MemoryOperation = {
-    tool: 'mem_session';
-    action: MemSessionAction;
-} | {
-    tool: 'mem_save';
-    kind: MemSaveKind;
-} | {
-    tool: 'mem_recall';
-    mode: MemRecallMode;
-} | {
-    tool: 'mem_get';
-    includeTimeline?: boolean;
-} | {
-    tool: 'mem_context';
-    recallQuery?: boolean;
-} | {
-    tool: 'mem_project';
-    action: MemProjectAction;
-};
-export type RootOwnedMemoryOperation = {
-    tool: 'mem_session';
-    action: MemSessionAction;
-} | {
-    tool: 'mem_save';
-    kind: 'prompt' | 'session_summary';
-};
-export type MemoryRuntimeEnforcement = 'runtime' | 'instruction-only';
+export type MemoryAuthorization = 'none' | 'recall' | 'observe';
+export interface MemoryDispatchContract {
+    provider: 'thoth-mem';
+    project: string;
+    rootSessionId?: string;
+    authorization: MemoryAuthorization;
+    context?: string[];
+}
 export interface RoleMemoryGovernance {
     role: AgentRoleName;
-    rootOwnedOperations: RootOwnedMemoryOperation[];
-    allowedTools: MemoryToolName[];
-    forbiddenTools: MemoryToolName[];
+    workspaceMode: AgentRoleContract['mode'];
     requiresParentContext: boolean;
-    mayReadProjectMemory: boolean;
-    mayWriteDurableObservations: boolean;
-    protectsSddNamespace: boolean;
+    availableAuthorizations: MemoryAuthorization[];
+    ownsRootLifecycle: boolean;
     rules: string[];
 }
-export interface MemoryGovernanceContract {
-    rootOwnedOperations: RootOwnedMemoryOperation[];
-    readRecallChain: MemoryOperation[];
-    writeCapableDelegatedTools: MemoryToolName[];
-    protectedTopicNamespaces: string[];
+export interface MemoryOrchestrationContract {
+    provider: 'thoth-mem';
+    providerOwnership: 'external';
+    installedGuidance: 'thoth-mem skill';
+    canonicalSddStore: 'openspec/';
+    prohibitsSddArtifactMirroring: true;
+    requiresParentAuthorization: true;
+    rootLifecycleOwner: 'orchestrator';
+    handoffOutcome: 'bounded-memory-contract';
+    completionOutcome: 'provider-confirmed-semantic-summary';
+    prohibitsFalseSuccess: true;
+    prohibitsConsumerFallback: true;
     roles: RoleMemoryGovernance[];
 }
+export type MemoryGovernanceContract = MemoryOrchestrationContract;
 export interface MemoryGovernanceDiagnosticInput {
     harness: string;
     permissionControls: HarnessCapabilityStatus;
     parentContextInjection: HarnessCapabilityStatus;
     memoryWriteControls: HarnessCapabilityStatus;
 }
-export declare const ROOT_OWNED_OPERATIONS: RootOwnedMemoryOperation[];
-export declare const READ_RECALL_CHAIN: MemoryOperation[];
-export declare const PARENT_SCOPED_READ_TOOLS: MemoryToolName[];
-export declare const WRITE_CAPABLE_DELEGATED_TOOLS: MemoryToolName[];
-export declare const ALL_MEMORY_TOOLS: MemoryToolName[];
 export declare function getRoleMemoryGovernance(role: AgentRoleContract): RoleMemoryGovernance;
 export declare function getMemoryGovernanceContract(roles: readonly AgentRoleContract[]): MemoryGovernanceContract;
 export declare function renderMemoryGovernanceInstructions(role: AgentRoleContract, dialect?: HarnessPromptDialect): string;