thoth-agents 0.4.1 → 0.5.0

package/dist/cli/types.d.ts

@@ -4,6 +4,7 @@ export interface InstallArgs {
     tui: boolean;
     agent?: InstallAgent;
     localPackageRoot?: string;
+    localPiRuntimeRoot?: string;
     tmux?: BooleanArg;
     dryRun?: boolean;
     reset?: boolean;
@@ -55,6 +56,7 @@ export interface InstallConfig {
     agent: InstallAgent;
     hasTmux: boolean;
     localPackageRoot?: string;
+    localPiRuntimeRoot?: string;
     dryRun?: boolean;
     reset: boolean;
 }

package/dist/config/constants.d.ts

@@ -1,6 +1,6 @@
-type BuiltinAgentName = 'orchestrator' | 'explorer' | 'librarian' | 'oracle' | 'designer' | 'quick' | 'deep';
+type BuiltinAgentName = 'orchestrator' | 'explorer' | 'librarian' | 'oracle' | 'designer' | 'worker';
 export type AgentName = BuiltinAgentName | (string & {});
-export declare const SUBAGENT_NAMES: readonly ["explorer", "librarian", "oracle", "designer", "quick", "deep"];
+export declare const SUBAGENT_NAMES: readonly ["explorer", "librarian", "oracle", "designer", "worker"];
 export declare const ORCHESTRATOR_NAME: "orchestrator";
 export declare const ALL_AGENT_NAMES: readonly BuiltinAgentName[];
 export declare const SUBAGENT_DELEGATION_RULES: Record<AgentName, readonly string[]>;
@@ -21,13 +21,9 @@ export declare const CONFIRMED_OPENAI_SUBAGENT_PRESET: {
         readonly model: "gpt-6-sol";
         readonly effort: "medium";
     };
-    readonly quick: {
+    readonly worker: {
         readonly model: "gpt-6-luna";
-        readonly effort: "medium";
-    };
-    readonly deep: {
-        readonly model: "gpt-6-sol";
-        readonly effort: "medium";
+        readonly effort: "max";
     };
 };
 export declare const OPENCODE_OPENAI_ORCHESTRATOR_PRESET: {

package/dist/config/schema.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-declare const FALLBACK_AGENT_NAMES: readonly ["orchestrator", "oracle", "designer", "explorer", "librarian", "quick", "deep"];
-declare const MANUAL_AGENT_NAMES: readonly ["orchestrator", "oracle", "designer", "explorer", "librarian", "quick", "deep"];
+declare const FALLBACK_AGENT_NAMES: readonly ["orchestrator", "oracle", "designer", "explorer", "librarian", "worker"];
+declare const MANUAL_AGENT_NAMES: readonly ["orchestrator", "oracle", "designer", "explorer", "librarian", "worker"];
 export declare const ManualAgentPlanSchema: z.ZodObject<{
     primary: z.ZodString;
     fallback1: z.ZodString;
@@ -38,13 +38,7 @@ export declare const ManualPlanSchema: z.ZodObject<{
         fallback2: z.ZodString;
         fallback3: z.ZodString;
     }, z.core.$strip>;
-    quick: z.ZodObject<{
-        primary: z.ZodString;
-        fallback1: z.ZodString;
-        fallback2: z.ZodString;
-        fallback3: z.ZodString;
-    }, z.core.$strip>;
-    deep: z.ZodObject<{
+    worker: z.ZodObject<{
         primary: z.ZodString;
         fallback1: z.ZodString;
         fallback2: z.ZodString;
@@ -106,8 +100,7 @@ export declare const AgentNameSchema: z.ZodEnum<{
     librarian: "librarian";
     oracle: "oracle";
     designer: "designer";
-    quick: "quick";
-    deep: "deep";
+    worker: "worker";
 }>;
 export declare const McpNameSchema: z.ZodEnum<{
     exa: "exa";
@@ -131,15 +124,7 @@ export declare const FailoverConfigSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     timeoutMs: z.ZodDefault<z.ZodNumber>;
     retryDelayMs: z.ZodDefault<z.ZodNumber>;
-    chains: z.ZodDefault<z.ZodObject<{
-        orchestrator: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        oracle: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        designer: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        explorer: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        librarian: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        quick: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        deep: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$catchall<z.ZodArray<z.ZodString>>>>;
+    chains: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
 }, z.core.$strip>;
 export type FailoverConfig = z.infer<typeof FailoverConfigSchema>;
 export declare const PluginConfigSchema: z.ZodObject<{
@@ -183,13 +168,7 @@ export declare const PluginConfigSchema: z.ZodObject<{
             fallback2: z.ZodString;
             fallback3: z.ZodString;
         }, z.core.$strip>;
-        quick: z.ZodObject<{
-            primary: z.ZodString;
-            fallback1: z.ZodString;
-            fallback2: z.ZodString;
-            fallback3: z.ZodString;
-        }, z.core.$strip>;
-        deep: z.ZodObject<{
+        worker: z.ZodObject<{
             primary: z.ZodString;
             fallback1: z.ZodString;
             fallback2: z.ZodString;
@@ -230,15 +209,7 @@ export declare const PluginConfigSchema: z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         timeoutMs: z.ZodDefault<z.ZodNumber>;
         retryDelayMs: z.ZodDefault<z.ZodNumber>;
-        chains: z.ZodDefault<z.ZodObject<{
-            orchestrator: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            oracle: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            designer: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            explorer: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            librarian: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            quick: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            deep: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$catchall<z.ZodArray<z.ZodString>>>>;
+        chains: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
     }, z.core.$strip>>;
     codex: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;

package/dist/harness/adapters/claude-code.d.ts

@@ -10,14 +10,12 @@ export declare const CLAUDE_CODE_SUBAGENT_DEFAULT_MODELS: {
     readonly librarian: "sonnet";
     readonly oracle: "opus";
     readonly designer: "sonnet";
-    readonly quick: "haiku";
-    readonly deep: "sonnet";
+    readonly worker: "sonnet";
 };
 export declare const CLAUDE_CODE_SUBAGENT_DEFAULT_EFFORTS: {
     readonly explorer: "low";
-    readonly quick: "low";
     readonly designer: "medium";
-    readonly deep: "medium";
+    readonly worker: "medium";
     readonly librarian: "high";
     readonly oracle: "high";
 };

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

@@ -1,6 +1,6 @@
-export type AgentRoleName = 'orchestrator' | 'explorer' | 'librarian' | 'oracle' | 'designer' | 'quick' | 'deep';
+export type AgentRoleName = 'orchestrator' | 'explorer' | 'librarian' | 'oracle' | 'designer' | 'worker';
 export type AgentMutationMode = 'adaptive-root' | 'read-only' | 'write-capable';
-export type AgentDispatchMethod = 'root-coordinator' | 'task' | 'synchronous-task-only';
+export type AgentDispatchMethod = 'root-coordinator' | 'task';
 export interface AgentRoleContract {
     name: AgentRoleName;
     mode: AgentMutationMode;
@@ -23,7 +23,7 @@ export interface OrchestrationPolicy {
     specialistDirectory: SpecialistDecision[];
     rules: string[];
 }
-export type TaskShapingStep = 'bound-work' | 'map-dependencies' | 'assign-ownership' | 'select-specialists' | 'mark-ready-and-blocked' | 'dispatch-ready-wave' | 'wait-for-terminal-evidence' | 'reconcile-and-verify';
+export type TaskShapingStep = 'bound-units' | 'map-output-dependencies' | 'assign-ownership' | 'select-specialists' | 'admit-ready-units' | 'dispatch-to-native-capacity' | 'wait-for-native-terminal-event' | 'accept-results' | 'refill-capacity';
 export interface TaskShapingPolicy {
     steps: TaskShapingStep[];
     nativeAuthority: boolean;
@@ -31,7 +31,13 @@ export interface TaskShapingPolicy {
     decisions: {
         dependency: string;
         ownershipConflict: string;
-        readyWave: string;
+        unitOutcome: string;
+        unitEnvelope: string;
+        phaseSplitting: string;
+        independentDiscovery: string;
+        scopeGrowth: string;
+        readyDispatch: string;
+        refill: string;
         terminalEvidence: string;
         degradation: string;
     };
@@ -41,34 +47,42 @@ export interface SpecialistDecision {
     selectWhen: string;
     rejectWhen: string;
 }
-export type ImplementationOwner = 'orchestrator' | 'designer' | 'quick' | 'deep';
+export type ImplementationOwner = 'orchestrator' | 'designer' | 'worker';
 export interface ImplementationOwnershipPolicy {
     eligibleOwners: ImplementationOwner[];
-    routeIndependent: boolean;
-    delegationBenefits: string[];
-    rootContinuityBenefits: string[];
+    workflowIndependent: boolean;
+    defaultImplementationOwner: 'specialist';
+    rootIdentity: string;
+    defaultRule: string;
+    rootResponsibilities: string[];
+    discovery: string[];
+    directConsultation: string[];
+    directException: string[];
+    writerRouting: string[];
+    evidenceHandling: string[];
+    delegationFailure: string[];
     userDirection: string;
     insufficientSignals: string[];
 }
 export interface AgentPackContract {
     roles: AgentRoleContract[];
     orchestrationPolicy: OrchestrationPolicy;
-    returnContract: string[];
+    returnContract: Record<AgentRoleName, string[]>;
     verificationProtocol: string[];
 }
-export declare const AGENT_ROLE_NAMES: readonly ["orchestrator", "explorer", "librarian", "oracle", "designer", "quick", "deep"];
+export declare const AGENT_ROLE_NAMES: readonly ["orchestrator", "explorer", "librarian", "oracle", "designer", "worker"];
 export declare const AGENT_ROLES: readonly [{
     readonly name: "orchestrator";
     readonly mode: "adaptive-root";
     readonly dispatch: "root-coordinator";
     readonly canMutateWorkspace: true;
-    readonly scope: "requirements, SDD coordination, routing, bounded implementation, decisions, and synthesis";
-    readonly responsibility: "Keep requirements, decisions, sequential SDD coordination, and final synthesis in the root thread; evaluate implementation ownership independently in every route, implement directly or delegate by demonstrated net gain, and run focused verification for trivial deterministic Direct work.";
-    readonly useWhen: ["Coordinate requirements, governed artifacts, routing, and synthesis.", "Implement an accepted mutable surface in any route when accumulated context and continuity outweigh delegation overhead."];
+    readonly scope: "human agreement, SDD coordination, bounded direct exceptions, decisions, and synthesis";
+    readonly responsibility: "Coordinate goals, decisions, acceptance, and synthesis under the specialist-default implementation-ownership policy; direct work is limited to its bounded exceptions and explicit user instructions.";
+    readonly useWhen: ["Coordinate goals, constraints, decisions, governed artifacts, routing, acceptance, and synthesis.", "Retain reviewed commits and known low-risk mechanical operations; honor explicit direct-work or no-delegation instructions.", "Consult a known source for one bounded question or make a minimal authorized low-risk edit only when source, scope, and verification are known and no discovery or independent judgment is needed."];
     readonly doNotUseWhen: ["Not for independent plan review or Oracle-required final verification."];
-    readonly escalateWhen: ["Delegate implementation when specialization, context isolation, or independent bounded work creates a demonstrated net gain; then select designer, quick, or deep by task shape."];
-    readonly toolGovernance: ["may inspect and edit the accepted bounded implementation surface in every route and may verify trivial deterministic Direct work without self-approval", "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: ["runs focused checks for trivial deterministic Direct work while final verification remains mandatory", "delegates selected plan review plus Accelerated, Full, and material-risk Direct final verification to a fresh oracle", "consolidates summarized evidence returned by child agents"];
+    readonly escalateWhen: ["Reassess ownership when actual uncertainty, scope, or risk increases, not because another search is needed; never override explicit no-delegation instructions."];
+    readonly toolGovernance: ["may inspect and edit the accepted bounded implementation surface and may verify trivial deterministic work without self-approval", "loads the matching thoth-sdd phase guidance on demand instead of carrying every phase protocol in its prompt", "owns proportional understanding, classification, one ID-named substantial-change record, semantic acceptance, and active .thoth/ work evidence", "uses the bounded implementation-ownership exceptions for reviewed commits and known low-risk mechanical work", "keeps requirements, decisions, and final synthesis in the root thread"];
+    readonly verification: ["runs focused checks for trivial deterministic work while final verification remains mandatory", "delegates selected focused plan review plus artifact-backed and material-risk final verification to a fresh oracle", "consolidates summarized evidence returned by child agents"];
 }, {
     readonly name: "explorer";
     readonly mode: "read-only";
@@ -76,7 +90,7 @@ export declare const AGENT_ROLES: readonly [{
     readonly canMutateWorkspace: false;
     readonly scope: "local repository discovery";
     readonly responsibility: "Resolve broad or uncertain repository questions and return distilled evidence.";
-    readonly useWhen: ["Repository ownership or behavior is broad or uncertain."];
+    readonly useWhen: ["Local source, effective flow, responsibility, repository ownership, or behavior is unknown or uncertain."];
     readonly doNotUseWhen: ["Not for implementation, edits, or known narrow questions."];
     readonly escalateWhen: ["Send external evidence to librarian and mutation scope to root."];
     readonly toolGovernance: ["uses read, search, and code-navigation tools only", "does not mutate files or delegate further"];
@@ -96,11 +110,11 @@ export declare const AGENT_ROLES: readonly [{
 }, {
     readonly name: "oracle";
     readonly mode: "read-only";
-    readonly dispatch: "synchronous-task-only";
+    readonly dispatch: "task";
     readonly canMutateWorkspace: false;
-    readonly scope: "diagnosis, architecture, optional plan review, and independent verification";
-    readonly responsibility: "Independently review plans when the user requests it and provide independent judgment for artifact-backed or material-risk final verification, exposing correctness risks and judging whether results satisfy their contracts.";
-    readonly useWhen: ["Selected plan review, persistent diagnosis, material architecture or security risk, contradictory evidence, high failure cost, or artifact-backed final verification needs independent judgment."];
+    readonly scope: "diagnosis, architecture, optional focused plan review, and independent verification";
+    readonly responsibility: "Independently review plans when selected and provide independent judgment for artifact-backed or material-risk final verification, exposing correctness risks and judging whether results satisfy their contracts.";
+    readonly useWhen: ["Selected focused plan review, persistent diagnosis, material architecture or security risk, contradictory evidence, high failure cost, or artifact-backed final verification needs independent judgment."];
     readonly doNotUseWhen: ["Not for implementation, mutation, persistence, or self-review."];
     readonly escalateWhen: ["Return blockers and remediation anchors to root."];
     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"];
@@ -108,42 +122,38 @@ export declare const AGENT_ROLES: readonly [{
 }, {
     readonly name: "designer";
     readonly mode: "write-capable";
-    readonly dispatch: "synchronous-task-only";
+    readonly dispatch: "task";
     readonly canMutateWorkspace: true;
     readonly scope: "UI/UX decisions, implementation, and visual verification";
     readonly responsibility: "Own user-facing implementation choices and visual quality for UI work.";
     readonly useWhen: ["User-facing UI/UX, interaction, accessibility, or visual quality is material."];
     readonly doNotUseWhen: ["Not for backend-only, non-visual, or correctness-heavy cross-cutting work."];
-    readonly escalateWhen: ["Escalate coupled contracts, migrations, or high risk to deep."];
+    readonly escalateWhen: ["Escalate coupled contracts, migrations, or high risk to worker."];
     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 narrow, clear, low-risk changes within an explicitly bounded surface.";
-    readonly useWhen: ["Known narrow mechanical low-risk work has exact targets."];
-    readonly doNotUseWhen: ["Not for coupled contracts, migrations, broad discovery, concurrency, edge cases, or high risk."];
-    readonly escalateWhen: ["Escalate discovery, coupling, edge cases, or higher risk to deep."];
-    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 name: "worker";
     readonly mode: "write-capable";
-    readonly dispatch: "synchronous-task-only";
+    readonly dispatch: "task";
     readonly canMutateWorkspace: true;
-    readonly scope: "correctness-critical implementation and verification";
-    readonly responsibility: "Handle multi-file, edge-case-heavy, or high-risk implementation with full local context.";
-    readonly useWhen: ["Implementation is multi-file, edge-case-heavy, migration, concurrency, shared-contract, or high-risk."];
-    readonly doNotUseWhen: ["Not for visual-only work or narrow known low-risk edits."];
+    readonly scope: "bounded nonvisual implementation and verification";
+    readonly responsibility: "Handle bounded nonvisual implementation with full local context, including exact low-risk edits and correctness-critical, multi-file, edge-case-heavy, or high-risk work.";
+    readonly useWhen: ["Known bounded nonvisual implementation is ready, regardless of complexity; root direct work is limited to the bounded implementation-ownership exceptions.", "Correctness-critical work may be multi-file, edge-case-heavy, migration, concurrency, shared-contract, or high-risk."];
+    readonly doNotUseWhen: ["Not for visual-only work, reviewed commits, or work explicitly retained by the user in root."];
     readonly escalateWhen: ["Return product or architecture choices to root."];
     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 function getImplementationOwnershipInstructions(policy: ImplementationOwnershipPolicy): string[];
 export declare const ORCHESTRATION_POLICY: OrchestrationPolicy;
-export declare const AGENT_RETURN_CONTRACT: readonly ["conclusion", "evidence", "verification", "risks", "openQuestions", "nextAction"];
+export declare const AGENT_RETURN_CONTRACT: {
+    readonly orchestrator: readonly ["conclusion", "evidence", "verification", "risks", "openQuestions", "nextAction"];
+    readonly explorer: readonly ["conclusion", "evidence", "verification", "risks", "openQuestions"];
+    readonly librarian: readonly ["conclusion", "evidence", "verification", "risks", "openQuestions"];
+    readonly oracle: readonly ["conclusion", "evidence", "verification", "risks", "openQuestions", "nextAction"];
+    readonly designer: readonly ["conclusion", "evidence", "verification", "risks", "openQuestions", "nextAction"];
+    readonly worker: 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;

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

@@ -21,8 +21,8 @@ export interface MemoryOrchestrationContract {
     provider: 'thoth-mem';
     providerOwnership: 'external';
     installedGuidance: 'thoth-mem skill';
-    canonicalSddStore: 'openspec/';
-    prohibitsSddArtifactMirroring: true;
+    canonicalWorkStore: '.thoth/';
+    prohibitsWorkArtifactMirroring: true;
     requiresParentAuthorization: true;
     rootLifecycleOwner: 'orchestrator';
     handoffOutcome: 'bounded-memory-contract';