@opencode_weave/weave 0.6.4 → 0.7.0-preview.1

package/dist/index.js

@@ -1,10 +1,10 @@
 // src/index.ts
-import { join as join10 } from "path";
+import { join as join13 } from "path";
 
 // src/config/loader.ts
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync as existsSync2, readFileSync } from "node:fs";
 import { join as join2 } from "node:path";
-import { homedir } from "node:os";
+import { homedir as homedir2 } from "node:os";
 import { parse } from "jsonc-parser";
 
 // src/config/schema.ts
@@ -77,7 +77,11 @@ var CustomAgentConfigSchema = z.object({
 });
 var CustomAgentsConfigSchema = z.record(z.string(), CustomAgentConfigSchema);
 var AnalyticsConfigSchema = z.object({
-  enabled: z.boolean().optional()
+  enabled: z.boolean().optional(),
+  use_fingerprint: z.boolean().optional()
+});
+var WorkflowConfigSchema = z.object({
+  disabled_workflows: z.array(z.string()).optional()
 });
 var WeaveConfigSchema = z.object({
   $schema: z.string().optional(),
@@ -91,7 +95,8 @@ var WeaveConfigSchema = z.object({
   background: BackgroundConfigSchema.optional(),
   analytics: AnalyticsConfigSchema.optional(),
   tmux: TmuxConfigSchema.optional(),
-  experimental: ExperimentalConfigSchema.optional()
+  experimental: ExperimentalConfigSchema.optional(),
+  workflows: WorkflowConfigSchema.optional()
 });
 
 // src/config/merge.ts
@@ -134,7 +139,20 @@ function mergeConfigs(user, project) {
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
-var LOG_FILE = path.join(os.tmpdir(), "weave-opencode.log");
+function getLogDir() {
+  const home = os.homedir();
+  return path.join(home, ".opencode", "logs");
+}
+function resolveLogFile() {
+  const dir = getLogDir();
+  try {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  } catch {}
+  return path.join(dir, "weave-opencode.log");
+}
+var LOG_FILE = resolveLogFile();
 function log(message, data) {
   try {
     const timestamp = new Date().toISOString();
@@ -170,15 +188,15 @@ function readJsoncFile(filePath) {
 }
 function detectConfigFile(basePath) {
   const jsoncPath = basePath + ".jsonc";
-  if (existsSync(jsoncPath))
+  if (existsSync2(jsoncPath))
     return jsoncPath;
   const jsonPath = basePath + ".json";
-  if (existsSync(jsonPath))
+  if (existsSync2(jsonPath))
     return jsonPath;
   return null;
 }
 function loadWeaveConfig(directory, _ctx, _homeDir) {
-  const userBasePath = join2(_homeDir ?? homedir(), ".config", "opencode", "weave-opencode");
+  const userBasePath = join2(_homeDir ?? homedir2(), ".config", "opencode", "weave-opencode");
   const projectBasePath = join2(directory, ".opencode", "weave-opencode");
   const userConfigPath = detectConfigFile(userBasePath);
   const projectConfigPath = detectConfigFile(projectBasePath);
@@ -267,6 +285,38 @@ For each unchecked \`- [ ]\` task in the plan:
 - Do NOT stop until all checkboxes are checked or you are explicitly told to stop
 - After all tasks are complete, report a final summary`;
 
+// src/features/builtin-commands/templates/metrics.ts
+var METRICS_TEMPLATE = `You are being activated by the /metrics command to present Weave analytics data to the user.
+
+## Your Mission
+Present the injected metrics data in a clear, readable format. The data has already been loaded and formatted by the command hook — simply relay it to the user.
+
+## Instructions
+
+1. **Read the injected context below** — it contains pre-formatted metrics markdown
+2. **Present it to the user** as-is — do NOT re-fetch or recalculate anything
+3. **Answer follow-up questions** about the data if the user asks
+4. If the data indicates analytics is disabled or no data exists, relay that message directly`;
+
+// src/features/builtin-commands/templates/run-workflow.ts
+var RUN_WORKFLOW_TEMPLATE = `You are being activated by the /run-workflow command to execute a multi-step workflow.
+
+## Your Mission
+The workflow engine will inject context below with:
+- The workflow definition to use
+- The user's goal for this workflow instance
+- The current step and its prompt
+- Context from any previously completed steps
+
+Follow the injected step prompt. When the step is complete, the workflow engine will
+automatically advance you to the next step.
+
+## Rules
+- Focus on the current step's task only
+- Signal completion clearly (the workflow engine detects it)
+- Do NOT skip ahead to future steps
+- If you need user input, ask for it and wait`;
+
 // src/features/builtin-commands/commands.ts
 var BUILTIN_COMMANDS = {
   "start-work": {
@@ -279,6 +329,36 @@ ${START_WORK_TEMPLATE}
 <session-context>Session ID: $SESSION_ID  Timestamp: $TIMESTAMP</session-context>
 <user-request>$ARGUMENTS</user-request>`,
     argumentHint: "[plan-name]"
+  },
+  "token-report": {
+    name: "token-report",
+    description: "Show token usage and cost report across sessions",
+    agent: "loom",
+    template: `<command-instruction>
+Display the token usage report that has been injected below. Present it clearly to the user.
+</command-instruction>
+<token-report>$ARGUMENTS</token-report>`
+  },
+  metrics: {
+    name: "metrics",
+    description: "Show Weave analytics and plan metrics reports",
+    agent: "loom",
+    template: `<command-instruction>
+${METRICS_TEMPLATE}
+</command-instruction>
+<metrics-data>$ARGUMENTS</metrics-data>`,
+    argumentHint: "[plan-name|all]"
+  },
+  "run-workflow": {
+    name: "run-workflow",
+    description: "Run a multi-step workflow",
+    agent: "loom",
+    template: `<command-instruction>
+${RUN_WORKFLOW_TEMPLATE}
+</command-instruction>
+<session-context>Session ID: $SESSION_ID  Timestamp: $TIMESTAMP</session-context>
+<user-request>$ARGUMENTS</user-request>`,
+    argumentHint: '<workflow-name> ["goal"]'
   }
 };
 // src/managers/config-handler.ts
@@ -1768,18 +1848,18 @@ function createBuiltinAgents(options = {}) {
 }
 
 // src/agents/prompt-loader.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
-import { resolve, isAbsolute, normalize } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
+import { resolve, isAbsolute, normalize, sep } from "path";
 function loadPromptFile(promptFilePath, basePath) {
   if (isAbsolute(promptFilePath)) {
     return null;
   }
   const base = resolve(basePath ?? process.cwd());
   const resolvedPath = normalize(resolve(base, promptFilePath));
-  if (!resolvedPath.startsWith(base + "/") && resolvedPath !== base) {
+  if (!resolvedPath.startsWith(base + sep) && resolvedPath !== base) {
     return null;
   }
-  if (!existsSync2(resolvedPath)) {
+  if (!existsSync3(resolvedPath)) {
     return null;
   }
   return readFileSync2(resolvedPath, "utf-8").trim();
@@ -2359,7 +2439,7 @@ var WORK_STATE_FILE = "state.json";
 var WORK_STATE_PATH = `${WEAVE_DIR}/${WORK_STATE_FILE}`;
 var PLANS_DIR = `${WEAVE_DIR}/plans`;
 // src/features/work-state/storage.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync, unlinkSync, mkdirSync, readdirSync as readdirSync2, statSync } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync, unlinkSync, mkdirSync as mkdirSync2, readdirSync as readdirSync2, statSync } from "fs";
 import { join as join6, basename } from "path";
 import { execSync } from "child_process";
 var UNCHECKED_RE = /^[-*]\s*\[\s*\]/gm;
@@ -2367,7 +2447,7 @@ var CHECKED_RE = /^[-*]\s*\[[xX]\]/gm;
 function readWorkState(directory) {
   const filePath = join6(directory, WEAVE_DIR, WORK_STATE_FILE);
   try {
-    if (!existsSync6(filePath))
+    if (!existsSync7(filePath))
       return null;
     const raw = readFileSync5(filePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -2386,8 +2466,8 @@ function readWorkState(directory) {
 function writeWorkState(directory, state) {
   try {
     const dir = join6(directory, WEAVE_DIR);
-    if (!existsSync6(dir)) {
-      mkdirSync(dir, { recursive: true });
+    if (!existsSync7(dir)) {
+      mkdirSync2(dir, { recursive: true });
     }
     writeFileSync(join6(dir, WORK_STATE_FILE), JSON.stringify(state, null, 2), "utf-8");
     return true;
@@ -2398,7 +2478,7 @@ function writeWorkState(directory, state) {
 function clearWorkState(directory) {
   const filePath = join6(directory, WEAVE_DIR, WORK_STATE_FILE);
   try {
-    if (existsSync6(filePath)) {
+    if (existsSync7(filePath)) {
       unlinkSync(filePath);
     }
     return true;
@@ -2442,7 +2522,7 @@ function getHeadSha(directory) {
 function findPlans(directory) {
   const plansDir = join6(directory, PLANS_DIR);
   try {
-    if (!existsSync6(plansDir))
+    if (!existsSync7(plansDir))
       return [];
     const files = readdirSync2(plansDir).filter((f) => f.endsWith(".md")).map((f) => {
       const fullPath = join6(plansDir, f);
@@ -2455,7 +2535,7 @@ function findPlans(directory) {
   }
 }
 function getPlanProgress(planPath) {
-  if (!existsSync6(planPath)) {
+  if (!existsSync7(planPath)) {
     return { total: 0, completed: 0, isComplete: true };
   }
   try {
@@ -2491,14 +2571,14 @@ function resumeWork(directory) {
   return writeWorkState(directory, state);
 }
 // src/features/work-state/validation.ts
-import { readFileSync as readFileSync6, existsSync as existsSync7 } from "fs";
-import { resolve as resolve3, sep } from "path";
+import { readFileSync as readFileSync6, existsSync as existsSync8 } from "fs";
+import { resolve as resolve3, sep as sep2 } from "path";
 function validatePlan(planPath, projectDir) {
   const errors = [];
   const warnings = [];
   const resolvedPlanPath = resolve3(planPath);
   const allowedDir = resolve3(projectDir, PLANS_DIR);
-  if (!resolvedPlanPath.startsWith(allowedDir + sep) && resolvedPlanPath !== allowedDir) {
+  if (!resolvedPlanPath.startsWith(allowedDir + sep2) && resolvedPlanPath !== allowedDir) {
     errors.push({
       severity: "error",
       category: "structure",
@@ -2506,7 +2586,7 @@ function validatePlan(planPath, projectDir) {
     });
     return { valid: false, errors, warnings };
   }
-  if (!existsSync7(resolvedPlanPath)) {
+  if (!existsSync8(resolvedPlanPath)) {
     errors.push({
       severity: "error",
       category: "structure",
@@ -2678,7 +2758,7 @@ function validateFileReferences(content, projectDir, warnings) {
       }
       const resolvedProject = resolve3(projectDir);
       const absolutePath = resolve3(projectDir, filePath);
-      if (!absolutePath.startsWith(resolvedProject + sep) && absolutePath !== resolvedProject) {
+      if (!absolutePath.startsWith(resolvedProject + sep2) && absolutePath !== resolvedProject) {
         warnings.push({
           severity: "warning",
           category: "file-references",
@@ -2686,7 +2766,7 @@ function validateFileReferences(content, projectDir, warnings) {
         });
         continue;
       }
-      if (!existsSync7(absolutePath)) {
+      if (!existsSync8(absolutePath)) {
         warnings.push({
           severity: "warning",
           category: "file-references",
@@ -2770,246 +2850,1203 @@ function validateVerificationSection(content, errors) {
     });
   }
 }
-// src/hooks/start-work-hook.ts
-function handleStartWork(input) {
-  const { promptText, sessionId, directory } = input;
-  if (!promptText.includes("<session-context>")) {
-    return { contextInjection: null, switchAgent: null };
+// src/features/workflow/constants.ts
+var WORKFLOWS_STATE_DIR = ".weave/workflows";
+var INSTANCE_STATE_FILE = "state.json";
+var ACTIVE_INSTANCE_FILE = "active-instance.json";
+var WORKFLOWS_DIR_PROJECT = ".opencode/workflows";
+var WORKFLOWS_DIR_USER = "workflows";
+// src/features/workflow/storage.ts
+import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync3 } from "fs";
+import { join as join7 } from "path";
+import { randomBytes } from "node:crypto";
+function generateInstanceId() {
+  return `wf_${randomBytes(4).toString("hex")}`;
+}
+function generateSlug(goal) {
+  return goal.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
+}
+function createWorkflowInstance(definition, definitionPath, goal, sessionId) {
+  const instanceId = generateInstanceId();
+  const slug = generateSlug(goal);
+  const firstStepId = definition.steps[0].id;
+  const steps = {};
+  for (const step of definition.steps) {
+    steps[step.id] = {
+      id: step.id,
+      status: step.id === firstStepId ? "active" : "pending",
+      ...step.id === firstStepId ? { started_at: new Date().toISOString() } : {}
+    };
   }
-  const explicitPlanName = extractPlanName(promptText);
-  const existingState = readWorkState(directory);
-  const allPlans = findPlans(directory);
-  if (explicitPlanName) {
-    return handleExplicitPlan(explicitPlanName, allPlans, sessionId, directory);
+  return {
+    instance_id: instanceId,
+    definition_id: definition.name,
+    definition_name: definition.name,
+    definition_path: definitionPath,
+    goal,
+    slug,
+    status: "running",
+    started_at: new Date().toISOString(),
+    session_ids: [sessionId],
+    current_step_id: firstStepId,
+    steps,
+    artifacts: {}
+  };
+}
+function readWorkflowInstance(directory, instanceId) {
+  const filePath = join7(directory, WORKFLOWS_STATE_DIR, instanceId, INSTANCE_STATE_FILE);
+  try {
+    if (!existsSync9(filePath))
+      return null;
+    const raw = readFileSync7(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return null;
+    if (typeof parsed.instance_id !== "string")
+      return null;
+    return parsed;
+  } catch {
+    return null;
   }
-  if (existingState) {
-    const progress = getPlanProgress(existingState.active_plan);
-    if (!progress.isComplete) {
-      const validation = validatePlan(existingState.active_plan, directory);
-      if (!validation.valid) {
-        clearWorkState(directory);
-        return {
-          switchAgent: "tapestry",
-          contextInjection: `## Plan Validation Failed
-The active plan "${existingState.plan_name}" has structural issues. Work state has been cleared.
-
-${formatValidationResults(validation)}
+}
+function writeWorkflowInstance(directory, instance) {
+  try {
+    const dir = join7(directory, WORKFLOWS_STATE_DIR, instance.instance_id);
+    if (!existsSync9(dir)) {
+      mkdirSync3(dir, { recursive: true });
+    }
+    writeFileSync2(join7(dir, INSTANCE_STATE_FILE), JSON.stringify(instance, null, 2), "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readActiveInstance(directory) {
+  const filePath = join7(directory, WORKFLOWS_STATE_DIR, ACTIVE_INSTANCE_FILE);
+  try {
+    if (!existsSync9(filePath))
+      return null;
+    const raw = readFileSync7(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || typeof parsed.instance_id !== "string")
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function setActiveInstance(directory, instanceId) {
+  try {
+    const dir = join7(directory, WORKFLOWS_STATE_DIR);
+    if (!existsSync9(dir)) {
+      mkdirSync3(dir, { recursive: true });
+    }
+    const pointer = { instance_id: instanceId };
+    writeFileSync2(join7(dir, ACTIVE_INSTANCE_FILE), JSON.stringify(pointer, null, 2), "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function clearActiveInstance(directory) {
+  const filePath = join7(directory, WORKFLOWS_STATE_DIR, ACTIVE_INSTANCE_FILE);
+  try {
+    if (existsSync9(filePath)) {
+      unlinkSync2(filePath);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getActiveWorkflowInstance(directory) {
+  const pointer = readActiveInstance(directory);
+  if (!pointer)
+    return null;
+  return readWorkflowInstance(directory, pointer.instance_id);
+}
+// src/features/workflow/discovery.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+import * as os3 from "os";
+import { parse as parseJsonc } from "jsonc-parser";
+
+// src/features/workflow/schema.ts
+import { z as z2 } from "zod";
+var CompletionConfigSchema = z2.object({
+  method: z2.enum(["user_confirm", "plan_created", "plan_complete", "review_verdict", "agent_signal"]),
+  plan_name: z2.string().optional(),
+  keywords: z2.array(z2.string()).optional()
+});
+var ArtifactRefSchema = z2.object({
+  name: z2.string(),
+  description: z2.string().optional()
+});
+var StepArtifactsSchema = z2.object({
+  inputs: z2.array(ArtifactRefSchema).optional(),
+  outputs: z2.array(ArtifactRefSchema).optional()
+});
+var WorkflowStepSchema = z2.object({
+  id: z2.string().regex(/^[a-z][a-z0-9-]*$/, "Step ID must be lowercase alphanumeric with hyphens"),
+  name: z2.string(),
+  type: z2.enum(["interactive", "autonomous", "gate"]),
+  agent: z2.string(),
+  prompt: z2.string(),
+  completion: CompletionConfigSchema,
+  artifacts: StepArtifactsSchema.optional(),
+  on_reject: z2.enum(["pause", "fail"]).optional()
+});
+var WorkflowDefinitionSchema = z2.object({
+  name: z2.string().regex(/^[a-z][a-z0-9-]*$/, "Workflow name must be lowercase alphanumeric with hyphens"),
+  description: z2.string().optional(),
+  version: z2.number().int().positive(),
+  steps: z2.array(WorkflowStepSchema).min(1, "Workflow must have at least one step")
+});
 
-Tell the user to fix the plan file and run /start-work again.`
-        };
+// src/features/workflow/discovery.ts
+function loadWorkflowDefinition(filePath) {
+  let raw;
+  try {
+    raw = fs5.readFileSync(filePath, "utf-8");
+  } catch (err) {
+    log("Failed to read workflow definition file", { filePath, error: String(err) });
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = parseJsonc(raw);
+  } catch (err) {
+    log("Failed to parse workflow definition JSONC", { filePath, error: String(err) });
+    return null;
+  }
+  const result = WorkflowDefinitionSchema.safeParse(parsed);
+  if (!result.success) {
+    log("Workflow definition failed validation", {
+      filePath,
+      errors: result.error.issues.map((i) => i.message)
+    });
+    return null;
+  }
+  return result.data;
+}
+function scanWorkflowDirectory(directory, scope) {
+  if (!fs5.existsSync(directory))
+    return [];
+  let entries;
+  try {
+    entries = fs5.readdirSync(directory, { withFileTypes: true });
+  } catch (err) {
+    log("Failed to read workflows directory", { directory, error: String(err) });
+    return [];
+  }
+  const workflows = [];
+  for (const entry of entries) {
+    if (!entry.isFile())
+      continue;
+    if (!entry.name.endsWith(".jsonc") && !entry.name.endsWith(".json"))
+      continue;
+    const filePath = path5.join(directory, entry.name);
+    const definition = loadWorkflowDefinition(filePath);
+    if (definition) {
+      workflows.push({ definition, path: filePath, scope });
+    }
+  }
+  return workflows;
+}
+function discoverWorkflows(directory) {
+  const projectDir = path5.join(directory, WORKFLOWS_DIR_PROJECT);
+  const userDir = path5.join(os3.homedir(), ".config", "opencode", WORKFLOWS_DIR_USER);
+  const userWorkflows = scanWorkflowDirectory(userDir, "user");
+  const projectWorkflows = scanWorkflowDirectory(projectDir, "project");
+  const byName = new Map;
+  for (const wf of userWorkflows) {
+    byName.set(wf.definition.name, wf);
+  }
+  for (const wf of projectWorkflows) {
+    byName.set(wf.definition.name, wf);
+  }
+  return Array.from(byName.values());
+}
+// src/features/workflow/context.ts
+function resolveTemplate(template, instance, definition) {
+  return template.replace(/\{\{(\w+)\.(\w+)\}\}/g, (_match, namespace, key) => {
+    switch (namespace) {
+      case "instance": {
+        const instanceRecord = instance;
+        const value = instanceRecord[key];
+        return typeof value === "string" ? value : _match;
       }
-      appendSessionId(directory, sessionId);
-      resumeWork(directory);
-      const resumeContext = buildResumeContext(existingState.active_plan, existingState.plan_name, progress, existingState.start_sha);
-      if (validation.warnings.length > 0) {
-        return {
-          switchAgent: "tapestry",
-          contextInjection: `${resumeContext}
-
-### Validation Warnings
-${formatValidationResults(validation)}`
-        };
+      case "artifacts": {
+        const value = instance.artifacts[key];
+        return value ?? "(not yet available)";
+      }
+      case "step": {
+        const currentStep = definition.steps.find((s) => s.id === instance.current_step_id);
+        if (!currentStep)
+          return _match;
+        const stepRecord = currentStep;
+        const value = stepRecord[key];
+        return typeof value === "string" ? value : _match;
       }
+      default:
+        return _match;
+    }
+  });
+}
+function buildContextHeader(instance, definition) {
+  const currentStepIndex = definition.steps.findIndex((s) => s.id === instance.current_step_id);
+  const currentStepDef = definition.steps[currentStepIndex];
+  const stepLabel = currentStepDef ? `step ${currentStepIndex + 1} of ${definition.steps.length}: ${currentStepDef.name}` : `step ${currentStepIndex + 1} of ${definition.steps.length}`;
+  const lines = [];
+  lines.push("## Workflow Context");
+  lines.push(`**Goal**: "${instance.goal}"`);
+  lines.push(`**Workflow**: ${definition.name} (${stepLabel})`);
+  lines.push("");
+  const completedSteps = definition.steps.filter((s) => {
+    const state = instance.steps[s.id];
+    return state && state.status === "completed";
+  });
+  if (completedSteps.length > 0) {
+    lines.push("### Completed Steps");
+    for (const stepDef of completedSteps) {
+      const state = instance.steps[stepDef.id];
+      const summary = state.summary ? ` → "${truncateSummary(state.summary)}"` : "";
+      lines.push(`- [✓] **${stepDef.name}**${summary}`);
+    }
+    lines.push("");
+  }
+  const artifactEntries = Object.entries(instance.artifacts);
+  if (artifactEntries.length > 0) {
+    lines.push("### Accumulated Artifacts");
+    for (const [name, value] of artifactEntries) {
+      lines.push(`- **${name}**: "${truncateSummary(value)}"`);
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function composeStepPrompt(stepDef, instance, definition) {
+  const contextHeader = buildContextHeader(instance, definition);
+  const resolvedPrompt = resolveTemplate(stepDef.prompt, instance, definition);
+  return `${contextHeader}---
+
+## Your Task
+${resolvedPrompt}`;
+}
+function truncateSummary(text) {
+  const maxLength = 200;
+  if (text.length <= maxLength)
+    return text;
+  return text.slice(0, maxLength - 3) + "...";
+}
+// src/features/workflow/completion.ts
+import { existsSync as existsSync11 } from "fs";
+import { join as join9 } from "path";
+var DEFAULT_CONFIRM_KEYWORDS = ["confirmed", "approved", "continue", "done", "let's proceed", "looks good", "lgtm"];
+var VERDICT_APPROVE_RE = /\[\s*APPROVE\s*\]/i;
+var VERDICT_REJECT_RE = /\[\s*REJECT\s*\]/i;
+var AGENT_SIGNAL_MARKER = "<!-- workflow:step-complete -->";
+function checkStepCompletion(method, context) {
+  switch (method) {
+    case "user_confirm":
+      return checkUserConfirm(context);
+    case "plan_created":
+      return checkPlanCreated(context);
+    case "plan_complete":
+      return checkPlanComplete(context);
+    case "review_verdict":
+      return checkReviewVerdict(context);
+    case "agent_signal":
+      return checkAgentSignal(context);
+    default:
+      return { complete: false, reason: `Unknown completion method: ${method}` };
+  }
+}
+function checkUserConfirm(context) {
+  const { lastUserMessage, config } = context;
+  if (!lastUserMessage)
+    return { complete: false };
+  const keywords = config.keywords ?? DEFAULT_CONFIRM_KEYWORDS;
+  const lowerMessage = lastUserMessage.toLowerCase().trim();
+  for (const keyword of keywords) {
+    if (lowerMessage.includes(keyword.toLowerCase())) {
       return {
-        switchAgent: "tapestry",
-        contextInjection: resumeContext
+        complete: true,
+        summary: `User confirmed: "${lastUserMessage.slice(0, 100)}"`
       };
     }
   }
-  return handlePlanDiscovery(allPlans, sessionId, directory);
-}
-function extractPlanName(promptText) {
-  const match = promptText.match(/<user-request>\s*([\s\S]*?)\s*<\/user-request>/i);
-  if (!match)
-    return null;
-  const cleaned = match[1].trim();
-  return cleaned || null;
+  return { complete: false };
 }
-function handleExplicitPlan(requestedName, allPlans, sessionId, directory) {
-  const matched = findPlanByName(allPlans, requestedName);
-  if (!matched) {
-    const incompletePlans = allPlans.filter((p) => !getPlanProgress(p).isComplete);
-    const listing = incompletePlans.length > 0 ? incompletePlans.map((p) => `  - ${getPlanName(p)}`).join(`
-`) : "  (none)";
-    return {
-      switchAgent: "tapestry",
-      contextInjection: `## Plan Not Found
-No plan matching "${requestedName}" was found.
-
-Available incomplete plans:
-${listing}
-
-Tell the user which plans are available and ask them to specify one.`
-    };
+function checkPlanCreated(context) {
+  const { config, directory } = context;
+  const planName = config.plan_name;
+  if (!planName) {
+    return { complete: false, reason: "plan_created requires plan_name in completion config" };
   }
-  const progress = getPlanProgress(matched);
-  if (progress.isComplete) {
+  const plans = findPlans(directory);
+  const matchingPlan = plans.find((p) => p.includes(planName));
+  if (matchingPlan) {
     return {
-      switchAgent: "tapestry",
-      contextInjection: `## Plan Already Complete
-The plan "${getPlanName(matched)}" has all ${progress.total} tasks completed.
-Tell the user this plan is already done and suggest creating a new one with Pattern.`
+      complete: true,
+      artifacts: { plan_path: matchingPlan },
+      summary: `Plan created at ${matchingPlan}`
     };
   }
-  const validation = validatePlan(matched, directory);
-  if (!validation.valid) {
+  const directPath = join9(directory, ".weave", "plans", `${planName}.md`);
+  if (existsSync11(directPath)) {
     return {
-      switchAgent: "tapestry",
-      contextInjection: `## Plan Validation Failed
-The plan "${getPlanName(matched)}" has structural issues that must be fixed before execution can begin.
-
-${formatValidationResults(validation)}
-
-Tell the user to fix these issues in the plan file and try again.`
+      complete: true,
+      artifacts: { plan_path: directPath },
+      summary: `Plan created at ${directPath}`
     };
   }
-  clearWorkState(directory);
-  const state = createWorkState(matched, sessionId, "tapestry", directory);
-  writeWorkState(directory, state);
-  const freshContext = buildFreshContext(matched, getPlanName(matched), progress, state.start_sha);
-  if (validation.warnings.length > 0) {
+  return { complete: false };
+}
+function checkPlanComplete(context) {
+  const { config, directory } = context;
+  const planName = config.plan_name;
+  if (!planName) {
+    return { complete: false, reason: "plan_complete requires plan_name in completion config" };
+  }
+  const planPath = join9(directory, ".weave", "plans", `${planName}.md`);
+  if (!existsSync11(planPath)) {
+    return { complete: false, reason: `Plan file not found: ${planPath}` };
+  }
+  const progress = getPlanProgress(planPath);
+  if (progress.isComplete) {
     return {
-      switchAgent: "tapestry",
-      contextInjection: `${freshContext}
-
-### Validation Warnings
-${formatValidationResults(validation)}`
+      complete: true,
+      summary: `Plan completed: ${progress.completed}/${progress.total} tasks done`
     };
   }
   return {
-    switchAgent: "tapestry",
-    contextInjection: freshContext
+    complete: false,
+    reason: `Plan in progress: ${progress.completed}/${progress.total} tasks done`
   };
 }
-function handlePlanDiscovery(allPlans, sessionId, directory) {
-  if (allPlans.length === 0) {
+function checkReviewVerdict(context) {
+  const { lastAssistantMessage } = context;
+  if (!lastAssistantMessage)
+    return { complete: false };
+  if (VERDICT_APPROVE_RE.test(lastAssistantMessage)) {
     return {
-      switchAgent: "tapestry",
-      contextInjection: "## No Plans Found\nNo plan files found at `.weave/plans/`.\nTell the user to switch to Pattern agent to create a work plan first."
+      complete: true,
+      verdict: "approve",
+      summary: "Review verdict: APPROVED"
     };
   }
-  const incompletePlans = allPlans.filter((p) => !getPlanProgress(p).isComplete);
-  if (incompletePlans.length === 0) {
+  if (VERDICT_REJECT_RE.test(lastAssistantMessage)) {
     return {
-      switchAgent: "tapestry",
-      contextInjection: `## All Plans Complete
-All existing plans have been completed.
-Tell the user to switch to Pattern agent to create a new plan.`
+      complete: true,
+      verdict: "reject",
+      summary: "Review verdict: REJECTED"
     };
   }
-  if (incompletePlans.length === 1) {
-    const plan = incompletePlans[0];
-    const progress = getPlanProgress(plan);
-    const validation = validatePlan(plan, directory);
-    if (!validation.valid) {
-      return {
-        switchAgent: "tapestry",
-        contextInjection: `## Plan Validation Failed
-The plan "${getPlanName(plan)}" has structural issues that must be fixed before execution can begin.
-
-${formatValidationResults(validation)}
-
-Tell the user to fix these issues in the plan file and try again.`
-      };
-    }
-    const state = createWorkState(plan, sessionId, "tapestry", directory);
-    writeWorkState(directory, state);
-    const freshContext = buildFreshContext(plan, getPlanName(plan), progress, state.start_sha);
-    if (validation.warnings.length > 0) {
-      return {
-        switchAgent: "tapestry",
-        contextInjection: `${freshContext}
-
-### Validation Warnings
-${formatValidationResults(validation)}`
-      };
+  return { complete: false };
+}
+function checkAgentSignal(context) {
+  const { lastAssistantMessage } = context;
+  if (!lastAssistantMessage)
+    return { complete: false };
+  if (lastAssistantMessage.includes(AGENT_SIGNAL_MARKER)) {
+    return {
+      complete: true,
+      summary: "Agent signaled completion"
+    };
+  }
+  return { complete: false };
+}
+// src/features/workflow/engine.ts
+function startWorkflow(input) {
+  const { definition, definitionPath, goal, sessionId, directory } = input;
+  const instance = createWorkflowInstance(definition, definitionPath, goal, sessionId);
+  writeWorkflowInstance(directory, instance);
+  setActiveInstance(directory, instance.instance_id);
+  const firstStepDef = definition.steps[0];
+  const prompt = composeStepPrompt(firstStepDef, instance, definition);
+  return {
+    type: "inject_prompt",
+    prompt,
+    agent: firstStepDef.agent
+  };
+}
+function checkAndAdvance(input) {
+  const { directory, context } = input;
+  const instance = getActiveWorkflowInstance(directory);
+  if (!instance)
+    return { type: "none" };
+  if (instance.status !== "running")
+    return { type: "none" };
+  const definition = loadWorkflowDefinition(instance.definition_path);
+  if (!definition)
+    return { type: "none", reason: "Failed to load workflow definition" };
+  const currentStepDef = definition.steps.find((s) => s.id === instance.current_step_id);
+  if (!currentStepDef)
+    return { type: "none", reason: "Current step not found in definition" };
+  const stepState = instance.steps[instance.current_step_id];
+  if (!stepState || stepState.status !== "active")
+    return { type: "none" };
+  const completionResult = checkStepCompletion(currentStepDef.completion.method, context);
+  if (!completionResult.complete) {
+    if (currentStepDef.type === "interactive")
+      return { type: "none" };
+    return { type: "none" };
+  }
+  if (currentStepDef.type === "gate" && completionResult.verdict === "reject") {
+    return handleGateReject(directory, instance, currentStepDef, completionResult);
+  }
+  return advanceToNextStep(directory, instance, definition, completionResult);
+}
+function handleGateReject(directory, instance, currentStepDef, completionResult) {
+  const stepState = instance.steps[currentStepDef.id];
+  stepState.status = "completed";
+  stepState.completed_at = new Date().toISOString();
+  stepState.verdict = "reject";
+  stepState.summary = completionResult.summary;
+  const action = currentStepDef.on_reject ?? "pause";
+  if (action === "fail") {
+    instance.status = "failed";
+    instance.ended_at = new Date().toISOString();
+    clearActiveInstance(directory);
+  } else {
+    instance.status = "paused";
+    instance.pause_reason = "Gate step rejected";
+  }
+  writeWorkflowInstance(directory, instance);
+  return {
+    type: "pause",
+    reason: `Gate step "${currentStepDef.id}" rejected${action === "fail" ? " — workflow failed" : " — workflow paused"}`
+  };
+}
+function advanceToNextStep(directory, instance, definition, completionResult) {
+  const currentStepDef = definition.steps.find((s) => s.id === instance.current_step_id);
+  const currentIndex = definition.steps.indexOf(currentStepDef);
+  const stepState = instance.steps[instance.current_step_id];
+  stepState.status = "completed";
+  stepState.completed_at = new Date().toISOString();
+  stepState.summary = completionResult.summary;
+  if (completionResult.verdict)
+    stepState.verdict = completionResult.verdict;
+  if (completionResult.artifacts) {
+    stepState.artifacts = completionResult.artifacts;
+    Object.assign(instance.artifacts, completionResult.artifacts);
+  }
+  if (currentIndex >= definition.steps.length - 1) {
+    instance.status = "completed";
+    instance.ended_at = new Date().toISOString();
+    clearActiveInstance(directory);
+    writeWorkflowInstance(directory, instance);
+    return { type: "complete", reason: "Workflow completed — all steps done" };
+  }
+  const nextStepDef = definition.steps[currentIndex + 1];
+  instance.current_step_id = nextStepDef.id;
+  instance.steps[nextStepDef.id].status = "active";
+  instance.steps[nextStepDef.id].started_at = new Date().toISOString();
+  writeWorkflowInstance(directory, instance);
+  const prompt = composeStepPrompt(nextStepDef, instance, definition);
+  return {
+    type: "inject_prompt",
+    prompt,
+    agent: nextStepDef.agent
+  };
+}
+function pauseWorkflow(directory, reason) {
+  const instance = getActiveWorkflowInstance(directory);
+  if (!instance || instance.status !== "running")
+    return false;
+  instance.status = "paused";
+  instance.pause_reason = reason ?? "Paused by user";
+  return writeWorkflowInstance(directory, instance);
+}
+function resumeWorkflow(directory) {
+  const instance = getActiveWorkflowInstance(directory);
+  if (!instance || instance.status !== "paused")
+    return { type: "none", reason: "No paused workflow to resume" };
+  const definition = loadWorkflowDefinition(instance.definition_path);
+  if (!definition)
+    return { type: "none", reason: "Failed to load workflow definition" };
+  instance.status = "running";
+  instance.pause_reason = undefined;
+  const currentStepState = instance.steps[instance.current_step_id];
+  if (currentStepState.status !== "active") {
+    currentStepState.status = "active";
+    currentStepState.started_at = new Date().toISOString();
+  }
+  writeWorkflowInstance(directory, instance);
+  const currentStepDef = definition.steps.find((s) => s.id === instance.current_step_id);
+  if (!currentStepDef)
+    return { type: "none", reason: "Current step not found in definition" };
+  const prompt = composeStepPrompt(currentStepDef, instance, definition);
+  return {
+    type: "inject_prompt",
+    prompt,
+    agent: currentStepDef.agent
+  };
+}
+function skipStep(directory) {
+  const instance = getActiveWorkflowInstance(directory);
+  if (!instance)
+    return { type: "none", reason: "No active workflow" };
+  const definition = loadWorkflowDefinition(instance.definition_path);
+  if (!definition)
+    return { type: "none", reason: "Failed to load workflow definition" };
+  return advanceToNextStep(directory, instance, definition, {
+    complete: true,
+    summary: "Step skipped by user"
+  });
+}
+function abortWorkflow(directory) {
+  const instance = getActiveWorkflowInstance(directory);
+  if (!instance)
+    return false;
+  instance.status = "cancelled";
+  instance.ended_at = new Date().toISOString();
+  clearActiveInstance(directory);
+  return writeWorkflowInstance(directory, instance);
+}
+// src/features/workflow/hook.ts
+var WORKFLOW_CONTINUATION_MARKER = "<!-- weave:workflow-continuation -->";
+function parseWorkflowArgs(args) {
+  const trimmed = args.trim();
+  if (!trimmed)
+    return { workflowName: null, goal: null };
+  const quotedMatch = trimmed.match(/^(\S+)\s+"([^"]+)"$/);
+  if (quotedMatch) {
+    return { workflowName: quotedMatch[1], goal: quotedMatch[2] };
+  }
+  const singleQuotedMatch = trimmed.match(/^(\S+)\s+'([^']+)'$/);
+  if (singleQuotedMatch) {
+    return { workflowName: singleQuotedMatch[1], goal: singleQuotedMatch[2] };
+  }
+  const parts = trimmed.split(/\s+/);
+  if (parts.length === 1) {
+    return { workflowName: parts[0], goal: null };
+  }
+  return { workflowName: parts[0], goal: parts.slice(1).join(" ") };
+}
+function handleRunWorkflow(input) {
+  const { promptText, sessionId, directory } = input;
+  if (!promptText.includes("<session-context>")) {
+    return { contextInjection: null, switchAgent: null };
+  }
+  const args = extractArguments(promptText);
+  const { workflowName, goal } = parseWorkflowArgs(args);
+  const workStateWarning = checkWorkStatePlanActive(directory);
+  const activeInstance = getActiveWorkflowInstance(directory);
+  if (!workflowName && !activeInstance) {
+    const result = listAvailableWorkflows(directory);
+    return prependWarning(result, workStateWarning);
+  }
+  if (!workflowName && activeInstance) {
+    const result = resumeActiveWorkflow(directory);
+    return prependWarning(result, workStateWarning);
+  }
+  if (workflowName && !goal && activeInstance && activeInstance.definition_id === workflowName) {
+    const result = resumeActiveWorkflow(directory);
+    return prependWarning(result, workStateWarning);
+  }
+  if (workflowName && goal) {
+    if (activeInstance) {
+      return {
+        contextInjection: `## Workflow Already Active
+There is already an active workflow: "${activeInstance.definition_name}" (${activeInstance.instance_id}).
+Goal: "${activeInstance.goal}"
+
+To start a new workflow, first abort the current one with \`/workflow abort\` or let it complete.`,
+        switchAgent: null
+      };
+    }
+    const result = startNewWorkflow(workflowName, goal, sessionId, directory);
+    return prependWarning(result, workStateWarning);
+  }
+  if (workflowName && !goal) {
+    if (activeInstance) {
+      return {
+        contextInjection: `## Workflow Already Active
+There is already an active workflow: "${activeInstance.definition_name}" (${activeInstance.instance_id}).
+Goal: "${activeInstance.goal}"
+
+Did you mean to resume the active workflow? Run \`/run-workflow\` without arguments to resume.`,
+        switchAgent: null
+      };
     }
     return {
-      switchAgent: "tapestry",
-      contextInjection: freshContext
+      contextInjection: `## Goal Required
+To start the "${workflowName}" workflow, provide a goal:
+\`/run-workflow ${workflowName} "your goal here"\``,
+      switchAgent: null
     };
   }
-  const listing = incompletePlans.map((p) => {
-    const progress = getPlanProgress(p);
-    return `  - **${getPlanName(p)}** (${progress.completed}/${progress.total} tasks done)`;
-  }).join(`
+  return { contextInjection: null, switchAgent: null };
+}
+function checkWorkflowContinuation(input) {
+  const { directory, lastAssistantMessage, lastUserMessage } = input;
+  const instance = getActiveWorkflowInstance(directory);
+  if (!instance)
+    return { continuationPrompt: null, switchAgent: null };
+  if (instance.status !== "running")
+    return { continuationPrompt: null, switchAgent: null };
+  const definition = loadWorkflowDefinition(instance.definition_path);
+  if (!definition)
+    return { continuationPrompt: null, switchAgent: null };
+  const currentStepDef = definition.steps.find((s) => s.id === instance.current_step_id);
+  if (!currentStepDef)
+    return { continuationPrompt: null, switchAgent: null };
+  const completionContext = {
+    directory,
+    config: currentStepDef.completion,
+    artifacts: instance.artifacts,
+    lastAssistantMessage,
+    lastUserMessage
+  };
+  const action = checkAndAdvance({ directory, context: completionContext });
+  switch (action.type) {
+    case "inject_prompt":
+      return {
+        continuationPrompt: `${WORKFLOW_CONTINUATION_MARKER}
+${action.prompt}`,
+        switchAgent: action.agent ?? null
+      };
+    case "complete":
+      return {
+        continuationPrompt: `${WORKFLOW_CONTINUATION_MARKER}
+## Workflow Complete
+${action.reason ?? "All steps have been completed."}
+
+Summarize what was accomplished across all workflow steps.`,
+        switchAgent: null
+      };
+    case "pause":
+      return {
+        continuationPrompt: `${WORKFLOW_CONTINUATION_MARKER}
+## Workflow Paused
+${action.reason ?? "The workflow has been paused."}
+
+Inform the user about the pause and what to do next.`,
+        switchAgent: null
+      };
+    case "none":
+    default:
+      return { continuationPrompt: null, switchAgent: null };
+  }
+}
+function checkWorkStatePlanActive(directory) {
+  const state = readWorkState(directory);
+  if (!state)
+    return null;
+  const progress = getPlanProgress(state.active_plan);
+  if (progress.isComplete)
+    return null;
+  const status = state.paused ? "paused" : "running";
+  const planName = state.plan_name ?? state.active_plan;
+  return `## Active Plan Detected
+
+There is currently an active plan being executed: "${planName}"
+Status: ${status} • Progress: ${progress.completed}/${progress.total} tasks complete
+
+Starting a workflow will take priority over the active plan — plan continuation will be suspended while the workflow runs.
+
+**Options:**
+- **Proceed anyway** — the plan will be paused and can be resumed with \`/start-work\` after the workflow completes
+- **Abort the plan first** — abandon the current plan, then start the workflow
+- **Cancel** — don't start the workflow, continue with the plan`;
+}
+function prependWarning(result, warning) {
+  if (!warning)
+    return result;
+  if (!result.contextInjection) {
+    return { ...result, contextInjection: warning };
+  }
+  return { ...result, contextInjection: `${warning}
+
+---
+
+${result.contextInjection}` };
+}
+function extractArguments(promptText) {
+  const match = promptText.match(/<user-request>\s*([\s\S]*?)\s*<\/user-request>/i);
+  if (!match)
+    return "";
+  return match[1].trim();
+}
+function listAvailableWorkflows(directory) {
+  const workflows = discoverWorkflows(directory);
+  if (workflows.length === 0) {
+    return {
+      contextInjection: "## No Workflows Available\nNo workflow definitions found.\n\nWorkflow definitions should be placed in `.opencode/workflows/` (project) or `~/.config/opencode/workflows/` (user).",
+      switchAgent: null
+    };
+  }
+  const listing = workflows.map((w) => `  - **${w.definition.name}**: ${w.definition.description ?? "(no description)"} (${w.scope})`).join(`
 `);
   return {
-    switchAgent: "tapestry",
-    contextInjection: `## Multiple Plans Found
-There are ${incompletePlans.length} incomplete plans:
+    contextInjection: `## Available Workflows
 ${listing}
 
-Ask the user which plan to work on. They can run \`/start-work [plan-name]\` to select one.`
+To start a workflow, run:
+\`/run-workflow <name> "your goal"\``,
+    switchAgent: null
   };
 }
-function findPlanByName(plans, requestedName) {
-  const lower = requestedName.toLowerCase();
-  const exact = plans.find((p) => getPlanName(p).toLowerCase() === lower);
-  if (exact)
-    return exact;
-  const partial = plans.find((p) => getPlanName(p).toLowerCase().includes(lower));
-  return partial || null;
-}
-function formatValidationResults(result) {
-  const lines = [];
-  if (result.errors.length > 0) {
-    lines.push("**Errors (blocking):**");
-    for (const err of result.errors) {
-      lines.push(`- [${err.category}] ${err.message}`);
+function resumeActiveWorkflow(directory) {
+  const action = resumeWorkflow(directory);
+  if (action.type === "none") {
+    const instance = getActiveWorkflowInstance(directory);
+    if (instance && instance.status === "running") {
+      const definition = loadWorkflowDefinition(instance.definition_path);
+      if (definition) {
+        const currentStep = definition.steps.find((s) => s.id === instance.current_step_id);
+        return {
+          contextInjection: `## Workflow In Progress
+Workflow "${instance.definition_name}" is already running.
+Current step: **${currentStep?.name ?? instance.current_step_id}**
+Goal: "${instance.goal}"
+
+Continue with the current step.`,
+          switchAgent: currentStep?.agent ?? null
+        };
+      }
     }
+    return { contextInjection: null, switchAgent: null };
   }
-  if (result.warnings.length > 0) {
-    if (result.errors.length > 0)
-      lines.push("");
-    lines.push("**Warnings:**");
-    for (const warn of result.warnings) {
-      lines.push(`- [${warn.category}] ${warn.message}`);
-    }
+  return {
+    contextInjection: action.prompt ?? null,
+    switchAgent: action.agent ?? null
+  };
+}
+function startNewWorkflow(workflowName, goal, sessionId, directory) {
+  const workflows = discoverWorkflows(directory);
+  const match = workflows.find((w) => w.definition.name === workflowName);
+  if (!match) {
+    const available = workflows.map((w) => w.definition.name).join(", ");
+    return {
+      contextInjection: `## Workflow Not Found
+No workflow definition named "${workflowName}" was found.
+${available ? `Available workflows: ${available}` : "No workflow definitions available."}`,
+      switchAgent: null
+    };
   }
-  return lines.join(`
+  const action = startWorkflow({
+    definition: match.definition,
+    definitionPath: match.path,
+    goal,
+    sessionId,
+    directory
+  });
+  log("Workflow started", {
+    workflowName: match.definition.name,
+    goal,
+    agent: action.agent
+  });
+  return {
+    contextInjection: action.prompt ?? null,
+    switchAgent: action.agent ?? null
+  };
+}
+// src/features/workflow/commands.ts
+var PAUSE_PATTERNS = [/\bworkflow\s+pause\b/i, /\bpause\s+workflow\b/i];
+var SKIP_PATTERNS = [/\bworkflow\s+skip\b/i, /\bskip\s+step\b/i];
+var ABORT_PATTERNS = [/\bworkflow\s+abort\b/i, /\babort\s+workflow\b/i];
+var STATUS_PATTERNS = [/\bworkflow\s+status\b/i];
+function handleWorkflowCommand(message, directory) {
+  const instance = getActiveWorkflowInstance(directory);
+  if (!instance)
+    return { handled: false };
+  const trimmed = message.trim();
+  if (matchesAny(trimmed, PAUSE_PATTERNS)) {
+    return handlePause(directory, instance);
+  }
+  if (matchesAny(trimmed, SKIP_PATTERNS)) {
+    return handleSkip(directory, instance);
+  }
+  if (matchesAny(trimmed, ABORT_PATTERNS)) {
+    return handleAbort(directory, instance);
+  }
+  if (matchesAny(trimmed, STATUS_PATTERNS)) {
+    return handleStatus(directory, instance);
+  }
+  return { handled: false };
+}
+function matchesAny(text, patterns) {
+  return patterns.some((p) => p.test(text));
+}
+function handlePause(directory, instance) {
+  if (instance.status !== "running") {
+    return {
+      handled: true,
+      contextInjection: `## Workflow Not Running
+The workflow "${instance.definition_name}" is currently ${instance.status}. Cannot pause.`
+    };
+  }
+  pauseWorkflow(directory, "Paused by user command");
+  return {
+    handled: true,
+    contextInjection: `## Workflow Paused
+Workflow "${instance.definition_name}" has been paused.
+Goal: "${instance.goal}"
+Current step: ${instance.current_step_id}
+
+To resume, run \`/run-workflow\`.`
+  };
+}
+function handleSkip(directory, instance) {
+  if (instance.status !== "running") {
+    return {
+      handled: true,
+      contextInjection: `## Workflow Not Running
+The workflow "${instance.definition_name}" is currently ${instance.status}. Cannot skip step.`
+    };
+  }
+  const currentStepId = instance.current_step_id;
+  const action = skipStep(directory);
+  if (action.type === "inject_prompt") {
+    return {
+      handled: true,
+      contextInjection: `## Step Skipped
+Skipped step "${currentStepId}".
+
+${action.prompt}`,
+      switchAgent: action.agent
+    };
+  }
+  if (action.type === "complete") {
+    return {
+      handled: true,
+      contextInjection: `## Step Skipped — Workflow Complete
+Skipped step "${currentStepId}".
+${action.reason ?? "All steps have been completed."}`
+    };
+  }
+  return {
+    handled: true,
+    contextInjection: `## Step Skipped
+Skipped step "${currentStepId}".`
+  };
+}
+function handleAbort(directory, instance) {
+  const name = instance.definition_name;
+  const goal = instance.goal;
+  abortWorkflow(directory);
+  return {
+    handled: true,
+    contextInjection: `## Workflow Aborted
+Workflow "${name}" has been cancelled.
+Goal: "${goal}"
+
+The workflow instance has been terminated and the active pointer cleared.`
+  };
+}
+function handleStatus(directory, instance) {
+  const definition = loadWorkflowDefinition(instance.definition_path);
+  let stepsDisplay = "";
+  if (definition) {
+    const lines = [];
+    for (const stepDef of definition.steps) {
+      const stepState = instance.steps[stepDef.id];
+      if (!stepState)
+        continue;
+      if (stepState.status === "completed") {
+        const summary = stepState.summary ? ` → ${truncate(stepState.summary, 80)}` : "";
+        lines.push(`- [✓] ${stepDef.name}${summary}`);
+      } else if (stepState.status === "active") {
+        lines.push(`- [→] ${stepDef.name} (active)`);
+      } else if (stepState.status === "skipped") {
+        lines.push(`- [⊘] ${stepDef.name} (skipped)`);
+      } else {
+        lines.push(`- [ ] ${stepDef.name}`);
+      }
+    }
+    stepsDisplay = lines.join(`
 `);
+  }
+  const completedCount = Object.values(instance.steps).filter((s) => s.status === "completed").length;
+  const totalCount = Object.keys(instance.steps).length;
+  return {
+    handled: true,
+    contextInjection: `## Workflow Status: ${instance.definition_name}
+**Goal**: "${instance.goal}"
+**Instance**: ${instance.instance_id}
+**Status**: ${instance.status}
+**Progress**: ${completedCount}/${totalCount} steps
+
+### Steps
+${stepsDisplay}`
+  };
 }
-function buildFreshContext(planPath, planName, progress, startSha) {
-  const shaLine = startSha ? `
-**Start SHA**: ${startSha}` : "";
-  return `## Starting Plan: ${planName}
-**Plan file**: ${planPath}
-**Progress**: ${progress.completed}/${progress.total} tasks completed${shaLine}
+function truncate(text, maxLength) {
+  if (text.length <= maxLength)
+    return text;
+  return text.slice(0, maxLength - 3) + "...";
+}
+// src/hooks/start-work-hook.ts
+function handleStartWork(input) {
+  const { promptText, sessionId, directory } = input;
+  if (!promptText.includes("<session-context>")) {
+    return { contextInjection: null, switchAgent: null };
+  }
+  const workflowWarning = checkWorkflowActive(directory);
+  if (workflowWarning) {
+    return { contextInjection: workflowWarning, switchAgent: null };
+  }
+  const explicitPlanName = extractPlanName(promptText);
+  const existingState = readWorkState(directory);
+  const allPlans = findPlans(directory);
+  if (explicitPlanName) {
+    return handleExplicitPlan(explicitPlanName, allPlans, sessionId, directory);
+  }
+  if (existingState) {
+    const progress = getPlanProgress(existingState.active_plan);
+    if (!progress.isComplete) {
+      const validation = validatePlan(existingState.active_plan, directory);
+      if (!validation.valid) {
+        clearWorkState(directory);
+        return {
+          switchAgent: "tapestry",
+          contextInjection: `## Plan Validation Failed
+The active plan "${existingState.plan_name}" has structural issues. Work state has been cleared.
 
-Read the plan file now and begin executing from the first unchecked \`- [ ]\` task.
+${formatValidationResults(validation)}
 
-**SIDEBAR TODOS — DO THIS FIRST:**
-Before starting any work, use todowrite to populate the sidebar:
-1. Create a summary todo (in_progress): "${planName} ${progress.completed}/${progress.total}"
-2. Create a todo for the first unchecked task (in_progress)
-3. Create todos for the next 2-3 tasks (pending)
-Keep each todo under 35 chars. Update as you complete tasks.`;
+Tell the user to fix the plan file and run /start-work again.`
+        };
+      }
+      appendSessionId(directory, sessionId);
+      resumeWork(directory);
+      const resumeContext = buildResumeContext(existingState.active_plan, existingState.plan_name, progress, existingState.start_sha);
+      if (validation.warnings.length > 0) {
+        return {
+          switchAgent: "tapestry",
+          contextInjection: `${resumeContext}
+
+### Validation Warnings
+${formatValidationResults(validation)}`
+        };
+      }
+      return {
+        switchAgent: "tapestry",
+        contextInjection: resumeContext
+      };
+    }
+  }
+  return handlePlanDiscovery(allPlans, sessionId, directory);
 }
-function buildResumeContext(planPath, planName, progress, startSha) {
-  const remaining = progress.total - progress.completed;
-  const shaLine = startSha ? `
-**Start SHA**: ${startSha}` : "";
-  return `## Resuming Plan: ${planName}
-**Plan file**: ${planPath}
-**Progress**: ${progress.completed}/${progress.total} tasks completed
-**Status**: RESUMING — continuing from where the previous session left off.${shaLine}
+function checkWorkflowActive(directory) {
+  const instance = getActiveWorkflowInstance(directory);
+  if (!instance)
+    return null;
+  if (instance.status !== "running" && instance.status !== "paused")
+    return null;
+  const definition = loadWorkflowDefinition(instance.definition_path);
+  const totalSteps = definition ? definition.steps.length : 0;
+  const completedSteps = Object.values(instance.steps).filter((s) => s.status === "completed").length;
+  const status = instance.status === "paused" ? "paused" : "running";
+  return `## Active Workflow Detected
 
-Read the plan file now and continue from the first unchecked \`- [ ]\` task.
+There is currently an active workflow: "${instance.definition_name}" (${instance.instance_id})
+Goal: "${instance.goal}"
+Status: ${status} • Progress: ${completedSteps}/${totalSteps} steps complete
 
-**SIDEBAR TODOS — RESTORE STATE:**
-Previous session's todos are lost. Use todowrite to restore the sidebar:
-1. Create a summary todo (in_progress): "${planName} ${progress.completed}/${progress.total}"
-2. Create a todo for the next unchecked task (in_progress)
-3. Create todos for the following 2-3 tasks (pending)
-Keep each todo under 35 chars. ${remaining} task${remaining !== 1 ? "s" : ""} remaining.`;
+Starting plan execution will conflict with the active workflow — both systems use the idle loop and only one can drive at a time.
+
+**Options:**
+- **Proceed anyway** — the workflow will be paused and can be resumed with \`/run-workflow\` after the plan completes
+- **Abort the workflow first** — cancel the workflow, then start the plan
+- **Cancel** — don't start the plan, continue with the workflow`;
+}
+function extractPlanName(promptText) {
+  const match = promptText.match(/<user-request>\s*([\s\S]*?)\s*<\/user-request>/i);
+  if (!match)
+    return null;
+  const cleaned = match[1].trim();
+  return cleaned || null;
 }
+function handleExplicitPlan(requestedName, allPlans, sessionId, directory) {
+  const matched = findPlanByName(allPlans, requestedName);
+  if (!matched) {
+    const incompletePlans = allPlans.filter((p) => !getPlanProgress(p).isComplete);
+    const listing = incompletePlans.length > 0 ? incompletePlans.map((p) => `  - ${getPlanName(p)}`).join(`
+`) : "  (none)";
+    return {
+      switchAgent: "tapestry",
+      contextInjection: `## Plan Not Found
+No plan matching "${requestedName}" was found.
 
-// src/hooks/work-continuation.ts
-var CONTINUATION_MARKER = "<!-- weave:continuation -->";
-var MAX_STALE_CONTINUATIONS = 3;
-function checkContinuation(input) {
-  const { directory } = input;
+Available incomplete plans:
+${listing}
+
+Tell the user which plans are available and ask them to specify one.`
+    };
+  }
+  const progress = getPlanProgress(matched);
+  if (progress.isComplete) {
+    return {
+      switchAgent: "tapestry",
+      contextInjection: `## Plan Already Complete
+The plan "${getPlanName(matched)}" has all ${progress.total} tasks completed.
+Tell the user this plan is already done and suggest creating a new one with Pattern.`
+    };
+  }
+  const validation = validatePlan(matched, directory);
+  if (!validation.valid) {
+    return {
+      switchAgent: "tapestry",
+      contextInjection: `## Plan Validation Failed
+The plan "${getPlanName(matched)}" has structural issues that must be fixed before execution can begin.
+
+${formatValidationResults(validation)}
+
+Tell the user to fix these issues in the plan file and try again.`
+    };
+  }
+  clearWorkState(directory);
+  const state = createWorkState(matched, sessionId, "tapestry", directory);
+  writeWorkState(directory, state);
+  const freshContext = buildFreshContext(matched, getPlanName(matched), progress, state.start_sha);
+  if (validation.warnings.length > 0) {
+    return {
+      switchAgent: "tapestry",
+      contextInjection: `${freshContext}
+
+### Validation Warnings
+${formatValidationResults(validation)}`
+    };
+  }
+  return {
+    switchAgent: "tapestry",
+    contextInjection: freshContext
+  };
+}
+function handlePlanDiscovery(allPlans, sessionId, directory) {
+  if (allPlans.length === 0) {
+    return {
+      switchAgent: "tapestry",
+      contextInjection: "## No Plans Found\nNo plan files found at `.weave/plans/`.\nTell the user to switch to Pattern agent to create a work plan first."
+    };
+  }
+  const incompletePlans = allPlans.filter((p) => !getPlanProgress(p).isComplete);
+  if (incompletePlans.length === 0) {
+    return {
+      switchAgent: "tapestry",
+      contextInjection: `## All Plans Complete
+All existing plans have been completed.
+Tell the user to switch to Pattern agent to create a new plan.`
+    };
+  }
+  if (incompletePlans.length === 1) {
+    const plan = incompletePlans[0];
+    const progress = getPlanProgress(plan);
+    const validation = validatePlan(plan, directory);
+    if (!validation.valid) {
+      return {
+        switchAgent: "tapestry",
+        contextInjection: `## Plan Validation Failed
+The plan "${getPlanName(plan)}" has structural issues that must be fixed before execution can begin.
+
+${formatValidationResults(validation)}
+
+Tell the user to fix these issues in the plan file and try again.`
+      };
+    }
+    const state = createWorkState(plan, sessionId, "tapestry", directory);
+    writeWorkState(directory, state);
+    const freshContext = buildFreshContext(plan, getPlanName(plan), progress, state.start_sha);
+    if (validation.warnings.length > 0) {
+      return {
+        switchAgent: "tapestry",
+        contextInjection: `${freshContext}
+
+### Validation Warnings
+${formatValidationResults(validation)}`
+      };
+    }
+    return {
+      switchAgent: "tapestry",
+      contextInjection: freshContext
+    };
+  }
+  const listing = incompletePlans.map((p) => {
+    const progress = getPlanProgress(p);
+    return `  - **${getPlanName(p)}** (${progress.completed}/${progress.total} tasks done)`;
+  }).join(`
+`);
+  return {
+    switchAgent: "tapestry",
+    contextInjection: `## Multiple Plans Found
+There are ${incompletePlans.length} incomplete plans:
+${listing}
+
+Ask the user which plan to work on. They can run \`/start-work [plan-name]\` to select one.`
+  };
+}
+function findPlanByName(plans, requestedName) {
+  const lower = requestedName.toLowerCase();
+  const exact = plans.find((p) => getPlanName(p).toLowerCase() === lower);
+  if (exact)
+    return exact;
+  const partial = plans.find((p) => getPlanName(p).toLowerCase().includes(lower));
+  return partial || null;
+}
+function formatValidationResults(result) {
+  const lines = [];
+  if (result.errors.length > 0) {
+    lines.push("**Errors (blocking):**");
+    for (const err of result.errors) {
+      lines.push(`- [${err.category}] ${err.message}`);
+    }
+  }
+  if (result.warnings.length > 0) {
+    if (result.errors.length > 0)
+      lines.push("");
+    lines.push("**Warnings:**");
+    for (const warn of result.warnings) {
+      lines.push(`- [${warn.category}] ${warn.message}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function buildFreshContext(planPath, planName, progress, startSha) {
+  const shaLine = startSha ? `
+**Start SHA**: ${startSha}` : "";
+  return `## Starting Plan: ${planName}
+**Plan file**: ${planPath}
+**Progress**: ${progress.completed}/${progress.total} tasks completed${shaLine}
+
+Read the plan file now and begin executing from the first unchecked \`- [ ]\` task.
+
+**SIDEBAR TODOS — DO THIS FIRST:**
+Before starting any work, use todowrite to populate the sidebar:
+1. Create a summary todo (in_progress): "${planName} ${progress.completed}/${progress.total}"
+2. Create a todo for the first unchecked task (in_progress)
+3. Create todos for the next 2-3 tasks (pending)
+Keep each todo under 35 chars. Update as you complete tasks.`;
+}
+function buildResumeContext(planPath, planName, progress, startSha) {
+  const remaining = progress.total - progress.completed;
+  const shaLine = startSha ? `
+**Start SHA**: ${startSha}` : "";
+  return `## Resuming Plan: ${planName}
+**Plan file**: ${planPath}
+**Progress**: ${progress.completed}/${progress.total} tasks completed
+**Status**: RESUMING — continuing from where the previous session left off.${shaLine}
+
+Read the plan file now and continue from the first unchecked \`- [ ]\` task.
+
+**SIDEBAR TODOS — RESTORE STATE:**
+Previous session's todos are lost. Use todowrite to restore the sidebar:
+1. Create a summary todo (in_progress): "${planName} ${progress.completed}/${progress.total}"
+2. Create a todo for the next unchecked task (in_progress)
+3. Create todos for the following 2-3 tasks (pending)
+Keep each todo under 35 chars. ${remaining} task${remaining !== 1 ? "s" : ""} remaining.`;
+}
+
+// src/hooks/work-continuation.ts
+var CONTINUATION_MARKER = "<!-- weave:continuation -->";
+var MAX_STALE_CONTINUATIONS = 3;
+function checkContinuation(input) {
+  const { directory } = input;
   const state = readWorkState(directory);
   if (!state) {
     return { continuationPrompt: null };
@@ -3017,123 +4054,661 @@ function checkContinuation(input) {
   if (state.paused) {
     return { continuationPrompt: null };
   }
-  if (state.session_ids.length > 0 && !state.session_ids.includes(input.sessionId)) {
-    return { continuationPrompt: null };
+  if (state.session_ids.length > 0 && !state.session_ids.includes(input.sessionId)) {
+    return { continuationPrompt: null };
+  }
+  const progress = getPlanProgress(state.active_plan);
+  if (progress.isComplete) {
+    return { continuationPrompt: null };
+  }
+  if (state.continuation_completed_snapshot === undefined) {
+    state.continuation_completed_snapshot = progress.completed;
+    state.stale_continuation_count = 0;
+    writeWorkState(directory, state);
+  } else if (progress.completed > state.continuation_completed_snapshot) {
+    state.continuation_completed_snapshot = progress.completed;
+    state.stale_continuation_count = 0;
+    writeWorkState(directory, state);
+  } else {
+    state.stale_continuation_count = (state.stale_continuation_count ?? 0) + 1;
+    if (state.stale_continuation_count >= MAX_STALE_CONTINUATIONS) {
+      state.paused = true;
+      writeWorkState(directory, state);
+      return { continuationPrompt: null };
+    }
+    writeWorkState(directory, state);
+  }
+  const remaining = progress.total - progress.completed;
+  return {
+    continuationPrompt: `${CONTINUATION_MARKER}
+You have an active work plan with incomplete tasks. Continue working.
+
+**Plan**: ${state.plan_name}
+**File**: ${state.active_plan}
+**Progress**: ${progress.completed}/${progress.total} tasks completed (${remaining} remaining)
+
+1. Read the plan file NOW to check exact current progress
+2. Use todowrite to restore sidebar: summary todo "${state.plan_name} ${progress.completed}/${progress.total}" (in_progress) + next task (in_progress) + 2-3 upcoming (pending). Max 35 chars each.
+3. Find the first unchecked \`- [ ]\` task
+4. Execute it, verify it, mark \`- [ ]\` → \`- [x]\`
+5. Update sidebar todos as you complete tasks
+6. Do not stop until all tasks are complete`
+  };
+}
+
+// src/hooks/verification-reminder.ts
+function buildVerificationReminder(input) {
+  const planContext = input.planName && input.progress ? `
+**Plan**: ${input.planName} (${input.progress.completed}/${input.progress.total} tasks done)` : "";
+  return {
+    verificationPrompt: `## Verification Required
+${planContext}
+
+Before marking this task complete, verify the work:
+
+1. **Read the changes**: \`git diff --stat\` then Read each changed file
+2. **Run checks**: Run relevant tests, check for linting/type errors
+3. **Validate behavior**: Does the code actually do what was requested?
+4. **Gate decision**: Can you explain what every changed line does?
+
+If uncertain about quality, delegate to \`weft\` agent for a formal review:
+\`call_weave_agent(agent="weft", prompt="Review the changes for [task description]")\`
+
+MANDATORY: If changes touch auth, crypto, certificates, tokens, signatures, or input validation, you MUST delegate to \`warp\` agent for a security audit — this is NOT optional:
+\`call_weave_agent(agent="warp", prompt="Security audit the changes for [task description]")\`
+
+Only mark complete when ALL checks pass.`
+  };
+}
+
+// src/hooks/create-hooks.ts
+function createHooks(args) {
+  const { pluginConfig, isHookEnabled, directory, analyticsEnabled = false } = args;
+  const writeGuardState = createWriteGuardState();
+  const writeGuard = createWriteGuard(writeGuardState);
+  const contextWindowThresholds = {
+    warningPct: pluginConfig.experimental?.context_window_warning_threshold ?? 0.8,
+    criticalPct: pluginConfig.experimental?.context_window_critical_threshold ?? 0.95
+  };
+  return {
+    checkContextWindow: isHookEnabled("context-window-monitor") ? (state) => checkContextWindow(state, contextWindowThresholds) : null,
+    writeGuard: isHookEnabled("write-existing-file-guard") ? writeGuard : null,
+    shouldInjectRules: isHookEnabled("rules-injector") ? shouldInjectRules : null,
+    getRulesForFile: isHookEnabled("rules-injector") ? getRulesForFile : null,
+    firstMessageVariant: isHookEnabled("first-message-variant") ? { shouldApplyVariant, markApplied, markSessionCreated, clearSession } : null,
+    processMessageForKeywords: isHookEnabled("keyword-detector") ? processMessageForKeywords : null,
+    patternMdOnly: isHookEnabled("pattern-md-only") ? checkPatternWrite : null,
+    startWork: isHookEnabled("start-work") ? (promptText, sessionId) => handleStartWork({ promptText, sessionId, directory }) : null,
+    workContinuation: isHookEnabled("work-continuation") ? (sessionId) => checkContinuation({ sessionId, directory }) : null,
+    workflowStart: isHookEnabled("workflow") ? (promptText, sessionId) => handleRunWorkflow({ promptText, sessionId, directory }) : null,
+    workflowContinuation: isHookEnabled("workflow") ? (sessionId, lastAssistantMessage, lastUserMessage) => checkWorkflowContinuation({ sessionId, directory, lastAssistantMessage, lastUserMessage }) : null,
+    workflowCommand: isHookEnabled("workflow") ? (message) => handleWorkflowCommand(message, directory) : null,
+    verificationReminder: isHookEnabled("verification-reminder") ? buildVerificationReminder : null,
+    analyticsEnabled
+  };
+}
+// src/hooks/session-token-state.ts
+var sessionMap = new Map;
+function setContextLimit(sessionId, maxTokens) {
+  const existing = sessionMap.get(sessionId);
+  sessionMap.set(sessionId, {
+    usedTokens: existing?.usedTokens ?? 0,
+    maxTokens
+  });
+}
+function updateUsage(sessionId, inputTokens) {
+  if (inputTokens <= 0)
+    return;
+  const existing = sessionMap.get(sessionId);
+  sessionMap.set(sessionId, {
+    maxTokens: existing?.maxTokens ?? 0,
+    usedTokens: inputTokens
+  });
+}
+function getState(sessionId) {
+  return sessionMap.get(sessionId);
+}
+function clearSession2(sessionId) {
+  sessionMap.delete(sessionId);
+}
+// src/features/analytics/storage.ts
+import { existsSync as existsSync12, mkdirSync as mkdirSync4, appendFileSync as appendFileSync2, readFileSync as readFileSync9, writeFileSync as writeFileSync3, statSync as statSync2 } from "fs";
+import { join as join10 } from "path";
+
+// src/features/analytics/types.ts
+var ANALYTICS_DIR = ".weave/analytics";
+var SESSION_SUMMARIES_FILE = "session-summaries.jsonl";
+var FINGERPRINT_FILE = "fingerprint.json";
+var METRICS_REPORTS_FILE = "metrics-reports.jsonl";
+var MAX_METRICS_ENTRIES = 100;
+function zeroTokenUsage() {
+  return { input: 0, output: 0, reasoning: 0, cacheRead: 0, cacheWrite: 0 };
+}
+
+// src/features/analytics/storage.ts
+var MAX_SESSION_ENTRIES = 1000;
+function ensureAnalyticsDir(directory) {
+  const dir = join10(directory, ANALYTICS_DIR);
+  mkdirSync4(dir, { recursive: true, mode: 448 });
+  return dir;
+}
+function appendSessionSummary(directory, summary) {
+  try {
+    const dir = ensureAnalyticsDir(directory);
+    const filePath = join10(dir, SESSION_SUMMARIES_FILE);
+    const line = JSON.stringify(summary) + `
+`;
+    appendFileSync2(filePath, line, { encoding: "utf-8", mode: 384 });
+    try {
+      const TYPICAL_ENTRY_BYTES = 200;
+      const rotationSizeThreshold = MAX_SESSION_ENTRIES * TYPICAL_ENTRY_BYTES * 0.9;
+      const { size } = statSync2(filePath);
+      if (size > rotationSizeThreshold) {
+        const content = readFileSync9(filePath, "utf-8");
+        const lines = content.split(`
+`).filter((l) => l.trim().length > 0);
+        if (lines.length > MAX_SESSION_ENTRIES) {
+          const trimmed = lines.slice(-MAX_SESSION_ENTRIES).join(`
+`) + `
+`;
+          writeFileSync3(filePath, trimmed, { encoding: "utf-8", mode: 384 });
+        }
+      }
+    } catch {}
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readSessionSummaries(directory) {
+  const filePath = join10(directory, ANALYTICS_DIR, SESSION_SUMMARIES_FILE);
+  try {
+    if (!existsSync12(filePath))
+      return [];
+    const content = readFileSync9(filePath, "utf-8");
+    const lines = content.split(`
+`).filter((line) => line.trim().length > 0);
+    const summaries = [];
+    for (const line of lines) {
+      try {
+        summaries.push(JSON.parse(line));
+      } catch {}
+    }
+    return summaries;
+  } catch {
+    return [];
+  }
+}
+function writeFingerprint(directory, fingerprint) {
+  try {
+    const dir = ensureAnalyticsDir(directory);
+    const filePath = join10(dir, FINGERPRINT_FILE);
+    writeFileSync3(filePath, JSON.stringify(fingerprint, null, 2), { encoding: "utf-8", mode: 384 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readFingerprint(directory) {
+  const filePath = join10(directory, ANALYTICS_DIR, FINGERPRINT_FILE);
+  try {
+    if (!existsSync12(filePath))
+      return null;
+    const content = readFileSync9(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.stack))
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeMetricsReport(directory, report) {
+  try {
+    const dir = ensureAnalyticsDir(directory);
+    const filePath = join10(dir, METRICS_REPORTS_FILE);
+    const line = JSON.stringify(report) + `
+`;
+    appendFileSync2(filePath, line, { encoding: "utf-8", mode: 384 });
+    try {
+      const TYPICAL_ENTRY_BYTES = 200;
+      const rotationSizeThreshold = MAX_METRICS_ENTRIES * TYPICAL_ENTRY_BYTES * 0.9;
+      const { size } = statSync2(filePath);
+      if (size > rotationSizeThreshold) {
+        const content = readFileSync9(filePath, "utf-8");
+        const lines = content.split(`
+`).filter((l) => l.trim().length > 0);
+        if (lines.length > MAX_METRICS_ENTRIES) {
+          const trimmed = lines.slice(-MAX_METRICS_ENTRIES).join(`
+`) + `
+`;
+          writeFileSync3(filePath, trimmed, { encoding: "utf-8", mode: 384 });
+        }
+      }
+    } catch {}
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readMetricsReports(directory) {
+  const filePath = join10(directory, ANALYTICS_DIR, METRICS_REPORTS_FILE);
+  try {
+    if (!existsSync12(filePath))
+      return [];
+    const content = readFileSync9(filePath, "utf-8");
+    const lines = content.split(`
+`).filter((line) => line.trim().length > 0);
+    const reports = [];
+    for (const line of lines) {
+      try {
+        reports.push(JSON.parse(line));
+      } catch {}
+    }
+    return reports;
+  } catch {
+    return [];
+  }
+}
+
+// src/features/analytics/token-report.ts
+function generateTokenReport(summaries) {
+  if (summaries.length === 0) {
+    return "No session data available.";
+  }
+  const sections = [];
+  const totalSessions = summaries.length;
+  const totalMessages = summaries.reduce((sum, s) => sum + (s.tokenUsage?.totalMessages ?? 0), 0);
+  const totalInput = summaries.reduce((sum, s) => sum + (s.tokenUsage?.inputTokens ?? 0), 0);
+  const totalOutput = summaries.reduce((sum, s) => sum + (s.tokenUsage?.outputTokens ?? 0), 0);
+  const totalReasoning = summaries.reduce((sum, s) => sum + (s.tokenUsage?.reasoningTokens ?? 0), 0);
+  const totalCacheRead = summaries.reduce((sum, s) => sum + (s.tokenUsage?.cacheReadTokens ?? 0), 0);
+  const totalCacheWrite = summaries.reduce((sum, s) => sum + (s.tokenUsage?.cacheWriteTokens ?? 0), 0);
+  const totalCost = summaries.reduce((sum, s) => sum + (s.totalCost ?? 0), 0);
+  sections.push(`## Overall Totals
+` + `- Sessions: ${fmt(totalSessions)}
+` + `- Messages: ${fmt(totalMessages)}
+` + `- Input tokens: ${fmt(totalInput)}
+` + `- Output tokens: ${fmt(totalOutput)}
+` + `- Reasoning tokens: ${fmt(totalReasoning)}
+` + `- Cache read tokens: ${fmt(totalCacheRead)}
+` + `- Cache write tokens: ${fmt(totalCacheWrite)}
+` + `- Total cost: ${fmtCost(totalCost)}`);
+  const agentGroups = new Map;
+  for (const s of summaries) {
+    const key = s.agentName ?? "(unknown)";
+    const group = agentGroups.get(key);
+    if (group) {
+      group.push(s);
+    } else {
+      agentGroups.set(key, [s]);
+    }
+  }
+  const agentStats = Array.from(agentGroups.entries()).map(([agent, sessions]) => {
+    const agentCost = sessions.reduce((sum, s) => sum + (s.totalCost ?? 0), 0);
+    const agentTokens = sessions.reduce((sum, s) => sum + (s.tokenUsage?.inputTokens ?? 0) + (s.tokenUsage?.outputTokens ?? 0) + (s.tokenUsage?.reasoningTokens ?? 0), 0);
+    const avgTokens = sessions.length > 0 ? Math.round(agentTokens / sessions.length) : 0;
+    const avgCost = sessions.length > 0 ? agentCost / sessions.length : 0;
+    return { agent, sessions: sessions.length, avgTokens, avgCost, totalCost: agentCost };
+  }).sort((a, b) => b.totalCost - a.totalCost);
+  const agentLines = agentStats.map((a) => `- **${a.agent}**: ${fmt(a.sessions)} session${a.sessions === 1 ? "" : "s"}, ` + `avg ${fmt(a.avgTokens)} tokens/session, ` + `avg ${fmtCost(a.avgCost)}/session, ` + `total ${fmtCost(a.totalCost)}`);
+  sections.push(`## Per-Agent Breakdown
+${agentLines.join(`
+`)}`);
+  const top5 = [...summaries].sort((a, b) => (b.totalCost ?? 0) - (a.totalCost ?? 0)).slice(0, 5);
+  const top5Lines = top5.map((s) => {
+    const id = s.sessionId.length > 8 ? s.sessionId.slice(0, 8) : s.sessionId;
+    const agent = s.agentName ?? "(unknown)";
+    const cost = fmtCost(s.totalCost ?? 0);
+    const tokens = (s.tokenUsage?.inputTokens ?? 0) + (s.tokenUsage?.outputTokens ?? 0) + (s.tokenUsage?.reasoningTokens ?? 0);
+    const duration = fmtDuration(s.durationMs);
+    return `- \`${id}\` ${agent} — ${cost}, ${fmt(tokens)} tokens, ${duration}`;
+  });
+  sections.push(`## Top 5 Costliest Sessions
+${top5Lines.join(`
+`)}`);
+  return sections.join(`
+
+`);
+}
+function fmt(n) {
+  return n.toLocaleString("en-US");
+}
+function fmtCost(n) {
+  return `$${n.toFixed(2)}`;
+}
+function fmtDuration(ms) {
+  const totalSeconds = Math.round(ms / 1000);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (minutes === 0)
+    return `${seconds}s`;
+  return `${minutes}m ${seconds}s`;
+}
+
+// src/features/analytics/format-metrics.ts
+function formatNumber(n) {
+  return n.toLocaleString("en-US");
+}
+function formatDuration(ms) {
+  const totalSeconds = Math.round(ms / 1000);
+  if (totalSeconds < 60)
+    return `${totalSeconds}s`;
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
+}
+function formatDate(iso) {
+  try {
+    const d = new Date(iso);
+    return d.toLocaleDateString("en-US", { year: "numeric", month: "short", day: "numeric" });
+  } catch {
+    return iso;
+  }
+}
+function formatReport(report) {
+  const lines = [];
+  const date = formatDate(report.generatedAt);
+  lines.push(`#### \uD83D\uDCCA ${report.planName} (${date})`);
+  lines.push("");
+  lines.push("| Metric | Value |");
+  lines.push("|--------|-------|");
+  lines.push(`| Coverage | ${Math.round(report.adherence.coverage * 100)}% |`);
+  lines.push(`| Precision | ${Math.round(report.adherence.precision * 100)}% |`);
+  lines.push(`| Sessions | ${report.sessionCount} |`);
+  lines.push(`| Duration | ${formatDuration(report.durationMs)} |`);
+  lines.push(`| Input Tokens | ${formatNumber(report.tokenUsage.input)} |`);
+  lines.push(`| Output Tokens | ${formatNumber(report.tokenUsage.output)} |`);
+  if (report.tokenUsage.reasoning > 0) {
+    lines.push(`| Reasoning Tokens | ${formatNumber(report.tokenUsage.reasoning)} |`);
+  }
+  if (report.tokenUsage.cacheRead > 0 || report.tokenUsage.cacheWrite > 0) {
+    lines.push(`| Cache Read | ${formatNumber(report.tokenUsage.cacheRead)} |`);
+    lines.push(`| Cache Write | ${formatNumber(report.tokenUsage.cacheWrite)} |`);
+  }
+  if (report.adherence.unplannedChanges.length > 0) {
+    lines.push("");
+    lines.push(`**Unplanned Changes**: ${report.adherence.unplannedChanges.map((f) => `\`${f}\``).join(", ")}`);
+  }
+  if (report.adherence.missedFiles.length > 0) {
+    lines.push("");
+    lines.push(`**Missed Files**: ${report.adherence.missedFiles.map((f) => `\`${f}\``).join(", ")}`);
+  }
+  return lines.join(`
+`);
+}
+function aggregateSessionTokens(summaries) {
+  const total = { input: 0, output: 0, reasoning: 0, cacheRead: 0, cacheWrite: 0 };
+  for (const s of summaries) {
+    if (s.tokenUsage) {
+      total.input += s.tokenUsage.inputTokens;
+      total.output += s.tokenUsage.outputTokens;
+      total.reasoning += s.tokenUsage.reasoningTokens;
+      total.cacheRead += s.tokenUsage.cacheReadTokens;
+      total.cacheWrite += s.tokenUsage.cacheWriteTokens;
+    }
+  }
+  return total;
+}
+function topTools(summaries, limit = 5) {
+  const counts = {};
+  for (const s of summaries) {
+    for (const t of s.toolUsage) {
+      counts[t.tool] = (counts[t.tool] ?? 0) + t.count;
+    }
+  }
+  return Object.entries(counts).map(([tool, count]) => ({ tool, count })).sort((a, b) => b.count - a.count).slice(0, limit);
+}
+function formatMetricsMarkdown(reports, summaries, args) {
+  if (reports.length === 0 && summaries.length === 0) {
+    return [
+      "## Weave Metrics Dashboard",
+      "",
+      "No metrics data yet.",
+      "",
+      "To generate metrics:",
+      '1. Enable analytics in `weave.json`: `{ "analytics": { "enabled": true } }`',
+      "2. Create and complete a plan using Pattern and `/start-work`",
+      "3. Metrics are generated automatically when a plan completes"
+    ].join(`
+`);
+  }
+  const lines = ["## Weave Metrics Dashboard"];
+  let filteredReports = reports;
+  const trimmedArgs = args?.trim() ?? "";
+  if (trimmedArgs && trimmedArgs !== "all") {
+    filteredReports = reports.filter((r) => r.planName.toLowerCase().includes(trimmedArgs.toLowerCase()));
+  }
+  if (!trimmedArgs || trimmedArgs === "") {
+    filteredReports = filteredReports.slice(-5);
+  }
+  if (filteredReports.length > 0) {
+    lines.push("");
+    lines.push("### Recent Plan Metrics");
+    for (let i = 0;i < filteredReports.length; i++) {
+      lines.push("");
+      lines.push(formatReport(filteredReports[i]));
+      if (i < filteredReports.length - 1) {
+        lines.push("");
+        lines.push("---");
+      }
+    }
+  } else if (reports.length > 0 && trimmedArgs) {
+    lines.push("");
+    lines.push(`### Recent Plan Metrics`);
+    lines.push("");
+    lines.push(`No reports found matching "${trimmedArgs}".`);
+  }
+  if (summaries.length > 0) {
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+    lines.push("### Aggregate Session Stats");
+    lines.push("");
+    const totalTokens = aggregateSessionTokens(summaries);
+    const avgDuration = summaries.reduce((sum, s) => sum + s.durationMs, 0) / summaries.length;
+    const tools = topTools(summaries);
+    lines.push(`- **Sessions tracked**: ${summaries.length}`);
+    lines.push(`- **Total input tokens**: ${formatNumber(totalTokens.input)}`);
+    lines.push(`- **Total output tokens**: ${formatNumber(totalTokens.output)}`);
+    lines.push(`- **Average session duration**: ${formatDuration(avgDuration)}`);
+    if (tools.length > 0) {
+      const toolStr = tools.map((t) => `${t.tool} (${formatNumber(t.count)})`).join(", ");
+      lines.push(`- **Top tools**: ${toolStr}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+
+// src/features/analytics/plan-parser.ts
+import { readFileSync as readFileSync10 } from "fs";
+function extractSection2(content, heading) {
+  const lines = content.split(`
+`);
+  let startIdx = -1;
+  for (let i = 0;i < lines.length; i++) {
+    if (lines[i].trim() === heading) {
+      startIdx = i + 1;
+      break;
+    }
+  }
+  if (startIdx === -1)
+    return null;
+  const sectionLines = [];
+  for (let i = startIdx;i < lines.length; i++) {
+    if (/^## /.test(lines[i]))
+      break;
+    sectionLines.push(lines[i]);
+  }
+  return sectionLines.join(`
+`);
+}
+function extractFilePath2(raw) {
+  let cleaned = raw.replace(/^\s*(create|modify|new:|add)\s+/i, "").replace(/\(new\)/gi, "").trim();
+  const firstToken = cleaned.split(/\s+/)[0];
+  if (firstToken && (firstToken.includes("/") || firstToken.endsWith(".ts") || firstToken.endsWith(".js") || firstToken.endsWith(".json") || firstToken.endsWith(".md"))) {
+    cleaned = firstToken;
+  } else if (!cleaned.includes("/")) {
+    return null;
+  }
+  return cleaned || null;
+}
+function extractPlannedFiles(planPath) {
+  let content;
+  try {
+    content = readFileSync10(planPath, "utf-8");
+  } catch {
+    return [];
+  }
+  const todosSection = extractSection2(content, "## TODOs");
+  if (todosSection === null)
+    return [];
+  const files = new Set;
+  const lines = todosSection.split(`
+`);
+  for (const line of lines) {
+    const filesMatch = /^\s*\*\*Files\*\*:?\s*(.+)$/.exec(line);
+    if (!filesMatch)
+      continue;
+    const rawValue = filesMatch[1].trim();
+    const parts = rawValue.split(",");
+    for (const part of parts) {
+      const trimmed = part.trim();
+      if (!trimmed)
+        continue;
+      const filePath = extractFilePath2(trimmed);
+      if (filePath) {
+        files.add(filePath);
+      }
+    }
+  }
+  return Array.from(files);
+}
+
+// src/features/analytics/git-diff.ts
+import { execFileSync } from "child_process";
+var SHA_PATTERN = /^[0-9a-f]{4,40}$/i;
+function getChangedFiles(directory, fromSha) {
+  if (!SHA_PATTERN.test(fromSha)) {
+    return [];
   }
-  const progress = getPlanProgress(state.active_plan);
-  if (progress.isComplete) {
-    return { continuationPrompt: null };
+  try {
+    const output = execFileSync("git", ["diff", "--name-only", `${fromSha}..HEAD`], {
+      cwd: directory,
+      encoding: "utf-8",
+      timeout: 1e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return output.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0);
+  } catch {
+    return [];
   }
-  if (state.continuation_completed_snapshot === undefined) {
-    state.continuation_completed_snapshot = progress.completed;
-    state.stale_continuation_count = 0;
-    writeWorkState(directory, state);
-  } else if (progress.completed > state.continuation_completed_snapshot) {
-    state.continuation_completed_snapshot = progress.completed;
-    state.stale_continuation_count = 0;
-    writeWorkState(directory, state);
-  } else {
-    state.stale_continuation_count = (state.stale_continuation_count ?? 0) + 1;
-    if (state.stale_continuation_count >= MAX_STALE_CONTINUATIONS) {
-      state.paused = true;
-      writeWorkState(directory, state);
-      return { continuationPrompt: null };
+}
+
+// src/features/analytics/adherence.ts
+function normalizePath(p) {
+  return p.trim().toLowerCase().replace(/^\.\//, "");
+}
+function calculateAdherence(plannedFiles, actualFiles) {
+  const plannedNorm = new Set(plannedFiles.map(normalizePath));
+  const actualNorm = new Set(actualFiles.map(normalizePath));
+  const plannedFilesChanged = [];
+  const missedFiles = [];
+  const unplannedChanges = [];
+  for (const planned of plannedFiles) {
+    if (actualNorm.has(normalizePath(planned))) {
+      plannedFilesChanged.push(planned);
+    } else {
+      missedFiles.push(planned);
     }
-    writeWorkState(directory, state);
   }
-  const remaining = progress.total - progress.completed;
+  for (const actual of actualFiles) {
+    if (!plannedNorm.has(normalizePath(actual))) {
+      unplannedChanges.push(actual);
+    }
+  }
+  const totalPlannedFiles = plannedFiles.length;
+  const totalActualFiles = actualFiles.length;
+  const coverage = totalPlannedFiles === 0 ? 1 : plannedFilesChanged.length / totalPlannedFiles;
+  const precision = totalActualFiles === 0 ? 1 : plannedFilesChanged.length / totalActualFiles;
   return {
-    continuationPrompt: `${CONTINUATION_MARKER}
-You have an active work plan with incomplete tasks. Continue working.
-
-**Plan**: ${state.plan_name}
-**File**: ${state.active_plan}
-**Progress**: ${progress.completed}/${progress.total} tasks completed (${remaining} remaining)
-
-1. Read the plan file NOW to check exact current progress
-2. Use todowrite to restore sidebar: summary todo "${state.plan_name} ${progress.completed}/${progress.total}" (in_progress) + next task (in_progress) + 2-3 upcoming (pending). Max 35 chars each.
-3. Find the first unchecked \`- [ ]\` task
-4. Execute it, verify it, mark \`- [ ]\` → \`- [x]\`
-5. Update sidebar todos as you complete tasks
-6. Do not stop until all tasks are complete`
+    coverage,
+    precision,
+    plannedFilesChanged,
+    unplannedChanges,
+    missedFiles,
+    totalPlannedFiles,
+    totalActualFiles
   };
 }
 
-// src/hooks/verification-reminder.ts
-function buildVerificationReminder(input) {
-  const planContext = input.planName && input.progress ? `
-**Plan**: ${input.planName} (${input.progress.completed}/${input.progress.total} tasks done)` : "";
-  return {
-    verificationPrompt: `## Verification Required
-${planContext}
-
-Before marking this task complete, verify the work:
-
-1. **Read the changes**: \`git diff --stat\` then Read each changed file
-2. **Run checks**: Run relevant tests, check for linting/type errors
-3. **Validate behavior**: Does the code actually do what was requested?
-4. **Gate decision**: Can you explain what every changed line does?
-
-If uncertain about quality, delegate to \`weft\` agent for a formal review:
-\`call_weave_agent(agent="weft", prompt="Review the changes for [task description]")\`
-
-MANDATORY: If changes touch auth, crypto, certificates, tokens, signatures, or input validation, you MUST delegate to \`warp\` agent for a security audit — this is NOT optional:
-\`call_weave_agent(agent="warp", prompt="Security audit the changes for [task description]")\`
-
-Only mark complete when ALL checks pass.`
-  };
+// src/features/analytics/plan-token-aggregator.ts
+function aggregateTokensForPlan(directory, sessionIds) {
+  const summaries = readSessionSummaries(directory);
+  const sessionIdSet = new Set(sessionIds);
+  const total = zeroTokenUsage();
+  for (const summary of summaries) {
+    if (!sessionIdSet.has(summary.sessionId))
+      continue;
+    if (summary.tokenUsage) {
+      total.input += summary.tokenUsage.inputTokens;
+      total.output += summary.tokenUsage.outputTokens;
+      total.reasoning += summary.tokenUsage.reasoningTokens;
+      total.cacheRead += summary.tokenUsage.cacheReadTokens;
+      total.cacheWrite += summary.tokenUsage.cacheWriteTokens;
+    }
+  }
+  return total;
 }
 
-// src/hooks/create-hooks.ts
-function createHooks(args) {
-  const { pluginConfig, isHookEnabled, directory, analyticsEnabled = false } = args;
-  const writeGuardState = createWriteGuardState();
-  const writeGuard = createWriteGuard(writeGuardState);
-  const contextWindowThresholds = {
-    warningPct: pluginConfig.experimental?.context_window_warning_threshold ?? 0.8,
-    criticalPct: pluginConfig.experimental?.context_window_critical_threshold ?? 0.95
-  };
-  return {
-    checkContextWindow: isHookEnabled("context-window-monitor") ? (state) => checkContextWindow(state, contextWindowThresholds) : null,
-    writeGuard: isHookEnabled("write-existing-file-guard") ? writeGuard : null,
-    shouldInjectRules: isHookEnabled("rules-injector") ? shouldInjectRules : null,
-    getRulesForFile: isHookEnabled("rules-injector") ? getRulesForFile : null,
-    firstMessageVariant: isHookEnabled("first-message-variant") ? { shouldApplyVariant, markApplied, markSessionCreated, clearSession } : null,
-    processMessageForKeywords: isHookEnabled("keyword-detector") ? processMessageForKeywords : null,
-    patternMdOnly: isHookEnabled("pattern-md-only") ? checkPatternWrite : null,
-    startWork: isHookEnabled("start-work") ? (promptText, sessionId) => handleStartWork({ promptText, sessionId, directory }) : null,
-    workContinuation: isHookEnabled("work-continuation") ? (sessionId) => checkContinuation({ sessionId, directory }) : null,
-    verificationReminder: isHookEnabled("verification-reminder") ? buildVerificationReminder : null,
-    analyticsEnabled
-  };
-}
-// src/hooks/session-token-state.ts
-var sessionMap = new Map;
-function setContextLimit(sessionId, maxTokens) {
-  const existing = sessionMap.get(sessionId);
-  sessionMap.set(sessionId, {
-    usedTokens: existing?.usedTokens ?? 0,
-    maxTokens
-  });
-}
-function updateUsage(sessionId, inputTokens) {
-  if (inputTokens <= 0)
-    return;
-  const existing = sessionMap.get(sessionId);
-  sessionMap.set(sessionId, {
-    maxTokens: existing?.maxTokens ?? 0,
-    usedTokens: inputTokens
-  });
-}
-function getState(sessionId) {
-  return sessionMap.get(sessionId);
-}
-function clearSession2(sessionId) {
-  sessionMap.delete(sessionId);
+// src/features/analytics/generate-metrics-report.ts
+function generateMetricsReport(directory, state) {
+  try {
+    const plannedFiles = extractPlannedFiles(state.active_plan);
+    const actualFiles = state.start_sha ? getChangedFiles(directory, state.start_sha) : [];
+    const adherence = calculateAdherence(plannedFiles, actualFiles);
+    const tokenUsage = aggregateTokensForPlan(directory, state.session_ids);
+    const summaries = readSessionSummaries(directory);
+    const matchingSummaries = summaries.filter((s) => state.session_ids.includes(s.sessionId));
+    const durationMs = matchingSummaries.reduce((sum, s) => sum + s.durationMs, 0);
+    const report = {
+      planName: getPlanName(state.active_plan),
+      generatedAt: new Date().toISOString(),
+      adherence,
+      quality: undefined,
+      gaps: undefined,
+      tokenUsage,
+      durationMs,
+      sessionCount: state.session_ids.length,
+      startSha: state.start_sha,
+      sessionIds: [...state.session_ids]
+    };
+    const written = writeMetricsReport(directory, report);
+    if (!written) {
+      log("[analytics] Failed to write metrics report (non-fatal)");
+      return null;
+    }
+    log("[analytics] Metrics report generated", {
+      plan: report.planName,
+      coverage: adherence.coverage,
+      precision: adherence.precision
+    });
+    return report;
+  } catch (err) {
+    log("[analytics] Failed to generate metrics report (non-fatal)", {
+      error: String(err)
+    });
+    return null;
+  }
 }
+
 // src/plugin/plugin-interface.ts
 function createPluginInterface(args) {
   const { pluginConfig, hooks, tools, configHandler, agents, client, directory = "", tracker } = args;
+  const lastAssistantMessageText = new Map;
+  const lastUserMessageText = new Map;
   return {
     tool: tools,
     config: async (config) => {
@@ -3187,13 +4762,74 @@ ${result.contextInjection}`;
           }
         }
       }
+      if (hooks.workflowStart) {
+        const parts = _output.parts;
+        const message = _output.message;
+        const promptText = parts?.filter((p) => p.type === "text" && p.text).map((p) => p.text).join(`
+`).trim() ?? "";
+        if (promptText.includes("workflow engine will inject context")) {
+          const result = hooks.workflowStart(promptText, sessionID);
+          if (result.switchAgent && message) {
+            message.agent = getAgentDisplayName(result.switchAgent);
+          }
+          if (result.contextInjection && parts) {
+            const idx = parts.findIndex((p) => p.type === "text" && p.text);
+            if (idx >= 0 && parts[idx].text) {
+              parts[idx].text += `
+
+---
+${result.contextInjection}`;
+            } else {
+              parts.push({ type: "text", text: result.contextInjection });
+            }
+          }
+        }
+      }
+      {
+        const parts = _output.parts;
+        const userText = parts?.filter((p) => p.type === "text" && p.text).map((p) => p.text).join(`
+`).trim() ?? "";
+        if (userText && sessionID) {
+          lastUserMessageText.set(sessionID, userText);
+        }
+      }
+      if (hooks.workflowCommand) {
+        const parts = _output.parts;
+        const message = _output.message;
+        const userText = parts?.filter((p) => p.type === "text" && p.text).map((p) => p.text).join(`
+`).trim() ?? "";
+        if (userText) {
+          const cmdResult = hooks.workflowCommand(userText);
+          if (cmdResult.handled) {
+            if (cmdResult.contextInjection && parts) {
+              const idx = parts.findIndex((p) => p.type === "text" && p.text);
+              if (idx >= 0 && parts[idx].text) {
+                parts[idx].text += `
+
+---
+${cmdResult.contextInjection}`;
+              } else {
+                parts.push({ type: "text", text: cmdResult.contextInjection });
+              }
+            }
+            if (cmdResult.switchAgent && message) {
+              message.agent = getAgentDisplayName(cmdResult.switchAgent);
+            }
+          }
+        }
+      }
       if (directory) {
         const parts = _output.parts;
         const promptText = parts?.filter((p) => p.type === "text" && p.text).map((p) => p.text).join(`
 `).trim() ?? "";
         const isStartWork = promptText.includes("<session-context>");
         const isContinuation = promptText.includes(CONTINUATION_MARKER);
-        if (!isStartWork && !isContinuation) {
+        const isWorkflowContinuation = promptText.includes(WORKFLOW_CONTINUATION_MARKER);
+        const isActiveWorkflow = (() => {
+          const wf = getActiveWorkflowInstance(directory);
+          return wf != null && wf.status === "running";
+        })();
+        if (!isStartWork && !isContinuation && !isWorkflowContinuation && !isActiveWorkflow) {
           const state = readWorkState(directory);
           if (state && !state.paused) {
             pauseWork(directory);
@@ -3210,6 +4846,9 @@ ${result.contextInjection}`;
         setContextLimit(sessionId, maxTokens);
         log("[context-window] Captured context limit", { sessionId, maxTokens });
       }
+      if (tracker && hooks.analyticsEnabled && sessionId && input.agent) {
+        tracker.setAgentName(sessionId, input.agent);
+      }
     },
     "chat.headers": async (_input, _output) => {},
     event: async (input) => {
@@ -3233,38 +4872,115 @@ ${result.contextInjection}`;
           } catch (err) {
             log("[analytics] Failed to end session (non-fatal)", { error: String(err) });
           }
+          if (directory) {
+            try {
+              const state = readWorkState(directory);
+              if (state) {
+                const progress = getPlanProgress(state.active_plan);
+                if (progress.isComplete) {
+                  generateMetricsReport(directory, state);
+                }
+              }
+            } catch (err) {
+              log("[analytics] Failed to generate metrics report on session end (non-fatal)", { error: String(err) });
+            }
+          }
         }
       }
-      if (event.type === "message.updated" && hooks.checkContextWindow) {
+      if (event.type === "message.updated") {
         const evt = event;
         const info = evt.properties?.info;
         if (info?.role === "assistant" && info.sessionID) {
-          const inputTokens = info.tokens?.input ?? 0;
-          if (inputTokens > 0) {
-            updateUsage(info.sessionID, inputTokens);
-            const tokenState = getState(info.sessionID);
-            if (tokenState && tokenState.maxTokens > 0) {
-              const result = hooks.checkContextWindow({
-                usedTokens: tokenState.usedTokens,
-                maxTokens: tokenState.maxTokens,
-                sessionId: info.sessionID
-              });
-              if (result.action !== "none") {
-                log("[context-window] Threshold crossed", {
-                  sessionId: info.sessionID,
-                  action: result.action,
-                  usagePct: result.usagePct
+          if (hooks.checkContextWindow) {
+            const inputTokens = info.tokens?.input ?? 0;
+            if (inputTokens > 0) {
+              updateUsage(info.sessionID, inputTokens);
+              const tokenState = getState(info.sessionID);
+              if (tokenState && tokenState.maxTokens > 0) {
+                const result = hooks.checkContextWindow({
+                  usedTokens: tokenState.usedTokens,
+                  maxTokens: tokenState.maxTokens,
+                  sessionId: info.sessionID
                 });
+                if (result.action !== "none") {
+                  log("[context-window] Threshold crossed", {
+                    sessionId: info.sessionID,
+                    action: result.action,
+                    usagePct: result.usagePct
+                  });
+                }
               }
             }
           }
         }
       }
+      if (event.type === "message.updated" && tracker && hooks.analyticsEnabled) {
+        const evt = event;
+        const info = evt.properties?.info;
+        if (info?.role === "assistant" && info.sessionID) {
+          if (typeof info.cost === "number" && info.cost > 0) {
+            tracker.trackCost(info.sessionID, info.cost);
+          }
+          if (info.tokens) {
+            tracker.trackTokenUsage(info.sessionID, {
+              input: info.tokens.input ?? 0,
+              output: info.tokens.output ?? 0,
+              reasoning: info.tokens.reasoning ?? 0,
+              cacheRead: info.tokens.cache?.read ?? 0,
+              cacheWrite: info.tokens.cache?.write ?? 0
+            });
+          }
+        }
+      }
       if (event.type === "tui.command.execute") {
         const evt = event;
         if (evt.properties?.command === "session.interrupt") {
           pauseWork(directory);
           log("[work-continuation] User interrupt detected — work paused");
+          if (directory) {
+            const activeWorkflow = getActiveWorkflowInstance(directory);
+            if (activeWorkflow && activeWorkflow.status === "running") {
+              pauseWorkflow(directory, "User interrupt");
+              log("[workflow] User interrupt detected — workflow paused");
+            }
+          }
+        }
+      }
+      if (event.type === "message.part.updated") {
+        const evt = event;
+        const part = evt.properties?.part;
+        if (part?.type === "text" && part.sessionID && part.text) {
+          lastAssistantMessageText.set(part.sessionID, part.text);
+        }
+      }
+      if (hooks.workflowContinuation && event.type === "session.idle") {
+        const evt = event;
+        const sessionId = evt.properties?.sessionID ?? "";
+        if (sessionId && directory) {
+          const activeWorkflow = getActiveWorkflowInstance(directory);
+          if (activeWorkflow && activeWorkflow.status === "running") {
+            const lastMsg = lastAssistantMessageText.get(sessionId) ?? undefined;
+            const lastUserMsg = lastUserMessageText.get(sessionId) ?? undefined;
+            const result = hooks.workflowContinuation(sessionId, lastMsg, lastUserMsg);
+            if (result.continuationPrompt && client) {
+              try {
+                await client.session.promptAsync({
+                  path: { id: sessionId },
+                  body: {
+                    parts: [{ type: "text", text: result.continuationPrompt }],
+                    ...result.switchAgent ? { agent: getAgentDisplayName(result.switchAgent) } : {}
+                  }
+                });
+                log("[workflow] Injected workflow continuation prompt", {
+                  sessionId,
+                  agent: result.switchAgent
+                });
+              } catch (err) {
+                log("[workflow] Failed to inject workflow continuation", { sessionId, error: String(err) });
+              }
+              return;
+            }
+          }
         }
       }
       if (hooks.workContinuation && event.type === "session.idle") {
@@ -3342,79 +5058,40 @@ ${result.contextInjection}`;
         const agentArg = input.tool === "task" && inputArgs ? inputArgs.subagent_type ?? inputArgs.description ?? "unknown" : undefined;
         tracker.trackToolEnd(input.sessionID, input.tool, input.callID, agentArg);
       }
+    },
+    "command.execute.before": async (input, output) => {
+      const { command, arguments: args2 } = input;
+      const parts = output.parts;
+      if (command === "token-report") {
+        const summaries = readSessionSummaries(directory);
+        const reportText = generateTokenReport(summaries);
+        parts.push({ type: "text", text: reportText });
+      }
+      if (command === "metrics") {
+        if (!hooks.analyticsEnabled) {
+          parts.push({
+            type: "text",
+            text: 'Analytics is not enabled. To enable it, set `"analytics": { "enabled": true }` in your `weave.json`.'
+          });
+          return;
+        }
+        const reports = readMetricsReports(directory);
+        const summaries = readSessionSummaries(directory);
+        const metricsMarkdown = formatMetricsMarkdown(reports, summaries, args2);
+        parts.push({ type: "text", text: metricsMarkdown });
+      }
     }
   };
 }
-
-// src/features/analytics/types.ts
-var ANALYTICS_DIR = ".weave/analytics";
-var SESSION_SUMMARIES_FILE = "session-summaries.jsonl";
-var FINGERPRINT_FILE = "fingerprint.json";
-// src/features/analytics/storage.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync2, appendFileSync as appendFileSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "fs";
-import { join as join7 } from "path";
-var MAX_SESSION_ENTRIES = 1000;
-function ensureAnalyticsDir(directory) {
-  const dir = join7(directory, ANALYTICS_DIR);
-  mkdirSync2(dir, { recursive: true, mode: 448 });
-  return dir;
-}
-function appendSessionSummary(directory, summary) {
-  try {
-    const dir = ensureAnalyticsDir(directory);
-    const filePath = join7(dir, SESSION_SUMMARIES_FILE);
-    const line = JSON.stringify(summary) + `
-`;
-    appendFileSync2(filePath, line, { encoding: "utf-8", mode: 384 });
-    try {
-      const content = readFileSync7(filePath, "utf-8");
-      const lines = content.split(`
-`).filter((l) => l.trim().length > 0);
-      if (lines.length > MAX_SESSION_ENTRIES) {
-        const trimmed = lines.slice(-MAX_SESSION_ENTRIES).join(`
-`) + `
-`;
-        writeFileSync2(filePath, trimmed, { encoding: "utf-8", mode: 384 });
-      }
-    } catch {}
-    return true;
-  } catch {
-    return false;
-  }
-}
-function writeFingerprint(directory, fingerprint) {
-  try {
-    const dir = ensureAnalyticsDir(directory);
-    const filePath = join7(dir, FINGERPRINT_FILE);
-    writeFileSync2(filePath, JSON.stringify(fingerprint, null, 2), { encoding: "utf-8", mode: 384 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function readFingerprint(directory) {
-  const filePath = join7(directory, ANALYTICS_DIR, FINGERPRINT_FILE);
-  try {
-    if (!existsSync8(filePath))
-      return null;
-    const content = readFileSync7(filePath, "utf-8");
-    const parsed = JSON.parse(content);
-    if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.stack))
-      return null;
-    return parsed;
-  } catch {
-    return null;
-  }
-}
 // src/features/analytics/fingerprint.ts
-import { existsSync as existsSync9, readFileSync as readFileSync9, readdirSync as readdirSync3 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync12, readdirSync as readdirSync5 } from "fs";
+import { join as join12 } from "path";
 import { arch } from "os";
 
 // src/shared/version.ts
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 import { fileURLToPath } from "url";
-import { dirname as dirname2, join as join8 } from "path";
+import { dirname as dirname2, join as join11 } from "path";
 var cachedVersion;
 function getWeaveVersion() {
   if (cachedVersion !== undefined)
@@ -3423,7 +5100,7 @@ function getWeaveVersion() {
     const thisDir = dirname2(fileURLToPath(import.meta.url));
     for (const rel of ["../../package.json", "../package.json"]) {
       try {
-        const pkg = JSON.parse(readFileSync8(join8(thisDir, rel), "utf-8"));
+        const pkg = JSON.parse(readFileSync11(join11(thisDir, rel), "utf-8"));
         if (pkg.name === "@opencode_weave/weave" && typeof pkg.version === "string") {
           const version = pkg.version;
           cachedVersion = version;
@@ -3528,7 +5205,7 @@ function detectStack(directory) {
   const detected = [];
   for (const marker of STACK_MARKERS) {
     for (const file of marker.files) {
-      if (existsSync9(join9(directory, file))) {
+      if (existsSync13(join12(directory, file))) {
         detected.push({
           name: marker.name,
           confidence: marker.confidence,
@@ -3539,9 +5216,9 @@ function detectStack(directory) {
     }
   }
   try {
-    const pkgPath = join9(directory, "package.json");
-    if (existsSync9(pkgPath)) {
-      const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
+    const pkgPath = join12(directory, "package.json");
+    if (existsSync13(pkgPath)) {
+      const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.react) {
         detected.push({
@@ -3554,7 +5231,7 @@ function detectStack(directory) {
   } catch {}
   if (!detected.some((d) => d.name === "dotnet")) {
     try {
-      const entries = readdirSync3(directory);
+      const entries = readdirSync5(directory);
       const dotnetFile = entries.find((e) => e.endsWith(".csproj") || e.endsWith(".fsproj") || e.endsWith(".sln"));
       if (dotnetFile) {
         detected.push({
@@ -3574,27 +5251,27 @@ function detectStack(directory) {
   });
 }
 function detectPackageManager(directory) {
-  if (existsSync9(join9(directory, "bun.lockb")))
+  if (existsSync13(join12(directory, "bun.lockb")))
     return "bun";
-  if (existsSync9(join9(directory, "pnpm-lock.yaml")))
+  if (existsSync13(join12(directory, "pnpm-lock.yaml")))
     return "pnpm";
-  if (existsSync9(join9(directory, "yarn.lock")))
+  if (existsSync13(join12(directory, "yarn.lock")))
     return "yarn";
-  if (existsSync9(join9(directory, "package-lock.json")))
+  if (existsSync13(join12(directory, "package-lock.json")))
     return "npm";
-  if (existsSync9(join9(directory, "package.json")))
+  if (existsSync13(join12(directory, "package.json")))
     return "npm";
   return;
 }
 function detectMonorepo(directory) {
   for (const marker of MONOREPO_MARKERS) {
-    if (existsSync9(join9(directory, marker)))
+    if (existsSync13(join12(directory, marker)))
       return true;
   }
   try {
-    const pkgPath = join9(directory, "package.json");
-    if (existsSync9(pkgPath)) {
-      const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
+    const pkgPath = join12(directory, "package.json");
+    if (existsSync13(pkgPath)) {
+      const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
       if (pkg.workspaces)
         return true;
     }
@@ -3659,6 +5336,11 @@ function getOrCreateFingerprint(directory) {
   }
 }
 // src/features/analytics/session-tracker.ts
+function safeNum(v) {
+  const n = Number(v);
+  return Number.isFinite(n) && n >= 0 ? n : 0;
+}
+
 class SessionTracker {
   sessions = new Map;
   directory;
@@ -3674,7 +5356,16 @@ class SessionTracker {
       startedAt: new Date().toISOString(),
       toolCounts: {},
       delegations: [],
-      inFlight: {}
+      inFlight: {},
+      totalCost: 0,
+      tokenUsage: {
+        inputTokens: 0,
+        outputTokens: 0,
+        reasoningTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        totalMessages: 0
+      }
     };
     this.sessions.set(sessionId, session);
     return session;
@@ -3708,6 +5399,29 @@ class SessionTracker {
       session.delegations.push(delegation);
     }
   }
+  setAgentName(sessionId, agentName) {
+    const session = this.sessions.get(sessionId);
+    if (!session)
+      return;
+    if (!session.agentName) {
+      session.agentName = agentName;
+    }
+  }
+  trackCost(sessionId, cost) {
+    const session = this.sessions.get(sessionId);
+    if (!session)
+      return;
+    session.totalCost += safeNum(cost);
+  }
+  trackTokenUsage(sessionId, tokens) {
+    const session = this.startSession(sessionId);
+    session.tokenUsage.inputTokens += safeNum(tokens.input);
+    session.tokenUsage.outputTokens += safeNum(tokens.output);
+    session.tokenUsage.reasoningTokens += safeNum(tokens.reasoning);
+    session.tokenUsage.cacheReadTokens += safeNum(tokens.cacheRead);
+    session.tokenUsage.cacheWriteTokens += safeNum(tokens.cacheWrite);
+    session.tokenUsage.totalMessages += 1;
+  }
   endSession(sessionId) {
     const session = this.sessions.get(sessionId);
     if (!session)
@@ -3725,14 +5439,21 @@ class SessionTracker {
       toolUsage,
       delegations: session.delegations,
       totalToolCalls,
-      totalDelegations: session.delegations.length
+      totalDelegations: session.delegations.length,
+      agentName: session.agentName,
+      totalCost: session.totalCost > 0 ? session.totalCost : undefined,
+      tokenUsage: session.tokenUsage.totalMessages > 0 ? session.tokenUsage : undefined
     };
     try {
       appendSessionSummary(this.directory, summary);
       log("[analytics] Session summary persisted", {
         sessionId,
         totalToolCalls,
-        totalDelegations: session.delegations.length
+        totalDelegations: session.delegations.length,
+        ...summary.tokenUsage ? {
+          inputTokens: summary.tokenUsage.inputTokens,
+          outputTokens: summary.tokenUsage.outputTokens
+        } : {}
       });
     } catch (err) {
       log("[analytics] Failed to persist session summary (non-fatal)", {
@@ -3759,8 +5480,7 @@ function createSessionTracker(directory) {
 // src/features/analytics/index.ts
 function createAnalytics(directory, fingerprint) {
   const tracker = createSessionTracker(directory);
-  const resolvedFingerprint = fingerprint ?? getOrCreateFingerprint(directory);
-  return { tracker, fingerprint: resolvedFingerprint };
+  return { tracker, fingerprint };
 }
 
 // src/index.ts
@@ -3769,8 +5489,9 @@ var WeavePlugin = async (ctx) => {
   const disabledHooks = new Set(pluginConfig.disabled_hooks ?? []);
   const isHookEnabled = (name) => !disabledHooks.has(name);
   const analyticsEnabled = pluginConfig.analytics?.enabled === true;
-  const fingerprint = analyticsEnabled ? getOrCreateFingerprint(ctx.directory) : null;
-  const configDir = join10(ctx.directory, ".opencode");
+  const fingerprintEnabled = analyticsEnabled && pluginConfig.analytics?.use_fingerprint === true;
+  const fingerprint = fingerprintEnabled ? getOrCreateFingerprint(ctx.directory) : null;
+  const configDir = join13(ctx.directory, ".opencode");
   const toolsResult = await createTools({ ctx, pluginConfig });
   const managers = createManagers({ ctx, pluginConfig, resolveSkills: toolsResult.resolveSkillsFn, fingerprint, configDir });
   const hooks = createHooks({ pluginConfig, isHookEnabled, directory: ctx.directory, analyticsEnabled });