thoth-agents 0.1.0

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

@@ -0,0 +1,219 @@
+import type { HarnessArtifactKind, HarnessDiagnostic } from '../types';
+export type CodexSurfaceStatus = 'validated' | 'unsupported' | 'unknown';
+export type CodexArtifactTarget = 'agent-definition' | 'config' | 'mcp-config' | 'plugin-manifest' | 'skill-directory' | 'hook-config' | 'permission-control' | 'delegation-runtime' | 'parent-context-injection';
+export interface CodexSurfaceRecord {
+    id: string;
+    target: CodexArtifactTarget;
+    status: CodexSurfaceStatus;
+    artifactKind?: HarnessArtifactKind;
+    path?: string;
+    fields: string[];
+    diagnosticCode: string;
+    summary: string;
+    evidence: string;
+    fallback?: 'instruction-only' | 'diagnostic-only' | 'none';
+}
+export type CodexHookEvent = 'SessionStart' | 'UserPromptSubmit' | 'PreToolUse' | 'PermissionRequest' | 'PostToolUse' | 'Stop';
+export type CodexHookHandlerType = 'command' | 'prompt' | 'agent';
+export interface CodexHookValidationInput {
+    event: string;
+    handler?: {
+        type?: string;
+        command?: unknown;
+        prompt?: unknown;
+        agent?: unknown;
+        async?: unknown;
+    };
+    outputFields?: readonly string[];
+    interceptsToolExecution?: boolean;
+}
+export type CodexHookValidationResult = {
+    ok: true;
+    event: CodexHookEvent;
+    handlerType: 'command';
+} | {
+    ok: false;
+    diagnostics: HarnessDiagnostic[];
+};
+export declare const CODEX_PLUGIN_MANIFEST_FIELDS: readonly ["name", "version", "description", "skills", "mcpServers", "apps", "hooks", "interface"];
+export declare const CODEX_SURFACES: readonly [{
+    readonly id: "project-agent-toml";
+    readonly target: "agent-definition";
+    readonly status: "validated";
+    readonly artifactKind: "agent-config";
+    readonly path: ".codex/agents/{name}.toml";
+    readonly fields: ["name", "description", "developer_instructions", "model", "model_reasoning_effort", "sandbox_mode"];
+    readonly diagnosticCode: "codex.surface.agent_definition.validated";
+    readonly summary: "Project-scoped custom agents are standalone TOML files.";
+    readonly evidence: "OpenAI Codex Subagents docs: ~/.codex/agents/ and .codex/agents/ with required name, description, developer_instructions.";
+}, {
+    readonly id: "project-config-toml";
+    readonly target: "config";
+    readonly status: "validated";
+    readonly artifactKind: "harness-config";
+    readonly path: ".codex/config.toml";
+    readonly fields: ["model", "model_reasoning_effort", "approval_policy", "sandbox_mode", "features", "mcp_servers", "skills.config", "agents"];
+    readonly diagnosticCode: "codex.surface.config.validated";
+    readonly summary: "Codex supports project-scoped config TOML after trust.";
+    readonly evidence: "OpenAI Codex Configuration Reference: ~/.codex/config.toml and project .codex/config.toml overrides.";
+}, {
+    readonly id: "mcp-server-config";
+    readonly target: "mcp-config";
+    readonly status: "validated";
+    readonly artifactKind: "mcp-config";
+    readonly path: ".codex/config.toml";
+    readonly fields: ["mcp_servers.<id>", "url", "command", "args", "env", "tools"];
+    readonly diagnosticCode: "codex.surface.mcp.validated";
+    readonly summary: "MCP servers are configured through Codex config TOML.";
+    readonly evidence: "OpenAI Codex config docs describe mcp_servers and per-tool approval overrides.";
+}, {
+    readonly id: "repo-skills-directory";
+    readonly target: "skill-directory";
+    readonly status: "validated";
+    readonly artifactKind: "skill";
+    readonly path: ".agents/skills/{skill}/SKILL.md";
+    readonly fields: ["SKILL.md", "scripts/", "references/", "assets/"];
+    readonly diagnosticCode: "codex.surface.skills.validated";
+    readonly summary: "Repository skills are discovered from .agents/skills.";
+    readonly evidence: "OpenAI Codex Skills docs: repo skills are scanned from .agents/skills up to the repository root.";
+}, {
+    readonly id: "project-hooks-json";
+    readonly target: "hook-config";
+    readonly status: "validated";
+    readonly artifactKind: "hook-config";
+    readonly path: ".codex/hooks.json";
+    readonly fields: ["SessionStart.command", "UserPromptSubmit.command", "PreToolUse.command", "PermissionRequest.command", "PostToolUse.command", "Stop.command"];
+    readonly diagnosticCode: "codex.surface.hooks_json.validated";
+    readonly summary: "Codex supports project-local hooks.json command handlers.";
+    readonly evidence: "OpenAI Codex hooks docs describe hooks.json with SessionStart, UserPromptSubmit, PreToolUse, PermissionRequest, PostToolUse, and Stop command handlers.";
+}, {
+    readonly id: "inline-hooks-table";
+    readonly target: "hook-config";
+    readonly status: "validated";
+    readonly artifactKind: "hook-config";
+    readonly path: ".codex/config.toml";
+    readonly fields: ["hooks.SessionStart.command", "hooks.UserPromptSubmit.command", "hooks.PreToolUse.command", "hooks.PermissionRequest.command", "hooks.PostToolUse.command", "hooks.Stop.command"];
+    readonly diagnosticCode: "codex.surface.inline_hooks.validated";
+    readonly summary: "Codex supports inline [hooks] configuration in TOML.";
+    readonly evidence: "OpenAI Codex configuration docs describe inline [hooks] settings gated by trusted project configuration.";
+}, {
+    readonly id: "features-hooks-toggle";
+    readonly target: "hook-config";
+    readonly status: "validated";
+    readonly artifactKind: "hook-config";
+    readonly path: ".codex/config.toml";
+    readonly fields: ["features.hooks"];
+    readonly diagnosticCode: "codex.surface.features_hooks.validated";
+    readonly summary: "Codex hook loading is controlled by the features.hooks toggle.";
+    readonly evidence: "OpenAI Codex configuration docs require enabling [features].hooks before project hook configuration is active.";
+}, {
+    readonly id: "plugin-hooks-bundle";
+    readonly target: "hook-config";
+    readonly status: "validated";
+    readonly artifactKind: "hook-config";
+    readonly path: ".codex/plugins/{plugin}/hooks.json";
+    readonly fields: ["features.plugin_hooks", "plugin.hooks", "plugin.trust_review"];
+    readonly diagnosticCode: "codex.surface.plugin_hooks.validated";
+    readonly summary: "Codex plugin hook bundles are documented behind plugin hook feature and trust review gates.";
+    readonly evidence: "OpenAI Codex plugin docs describe bundled hook configuration requiring plugin_hooks enablement and trust review.";
+}, {
+    readonly id: "plugin-manifest-json";
+    readonly target: "plugin-manifest";
+    readonly status: "validated";
+    readonly artifactKind: "manifest";
+    readonly path: ".codex-plugin/plugin.json";
+    readonly fields: ["name", "version", "description", "skills", "mcpServers", "apps", "hooks", "interface"];
+    readonly diagnosticCode: "codex.surface.plugin_manifest.validated";
+    readonly summary: "Codex plugin packages are described by a plugin-root plugin.json manifest.";
+    readonly evidence: "OpenAI Codex plugin docs describe plugin.json with official fields including name, version, description, skills, mcpServers, apps, hooks, and interface.";
+}, {
+    readonly id: "plugin-skills-directory";
+    readonly target: "skill-directory";
+    readonly status: "validated";
+    readonly artifactKind: "skill";
+    readonly path: ".codex-plugin/skills/{skill}/SKILL.md";
+    readonly fields: ["skills", "./skills/"];
+    readonly diagnosticCode: "codex.surface.plugin_skills.validated";
+    readonly summary: "Codex plugin packages can bundle skills under plugin-root skills/.";
+    readonly evidence: "OpenAI Codex plugin docs describe plugin-bundled skills referenced from plugin.json using plugin-root relative paths.";
+}, {
+    readonly id: "plugin-hooks-json";
+    readonly target: "hook-config";
+    readonly status: "validated";
+    readonly artifactKind: "hook-config";
+    readonly path: ".codex-plugin/hooks/hooks.json";
+    readonly fields: ["hooks", "./hooks/hooks.json"];
+    readonly diagnosticCode: "codex.surface.plugin_hooks_json.validated";
+    readonly summary: "Codex plugin packages can bundle hook configuration under plugin-root hooks/.";
+    readonly evidence: "OpenAI Codex plugin docs describe hook bundle assets referenced from plugin.json and gated by plugin_hooks plus trust review.";
+}, {
+    readonly id: "plugin-mcp-json";
+    readonly target: "mcp-config";
+    readonly status: "validated";
+    readonly artifactKind: "mcp-config";
+    readonly path: ".codex-plugin/.mcp.json";
+    readonly fields: ["mcpServers", "./.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 evidence: "OpenAI Codex plugin docs describe bundled .mcp.json server definitions referenced from plugin.json using plugin-root relative paths.";
+}, {
+    readonly id: "inline-hooks";
+    readonly target: "hook-config";
+    readonly status: "unknown";
+    readonly artifactKind: "hook-config";
+    readonly fields: ["features.hooks", "hooks"];
+    readonly diagnosticCode: "codex.surface.hooks.unvalidated";
+    readonly summary: "Lifecycle hook availability is documented, but hook event shape and parity with OpenCode runtime hooks is not validated for this adapter.";
+    readonly evidence: "Codex config reference mentions hooks; this implementation has not validated exact event schemas for plugin parity.";
+    readonly fallback: "diagnostic-only";
+}, {
+    readonly id: "per-agent-runtime-permissions";
+    readonly target: "permission-control";
+    readonly status: "unsupported";
+    readonly fields: ["per-agent tool allow/deny equivalent to OpenCode permissions"];
+    readonly diagnosticCode: "codex.permission.memory.enforcement_gap";
+    readonly summary: "Codex sandbox and approval policy can constrain sessions, but OpenCode-style per-agent MCP/tool deny maps are not validated.";
+    readonly evidence: "Codex approvals/security docs cover sandbox and approval policies, not exact OpenCode per-agent permission maps.";
+    readonly fallback: "instruction-only";
+}, {
+    readonly id: "programmatic-delegation-runtime";
+    readonly target: "delegation-runtime";
+    readonly status: "unsupported";
+    readonly fields: ["task API", "background task sessions", "tmux lifecycle hooks", "automatic subagent session close"];
+    readonly diagnosticCode: "codex.delegation.runtime.unsupported";
+    readonly summary: "Codex subagents are user/instruction-triggered; no OpenCode plugin task API or automatic subagent session close parity is validated.";
+    readonly evidence: "Codex subagents docs describe manual spawning and agent threads, not this plugin runtime task API or a validated runtime close hook.";
+    readonly fallback: "instruction-only";
+}, {
+    readonly id: "parent-context-injection";
+    readonly target: "parent-context-injection";
+    readonly status: "unknown";
+    readonly fields: ["parent session_id", "project"];
+    readonly diagnosticCode: "codex.context.parent_injection.unvalidated";
+    readonly summary: "No machine-enforced parent context injection mechanism is validated; prompts must instruct users to include parent session_id/project.";
+    readonly evidence: "No validated Codex surface in Phase 1 proves automatic parent context injection into spawned agents.";
+    readonly fallback: "instruction-only";
+}];
+export declare function getCodexSurfaceRecords(): CodexSurfaceRecord[];
+export declare function getCodexSurface(id: string): CodexSurfaceRecord | undefined;
+export declare function getValidatedCodexArtifactTargets(): CodexSurfaceRecord[];
+export declare function assertCodexSurfaceCanGenerate(id: string): {
+    ok: true;
+    surface: CodexSurfaceRecord;
+} | {
+    ok: false;
+    diagnostic: HarnessDiagnostic;
+};
+export declare function codexSurfaceDiagnostic(surface: CodexSurfaceRecord): HarnessDiagnostic;
+export declare function validateCodexPluginPackageSurface(input: {
+    surfaceId: string;
+    path?: string;
+    fields?: readonly string[];
+}): {
+    ok: true;
+    surface: CodexSurfaceRecord;
+} | {
+    ok: false;
+    diagnostics: HarnessDiagnostic[];
+};
+export declare function validateCodexHookSurface(input: CodexHookValidationInput): CodexHookValidationResult;

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

@@ -0,0 +1,8 @@
+import { type PluginConfig } from '../../config';
+import type { HarnessAdapter, HarnessCapabilities, HarnessRenderContext } from '../types';
+export interface CodexRenderContext extends HarnessRenderContext {
+    config?: PluginConfig;
+}
+export declare const CODEX_CAPABILITIES: HarnessCapabilities;
+export declare function renderCodexRootInstructions(config?: PluginConfig): string;
+export declare const codexAdapter: HarnessAdapter;

package/dist/harness/adapters/opencode.d.ts

@@ -0,0 +1,10 @@
+import type { AgentConfig } from '@opencode-ai/sdk/v2';
+import type { PluginConfig } from '../../config';
+import type { HarnessAdapter, HarnessCapabilities, HarnessRenderContext } from '../types';
+export type OpenCodeAgentConfigs = Record<string, AgentConfig>;
+export interface OpenCodeRenderContext extends HarnessRenderContext {
+    config?: PluginConfig;
+}
+export declare const OPENCODE_CAPABILITIES: HarnessCapabilities;
+export declare function renderOpenCodeAgentConfigs(config?: PluginConfig): OpenCodeAgentConfigs;
+export declare const opencodeAdapter: HarnessAdapter;

package/dist/harness/codex-plugin-paths.d.ts

@@ -0,0 +1 @@
+export declare function codexPluginRootArtifactPath(artifactPath: string): string;

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

@@ -0,0 +1,88 @@
+export type AgentRoleName = 'orchestrator' | 'explorer' | 'librarian' | 'oracle' | 'designer' | 'quick' | 'deep';
+export type AgentMutationMode = 'primary-non-mutating' | 'read-only' | 'write-capable';
+export type AgentDispatchMethod = 'root-coordinator' | 'task' | 'synchronous-task-only';
+export interface AgentRoleContract {
+    name: AgentRoleName;
+    mode: AgentMutationMode;
+    dispatch: AgentDispatchMethod;
+    canMutateWorkspace: boolean;
+    scope: string;
+    responsibility: string;
+    toolGovernance: string[];
+    verification: string[];
+}
+export interface AgentPackContract {
+    roles: AgentRoleContract[];
+    delegateFirstRules: 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 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 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 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 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 or artifact-producing SDD phases", "no task delegation"];
+    readonly verification: ["separates observations, risks, and recommendations"];
+}, {
+    readonly name: "designer";
+    readonly mode: "write-capable";
+    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 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 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"];
+}];
+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 AGENT_PACK_CONTRACT: AgentPackContract;
+export declare function getAgentRole(name: AgentRoleName): AgentRoleContract;
+export declare function getAgentPackContract(): AgentPackContract;

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

@@ -0,0 +1,33 @@
+import type { HarnessPromptDialect } from '../../agents/prompt-dialects';
+import type { HarnessCapabilityStatus, HarnessDiagnostic } from '../types';
+import type { AgentRoleContract, AgentRoleName } from './agent-pack';
+export type MemoryToolName = 'mem_session_start' | 'mem_session_summary' | 'mem_save_prompt' | 'mem_search' | 'mem_timeline' | 'mem_get_observation' | 'mem_suggest_topic_key' | 'mem_save';
+export type MemoryRuntimeEnforcement = 'runtime' | 'instruction-only';
+export interface RoleMemoryGovernance {
+    role: AgentRoleName;
+    rootOwnedTools: MemoryToolName[];
+    allowedTools: MemoryToolName[];
+    forbiddenTools: MemoryToolName[];
+    requiresParentContext: boolean;
+    mayReadProjectMemory: boolean;
+    mayWriteDurableObservations: boolean;
+    protectsSddNamespace: boolean;
+    rules: string[];
+}
+export interface MemoryGovernanceContract {
+    rootOwnedTools: MemoryToolName[];
+    readRecallChain: MemoryToolName[];
+    writeCapableDelegatedTools: MemoryToolName[];
+    protectedTopicNamespaces: string[];
+    roles: RoleMemoryGovernance[];
+}
+export interface MemoryGovernanceDiagnosticInput {
+    harness: string;
+    permissionControls: HarnessCapabilityStatus;
+    parentContextInjection: HarnessCapabilityStatus;
+    memoryWriteControls: HarnessCapabilityStatus;
+}
+export declare function getRoleMemoryGovernance(role: AgentRoleContract): RoleMemoryGovernance;
+export declare function getMemoryGovernanceContract(roles: readonly AgentRoleContract[]): MemoryGovernanceContract;
+export declare function renderMemoryGovernanceInstructions(role: AgentRoleContract, dialect?: HarnessPromptDialect): string;
+export declare function memoryGovernanceDiagnostics(input: MemoryGovernanceDiagnosticInput): HarnessDiagnostic[];

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

@@ -0,0 +1,100 @@
+export type SddPipelineType = 'direct' | 'accelerated' | 'full';
+export type SddPhaseId = 'requirements-interview' | 'proposal' | 'spec' | 'design' | 'tasks' | 'plan-review' | 'implementation-confirmation' | 'apply' | 'verify' | 'archive';
+export interface SddPhaseContract {
+    id: SddPhaseId;
+    order: number;
+    requiredFor: SddPipelineType[];
+    prerequisites: SddPhaseId[];
+    producesArtifact: boolean;
+    gate?: 'oracle-review' | 'user-confirmation';
+    owner: 'orchestrator' | 'write-capable-agent' | 'oracle' | 'user';
+}
+export interface SddWorkflowContract {
+    phases: SddPhaseContract[];
+    routingRules: string[];
+    artifactRules: string[];
+    verificationRules: string[];
+}
+export declare const FULL_SDD_PHASE_ORDER: readonly ["requirements-interview", "proposal", "spec", "design", "tasks", "plan-review", "implementation-confirmation", "apply", "verify", "archive"];
+export declare const SDD_PHASES: readonly [{
+    readonly id: "requirements-interview";
+    readonly order: 0;
+    readonly requiredFor: ["direct", "accelerated", "full"];
+    readonly prerequisites: [];
+    readonly producesArtifact: false;
+    readonly owner: "orchestrator";
+}, {
+    readonly id: "proposal";
+    readonly order: 1;
+    readonly requiredFor: ["accelerated", "full"];
+    readonly prerequisites: ["requirements-interview"];
+    readonly producesArtifact: true;
+    readonly owner: "write-capable-agent";
+}, {
+    readonly id: "spec";
+    readonly order: 2;
+    readonly requiredFor: ["full"];
+    readonly prerequisites: ["proposal"];
+    readonly producesArtifact: true;
+    readonly owner: "write-capable-agent";
+}, {
+    readonly id: "design";
+    readonly order: 3;
+    readonly requiredFor: ["full"];
+    readonly prerequisites: ["proposal", "spec"];
+    readonly producesArtifact: true;
+    readonly owner: "write-capable-agent";
+}, {
+    readonly id: "tasks";
+    readonly order: 4;
+    readonly requiredFor: ["accelerated", "full"];
+    readonly prerequisites: ["proposal", "spec", "design"];
+    readonly producesArtifact: true;
+    readonly owner: "write-capable-agent";
+}, {
+    readonly id: "plan-review";
+    readonly order: 5;
+    readonly requiredFor: ["accelerated", "full"];
+    readonly prerequisites: ["tasks"];
+    readonly producesArtifact: false;
+    readonly gate: "oracle-review";
+    readonly owner: "oracle";
+}, {
+    readonly id: "implementation-confirmation";
+    readonly order: 6;
+    readonly requiredFor: ["accelerated", "full"];
+    readonly prerequisites: ["plan-review"];
+    readonly producesArtifact: false;
+    readonly gate: "user-confirmation";
+    readonly owner: "user";
+}, {
+    readonly id: "apply";
+    readonly order: 7;
+    readonly requiredFor: ["direct", "accelerated", "full"];
+    readonly prerequisites: ["implementation-confirmation"];
+    readonly producesArtifact: false;
+    readonly owner: "write-capable-agent";
+}, {
+    readonly id: "verify";
+    readonly order: 8;
+    readonly requiredFor: ["accelerated", "full"];
+    readonly prerequisites: ["apply"];
+    readonly producesArtifact: true;
+    readonly owner: "write-capable-agent";
+}, {
+    readonly id: "archive";
+    readonly order: 9;
+    readonly requiredFor: ["accelerated", "full"];
+    readonly prerequisites: ["verify"];
+    readonly producesArtifact: true;
+    readonly owner: "write-capable-agent";
+}];
+export declare const SDD_WORKFLOW_CONTRACT: SddWorkflowContract;
+export declare function getSddWorkflowContract(): SddWorkflowContract;
+export declare function getSddPhase(id: SddPhaseId): SddPhaseContract;
+export declare function getRequiredSddPhaseOrder(pipeline: SddPipelineType): SddPhaseId[];
+export declare function canEnterSddPhase({ pipeline, completed, target, }: {
+    pipeline: SddPipelineType;
+    completed: readonly SddPhaseId[];
+    target: SddPhaseId;
+}): boolean;

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

@@ -0,0 +1,183 @@
+import type { AgentRoleName } from './agent-pack';
+export type SkillRegistryEntryKind = 'skill' | 'shared-support';
+export interface SkillRegistryEntry {
+    name: string;
+    description: string;
+    allowedRoles: AgentRoleName[];
+    sourcePath: string;
+    kind: SkillRegistryEntryKind;
+    purpose: 'requirements' | 'sdd' | 'review' | 'memory' | 'discovery' | 'support';
+}
+export declare const SHARED_SKILL_SUPPORT: SkillRegistryEntry;
+export declare const BUNDLED_SKILL_REGISTRY: readonly [{
+    readonly name: "requirements-interview";
+    readonly description: "Mandatory step-0 discovery interview to understand user intent, clarify scope, and choose the right path before implementation";
+    readonly allowedRoles: AgentRoleName[];
+    readonly sourcePath: "src/skills/requirements-interview";
+    readonly kind: "skill";
+    readonly purpose: "requirements";
+}, {
+    readonly name: "thoth-mem-agents";
+    readonly description: "Orchestrator/subagent thoth-mem workflow contract for parent session_id/project ownership, prompt-save prohibitions, and safe durable memory usage";
+    readonly allowedRoles: ["orchestrator", "explorer", "librarian", "oracle", "designer", "quick", "deep"];
+    readonly sourcePath: "src/skills/thoth-mem-agents";
+    readonly kind: "skill";
+    readonly purpose: "memory";
+}, {
+    readonly name: "plan-reviewer";
+    readonly description: "Review SDD task plans for execution blockers and valid references";
+    readonly allowedRoles: ["orchestrator", "oracle"];
+    readonly sourcePath: "src/skills/plan-reviewer";
+    readonly kind: "skill";
+    readonly purpose: "review";
+}, {
+    readonly name: "sdd-init";
+    readonly description: "Initialize OpenSpec structure and SDD project context";
+    readonly allowedRoles: AgentRoleName[];
+    readonly sourcePath: "src/skills/sdd-init";
+    readonly kind: "skill";
+    readonly purpose: "sdd";
+}, {
+    readonly name: "sdd-propose";
+    readonly description: "Create change proposals for OpenSpec workflows";
+    readonly allowedRoles: AgentRoleName[];
+    readonly sourcePath: "src/skills/sdd-propose";
+    readonly kind: "skill";
+    readonly purpose: "sdd";
+}, {
+    readonly name: "sdd-spec";
+    readonly description: "Write OpenSpec delta specifications";
+    readonly allowedRoles: AgentRoleName[];
+    readonly sourcePath: "src/skills/sdd-spec";
+    readonly kind: "skill";
+    readonly purpose: "sdd";
+}, {
+    readonly name: "sdd-design";
+    readonly description: "Create technical design artifacts for changes";
+    readonly allowedRoles: AgentRoleName[];
+    readonly sourcePath: "src/skills/sdd-design";
+    readonly kind: "skill";
+    readonly purpose: "sdd";
+}, {
+    readonly name: "sdd-tasks";
+    readonly description: "Generate phased implementation task checklists";
+    readonly allowedRoles: AgentRoleName[];
+    readonly sourcePath: "src/skills/sdd-tasks";
+    readonly kind: "skill";
+    readonly purpose: "sdd";
+}, {
+    readonly name: "sdd-apply";
+    readonly description: "Execute tasks and persist implementation progress";
+    readonly allowedRoles: AgentRoleName[];
+    readonly sourcePath: "src/skills/sdd-apply";
+    readonly kind: "skill";
+    readonly purpose: "sdd";
+}, {
+    readonly name: "executing-plans";
+    readonly description: "Execute SDD task lists with real-time progress tracking, sub-agent dispatch, and verification checkpoints";
+    readonly allowedRoles: AgentRoleName[];
+    readonly sourcePath: "src/skills/executing-plans";
+    readonly kind: "skill";
+    readonly purpose: "sdd";
+}, {
+    readonly name: "sdd-verify";
+    readonly description: "Build verification reports and compliance matrices";
+    readonly allowedRoles: AgentRoleName[];
+    readonly sourcePath: "src/skills/sdd-verify";
+    readonly kind: "skill";
+    readonly purpose: "sdd";
+}, {
+    readonly name: "sdd-archive";
+    readonly description: "Archive completed OpenSpec changes with audit trails";
+    readonly allowedRoles: AgentRoleName[];
+    readonly sourcePath: "src/skills/sdd-archive";
+    readonly kind: "skill";
+    readonly purpose: "sdd";
+}];
+export declare const SKILL_REGISTRY: readonly [{
+    readonly name: "requirements-interview";
+    readonly description: "Mandatory step-0 discovery interview to understand user intent, clarify scope, and choose the right path before implementation";
+    readonly allowedRoles: AgentRoleName[];
+    readonly sourcePath: "src/skills/requirements-interview";
+    readonly kind: "skill";
+    readonly purpose: "requirements";
+}, {
+    readonly name: "thoth-mem-agents";
+    readonly description: "Orchestrator/subagent thoth-mem workflow contract for parent session_id/project ownership, prompt-save prohibitions, and safe durable memory usage";
+    readonly allowedRoles: ["orchestrator", "explorer", "librarian", "oracle", "designer", "quick", "deep"];
+    readonly sourcePath: "src/skills/thoth-mem-agents";
+    readonly kind: "skill";
+    readonly purpose: "memory";
+}, {
+    readonly name: "plan-reviewer";
+    readonly description: "Review SDD task plans for execution blockers and valid references";
+    readonly allowedRoles: ["orchestrator", "oracle"];
+    readonly sourcePath: "src/skills/plan-reviewer";
+    readonly kind: "skill";
+    readonly purpose: "review";
+}, {
+    readonly name: "sdd-init";
+    readonly description: "Initialize OpenSpec structure and SDD project context";
+    readonly allowedRoles: AgentRoleName[];
+    readonly sourcePath: "src/skills/sdd-init";
+    readonly kind: "skill";
+    readonly purpose: "sdd";
+}, {
+    readonly name: "sdd-propose";
+    readonly description: "Create change proposals for OpenSpec workflows";
+    readonly allowedRoles: AgentRoleName[];
+    readonly sourcePath: "src/skills/sdd-propose";
+    readonly kind: "skill";
+    readonly purpose: "sdd";
+}, {
+    readonly name: "sdd-spec";
+    readonly description: "Write OpenSpec delta specifications";
+    readonly allowedRoles: AgentRoleName[];
+    readonly sourcePath: "src/skills/sdd-spec";
+    readonly kind: "skill";
+    readonly purpose: "sdd";
+}, {
+    readonly name: "sdd-design";
+    readonly description: "Create technical design artifacts for changes";
+    readonly allowedRoles: AgentRoleName[];
+    readonly sourcePath: "src/skills/sdd-design";
+    readonly kind: "skill";
+    readonly purpose: "sdd";
+}, {
+    readonly name: "sdd-tasks";
+    readonly description: "Generate phased implementation task checklists";
+    readonly allowedRoles: AgentRoleName[];
+    readonly sourcePath: "src/skills/sdd-tasks";
+    readonly kind: "skill";
+    readonly purpose: "sdd";
+}, {
+    readonly name: "sdd-apply";
+    readonly description: "Execute tasks and persist implementation progress";
+    readonly allowedRoles: AgentRoleName[];
+    readonly sourcePath: "src/skills/sdd-apply";
+    readonly kind: "skill";
+    readonly purpose: "sdd";
+}, {
+    readonly name: "executing-plans";
+    readonly description: "Execute SDD task lists with real-time progress tracking, sub-agent dispatch, and verification checkpoints";
+    readonly allowedRoles: AgentRoleName[];
+    readonly sourcePath: "src/skills/executing-plans";
+    readonly kind: "skill";
+    readonly purpose: "sdd";
+}, {
+    readonly name: "sdd-verify";
+    readonly description: "Build verification reports and compliance matrices";
+    readonly allowedRoles: AgentRoleName[];
+    readonly sourcePath: "src/skills/sdd-verify";
+    readonly kind: "skill";
+    readonly purpose: "sdd";
+}, {
+    readonly name: "sdd-archive";
+    readonly description: "Archive completed OpenSpec changes with audit trails";
+    readonly allowedRoles: AgentRoleName[];
+    readonly sourcePath: "src/skills/sdd-archive";
+    readonly kind: "skill";
+    readonly purpose: "sdd";
+}, SkillRegistryEntry];
+export declare function getSkillRegistry(): SkillRegistryEntry[];
+export declare function getBundledSkillRegistry(): SkillRegistryEntry[];

package/dist/harness/generate-codex-plugin.d.ts

@@ -0,0 +1,9 @@
+import type { HarnessDiagnostic } from './types';
+export interface GenerateCodexPluginPackageOptions {
+    projectRoot: string;
+}
+export interface GenerateCodexPluginPackageResult {
+    written: string[];
+    diagnostics: HarnessDiagnostic[];
+}
+export declare function generateCodexPluginPackage({ projectRoot, }: GenerateCodexPluginPackageOptions): GenerateCodexPluginPackageResult;