@fabriccode/weave 0.7.0

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

@@ -0,0 +1,118 @@
+import { z } from "zod";
+/**
+ * Zod schema for step completion configuration in workflow definitions.
+ */
+export declare const CompletionConfigSchema: z.ZodObject<{
+    method: z.ZodEnum<{
+        user_confirm: "user_confirm";
+        plan_created: "plan_created";
+        plan_complete: "plan_complete";
+        review_verdict: "review_verdict";
+        agent_signal: "agent_signal";
+    }>;
+    plan_name: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Zod schema for artifact references.
+ */
+export declare const ArtifactRefSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Zod schema for step artifact declarations.
+ */
+export declare const StepArtifactsSchema: z.ZodObject<{
+    inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/**
+ * Zod schema for a workflow step definition.
+ */
+export declare const WorkflowStepSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        interactive: "interactive";
+        autonomous: "autonomous";
+        gate: "gate";
+    }>;
+    agent: z.ZodString;
+    prompt: z.ZodString;
+    completion: z.ZodObject<{
+        method: z.ZodEnum<{
+            user_confirm: "user_confirm";
+            plan_created: "plan_created";
+            plan_complete: "plan_complete";
+            review_verdict: "review_verdict";
+            agent_signal: "agent_signal";
+        }>;
+        plan_name: z.ZodOptional<z.ZodString>;
+        keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    artifacts: z.ZodOptional<z.ZodObject<{
+        inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    on_reject: z.ZodOptional<z.ZodEnum<{
+        pause: "pause";
+        fail: "fail";
+    }>>;
+}, z.core.$strip>;
+/**
+ * Zod schema for a complete workflow definition file.
+ */
+export declare const WorkflowDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    version: z.ZodNumber;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            interactive: "interactive";
+            autonomous: "autonomous";
+            gate: "gate";
+        }>;
+        agent: z.ZodString;
+        prompt: z.ZodString;
+        completion: z.ZodObject<{
+            method: z.ZodEnum<{
+                user_confirm: "user_confirm";
+                plan_created: "plan_created";
+                plan_complete: "plan_complete";
+                review_verdict: "review_verdict";
+                agent_signal: "agent_signal";
+            }>;
+            plan_name: z.ZodOptional<z.ZodString>;
+            keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+        artifacts: z.ZodOptional<z.ZodObject<{
+            inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        on_reject: z.ZodOptional<z.ZodEnum<{
+            pause: "pause";
+            fail: "fail";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

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

@@ -0,0 +1,51 @@
+import type { WorkflowDefinition, WorkflowInstance, ActiveInstancePointer } from "./types";
+/**
+ * Generate a unique instance ID.
+ * Format: wf_{8 random hex chars} (e.g., "wf_a1b2c3d4").
+ */
+export declare function generateInstanceId(): string;
+/**
+ * Generate a URL-safe slug from a goal string.
+ * Lowercase, spaces to hyphens, strip non-alphanumeric, truncate to 50 chars.
+ */
+export declare function generateSlug(goal: string): string;
+/**
+ * Create a fresh WorkflowInstance for a definition + goal.
+ */
+export declare function createWorkflowInstance(definition: WorkflowDefinition, definitionPath: string, goal: string, sessionId: string): WorkflowInstance;
+/**
+ * Read a workflow instance by ID. Returns null if not found or invalid.
+ */
+export declare function readWorkflowInstance(directory: string, instanceId: string): WorkflowInstance | null;
+/**
+ * Write a workflow instance to its state directory.
+ * Creates directories as needed.
+ */
+export declare function writeWorkflowInstance(directory: string, instance: WorkflowInstance): boolean;
+/**
+ * Read the active instance pointer. Returns null if no active instance.
+ */
+export declare function readActiveInstance(directory: string): ActiveInstancePointer | null;
+/**
+ * Set the active instance pointer.
+ */
+export declare function setActiveInstance(directory: string, instanceId: string): boolean;
+/**
+ * Clear the active instance pointer (without deleting the instance).
+ */
+export declare function clearActiveInstance(directory: string): boolean;
+/**
+ * Get the active workflow instance (resolves pointer -> reads instance).
+ * Returns null if no active instance or instance not found.
+ */
+export declare function getActiveWorkflowInstance(directory: string): WorkflowInstance | null;
+/**
+ * List all instance IDs (for status/history commands).
+ * Returns IDs sorted alphabetically.
+ */
+export declare function listInstances(directory: string): string[];
+/**
+ * Append a session ID to an instance's session_ids.
+ * Returns the updated instance, or null if the instance doesn't exist.
+ */
+export declare function appendInstanceSessionId(directory: string, instanceId: string, sessionId: string): WorkflowInstance | null;

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

@@ -0,0 +1,142 @@
+/**
+ * Step execution types: interactive (needs user input), autonomous (runs without user),
+ * gate (requires APPROVE/REJECT verdict).
+ */
+export type StepType = "interactive" | "autonomous" | "gate";
+/**
+ * How a step's completion is detected.
+ */
+export type CompletionMethod = "user_confirm" | "plan_created" | "plan_complete" | "review_verdict" | "agent_signal";
+/**
+ * Per-step status in a workflow instance.
+ */
+export type StepStatus = "pending" | "active" | "awaiting_user" | "completed" | "failed" | "skipped";
+/**
+ * Instance-level workflow status.
+ */
+export type WorkflowStatus = "running" | "paused" | "completed" | "failed" | "cancelled";
+/**
+ * What happens when a gate step rejects.
+ */
+export type OnRejectAction = "pause" | "fail";
+/**
+ * Reference to an artifact that a step consumes or produces.
+ */
+export interface ArtifactRef {
+    name: string;
+    description?: string;
+}
+/**
+ * Artifact input/output declarations for a step.
+ */
+export interface StepArtifacts {
+    inputs?: ArtifactRef[];
+    outputs?: ArtifactRef[];
+}
+/**
+ * Configuration for how a step's completion is detected.
+ */
+export interface CompletionConfig {
+    method: CompletionMethod;
+    /** For plan_created/plan_complete: the plan name to check */
+    plan_name?: string;
+    /** For user_confirm: custom keywords to detect */
+    keywords?: string[];
+}
+/**
+ * A single step in a workflow definition (template).
+ */
+export interface WorkflowStepDefinition {
+    /** Unique step ID within the workflow (e.g., "gather", "plan-review") */
+    id: string;
+    /** Human-readable step name */
+    name: string;
+    /** Step execution type */
+    type: StepType;
+    /** Agent to activate for this step */
+    agent: string;
+    /** Prompt template with {{instance.goal}}, {{artifacts.X}} variables */
+    prompt: string;
+    /** How to detect step completion */
+    completion: CompletionConfig;
+    /** Artifact declarations */
+    artifacts?: StepArtifacts;
+    /** For gate steps: what to do on reject */
+    on_reject?: OnRejectAction;
+}
+/**
+ * A workflow definition (reusable template).
+ * Stored as JSONC in .fabric/workflows/ or ~/.config/fabric/workflows/.
+ */
+export interface WorkflowDefinition {
+    /** Workflow name matching the filename (e.g., "secure-feature") */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+    /** Schema version for future migration */
+    version: number;
+    /** Ordered list of steps */
+    steps: WorkflowStepDefinition[];
+}
+/**
+ * Per-step state in a workflow instance.
+ */
+export interface StepState {
+    /** Step ID matching the definition */
+    id: string;
+    /** Current step status */
+    status: StepStatus;
+    /** ISO timestamp when the step became active */
+    started_at?: string;
+    /** ISO timestamp when the step completed/failed/skipped */
+    completed_at?: string;
+    /** For gate steps: the verdict */
+    verdict?: "approve" | "reject";
+    /** Error message if failed */
+    error?: string;
+    /** Artifacts produced by this step */
+    artifacts?: Record<string, string>;
+    /** Summary of what this step produced (for context threading) */
+    summary?: string;
+}
+/**
+ * A workflow instance — a specific execution of a workflow definition,
+ * bound to a user goal with accumulated artifacts and step states.
+ */
+export interface WorkflowInstance {
+    /** Unique instance ID (e.g., "wf_a1b2c3d4") */
+    instance_id: string;
+    /** ID of the workflow definition (matches definition name) */
+    definition_id: string;
+    /** Human-readable workflow name */
+    definition_name: string;
+    /** Path to the workflow definition file */
+    definition_path: string;
+    /** The user's goal — what they're trying to accomplish */
+    goal: string;
+    /** URL-safe slug derived from the goal (for plan filenames, etc.) */
+    slug: string;
+    /** Current workflow-level status */
+    status: WorkflowStatus;
+    /** ISO timestamp when the instance was created */
+    started_at: string;
+    /** ISO timestamp when the instance completed/failed/cancelled */
+    ended_at?: string;
+    /** Session IDs that have participated in this instance */
+    session_ids: string[];
+    /** ID of the currently active step */
+    current_step_id: string;
+    /** Per-step state */
+    steps: Record<string, StepState>;
+    /** Accumulated artifacts from completed steps (name -> value) */
+    artifacts: Record<string, string>;
+    /** Why the workflow is paused (if paused) */
+    pause_reason?: string;
+}
+/**
+ * Pointer file content — tracks which instance is currently active.
+ * Stored at .weave/workflows/active-instance.json.
+ */
+export interface ActiveInstancePointer {
+    instance_id: string;
+}

package/dist/hooks/context-window-monitor.d.ts

@@ -0,0 +1,19 @@
+export interface ContextWindowState {
+    usedTokens: number;
+    maxTokens: number;
+    sessionId: string;
+}
+export interface ContextWindowThresholds {
+    warningPct: number;
+    criticalPct: number;
+}
+export type ContextWindowAction = "none" | "warn" | "recover";
+export interface ContextWindowCheckResult {
+    action: ContextWindowAction;
+    usagePct: number;
+    message?: string;
+}
+export declare function checkContextWindow(state: ContextWindowState, thresholds?: ContextWindowThresholds): ContextWindowCheckResult;
+export declare function createContextWindowMonitor(thresholds?: ContextWindowThresholds): {
+    check: (state: ContextWindowState) => ContextWindowCheckResult;
+};

package/dist/hooks/create-hooks.d.ts

@@ -0,0 +1,40 @@
+import type { WeaveConfig } from "../config/schema";
+import { checkContextWindow } from "./context-window-monitor";
+import { getRulesForFile, shouldInjectRules } from "./rules-injector";
+import { shouldApplyVariant, markApplied, markSessionCreated, clearSession } from "./first-message-variant";
+import { processMessageForKeywords } from "./keyword-detector";
+import { checkPatternWrite } from "./pattern-md-only";
+import { buildVerificationReminder } from "./verification-reminder";
+export type CreatedHooks = ReturnType<typeof createHooks>;
+export declare function createHooks(args: {
+    pluginConfig: WeaveConfig;
+    isHookEnabled: (hookName: string) => boolean;
+    directory: string;
+    analyticsEnabled?: boolean;
+}): {
+    checkContextWindow: ((state: Parameters<typeof checkContextWindow>[0]) => import("./context-window-monitor").ContextWindowCheckResult) | null;
+    writeGuard: {
+        trackRead: (filePath: string) => void;
+        checkWrite: (filePath: string) => import("./write-existing-file-guard").WriteGuardCheckResult;
+    } | null;
+    shouldInjectRules: typeof shouldInjectRules | null;
+    getRulesForFile: typeof getRulesForFile | null;
+    firstMessageVariant: {
+        shouldApplyVariant: typeof shouldApplyVariant;
+        markApplied: typeof markApplied;
+        markSessionCreated: typeof markSessionCreated;
+        clearSession: typeof clearSession;
+    } | null;
+    processMessageForKeywords: typeof processMessageForKeywords | null;
+    patternMdOnly: typeof checkPatternWrite | null;
+    startWork: ((promptText: string, sessionId: string) => import("./start-work-hook").StartWorkResult) | null;
+    workContinuation: ((sessionId: string) => import("./work-continuation").ContinuationResult) | null;
+    workflowStart: ((promptText: string, sessionId: string) => import("../features/workflow").WorkflowHookResult) | null;
+    workflowContinuation: ((sessionId: string, lastAssistantMessage?: string, lastUserMessage?: string) => {
+        continuationPrompt: string | null;
+        switchAgent: string | null;
+    }) | null;
+    workflowCommand: ((message: string) => import("../features/workflow").WorkflowCommandResult) | null;
+    verificationReminder: typeof buildVerificationReminder | null;
+    analyticsEnabled: boolean;
+};

package/dist/hooks/first-message-variant.d.ts

@@ -0,0 +1,5 @@
+export declare function markSessionCreated(sessionId: string): void;
+export declare function markApplied(sessionId: string): void;
+export declare function shouldApplyVariant(sessionId: string): boolean;
+export declare function clearSession(sessionId: string): void;
+export declare function clearAll(): void;

package/dist/hooks/index.d.ts

@@ -0,0 +1,14 @@
+export { createHooks } from "./create-hooks";
+export type { CreatedHooks } from "./create-hooks";
+export { checkContextWindow, createContextWindowMonitor } from "./context-window-monitor";
+export type { ContextWindowState, ContextWindowThresholds, ContextWindowCheckResult, ContextWindowAction, } from "./context-window-monitor";
+export { createWriteGuard, createWriteGuardState, trackFileRead, checkWriteAllowed, } from "./write-existing-file-guard";
+export type { WriteGuardState, WriteGuardCheckResult } from "./write-existing-file-guard";
+export { shouldInjectRules, getRulesForFile, buildRulesInjection, getDirectoryFromFilePath, findRulesFile, loadRulesForDirectory, } from "./rules-injector";
+export { shouldApplyVariant, markApplied, markSessionCreated, clearSession, clearAll, } from "./first-message-variant";
+export { detectKeywords, buildKeywordInjection, processMessageForKeywords, DEFAULT_KEYWORD_ACTIONS, } from "./keyword-detector";
+export type { KeywordAction } from "./keyword-detector";
+export { buildVerificationReminder } from "./verification-reminder";
+export type { VerificationInput, VerificationResult } from "./verification-reminder";
+export { setContextLimit, updateUsage, getState, clearSession as clearTokenSession, clear as clearAllTokenState, } from "./session-token-state";
+export type { SessionTokenEntry } from "./session-token-state";

package/dist/hooks/keyword-detector.d.ts

@@ -0,0 +1,8 @@
+export interface KeywordAction {
+    keyword: string;
+    injection: string;
+}
+export declare const DEFAULT_KEYWORD_ACTIONS: KeywordAction[];
+export declare function detectKeywords(message: string, actions?: KeywordAction[]): KeywordAction[];
+export declare function buildKeywordInjection(detected: KeywordAction[]): string | undefined;
+export declare function processMessageForKeywords(message: string, sessionId: string, actions?: KeywordAction[]): string | undefined;

package/dist/hooks/pattern-md-only.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Guard hook that prevents Pattern agent from writing non-.md files
+ * or writing outside the .weave/ directory.
+ */
+export interface PatternWriteCheckResult {
+    allowed: boolean;
+    reason?: string;
+}
+/**
+ * Check whether a write/edit operation should be allowed for the given agent.
+ * Only blocks writes from the "pattern" agent to non-.md files or files outside .weave/.
+ */
+export declare function checkPatternWrite(agentName: string, toolName: string, filePath: string): PatternWriteCheckResult;

package/dist/hooks/rules-injector.d.ts

@@ -0,0 +1,6 @@
+export declare function findRulesFile(directory: string): string | undefined;
+export declare function loadRulesForDirectory(directory: string): string | undefined;
+export declare function shouldInjectRules(toolName: string): boolean;
+export declare function getDirectoryFromFilePath(filePath: string): string;
+export declare function buildRulesInjection(rulesContent: string, directory: string): string;
+export declare function getRulesForFile(filePath: string): string | undefined;

package/dist/hooks/session-token-state.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Per-session token state tracker.
+ *
+ * Bridges the gap between:
+ * - `chat.params` hook → provides model context limit (maxTokens)
+ * - `message.updated` event → provides latest input token usage (usedTokens)
+ *
+ * Uses an in-memory Map keyed by sessionId. State resets on plugin restart,
+ * which is acceptable — data rebuilds on the next `chat.params` + `message.updated` pair.
+ */
+export interface SessionTokenEntry {
+    maxTokens: number;
+    usedTokens: number;
+}
+/**
+ * Store the model's context limit for a session.
+ * Called from the `chat.params` hook when a session starts.
+ * Does NOT overwrite existing `usedTokens`.
+ */
+export declare function setContextLimit(sessionId: string, maxTokens: number): void;
+/**
+ * Update the latest input token usage for a session.
+ * Called from `message.updated` events with AssistantMessage tokens.
+ * Stores the latest value — NOT cumulative across messages.
+ * Does NOT overwrite existing `maxTokens`.
+ * Only updates when inputTokens > 0 (guards against partial streaming updates).
+ */
+export declare function updateUsage(sessionId: string, inputTokens: number): void;
+/**
+ * Get the current token state for a session.
+ * Returns undefined if the session is unknown.
+ */
+export declare function getState(sessionId: string): SessionTokenEntry | undefined;
+/**
+ * Remove a session from the tracker.
+ * Called on `session.deleted` events.
+ */
+export declare function clearSession(sessionId: string): void;
+/**
+ * Clear all session state. Used in tests only.
+ */
+export declare function clear(): void;

package/dist/hooks/start-work-hook.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Start-work hook: detects the /start-work command, resolves the target plan,
+ * creates/updates work state, and returns context for injection into the prompt.
+ */
+import type { ValidationResult } from "../features/work-state";
+export interface StartWorkInput {
+    promptText: string;
+    sessionId: string;
+    directory: string;
+}
+export interface StartWorkResult {
+    /** Context to inject into the prompt (plan path, progress, instructions) */
+    contextInjection: string | null;
+    /** Agent to switch to (always "tapestry" when command is detected) */
+    switchAgent: string | null;
+}
+/**
+ * Handle the /start-work command.
+ * Returns null contextInjection if this message is not a /start-work command.
+ */
+export declare function handleStartWork(input: StartWorkInput): StartWorkResult;
+/**
+ * Format validation errors and warnings as a markdown string.
+ */
+export declare function formatValidationResults(result: ValidationResult): string;

package/dist/hooks/verification-reminder.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Verification reminder hook: builds a prompt that reminds the orchestrator
+ * to verify completed work, optionally delegating to Weft for review.
+ */
+export interface VerificationInput {
+    /** Name of the plan being executed, if any */
+    planName?: string;
+    /** Progress of the current plan */
+    progress?: {
+        total: number;
+        completed: number;
+    };
+}
+export interface VerificationResult {
+    /** Verification prompt to inject, or null if not applicable */
+    verificationPrompt: string | null;
+}
+/**
+ * Build a verification reminder prompt to inject after task completion.
+ * Returns a structured reminder for the orchestrator to verify work.
+ */
+export declare function buildVerificationReminder(input: VerificationInput): VerificationResult;

package/dist/hooks/work-continuation.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Work continuation hook: checks if there's an active plan with remaining tasks
+ * and returns a continuation prompt to keep the executor going.
+ */
+/**
+ * Marker embedded in continuation prompts so that `chat.message` can distinguish
+ * continuation-injected messages from user-initiated messages.
+ * When a user message arrives WITHOUT this marker (and is not a /start-work command),
+ * the plugin auto-pauses work to prevent the infinite continuation loop.
+ */
+export declare const CONTINUATION_MARKER = "<!-- weave:continuation -->";
+/** Maximum consecutive continuations without progress before auto-pausing */
+export declare const MAX_STALE_CONTINUATIONS = 3;
+export interface ContinuationInput {
+    sessionId: string;
+    directory: string;
+}
+export interface ContinuationResult {
+    /** Continuation prompt to inject, or null if no active work / plan complete */
+    continuationPrompt: string | null;
+}
+/**
+ * Check if there's active work that should continue.
+ * Returns a continuation prompt if the plan has remaining tasks, null otherwise.
+ */
+export declare function checkContinuation(input: ContinuationInput): ContinuationResult;

package/dist/hooks/write-existing-file-guard.d.ts

@@ -0,0 +1,14 @@
+export interface WriteGuardState {
+    readFiles: Set<string>;
+}
+export declare function createWriteGuardState(): WriteGuardState;
+export declare function trackFileRead(state: WriteGuardState, filePath: string): void;
+export interface WriteGuardCheckResult {
+    allowed: boolean;
+    warning?: string;
+}
+export declare function checkWriteAllowed(state: WriteGuardState, filePath: string): WriteGuardCheckResult;
+export declare function createWriteGuard(state: WriteGuardState): {
+    trackRead: (filePath: string) => void;
+    checkWrite: (filePath: string) => WriteGuardCheckResult;
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from "@fabriccode/plugin";
+declare const WeavePlugin: Plugin;
+export default WeavePlugin;
+export type { WeaveConfig } from "./config/schema";
+export type { WeaveAgentName } from "./agents/types";