@fabriccode/weave 0.7.0

package/dist/features/evals/types.d.ts

@@ -0,0 +1,223 @@
+import type { WeaveAgentName } from "../../agents/types";
+export declare const EVAL_PHASES: readonly ["phase1", "phase2", "phase3", "phase4"];
+export type EvalPhase = (typeof EVAL_PHASES)[number];
+export declare const EVAL_TARGET_KINDS: readonly ["builtin-agent-prompt", "custom-agent-prompt", "single-turn-agent", "trajectory-agent"];
+export type EvalTargetKind = (typeof EVAL_TARGET_KINDS)[number];
+export declare const EXECUTOR_KINDS: readonly ["prompt-render", "model-response", "trajectory-run"];
+export type ExecutorKind = (typeof EXECUTOR_KINDS)[number];
+export declare const EVALUATOR_KINDS: readonly ["contains-all", "contains-any", "excludes-all", "section-contains-all", "ordered-contains", "xml-sections-present", "tool-policy", "min-length", "llm-judge", "baseline-diff", "trajectory-assertion"];
+export type EvaluatorKind = (typeof EVALUATOR_KINDS)[number];
+export type BuiltinEvalAgentName = Exclude<WeaveAgentName, "shuttle">;
+export interface BuiltinAgentPromptVariant {
+    disabledAgents?: string[];
+}
+export interface BuiltinAgentPromptTarget {
+    kind: "builtin-agent-prompt";
+    agent: BuiltinEvalAgentName;
+    variant?: BuiltinAgentPromptVariant;
+}
+export interface CustomAgentPromptTarget {
+    kind: "custom-agent-prompt";
+    agentId: string;
+}
+export interface SingleTurnAgentTarget {
+    kind: "single-turn-agent";
+    agent: string;
+    input?: string;
+}
+export interface TrajectoryAgentTarget {
+    kind: "trajectory-agent";
+    agent: string;
+    scenarioRef?: string;
+}
+export type EvalTarget = BuiltinAgentPromptTarget | CustomAgentPromptTarget | SingleTurnAgentTarget | TrajectoryAgentTarget;
+export interface PromptRenderExecutor {
+    kind: "prompt-render";
+}
+export interface ModelResponseExecutor {
+    kind: "model-response";
+    provider: string;
+    model: string;
+    input: string;
+}
+export interface TrajectoryRunExecutor {
+    kind: "trajectory-run";
+    scenarioRef: string;
+}
+export type ExecutorSpec = PromptRenderExecutor | ModelResponseExecutor | TrajectoryRunExecutor;
+export interface WeightedEvaluatorSpec {
+    weight?: number;
+}
+export interface ContainsAllEvaluator extends WeightedEvaluatorSpec {
+    kind: "contains-all";
+    patterns: string[];
+}
+export interface ContainsAnyEvaluator extends WeightedEvaluatorSpec {
+    kind: "contains-any";
+    patterns: string[];
+}
+export interface ExcludesAllEvaluator extends WeightedEvaluatorSpec {
+    kind: "excludes-all";
+    patterns: string[];
+}
+export interface SectionContainsAllEvaluator extends WeightedEvaluatorSpec {
+    kind: "section-contains-all";
+    section: string;
+    patterns: string[];
+}
+export interface OrderedContainsEvaluator extends WeightedEvaluatorSpec {
+    kind: "ordered-contains";
+    patterns: string[];
+}
+export interface XmlSectionsPresentEvaluator extends WeightedEvaluatorSpec {
+    kind: "xml-sections-present";
+    sections: string[];
+}
+export interface ToolPolicyEvaluator extends WeightedEvaluatorSpec {
+    kind: "tool-policy";
+    expectations: Record<string, boolean>;
+}
+export interface MinLengthEvaluator extends WeightedEvaluatorSpec {
+    kind: "min-length";
+    min: number;
+}
+export interface LlmJudgeEvaluator extends WeightedEvaluatorSpec {
+    kind: "llm-judge";
+    rubricRef?: string;
+    expectedContains?: string[];
+    forbiddenContains?: string[];
+}
+export interface BaselineDiffEvaluator extends WeightedEvaluatorSpec {
+    kind: "baseline-diff";
+    baselineRef?: string;
+}
+export interface TrajectoryAssertionEvaluator extends WeightedEvaluatorSpec {
+    kind: "trajectory-assertion";
+    assertionRef?: string;
+}
+export type EvaluatorSpec = ContainsAllEvaluator | ContainsAnyEvaluator | ExcludesAllEvaluator | SectionContainsAllEvaluator | OrderedContainsEvaluator | XmlSectionsPresentEvaluator | ToolPolicyEvaluator | MinLengthEvaluator | LlmJudgeEvaluator | BaselineDiffEvaluator | TrajectoryAssertionEvaluator;
+export interface EvalSuiteManifest {
+    id: string;
+    title: string;
+    phase: EvalPhase;
+    caseFiles: string[];
+    tags?: string[];
+}
+export interface EvalCase {
+    id: string;
+    title: string;
+    phase: EvalPhase;
+    target: EvalTarget;
+    executor: ExecutorSpec;
+    evaluators: EvaluatorSpec[];
+    tags?: string[];
+    notes?: string;
+}
+export interface LoadedEvalSuiteManifest extends EvalSuiteManifest {
+    filePath: string;
+}
+export interface LoadedEvalCase extends EvalCase {
+    filePath: string;
+}
+export interface AgentPromptMetadataArtifact {
+    agent: string;
+    description?: string;
+    sourceKind: "composer" | "default";
+}
+export interface EvalArtifacts {
+    renderedPrompt?: string;
+    agentMetadata?: AgentPromptMetadataArtifact;
+    toolPolicy?: Record<string, boolean>;
+    promptLength?: number;
+    modelOutput?: string;
+    judgeOutput?: string;
+    trace?: unknown;
+    tokens?: number;
+    cost?: number;
+    baselineDelta?: unknown;
+}
+export interface AssertionResult {
+    evaluatorKind: EvaluatorKind;
+    passed: boolean;
+    score: number;
+    maxScore: number;
+    message: string;
+}
+export interface EvalCaseResult {
+    caseId: string;
+    status: "passed" | "failed" | "error";
+    score: number;
+    normalizedScore: number;
+    maxScore: number;
+    durationMs: number;
+    artifacts: EvalArtifacts;
+    assertionResults: AssertionResult[];
+    errors: string[];
+}
+export interface EvalRunSummary {
+    totalCases: number;
+    passedCases: number;
+    failedCases: number;
+    errorCases: number;
+    totalScore: number;
+    normalizedScore: number;
+    maxScore: number;
+}
+export interface EvalRunResult {
+    runId: string;
+    startedAt: string;
+    finishedAt: string;
+    suiteId: string;
+    phase: EvalPhase;
+    summary: EvalRunSummary;
+    caseResults: EvalCaseResult[];
+}
+export interface ResolvedTarget {
+    target: EvalTarget;
+    artifacts: EvalArtifacts;
+}
+export interface ExecutionContext {
+    mode: "local" | "ci" | "hosted";
+    directory: string;
+    outputPath?: string;
+}
+export interface RunnerFilters {
+    caseIds?: string[];
+    agents?: string[];
+    tags?: string[];
+}
+export interface RunEvalSuiteOptions {
+    directory: string;
+    suite: string;
+    filters?: RunnerFilters;
+    outputPath?: string;
+    mode?: ExecutionContext["mode"];
+}
+export interface EvalLoadErrorContext {
+    filePath: string;
+    detail: string;
+}
+export interface DeterministicBaselineCase {
+    caseId: string;
+    status: EvalCaseResult["status"];
+    normalizedScore: number;
+    assertionPassed: number;
+    assertionFailed: number;
+    errorCount: number;
+}
+export interface DeterministicBaseline {
+    version: 1;
+    suiteId: string;
+    phase: EvalPhase;
+    generatedAt: string;
+    normalizedScore: number;
+    cases: DeterministicBaselineCase[];
+}
+export interface BaselineComparisonOptions {
+    scoreDropTolerance?: number;
+}
+export interface BaselineComparison {
+    outcome: "no-regression" | "informational-diff" | "regression";
+    regressions: string[];
+    informational: string[];
+}

package/dist/features/skill-loader/discovery.d.ts

@@ -0,0 +1,12 @@
+import type { LoadedSkill, SkillMetadata, SkillScope } from "./types";
+interface ParsedFrontmatter {
+    metadata: SkillMetadata;
+    content: string;
+}
+export declare function parseFrontmatter(text: string): ParsedFrontmatter;
+export interface ScanDirectoryOptions {
+    directory: string;
+    scope: SkillScope;
+}
+export declare function scanDirectory(options: ScanDirectoryOptions): LoadedSkill[];
+export {};

package/dist/features/skill-loader/fabric-client.d.ts

@@ -0,0 +1,2 @@
+import type { LoadedSkill } from "./types";
+export declare function fetchSkillsFromFabric(serverUrl: string | URL, directory: string): Promise<LoadedSkill[]>;

package/dist/features/skill-loader/index.d.ts

@@ -0,0 +1,6 @@
+export { loadSkills } from "./loader";
+export type { LoadSkillsOptions } from "./loader";
+export { createResolveSkillsFn, createSkillResolver, resolveMultipleSkills, resolveSkill } from "./resolver";
+export { fetchSkillsFromFabric } from "./fabric-client";
+export { scanDirectory, parseFrontmatter } from "./discovery";
+export type { SkillScope, SkillMetadata, LoadedSkill, SkillDiscoveryResult } from "./types";

package/dist/features/skill-loader/loader.d.ts

@@ -0,0 +1,7 @@
+import type { SkillDiscoveryResult } from './types';
+export interface LoadSkillsOptions {
+    serverUrl: string | URL;
+    directory?: string;
+    disabledSkills?: string[];
+}
+export declare function loadSkills(options: LoadSkillsOptions): Promise<SkillDiscoveryResult>;

package/dist/features/skill-loader/resolver.d.ts

@@ -0,0 +1,6 @@
+import type { SkillDiscoveryResult } from "./types";
+export declare function resolveSkill(name: string, result: SkillDiscoveryResult): string;
+export declare function resolveMultipleSkills(skillNames: string[], disabledSkills?: Set<string>, discovered?: SkillDiscoveryResult): string;
+export declare function createSkillResolver(discovered: SkillDiscoveryResult): (skillNames: string[], disabledSkills?: Set<string>) => string;
+/** @deprecated Use createSkillResolver instead */
+export declare const createResolveSkillsFn: typeof createSkillResolver;

package/dist/features/skill-loader/types.d.ts

@@ -0,0 +1,18 @@
+export type SkillScope = "builtin" | "user" | "project";
+export interface SkillMetadata {
+    name?: string;
+    description?: string;
+    model?: string;
+    tools?: string | string[];
+}
+export interface LoadedSkill {
+    name: string;
+    description: string;
+    content: string;
+    scope?: SkillScope;
+    path?: string;
+    model?: string;
+}
+export interface SkillDiscoveryResult {
+    skills: LoadedSkill[];
+}

package/dist/features/work-state/constants.d.ts

@@ -0,0 +1,8 @@
+/** Root directory for Weave state and plans */
+export declare const WEAVE_DIR = ".weave";
+/** Work state file name */
+export declare const WORK_STATE_FILE = "state.json";
+/** Full relative path to work state */
+export declare const WORK_STATE_PATH = ".weave/state.json";
+/** Directory where plan files are stored */
+export declare const PLANS_DIR = ".weave/plans";

package/dist/features/work-state/index.d.ts

@@ -0,0 +1,5 @@
+export type { WorkState, PlanProgress } from "./types";
+export type { ValidationResult, ValidationIssue, ValidationSeverity, ValidationCategory } from "./validation-types";
+export { WEAVE_DIR, WORK_STATE_FILE, WORK_STATE_PATH, PLANS_DIR } from "./constants";
+export { readWorkState, writeWorkState, clearWorkState, appendSessionId, createWorkState, findPlans, getPlanProgress, getPlanName, getHeadSha, pauseWork, resumeWork, } from "./storage";
+export { validatePlan } from "./validation";

package/dist/features/work-state/storage.d.ts

@@ -0,0 +1,53 @@
+import type { WorkState, PlanProgress } from "./types";
+/**
+ * Read work state from .weave/state.json.
+ * Returns null if file is missing, unparseable, or invalid.
+ */
+export declare function readWorkState(directory: string): WorkState | null;
+/**
+ * Write work state to .weave/state.json.
+ * Creates .weave/ directory if needed.
+ */
+export declare function writeWorkState(directory: string, state: WorkState): boolean;
+/**
+ * Clear work state by deleting .weave/state.json.
+ */
+export declare function clearWorkState(directory: string): boolean;
+/**
+ * Append a session ID to the work state (if not already present).
+ * Returns the updated state, or null if no state exists.
+ */
+export declare function appendSessionId(directory: string, sessionId: string): WorkState | null;
+/**
+ * Create a fresh WorkState for a plan file.
+ */
+export declare function createWorkState(planPath: string, sessionId: string, agent?: string, directory?: string): WorkState;
+/**
+ * Get the current HEAD SHA of the git repo at the given directory.
+ * Returns undefined if not a git repo or git is unavailable.
+ */
+export declare function getHeadSha(directory: string): string | undefined;
+/**
+ * Find all plan files in .weave/plans/, sorted by modification time (newest first).
+ * Returns absolute paths.
+ */
+export declare function findPlans(directory: string): string[];
+/**
+ * Count checked and unchecked markdown checkboxes in a plan file.
+ * Returns isComplete: true if file is missing, has 0 checkboxes, or all are checked.
+ */
+export declare function getPlanProgress(planPath: string): PlanProgress;
+/**
+ * Extract plan name from file path (basename minus .md extension).
+ */
+export declare function getPlanName(planPath: string): string;
+/**
+ * Pause work by setting paused: true in the work state.
+ * Returns false if no state exists (e.g., no active plan).
+ */
+export declare function pauseWork(directory: string): boolean;
+/**
+ * Resume work by setting paused: false in the work state.
+ * Returns false if no state exists.
+ */
+export declare function resumeWork(directory: string): boolean;

package/dist/features/work-state/types.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Tracks the active plan being executed via /start-work.
+ * Stored at .weave/state.json in the project root.
+ */
+export interface WorkState {
+    /** Absolute path to the active plan file */
+    active_plan: string;
+    /** ISO timestamp when work started */
+    started_at: string;
+    /** Session IDs that have worked on this plan */
+    session_ids: string[];
+    /** Plan name derived from filename (without .md) */
+    plan_name: string;
+    /** Agent type to use when resuming (e.g., "tapestry") */
+    agent?: string;
+    /** Git HEAD SHA at the time work started (absent if not a git repo) */
+    start_sha?: string;
+    /** Whether work has been paused by a user interrupt; continuation is suppressed while true */
+    paused?: boolean;
+    /** The `completed` count from getPlanProgress() at the time of the last continuation prompt */
+    continuation_completed_snapshot?: number;
+    /** How many consecutive continuations have fired without progress changing */
+    stale_continuation_count?: number;
+}
+/**
+ * Progress snapshot from counting checkboxes in a plan file.
+ */
+export interface PlanProgress {
+    /** Total number of checkboxes (checked + unchecked) */
+    total: number;
+    /** Number of completed checkboxes */
+    completed: number;
+    /** Whether all tasks are done (total === 0 or completed === total) */
+    isComplete: boolean;
+}

package/dist/features/work-state/validation-types.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The 6 validation categories checked by validatePlan().
+ */
+export type ValidationCategory = "structure" | "checkboxes" | "file-references" | "numbering" | "effort-estimate" | "verification";
+/** Severity level for a validation issue. */
+export type ValidationSeverity = "error" | "warning";
+/**
+ * A single validation issue found in a plan file.
+ */
+export interface ValidationIssue {
+    severity: ValidationSeverity;
+    category: ValidationCategory;
+    message: string;
+}
+/**
+ * The result of validating a plan file.
+ * `valid` is false if there are any blocking errors.
+ */
+export interface ValidationResult {
+    /** False when there is at least one error (blocking). True when only warnings or clean. */
+    valid: boolean;
+    /** Blocking issues — prevent /start-work from proceeding */
+    errors: ValidationIssue[];
+    /** Non-blocking issues — surfaced to user but don't block execution */
+    warnings: ValidationIssue[];
+}

package/dist/features/work-state/validation.d.ts

@@ -0,0 +1,9 @@
+import type { ValidationResult } from "./validation-types";
+/**
+ * Validates a plan file's structure and content before /start-work execution.
+ *
+ * @param planPath  Absolute path to the plan markdown file
+ * @param projectDir  Absolute path to the project root (used for file-reference checks)
+ * @returns ValidationResult with errors (blocking) and warnings (non-blocking)
+ */
+export declare function validatePlan(planPath: string, projectDir: string): ValidationResult;

package/dist/features/workflow/commands.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Workflow control sub-commands: keyword detection in user messages during active workflows.
+ * These are NOT separate slash commands — they're natural language keywords detected in chat.message.
+ */
+export interface WorkflowCommandResult {
+    /** Whether a workflow control keyword was detected and handled */
+    handled: boolean;
+    /** Context to inject into the response */
+    contextInjection?: string;
+    /** Agent to switch to (if any) */
+    switchAgent?: string;
+}
+/**
+ * Check if a user message contains a workflow control keyword and handle it.
+ * Only active when a workflow instance is running.
+ */
+export declare function handleWorkflowCommand(message: string, directory: string): WorkflowCommandResult;

package/dist/features/workflow/completion.d.ts

@@ -0,0 +1,31 @@
+import type { CompletionConfig, CompletionMethod } from "./types";
+/**
+ * Result of checking whether a step's completion condition is met.
+ */
+export interface CompletionCheckResult {
+    complete: boolean;
+    verdict?: "approve" | "reject";
+    artifacts?: Record<string, string>;
+    /** Concise summary of step output for context threading */
+    summary?: string;
+    reason?: string;
+}
+/**
+ * Context provided to completion checkers.
+ */
+export interface CompletionContext {
+    /** Last assistant message text (from message.part.updated tracking) */
+    lastAssistantMessage?: string;
+    /** Last user message text (for user_confirm) */
+    lastUserMessage?: string;
+    /** Working directory */
+    directory: string;
+    /** Completion config from the step definition */
+    config: CompletionConfig;
+    /** Current artifacts in the instance */
+    artifacts: Record<string, string>;
+}
+/**
+ * Check whether a step's completion condition is met.
+ */
+export declare function checkStepCompletion(method: CompletionMethod, context: CompletionContext): CompletionCheckResult;

package/dist/features/workflow/constants.d.ts

@@ -0,0 +1,12 @@
+/** Root directory for Weave state and plans */
+export { WEAVE_DIR } from "../work-state/constants";
+/** Directory under .weave/ for workflow instance state */
+export declare const WORKFLOWS_STATE_DIR = ".weave/workflows";
+/** File name for individual instance state */
+export declare const INSTANCE_STATE_FILE = "state.json";
+/** Pointer file tracking the currently active workflow instance */
+export declare const ACTIVE_INSTANCE_FILE = "active-instance.json";
+/** Project-level directory for workflow definitions */
+export declare const WORKFLOWS_DIR_PROJECT = ".fabric/workflows";
+/** User-level directory for workflow definitions (under ~/.config/fabric/) */
+export declare const WORKFLOWS_DIR_USER = "workflows";

package/dist/features/workflow/context.d.ts

@@ -0,0 +1,16 @@
+import type { WorkflowInstance, WorkflowDefinition, WorkflowStepDefinition } from "./types";
+/**
+ * Resolve template variables in a string.
+ * Supports: {{instance.goal}}, {{instance.slug}}, {{artifacts.X}}, {{step.name}}, {{step.id}}
+ * Unknown variables are left as-is.
+ */
+export declare function resolveTemplate(template: string, instance: WorkflowInstance, definition: WorkflowDefinition): string;
+/**
+ * Build the workflow context header showing goal, step history, and accumulated artifacts.
+ */
+export declare function buildContextHeader(instance: WorkflowInstance, definition: WorkflowDefinition): string;
+/**
+ * Build the full context-threaded prompt for a step.
+ * Combines: (1) workflow context header, (2) resolved step prompt.
+ */
+export declare function composeStepPrompt(stepDef: WorkflowStepDefinition, instance: WorkflowInstance, definition: WorkflowDefinition): string;

package/dist/features/workflow/discovery.d.ts

@@ -0,0 +1,19 @@
+import type { WorkflowDefinition } from "./types";
+/**
+ * A workflow definition discovered from the filesystem.
+ */
+export interface DiscoveredWorkflow {
+    definition: WorkflowDefinition;
+    path: string;
+    scope: "project" | "user";
+}
+/**
+ * Load and validate a single workflow definition from a JSONC file path.
+ * Returns null if the file can't be read, parsed, or fails validation.
+ */
+export declare function loadWorkflowDefinition(filePath: string): WorkflowDefinition | null;
+/**
+ * Discover all valid workflow definitions from project and user directories.
+ * Project workflows override user workflows with the same name.
+ */
+export declare function discoverWorkflows(directory: string): DiscoveredWorkflow[];

package/dist/features/workflow/engine.d.ts

@@ -0,0 +1,49 @@
+import type { WorkflowDefinition } from "./types";
+import type { CompletionContext } from "./completion";
+/**
+ * An action the engine wants the caller to take.
+ */
+export interface EngineAction {
+    type: "inject_prompt" | "switch_agent" | "pause" | "complete" | "none";
+    /** Context-threaded prompt to inject */
+    prompt?: string;
+    /** Agent to switch to for the next step */
+    agent?: string;
+    reason?: string;
+}
+/**
+ * Start a new workflow instance from a definition and goal.
+ * Creates the instance, sets it as active, and returns the first step's prompt.
+ */
+export declare function startWorkflow(input: {
+    definition: WorkflowDefinition;
+    definitionPath: string;
+    goal: string;
+    sessionId: string;
+    directory: string;
+}): EngineAction;
+/**
+ * Check the current step's completion and advance if complete.
+ * This is called on session.idle events.
+ */
+export declare function checkAndAdvance(input: {
+    directory: string;
+    context: CompletionContext;
+}): EngineAction;
+/**
+ * Pause the active workflow instance.
+ */
+export declare function pauseWorkflow(directory: string, reason?: string): boolean;
+/**
+ * Resume a paused workflow instance.
+ * Returns the current step's context-threaded prompt.
+ */
+export declare function resumeWorkflow(directory: string): EngineAction;
+/**
+ * Skip the current step and advance to the next.
+ */
+export declare function skipStep(directory: string): EngineAction;
+/**
+ * Abort the active workflow instance.
+ */
+export declare function abortWorkflow(directory: string): boolean;

package/dist/features/workflow/hook.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Workflow hook handler: detects /run-workflow commands, parses arguments,
+ * manages workflow instances, and drives step transitions on session.idle.
+ */
+/**
+ * Marker embedded in workflow continuation prompts so the auto-pause guard
+ * in plugin-interface.ts can recognize them and NOT pause coexisting WorkState plans.
+ */
+export declare const WORKFLOW_CONTINUATION_MARKER = "<!-- weave:workflow-continuation -->";
+export interface WorkflowHookResult {
+    /** Context to inject into the prompt (step prompt with workflow context) */
+    contextInjection: string | null;
+    /** Agent to switch to for the current step */
+    switchAgent: string | null;
+}
+/**
+ * Parse /run-workflow arguments into workflow name and optional goal.
+ * Argument format: `<workflow-name> "goal text"` or `<workflow-name>` or empty.
+ */
+export declare function parseWorkflowArgs(args: string): {
+    workflowName: string | null;
+    goal: string | null;
+};
+/**
+ * Handle the /run-workflow command.
+ * Detects the command via <session-context> tag, parses arguments,
+ * and either creates a new instance, resumes an existing one, or lists available definitions.
+ */
+export declare function handleRunWorkflow(input: {
+    promptText: string;
+    sessionId: string;
+    directory: string;
+}): WorkflowHookResult;
+/**
+ * Check workflow continuation on session.idle.
+ * If an active workflow instance exists and the current step's completion condition is met,
+ * advance to the next step and return a continuation prompt.
+ */
+export declare function checkWorkflowContinuation(input: {
+    sessionId: string;
+    directory: string;
+    lastAssistantMessage?: string;
+    lastUserMessage?: string;
+}): {
+    continuationPrompt: string | null;
+    switchAgent: string | null;
+};

package/dist/features/workflow/index.d.ts

@@ -0,0 +1,15 @@
+export type { StepType, CompletionMethod, StepStatus, WorkflowStatus, OnRejectAction, ArtifactRef, StepArtifacts, CompletionConfig, WorkflowStepDefinition, WorkflowDefinition, StepState, WorkflowInstance, ActiveInstancePointer, } from "./types";
+export { WORKFLOWS_STATE_DIR, INSTANCE_STATE_FILE, ACTIVE_INSTANCE_FILE, WORKFLOWS_DIR_PROJECT, WORKFLOWS_DIR_USER, } from "./constants";
+export { generateInstanceId, generateSlug, createWorkflowInstance, readWorkflowInstance, writeWorkflowInstance, readActiveInstance, setActiveInstance, clearActiveInstance, getActiveWorkflowInstance, listInstances, appendInstanceSessionId, } from "./storage";
+export type { DiscoveredWorkflow } from "./discovery";
+export { loadWorkflowDefinition, discoverWorkflows } from "./discovery";
+export { resolveTemplate, buildContextHeader, composeStepPrompt } from "./context";
+export type { CompletionCheckResult, CompletionContext } from "./completion";
+export { checkStepCompletion } from "./completion";
+export type { EngineAction } from "./engine";
+export { startWorkflow, checkAndAdvance, pauseWorkflow, resumeWorkflow, skipStep, abortWorkflow, } from "./engine";
+export { WORKFLOW_CONTINUATION_MARKER } from "./hook";
+export type { WorkflowHookResult } from "./hook";
+export { parseWorkflowArgs, handleRunWorkflow, checkWorkflowContinuation } from "./hook";
+export type { WorkflowCommandResult } from "./commands";
+export { handleWorkflowCommand } from "./commands";