@a4hgehad/weave-mcp 0.8.6 → 0.8.7

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/index.d.ts

@@ -0,0 +1,6 @@
+export { loadSkills } from "./loader";
+export type { LoadSkillsOptions } from "./loader";
+export { createResolveSkillsFn, createSkillResolver, resolveMultipleSkills, resolveSkill } from "./resolver";
+export { fetchSkillsFromOpenCode } from "./opencode-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/opencode-client.d.ts

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

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/task-system/index.d.ts

@@ -0,0 +1,6 @@
+export { createTaskCreateTool, createTaskUpdateTool, createTaskListTool } from "./tools";
+export { TaskStatus, TaskObjectSchema, TaskStatusSchema } from "./types";
+export type { TaskObject, TaskCreateInput, TaskUpdateInput, TaskListInput } from "./types";
+export { getTaskDir, generateTaskId, readTask, writeTask, readAllTasks } from "./storage";
+export { syncTaskToTodo, syncTaskTodoUpdate, syncAllTasksToTodos } from "./todo-sync";
+export type { TodoWriter, TodoInfo } from "./todo-sync";

package/dist/features/task-system/storage.d.ts

@@ -0,0 +1,38 @@
+import { type TaskObject } from "./types";
+/**
+ * Derive the task storage directory for a given project.
+ * Uses the opencode config dir (~/.config/opencode by default) + sanitized project slug.
+ */
+export declare function getTaskDir(directory: string, configDir?: string): string;
+/** Generate a unique task ID */
+export declare function generateTaskId(): string;
+/**
+ * Read and parse a JSON file safely. Returns null for missing, corrupt, or invalid data.
+ */
+export declare function readJsonSafe<T>(filePath: string, schema: {
+    parse: (data: unknown) => T;
+}): T | null;
+/**
+ * Write JSON atomically: write to a temp file then rename.
+ * This prevents partial writes from corrupting the target file.
+ */
+export declare function writeJsonAtomic(filePath: string, data: unknown): void;
+/**
+ * Acquire a file-based lock. Uses exclusive file creation (wx flag).
+ * Returns a release function on success, null on failure.
+ *
+ * Stale locks older than `staleThresholdMs` (default 30s) are automatically broken.
+ */
+export declare function acquireLock(lockPath: string, staleThresholdMs?: number): (() => void) | null;
+/** Ensure a directory exists */
+export declare function ensureDir(dirPath: string): void;
+/** List task files (T-*.json) in the task directory */
+export declare function listTaskFiles(taskDir: string): string[];
+/** Get the file path for a task by ID */
+export declare function getTaskFilePath(taskDir: string, taskId: string): string;
+/** Read a single task from file storage */
+export declare function readTask(taskDir: string, taskId: string): TaskObject | null;
+/** Write a single task to file storage (atomic) */
+export declare function writeTask(taskDir: string, task: TaskObject): void;
+/** Read all tasks from a task directory */
+export declare function readAllTasks(taskDir: string): TaskObject[];

package/dist/features/task-system/todo-sync.d.ts

@@ -0,0 +1,38 @@
+import type { TaskObject } from "./types";
+/** TodoInfo matches the shape expected by OpenCode's todo sidebar */
+export interface TodoInfo {
+    id?: string;
+    content: string;
+    status: "pending" | "in_progress" | "completed";
+    priority?: "high" | "medium" | "low";
+}
+/** TodoWriter interface — abstracts the OpenCode todo write API */
+export interface TodoWriter {
+    read(sessionId: string): Promise<TodoInfo[]>;
+    update(sessionId: string, todos: TodoInfo[]): Promise<void>;
+}
+/**
+ * Map a TaskObject to a TodoInfo for the sidebar.
+ * Returns null for deleted tasks (they should be removed from the sidebar).
+ */
+export declare function syncTaskToTodo(task: TaskObject): TodoInfo | null;
+/**
+ * Check if two todo items match by ID first, then by content as fallback.
+ */
+export declare function todosMatch(a: TodoInfo, b: TodoInfo): boolean;
+/**
+ * Sync a single task to the todo sidebar.
+ * This is the anti-obliteration mechanism:
+ * 1. Read current todos
+ * 2. Filter out the matching item (by ID or content)
+ * 3. Push the updated item (or omit it if deleted)
+ * 4. Write back the full list
+ *
+ * Non-task todos (those not matching any task ID) survive intact.
+ */
+export declare function syncTaskTodoUpdate(writer: TodoWriter | null, sessionId: string, task: TaskObject): Promise<void>;
+/**
+ * Sync all tasks to the todo sidebar, preserving non-task todos.
+ * Used for bulk reconciliation.
+ */
+export declare function syncAllTasksToTodos(writer: TodoWriter | null, sessionId: string, tasks: TaskObject[]): Promise<void>;

package/dist/features/task-system/tools/index.d.ts

@@ -0,0 +1,3 @@
+export { createTaskCreateTool } from "./task-create";
+export { createTaskUpdateTool } from "./task-update";
+export { createTaskListTool } from "./task-list";

package/dist/features/task-system/tools/task-create.d.ts

@@ -0,0 +1,9 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import { type TodoWriter } from "../todo-sync";
+declare const TASK_ID_PATTERN: RegExp;
+export declare function createTaskCreateTool(options: {
+    directory: string;
+    configDir?: string;
+    todoWriter?: TodoWriter | null;
+}): ToolDefinition;
+export { TASK_ID_PATTERN };

package/dist/features/task-system/tools/task-list.d.ts

@@ -0,0 +1,5 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+export declare function createTaskListTool(options: {
+    directory: string;
+    configDir?: string;
+}): ToolDefinition;

package/dist/features/task-system/tools/task-update.d.ts

@@ -0,0 +1,7 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import { type TodoWriter } from "../todo-sync";
+export declare function createTaskUpdateTool(options: {
+    directory: string;
+    configDir?: string;
+    todoWriter?: TodoWriter | null;
+}): ToolDefinition;

package/dist/features/task-system/types.d.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+/** Task status values */
+export declare const TaskStatus: {
+    readonly PENDING: "pending";
+    readonly IN_PROGRESS: "in_progress";
+    readonly COMPLETED: "completed";
+    readonly DELETED: "deleted";
+};
+export type TaskStatus = (typeof TaskStatus)[keyof typeof TaskStatus];
+export declare const TaskStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    completed: "completed";
+    in_progress: "in_progress";
+    deleted: "deleted";
+}>;
+/**
+ * Core task object — simplified from OmO's schema.
+ * Drops: activeForm, owner, repoURL, parentID (per design decision D4).
+ */
+export declare const TaskObjectSchema: z.ZodObject<{
+    id: z.ZodString;
+    subject: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        completed: "completed";
+        in_progress: "in_progress";
+        deleted: "deleted";
+    }>;
+    threadID: z.ZodString;
+    blocks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    blockedBy: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type TaskObject = z.infer<typeof TaskObjectSchema>;
+/** Input schema for task_create tool */
+export declare const TaskCreateInputSchema: z.ZodObject<{
+    subject: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    blocks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    blockedBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type TaskCreateInput = z.infer<typeof TaskCreateInputSchema>;
+/** Input schema for task_update tool */
+export declare const TaskUpdateInputSchema: z.ZodObject<{
+    id: z.ZodString;
+    subject: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        pending: "pending";
+        completed: "completed";
+        in_progress: "in_progress";
+        deleted: "deleted";
+    }>>;
+    addBlocks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    addBlockedBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type TaskUpdateInput = z.infer<typeof TaskUpdateInputSchema>;
+/** Input schema for task_list tool (no args needed for PoC) */
+export declare const TaskListInputSchema: z.ZodObject<{}, z.core.$strip>;
+export type TaskListInput = z.infer<typeof TaskListInputSchema>;

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;