@opencode_weave/weave 0.6.4 → 0.7.0-preview.1

package/dist/config/schema.d.ts

@@ -155,6 +155,10 @@ export declare const CustomAgentsConfigSchema: z.ZodRecord<z.ZodString, z.ZodObj
 }, z.core.$strip>>;
 export declare const AnalyticsConfigSchema: z.ZodObject<{
     enabled: z.ZodOptional<z.ZodBoolean>;
+    use_fingerprint: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const WorkflowConfigSchema: z.ZodObject<{
+    disabled_workflows: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export declare const WeaveConfigSchema: z.ZodObject<{
     $schema: z.ZodOptional<z.ZodString>;
@@ -234,6 +238,7 @@ export declare const WeaveConfigSchema: z.ZodObject<{
     }, z.core.$strip>>;
     analytics: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
+        use_fingerprint: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
     tmux: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
@@ -251,6 +256,9 @@ export declare const WeaveConfigSchema: z.ZodObject<{
         context_window_warning_threshold: z.ZodOptional<z.ZodNumber>;
         context_window_critical_threshold: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
+    workflows: z.ZodOptional<z.ZodObject<{
+        disabled_workflows: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type AgentOverrideConfig = z.infer<typeof AgentOverrideConfigSchema>;
 export type AgentOverrides = z.infer<typeof AgentOverridesSchema>;
@@ -262,4 +270,5 @@ export type BackgroundConfig = z.infer<typeof BackgroundConfigSchema>;
 export type AnalyticsConfig = z.infer<typeof AnalyticsConfigSchema>;
 export type TmuxConfig = z.infer<typeof TmuxConfigSchema>;
 export type ExperimentalConfig = z.infer<typeof ExperimentalConfigSchema>;
+export type WorkflowConfig = z.infer<typeof WorkflowConfigSchema>;
 export type WeaveConfig = z.infer<typeof WeaveConfigSchema>;

package/dist/features/analytics/adherence.d.ts

@@ -0,0 +1,10 @@
+import type { AdherenceReport } from "./types";
+/**
+ * Calculate plan adherence by comparing planned vs actual file changes.
+ *
+ * - **coverage**: fraction of planned files that were actually changed (0-1).
+ *   If no files were planned, coverage = 1 (vacuously complete).
+ * - **precision**: fraction of actual changes that were planned (0-1).
+ *   If no files were changed, precision = 1 (vacuously precise).
+ */
+export declare function calculateAdherence(plannedFiles: string[], actualFiles: string[]): AdherenceReport;

package/dist/features/analytics/format-metrics.d.ts

@@ -0,0 +1,10 @@
+import type { MetricsReport, SessionSummary } from "./types";
+/**
+ * Format metrics reports and session summaries into a markdown dashboard.
+ *
+ * @param reports - Array of MetricsReport from readMetricsReports()
+ * @param summaries - Array of SessionSummary from readSessionSummaries()
+ * @param args - Optional arguments: a plan name to filter, "all" for all reports, or empty for last 5
+ * @returns Formatted markdown string
+ */
+export declare function formatMetricsMarkdown(reports: MetricsReport[], summaries: SessionSummary[], args?: string): string;

package/dist/features/analytics/generate-metrics-report.d.ts

@@ -0,0 +1,17 @@
+import type { WorkState } from "../work-state/types";
+import type { MetricsReport } from "./types";
+/**
+ * Generate a Phase 1 metrics report for a completed plan.
+ *
+ * Orchestrates:
+ * 1. Extract planned files from the plan markdown
+ * 2. Get actual changed files via git diff (startSha..HEAD)
+ * 3. Calculate adherence (coverage, precision)
+ * 4. Aggregate token usage across all sessions for this plan
+ * 5. Compute total duration from session summaries
+ * 6. Write the report to metrics-reports.jsonl
+ *
+ * In Phase 1, `quality` and `gaps` are undefined.
+ * Returns the report if successful, null on error.
+ */
+export declare function generateMetricsReport(directory: string, state: WorkState): MetricsReport | null;

package/dist/features/analytics/git-diff.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Get the list of files changed between a given SHA and HEAD.
+ *
+ * Uses `git diff --name-only fromSha..HEAD` and returns relative paths.
+ * Returns an empty array on any error (non-git repo, invalid SHA, etc.).
+ */
+export declare function getChangedFiles(directory: string, fromSha: string): string[];

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

@@ -1,9 +1,16 @@
-export type { ToolUsageEntry, DelegationEntry, SessionSummary, DetectedStack, ProjectFingerprint, Suggestion, InFlightToolCall, TrackedSession, } from "./types";
-export { ANALYTICS_DIR, SESSION_SUMMARIES_FILE, FINGERPRINT_FILE } from "./types";
-export { ensureAnalyticsDir, appendSessionSummary, readSessionSummaries, writeFingerprint, readFingerprint, } from "./storage";
+export type { ToolUsageEntry, DelegationEntry, SessionSummary, TokenUsage, MetricsTokenUsage, AdherenceReport, MetricsReport, DetectedStack, ProjectFingerprint, Suggestion, InFlightToolCall, TrackedSession, } from "./types";
+export { ANALYTICS_DIR, SESSION_SUMMARIES_FILE, FINGERPRINT_FILE, METRICS_REPORTS_FILE, MAX_METRICS_ENTRIES, zeroTokenUsage, } from "./types";
+export { ensureAnalyticsDir, appendSessionSummary, readSessionSummaries, writeFingerprint, readFingerprint, writeMetricsReport, readMetricsReports, } from "./storage";
 export { detectStack, detectPackageManager, detectMonorepo, detectPrimaryLanguage, generateFingerprint, fingerprintProject, getOrCreateFingerprint, } from "./fingerprint";
 export { SessionTracker, createSessionTracker } from "./session-tracker";
 export { generateSuggestions, getSuggestionsForProject } from "./suggestions";
+export { generateTokenReport, getTokenReport } from "./token-report";
+export { formatMetricsMarkdown } from "./format-metrics";
+export { generateMetricsReport } from "./generate-metrics-report";
+export { extractPlannedFiles } from "./plan-parser";
+export { getChangedFiles } from "./git-diff";
+export { calculateAdherence } from "./adherence";
+export { aggregateTokensForPlan } from "./plan-token-aggregator";
 import type { SessionTracker } from "./session-tracker";
 import type { ProjectFingerprint } from "./types";
 /** Return value of createAnalytics — bundles tracker + fingerprint */
@@ -15,8 +22,8 @@ export interface Analytics {
 }
 /**
  * Create all analytics services for a project.
- * Instantiates the session tracker and optionally generates/loads the project fingerprint.
- * If a fingerprint is provided, it is reused; otherwise one is generated.
+ * Instantiates the session tracker and uses the provided fingerprint (if any).
+ * Fingerprint generation is the caller's responsibility — pass null to opt out.
  * This is the single entry point called from the plugin's main init.
  */
-export declare function createAnalytics(directory: string, fingerprint?: ProjectFingerprint | null): Analytics;
+export declare function createAnalytics(directory: string, fingerprint: ProjectFingerprint | null): Analytics;

package/dist/features/analytics/plan-parser.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Extract all planned file paths from a plan's `## TODOs` section.
+ *
+ * Parses `**Files**:` lines, splits on commas, strips `(new)` / `Create` prefixes,
+ * deduplicates, and returns normalized relative paths.
+ */
+export declare function extractPlannedFiles(planPath: string): string[];

package/dist/features/analytics/plan-token-aggregator.d.ts

@@ -0,0 +1,11 @@
+import type { MetricsTokenUsage } from "./types";
+/**
+ * Aggregate token usage for a plan by summing across matching session summaries.
+ *
+ * Reads all session summaries, filters to those whose `sessionId` is in `sessionIds`,
+ * and sums their `tokenUsage` fields. Sessions without `tokenUsage` contribute zeros
+ * (backward compatibility).
+ *
+ * Maps from session TokenUsage (inputTokens/outputTokens) to MetricsTokenUsage (input/output).
+ */
+export declare function aggregateTokensForPlan(directory: string, sessionIds: string[]): MetricsTokenUsage;

package/dist/features/analytics/session-tracker.d.ts

@@ -24,6 +24,26 @@ export declare class SessionTracker {
      * Track a tool execution end. Records delegation if it was a task tool.
      */
     trackToolEnd(sessionId: string, toolName: string, callId: string, agent?: string): void;
+    /**
+     * Set the agent name for a session. Only sets on first call (captures primary agent).
+     */
+    setAgentName(sessionId: string, agentName: string): void;
+    /**
+     * Accumulate dollar cost from a message into the session total.
+     */
+    trackCost(sessionId: string, cost: number): void;
+    /**
+     * Track token usage from a message.updated event.
+     * Accumulates all token fields into the session's running totals.
+     * Lazily starts the session if needed.
+     */
+    trackTokenUsage(sessionId: string, tokens: {
+        input?: number;
+        output?: number;
+        reasoning?: number;
+        cacheRead?: number;
+        cacheWrite?: number;
+    }): void;
     /**
      * End a session and persist the summary. Removes the session from tracking.
      * Returns the generated summary, or null if the session wasn't being tracked.

package/dist/features/analytics/storage.d.ts

@@ -1,4 +1,4 @@
-import type { SessionSummary, ProjectFingerprint } from "./types";
+import type { SessionSummary, ProjectFingerprint, MetricsReport } from "./types";
 /** Maximum number of session summary entries to keep in the JSONL file */
 export declare const MAX_SESSION_ENTRIES = 1000;
 /**
@@ -9,6 +9,7 @@ export declare function ensureAnalyticsDir(directory: string): string;
 /**
  * Append a session summary to the JSONL file.
  * Auto-creates the analytics directory if needed.
+ * Rotates the file to at most MAX_SESSION_ENTRIES when the threshold is exceeded.
  */
 export declare function appendSessionSummary(directory: string, summary: SessionSummary): boolean;
 /**
@@ -26,3 +27,14 @@ export declare function writeFingerprint(directory: string, fingerprint: Project
  * Returns null if the file doesn't exist or is unparseable.
  */
 export declare function readFingerprint(directory: string): ProjectFingerprint | null;
+/**
+ * Write a metrics report to the JSONL file.
+ * Auto-creates the analytics directory if needed.
+ * Appends the report and rotates if exceeding MAX_METRICS_ENTRIES.
+ */
+export declare function writeMetricsReport(directory: string, report: MetricsReport): boolean;
+/**
+ * Read all metrics reports from the JSONL file.
+ * Returns an empty array if the file doesn't exist or is unparseable.
+ */
+export declare function readMetricsReports(directory: string): MetricsReport[];

package/dist/features/analytics/token-report.d.ts

@@ -0,0 +1,14 @@
+import type { SessionSummary } from "./types";
+/**
+ * Generate a human-readable token usage and cost report from session summaries.
+ *
+ * Sections:
+ * 1. Overall Totals — aggregate metrics across all sessions
+ * 2. Per-Agent Breakdown — grouped by agentName, sorted by total cost
+ * 3. Top 5 Costliest Sessions — most expensive individual sessions
+ */
+export declare function generateTokenReport(summaries: SessionSummary[]): string;
+/**
+ * Convenience function: read summaries from disk and generate the report.
+ */
+export declare function getTokenReport(directory: string): string;

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

@@ -24,6 +24,21 @@ export interface DelegationEntry {
     /** Duration in milliseconds (if completed) */
     durationMs?: number;
 }
+/** Accumulated token usage across all messages in a session */
+export interface TokenUsage {
+    /** Total input tokens consumed */
+    inputTokens: number;
+    /** Total output tokens generated */
+    outputTokens: number;
+    /** Total reasoning tokens used */
+    reasoningTokens: number;
+    /** Total cache read tokens */
+    cacheReadTokens: number;
+    /** Total cache write tokens */
+    cacheWriteTokens: number;
+    /** Total number of assistant messages processed */
+    totalMessages: number;
+}
 /** Summary of a completed session, appended as a JSONL line */
 export interface SessionSummary {
     /** Unique session identifier */
@@ -42,6 +57,12 @@ export interface SessionSummary {
     totalToolCalls: number;
     /** Total number of delegations */
     totalDelegations: number;
+    /** Display name of the agent that ran this session (e.g., "Loom (Main Orchestrator)") */
+    agentName?: string;
+    /** Total dollar cost accumulated across all messages */
+    totalCost?: number;
+    /** Aggregated token usage across all messages (absent for old entries or sessions with no messages) */
+    tokenUsage?: TokenUsage;
 }
 /** Detected language/framework in the project */
 export interface DetectedStack {
@@ -78,10 +99,71 @@ export interface Suggestion {
     /** Human-readable suggestion text */
     text: string;
     /** Category of suggestion */
-    category: "tool-usage" | "delegation" | "workflow";
+    category: "tool-usage" | "delegation" | "workflow" | "token-usage";
     /** Confidence level */
     confidence: "high" | "medium" | "low";
 }
+/** File name for metrics reports (JSONL format) */
+export declare const METRICS_REPORTS_FILE = "metrics-reports.jsonl";
+/** Maximum number of metrics report entries to keep in the JSONL file */
+export declare const MAX_METRICS_ENTRIES = 100;
+/** Token usage for metrics reports (simplified field names vs session TokenUsage) */
+export interface MetricsTokenUsage {
+    /** Total input tokens consumed */
+    input: number;
+    /** Total output tokens generated */
+    output: number;
+    /** Total reasoning tokens used */
+    reasoning: number;
+    /** Total cache read tokens */
+    cacheRead: number;
+    /** Total cache write tokens */
+    cacheWrite: number;
+}
+/** Create a zero-valued MetricsTokenUsage */
+export declare function zeroTokenUsage(): MetricsTokenUsage;
+/** Plan execution adherence metrics */
+export interface AdherenceReport {
+    /** Proportion of planned files that actually changed (0-1) */
+    coverage: number;
+    /** Proportion of actual changes that were planned (0-1) */
+    precision: number;
+    /** Planned files that actually changed */
+    plannedFilesChanged: string[];
+    /** Files changed but not in the plan */
+    unplannedChanges: string[];
+    /** Planned files that did not change */
+    missedFiles: string[];
+    /** Total number of files in the plan */
+    totalPlannedFiles: number;
+    /** Total number of files actually changed */
+    totalActualFiles: number;
+}
+/** Metrics report for a completed plan */
+export interface MetricsReport {
+    /** Plan name (from plan file basename) */
+    planName: string;
+    /** ISO timestamp when report was generated */
+    generatedAt: string;
+    /** Adherence metrics */
+    adherence: AdherenceReport;
+    /** Code quality score (Phase 2 — undefined in Phase 1) */
+    quality?: unknown;
+    /** Quality gaps (Phase 2 — undefined in Phase 1) */
+    gaps?: unknown;
+    /** Token usage across all sessions */
+    tokenUsage: MetricsTokenUsage;
+    /** Total duration of all sessions in milliseconds */
+    durationMs: number;
+    /** Number of sessions that worked on this plan */
+    sessionCount: number;
+    /** Git HEAD SHA when work started */
+    startSha?: string;
+    /** Git HEAD SHA when work ended (optional) */
+    endSha?: string;
+    /** Session IDs that contributed to this report */
+    sessionIds: string[];
+}
 /** Tracks in-flight tool calls for duration measurement */
 export interface InFlightToolCall {
     /** Tool name */
@@ -103,4 +185,10 @@ export interface TrackedSession {
     delegations: DelegationEntry[];
     /** In-flight tool calls keyed by callID */
     inFlight: Record<string, InFlightToolCall>;
+    /** Display name of the agent running this session */
+    agentName?: string;
+    /** Accumulated dollar cost across all messages */
+    totalCost: number;
+    /** Cumulative token usage across all messages */
+    tokenUsage: TokenUsage;
 }

package/dist/features/builtin-commands/templates/metrics.d.ts

@@ -0,0 +1 @@
+export declare const METRICS_TEMPLATE = "You are being activated by the /metrics command to present Weave analytics data to the user.\n\n## Your Mission\nPresent the injected metrics data in a clear, readable format. The data has already been loaded and formatted by the command hook \u2014 simply relay it to the user.\n\n## Instructions\n\n1. **Read the injected context below** \u2014 it contains pre-formatted metrics markdown\n2. **Present it to the user** as-is \u2014 do NOT re-fetch or recalculate anything\n3. **Answer follow-up questions** about the data if the user asks\n4. If the data indicates analytics is disabled or no data exists, relay that message directly";

package/dist/features/builtin-commands/templates/run-workflow.d.ts

@@ -0,0 +1 @@
+export declare const RUN_WORKFLOW_TEMPLATE = "You are being activated by the /run-workflow command to execute a multi-step workflow.\n\n## Your Mission\nThe workflow engine will inject context below with:\n- The workflow definition to use\n- The user's goal for this workflow instance\n- The current step and its prompt\n- Context from any previously completed steps\n\nFollow the injected step prompt. When the step is complete, the workflow engine will\nautomatically advance you to the next step.\n\n## Rules\n- Focus on the current step's task only\n- Signal completion clearly (the workflow engine detects it)\n- Do NOT skip ahead to future steps\n- If you need user input, ask for it and wait";

package/dist/features/builtin-commands/types.d.ts

@@ -13,4 +13,4 @@ export interface BuiltinCommand {
     /** Hint shown for the argument (e.g., "[plan-name]") */
     argumentHint?: string;
 }
-export type BuiltinCommandName = "start-work";
+export type BuiltinCommandName = "start-work" | "token-report" | "metrics" | "run-workflow";

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 = ".opencode/workflows";
+/** User-level directory for workflow definitions (under ~/.config/opencode/) */
+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";