cc-codeconductor 0.5.0 → 1.1.0

package/dist/cli/errors.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Exit codes as per CLI contract
+ */
+export declare const ExitCode: {
+    readonly SUCCESS: 0;
+    readonly VALIDATION_ERROR: 1;
+    readonly UNSAFE_OPERATION: 2;
+    readonly UNSUPPORTED_PROJECT: 3;
+    readonly CONFIG_CONFLICT: 4;
+    readonly CREDENTIAL_LEAK: 5;
+};
+export type ExitCodeType = (typeof ExitCode)[keyof typeof ExitCode];
+/**
+ * Base error class for CLI errors
+ */
+export declare class CliError extends Error {
+    readonly code: ExitCodeType;
+    readonly details?: unknown | undefined;
+    constructor(message: string, code: ExitCodeType, details?: unknown | undefined);
+}
+/**
+ * Validation error - invalid arguments, malformed config, Zod validation failure
+ */
+export declare class ValidationError extends CliError {
+    constructor(message: string, details?: unknown);
+}
+/**
+ * Unsafe operation - destructive operation without --force, protected path conflict
+ */
+export declare class UnsafeOperationError extends CliError {
+    constructor(message: string, details?: unknown);
+}
+/**
+ * Unsupported project - project stack not detected or not supported
+ */
+export declare class UnsupportedProjectError extends CliError {
+    constructor(message: string, details?: unknown);
+}
+/**
+ * Config conflict - existing config conflicts with requested operation
+ */
+export declare class ConfigConflictError extends CliError {
+    constructor(message: string, details?: unknown);
+}
+/**
+ * Credential leak - content contains secrets or API keys
+ */
+export declare class CredentialGuardError extends CliError {
+    readonly matches: ReadonlyArray<{
+        filePath: string;
+        line: number;
+        pattern: string;
+        matched: string;
+    }>;
+    constructor(message: string, matches: ReadonlyArray<{
+        filePath: string;
+        line: number;
+        pattern: string;
+        matched: string;
+    }>, details?: unknown);
+}
+/**
+ * Map error to exit code
+ */
+export declare function getExitCode(error: unknown): ExitCodeType;

package/dist/core/compilation/compile-checker.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Compile Check — runs a build command via Bun.spawn, captures output,
+ * parses errors, and returns structured results for re-injection.
+ */
+export interface CompileError {
+    file: string;
+    line?: number;
+    column?: number;
+    code: string;
+    message: string;
+    raw: string;
+}
+export interface CompileResult {
+    success: boolean;
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    errors: CompileError[];
+    durationMs: number;
+    timedOut: boolean;
+    skipped?: boolean;
+    skipReason?: string;
+}
+export interface CompileCheckOptions {
+    /**
+     * Shell command to run (string or pre-split args). Default: `tsc --noEmit`.
+     * Must be a project-trusted compile command from config, never unsanitized CLI input.
+     */
+    command?: string | string[];
+    /** Working directory. Default: process.cwd() */
+    cwd?: string;
+    /** Timeout in milliseconds. Default: 120 000 (2 min) */
+    timeoutMs?: number;
+}
+/**
+ * Tokenize a shell command string, respecting single and double quotes.
+ *
+ * Exported so other modules that must spawn configured commands (e.g. the
+ * regression checklist) can avoid invoking a shell entirely.
+ */
+export declare function tokenizeCommand(cmd: string): string[];
+export declare function isAllowlistedCompileCommand(command: string | string[]): boolean;
+/** Allowlisted commands that actually run a test suite (`bun test`, `npm test`, …). */
+export declare function isAllowlistedTestCommand(command: string | string[]): boolean;
+/**
+ * Parse compile stderr output into structured CompileError[].
+ * Tries TypeScript format first, then ESLint, then generic.
+ */
+export declare function parseCompileErrors(stderr: string): CompileError[];
+/**
+ * Run a compile check via Bun.spawn with configurable timeout.
+ */
+export declare function runCompileCheck(options?: CompileCheckOptions): Promise<CompileResult>;

package/dist/core/config/codeconductor-config.d.ts

@@ -0,0 +1,42 @@
+/**
+ * CodeConductor configuration interface
+ */
+export interface CodeConductorConfig {
+    version: string;
+    project: {
+        name: string;
+        profile?: string;
+    };
+    defaults: {
+        target: 'opencode' | 'claude' | 'codex' | 'gemini' | 'cursor' | 'agy';
+        overwrite: boolean;
+        locale: 'en' | 'es';
+    };
+    presets: {
+        council: {
+            enabled: boolean;
+            version: string;
+        };
+    };
+    safety: {
+        destructiveCommands: string[];
+        secretPatterns: string[];
+        compileCheck?: {
+            enabled: boolean;
+            command?: string;
+            timeoutMs?: number;
+        };
+    };
+    loop?: {
+        enabled?: boolean;
+        maxIterations?: number;
+        maxTokenBudget?: number;
+    };
+}
+/**
+ * Default configuration.
+ * `safety.secretPatterns` references `DEFAULT_SECRET_PATTERNS` from
+ * credential-guard.ts so there is a single source of truth for default
+ * credential patterns.
+ */
+export declare const DEFAULT_CONFIG: CodeConductorConfig;

package/dist/core/config/config-loader.d.ts

@@ -0,0 +1,11 @@
+import { ValidationError } from '../../cli/errors';
+import { type Result } from '../../utils/result';
+import type { CodeConductorConfig } from './codeconductor-config';
+/**
+ * Load configuration from project root
+ */
+export declare function loadConfig(projectRoot: string): Promise<Result<CodeConductorConfig, ValidationError>>;
+/**
+ * Check if config exists
+ */
+export declare function configExists(projectRoot: string): Promise<boolean>;

package/dist/core/filesystem/credential-guard.d.ts

@@ -0,0 +1,18 @@
+import type { CodeConductorConfig } from '../config/codeconductor-config';
+/**
+ * Default keyword patterns. Empty by design: built-in detection is handled by
+ * the high-confidence signatures in `safety.ts`, which match provider-specific
+ * credential shapes instead of generic keyword assignments. Keyword matching
+ * remains available as an opt-in via project `secretPatterns`.
+ */
+export declare const DEFAULT_SECRET_PATTERNS: string[];
+/**
+ * Load opt-in keyword patterns by merging sources in priority order:
+ * 1. CodeConductorConfig.safety.secretPatterns (highest — user/project overrides)
+ * 2. policy.yml secretPatterns (declarative policy)
+ * 3. DEFAULT_SECRET_PATTERNS (empty — see above)
+ *
+ * These are additive to the always-on high-confidence signatures.
+ * Note: policy.yml loading is async, so this function is async.
+ */
+export declare function loadCredentialPatterns(config?: CodeConductorConfig): Promise<ReadonlyArray<string>>;

package/dist/core/goal/goal-planner.d.ts

@@ -0,0 +1,8 @@
+import type { GoalGraphInput } from '../../validation/schemas';
+/**
+ * Pure function: objective string → GoalGraph
+ *
+ * Matches the objective against built-in templates (auth, crud, search,
+ * notification, migration) or falls back to a generic 4-task chain.
+ */
+export declare function planGoal(objective: string): GoalGraphInput;

package/dist/core/goal/goal-state.d.ts

@@ -0,0 +1,15 @@
+import { type GoalGraphInput } from '../../validation/schemas';
+import { type Result } from '../../utils/result';
+/**
+ * Write a goal graph to .codeconductor/current-goal.yml
+ */
+export declare function writeGoal(projectRoot: string, graph: GoalGraphInput): Promise<Result<void, Error>>;
+/**
+ * Load and validate a goal graph from .codeconductor/current-goal.yml
+ */
+export declare function loadGoal(projectRoot: string): Promise<Result<GoalGraphInput, Error>>;
+/**
+ * Mark a task as blocked in the goal graph.
+ * Loads the graph, finds the task by ID, sets status to 'blocked', and writes back.
+ */
+export declare function markTaskBlocked(projectRoot: string, taskId: string, reason: string): Promise<Result<void, Error>>;

package/dist/core/loop/git-stats.d.ts

@@ -0,0 +1,13 @@
+/** Shared TTL so loop iterations do not spawn git on every tick. */
+export declare const GIT_STATS_CACHE_TTL_MS = 3000;
+export interface GitChangeStats {
+    readonly filesModified: number;
+    readonly linesChanged: number;
+}
+export type GitStatsReader = (cwd: string) => Promise<GitChangeStats>;
+export declare function resetGitStatsCache(): void;
+export declare function fetchGitChangeStats(cwd: string): Promise<GitChangeStats>;
+export declare function readGitChangeStats(cwd: string, options?: {
+    readonly now?: number;
+    readonly fetch?: GitStatsReader;
+}): Promise<GitChangeStats>;

package/dist/core/loop/loop-engine.d.ts

@@ -0,0 +1,82 @@
+import { type CompileError, type CompileResult } from '../compilation/compile-checker';
+import { type LoopState, type TddState } from '../../domain/loop/loop-state';
+import { type GitStatsReader } from './git-stats';
+import { type Result } from '../../utils/result';
+export interface LoopConfig {
+    maxIterations?: number;
+    maxTokenBudget?: number;
+    buildCommand?: string;
+    cwd?: string;
+    maxWallClockSeconds?: number;
+    maxFilesModified?: number;
+    maxLinesChanged?: number;
+    gitStats?: GitStatsReader;
+}
+export interface EscalationReport {
+    readonly taskTitle: string;
+    readonly iterationsAttempted: number;
+    readonly errorHistory: readonly (readonly CompileError[])[];
+    readonly attemptedFixes: readonly string[];
+    readonly originalContext: string;
+    readonly recommendedAction: string;
+}
+export interface LoopResult {
+    readonly success: boolean;
+    readonly iterations: number;
+    readonly totalErrors: number;
+    readonly finalPhase: LoopState['phase'];
+    readonly escalationReport?: EscalationReport;
+    readonly errorHistory: readonly (readonly CompileError[])[];
+    readonly compileCheck?: 'ran' | 'skipped';
+    readonly compileCheckSkipReason?: string;
+}
+export type GuardrailHit = {
+    readonly kind: 'timeout';
+    readonly elapsedSeconds: number;
+    readonly limit: number;
+} | {
+    readonly kind: 'files';
+    readonly count: number;
+    readonly limit: number;
+} | {
+    readonly kind: 'lines';
+    readonly count: number;
+    readonly limit: number;
+};
+/**
+ * Shared wall-clock / git-diff budget checks for compile-fix and the 8-phase pipeline.
+ */
+export declare class LoopEngine {
+    private readonly limits;
+    readonly startedAt: number;
+    constructor(limits: {
+        readonly maxWallClockSeconds?: number;
+        readonly maxFilesModified?: number;
+        readonly maxLinesChanged?: number;
+        readonly cwd?: string;
+    }, gitStats?: GitStatsReader, startedAt?: number);
+    private readonly gitStats;
+    evaluate(scope?: 'time' | 'all'): Promise<GuardrailHit | null>;
+}
+export declare function formatFeedback(errors: readonly CompileError[]): string;
+export type GenerateFn = (feedback?: string) => Promise<{
+    tokenUsage: number;
+} | void>;
+export type CompileCheckFn = () => Promise<CompileResult>;
+export declare function runLoop(generateFn: GenerateFn, compileCheckFn: CompileCheckFn, config?: LoopConfig, taskTitle?: string, originalTask?: string): Promise<LoopResult>;
+export declare function skippedCompileResult(reason: string): CompileResult;
+/** implement / test agent phases that must run the compile-fix engine. */
+export declare function shouldRunAgentLoop(type?: string, agentType?: string, phase?: string): boolean;
+/**
+ * Apply runner-captured TDD suite evidence to the domain TDD machine.
+ * Hand-written evidence files fail closed via `loadTddSuiteEvidence`.
+ */
+export declare function advanceTddPhase(projectRoot: string, taskId: string, state: TddState, evidenceId: string): Promise<Result<{
+    state: TddState;
+    result: 'CONTINUE' | 'TERMINATE';
+}, Error>>;
+export declare function runLoopForProject(projectRoot: string, options: {
+    readonly taskTitle: string;
+    readonly allowCompileCheck?: boolean;
+    readonly originalTask?: string;
+}): Promise<LoopResult>;

package/dist/core/memory/episodic-store.d.ts

@@ -0,0 +1,6 @@
+import { type ProductEventInput } from '../../validation/schemas';
+import { type Result } from '../../utils/result';
+export declare function appendEvent(projectRoot: string, event: Omit<ProductEventInput, 'id'> & {
+    id?: string;
+}): Promise<Result<ProductEventInput, Error>>;
+export declare function listEvents(projectRoot: string, since?: string, type?: ProductEventInput['type']): Promise<Result<ProductEventInput[], Error>>;

package/dist/core/memory/operational-state.d.ts

@@ -0,0 +1,6 @@
+import { type OperationalStateInput } from '../../validation/schemas';
+import { type Result } from '../../utils/result';
+export declare function loadOperationalState(projectRoot: string): Promise<Result<OperationalStateInput, Error>>;
+export declare function saveOperationalState(projectRoot: string, state: OperationalStateInput): Promise<Result<void, Error>>;
+export declare function setActiveTask(projectRoot: string, taskId: string, agent?: string): Promise<Result<void, Error>>;
+export declare function clearActiveTask(projectRoot: string, taskId: string): Promise<Result<void, Error>>;

package/dist/core/orchestrator/runtime-orchestrator.d.ts

@@ -0,0 +1,25 @@
+import type { CanonicalTaskCardInput, GoalGraphInput, GoalTaskInput, OperationalStateInput } from '../../validation/schemas';
+import { type Result } from '../../utils/result';
+import type { CommandEnvelopeInput } from '../../validation/schemas';
+/**
+ * Undo a task status change and restore the operational state captured before
+ * it. Used when a later step fails, so a task is never left half-transitioned.
+ * The original failure is returned, annotated when the undo itself fails.
+ */
+export declare function rollbackTaskStatus(projectRoot: string, graph: GoalGraphInput, task: GoalTaskInput, previousStatus: GoalTaskInput['status'], previousState: OperationalStateInput, cause: Error): Promise<Result<never, Error>>;
+export declare function getReadyTasks(graph: GoalGraphInput): GoalTaskInput[];
+export declare function goalTaskToCanonicalCard(task: GoalTaskInput & {
+    targetFiles?: string[];
+    agentType?: string;
+    evidenceRequired?: string[];
+}, objective: string): CanonicalTaskCardInput;
+export declare function buildTaskEnvelope(card: CanonicalTaskCardInput, projectRoot: string, projectName: string): CommandEnvelopeInput;
+export interface OrchestratorNextResult {
+    task: CanonicalTaskCardInput;
+    envelope: CommandEnvelopeInput;
+    readyCount: number;
+}
+export declare function getNextTask(projectRoot: string, projectName: string): Promise<Result<OrchestratorNextResult, Error>>;
+export declare function startTask(projectRoot: string, taskId: string, agent?: string): Promise<Result<void, Error>>;
+export declare function completeTask(projectRoot: string, taskId: string, evidenceIds?: string[]): Promise<Result<void, Error>>;
+export declare function formatGoalStatus(graph: GoalGraphInput): string;

package/dist/core/planner/product-planner.d.ts

@@ -0,0 +1,18 @@
+import type { GoalGraphInput, GoalTaskInput, ProductGraphInput } from '../../validation/schemas';
+export declare function inferEvidenceRequired(task: GoalTaskInput): string[];
+export interface ProductGoalGraph extends GoalGraphInput {
+    productEnriched: boolean;
+    impactPreview?: {
+        components: string[];
+        requirements: string[];
+    };
+}
+export declare function planProductGoal(objective: string, graph?: ProductGraphInput): ProductGoalGraph;
+export declare function enrichGoalWithProduct(graph: GoalGraphInput, productGraph?: ProductGraphInput): GoalGraphInput & {
+    enrichedTasks: Array<GoalTaskInput & {
+        targetFiles: string[];
+        agentType: string;
+        evidenceRequired: string[];
+    }>;
+};
+export declare function scoreTaskPriority(task: GoalTaskInput, graph?: ProductGraphInput): number;

package/dist/core/presets/package-paths.d.ts

@@ -0,0 +1,4 @@
+export declare const PACKAGE_ROOT: string;
+export declare const SRC_PRESETS_DIR: string;
+export declare const ROOT_PRESETS_DIR: string;
+export declare const POLICY_PATH: string;

package/dist/core/product-graph/graph-store.d.ts

@@ -0,0 +1,11 @@
+import type { ProductNodeType } from '../../domain/product/entities';
+import { type ProductGraphInput, type ProductGraphNodeInput, type ProductGraphEdgeInput } from '../../validation/schemas';
+import { type Result } from '../../utils/result';
+export declare function loadGraph(projectRoot: string): Promise<Result<ProductGraphInput, Error>>;
+export declare function saveGraph(projectRoot: string, graph: ProductGraphInput): Promise<Result<void, Error>>;
+export declare function upsertNode(graph: ProductGraphInput, node: ProductGraphNodeInput): ProductGraphInput;
+export declare function linkNodes(graph: ProductGraphInput, edge: ProductGraphEdgeInput): ProductGraphInput;
+export declare function queryNodes(graph: ProductGraphInput, type?: ProductNodeType, textFilter?: string): ProductGraphNodeInput[];
+export declare function findPath(graph: ProductGraphInput, fromId: string, toId: string): string[] | null;
+export declare function countByType(graph: ProductGraphInput): Record<string, number>;
+export declare function getNeighbors(graph: ProductGraphInput, nodeId: string, relation?: ProductGraphEdgeInput['relation']): ProductGraphNodeInput[];

package/dist/core/product-graph/paths.d.ts

@@ -0,0 +1,18 @@
+export declare const PRODUCT_DIR = ".codeconductor";
+export declare const PRODUCT_GRAPH_FILE = "product-graph.json";
+export declare const PRODUCT_META_FILE = "product-meta.json";
+export declare const EVENTS_FILE = "events.jsonl";
+export declare const OPERATIONAL_STATE_FILE = "operational-state.json";
+export declare const STRATEGIC_FILE = "strategic.json";
+export declare const PRODUCT_REPORT_FILE = "product-report.md";
+export declare const FEEDBACK_SOURCES_FILE = "feedback-sources.yml";
+export declare const DECISIONS_DIR = "decisions";
+export declare const EVIDENCE_DIR = "evidence";
+export declare function productGraphPath(projectRoot: string): string;
+export declare function productMetaPath(projectRoot: string): string;
+export declare function eventsPath(projectRoot: string): string;
+export declare function operationalStatePath(projectRoot: string): string;
+export declare function strategicPath(projectRoot: string): string;
+export declare function productReportPath(projectRoot: string): string;
+export declare function decisionsDir(projectRoot: string): string;
+export declare function evidenceDir(projectRoot: string): string;

package/dist/core/verification/verification-runner.d.ts

@@ -0,0 +1,57 @@
+import type { GoalGraphInput } from '../../validation/schemas';
+import type { TddSuiteEvidence } from '../../domain/loop/loop-state';
+import { type Result } from '../../utils/result';
+export interface VerificationCheck {
+    name: string;
+    passed: boolean;
+    message: string;
+}
+/**
+ * Check that ids handed to a completion really name evidence of this task.
+ *
+ * Every id must resolve to a stored record that parses as `EvidenceSchema`,
+ * carries that exact id, is related to this task and records a passing result —
+ * and at least one cited id must be a passing `verification` record, so
+ * supporting test/review evidence alone cannot stand in for verification.
+ */
+export declare function validateEvidenceIds(projectRoot: string, taskId: string, evidenceIds: string[]): Promise<Result<void, Error>>;
+export interface RunVerificationOptions {
+    /**
+     * Explicit trust to execute the compile command configured by the analyzed
+     * project itself (`.codeconductor/config.yml`). Without this opt-in the
+     * command is executed only if it matches the compile allowlist
+     * (`tsc`, `bun run`, `npm test`, …). Anything else fails closed.
+     */
+    readonly allowCompileCheck?: boolean;
+}
+export declare function runVerification(projectRoot: string, taskId: string, goal?: GoalGraphInput, options?: RunVerificationOptions): Promise<Result<{
+    passed: boolean;
+    checks: VerificationCheck[];
+    evidenceIds: string[];
+}, Error>>;
+/**
+ * Decide whether a task may be completed.
+ *
+ * A requirement is only satisfied by evidence of the matching type whose
+ * payload proves success. Unknown requirements, missing evidence and
+ * unreadable evidence all block completion.
+ */
+export declare function gateTaskCompletion(projectRoot: string, taskId: string, evidenceRequired: string[], evidenceIds?: string[]): Promise<Result<boolean, Error>>;
+export interface CaptureTddSuiteOptions extends RunVerificationOptions {
+    /** Allowlisted test command (`bun test`, `npm test`, …). */
+    readonly command: string;
+}
+/**
+ * Run a test suite and store TDD evidence. Only this function writes records
+ * that `tddCycleStateMachine` will accept as RED/GREEN gates.
+ */
+export declare function captureTddSuiteEvidence(projectRoot: string, taskId: string, options: CaptureTddSuiteOptions): Promise<Result<{
+    evidenceId: string;
+    suiteFailed: boolean;
+    suitePassed: boolean;
+}, Error>>;
+/**
+ * Load TDD suite evidence written by `captureTddSuiteEvidence`. Hand-edited
+ * files (wrong source/type/`capturedBy`) are rejected.
+ */
+export declare function loadTddSuiteEvidence(projectRoot: string, taskId: string, evidenceId: string): Promise<Result<TddSuiteEvidence, Error>>;

package/dist/domain/loop/loop-state.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Loop State Machine — pure state transitions for compile-fix iteration cycles.
+ *
+ * Phases: IDLE → RUNNING → CHECKING → FEEDBACK → (back to RUNNING or DONE/FAILED/ESCALATED)
+ */
+import type { CompileError } from '../../core/compilation/compile-checker';
+export type LoopPhase = 'IDLE' | 'RUNNING' | 'CHECKING' | 'FEEDBACK' | 'DONE' | 'FAILED' | 'ESCALATED';
+export interface LoopState {
+    readonly phase: LoopPhase;
+    readonly iteration: number;
+    readonly maxIterations: number;
+    readonly errors: readonly CompileError[];
+    readonly errorHistory: readonly (readonly CompileError[])[];
+    readonly tokenBudgetUsed: number;
+    readonly maxTokenBudget: number;
+}
+export type LoopAction = {
+    readonly type: 'START';
+} | {
+    readonly type: 'CODE_GENERATED';
+} | {
+    readonly type: 'COMPILE_CHECK_COMPLETED';
+    readonly errors: readonly CompileError[];
+} | {
+    readonly type: 'FEEDBACK_FORMATTED';
+} | {
+    readonly type: 'TOKEN_BUDGET_EXCEEDED';
+    readonly tokenUsage: number;
+} | {
+    readonly type: 'ABORT';
+};
+export type LoopActionResult = 'CONTINUE' | 'TERMINATE';
+/**
+ * Create an initial LoopState with sensible defaults.
+ */
+export declare function createInitialState(overrides?: Partial<LoopState>): LoopState;
+/**
+ * Pure state machine — given a state and an action, returns the new state.
+ * No side effects. Logs are the caller's responsibility.
+ */
+export declare function loopStateMachine(state: LoopState, action: LoopAction): {
+    state: LoopState;
+    result: LoopActionResult;
+};
+/**
+ * Evidence payload that may advance TDD phases. Only records written by
+ * `captureTddSuiteEvidence` set `capturedBy: 'verification-runner'`.
+ */
+export interface TddSuiteEvidence {
+    readonly capturedBy: string;
+    readonly suiteFailed: boolean;
+    readonly suitePassed: boolean;
+}
+export type TddPhase = 'RED' | 'GREEN' | 'REFACTOR' | 'FAILED';
+export interface TddState {
+    readonly phase: TddPhase;
+    readonly evidenceIds: readonly string[];
+}
+export type TddAction = {
+    readonly type: 'SUITE_EVIDENCE';
+    readonly evidenceId: string;
+    readonly evidence: TddSuiteEvidence;
+} | {
+    readonly type: 'ABORT';
+};
+export declare function createInitialTddState(): TddState;
+/**
+ * Guarded TDD phase machine. RED→GREEN needs a failing suite captured by the
+ * verification runner; GREEN→REFACTOR needs a passing suite from the same source.
+ */
+export declare function tddCycleStateMachine(state: TddState, action: TddAction): {
+    state: TddState;
+    result: LoopActionResult;
+};

package/dist/domain/product/entities.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Product OS entity taxonomy — pure types for the product AST.
+ * Persisted forms are validated via Zod schemas in validation/schemas.ts.
+ */
+export type ConfidenceLevel = 'low' | 'medium' | 'high';
+export type ProductNodeType = 'product' | 'domain' | 'capability' | 'requirement' | 'decision' | 'component' | 'flow' | 'contract' | 'metric' | 'risk' | 'task' | 'evidence';
+export type GraphRelation = 'implements' | 'depends_on' | 'documents' | 'affects' | 'evidences' | 'blocks' | 'contains';
+export type MemoryLayer = 'operational' | 'semantic' | 'episodic' | 'procedural' | 'strategic';
+export type ProductEventType = 'task.started' | 'task.completed' | 'decision.recorded' | 'evidence.added' | 'ingest.completed' | 'goal.updated' | 'blocker.detected' | 'verification.completed' | 'feedback.processed';
+export declare const PRODUCT_NODE_TYPES: readonly ProductNodeType[];
+export declare const GRAPH_RELATIONS: readonly GraphRelation[];

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Public library surface for CodeConductor.
+ *
+ * CLI remains `dist/index.js` (`bin`). This module is the programmatic API.
+ * Do not re-export `infrastructure/` or `*-internal` modules.
+ */
+export { getReadyTasks, goalTaskToCanonicalCard, buildTaskEnvelope, getNextTask, startTask, completeTask, rollbackTaskStatus, formatGoalStatus, } from './core/orchestrator/runtime-orchestrator';
+export type { OrchestratorNextResult } from './core/orchestrator/runtime-orchestrator';
+export { LoopEngine, runLoop, runLoopForProject, shouldRunAgentLoop, formatFeedback, advanceTddPhase, } from './core/loop/loop-engine';
+export type { LoopConfig, LoopResult, EscalationReport, GuardrailHit, GenerateFn, CompileCheckFn, } from './core/loop/loop-engine';
+export { runVerification, gateTaskCompletion, validateEvidenceIds, captureTddSuiteEvidence, loadTddSuiteEvidence, } from './core/verification/verification-runner';
+export type { RunVerificationOptions, VerificationCheck, CaptureTddSuiteOptions, } from './core/verification/verification-runner';
+export * from './validation/schemas';
+export { createInitialState, loopStateMachine, createInitialTddState, tddCycleStateMachine, } from './domain/loop/loop-state';
+export type { LoopPhase, LoopState, LoopAction, LoopActionResult, TddPhase, TddState, TddAction, TddSuiteEvidence, } from './domain/loop/loop-state';