@opencode_weave/weave 0.6.1 → 0.6.3

package/dist/index.js

@@ -1,3 +1,6 @@
+// src/index.ts
+import { join as join9 } from "path";
+
 // src/config/loader.ts
 import { existsSync, readFileSync } from "node:fs";
 import { join as join2 } from "node:path";
@@ -51,15 +54,42 @@ var ExperimentalConfigSchema = z.object({
   context_window_warning_threshold: z.number().min(0).max(1).optional(),
   context_window_critical_threshold: z.number().min(0).max(1).optional()
 });
+var DelegationTriggerSchema = z.object({
+  domain: z.string(),
+  trigger: z.string()
+});
+var CustomAgentConfigSchema = z.object({
+  prompt: z.string().optional(),
+  prompt_file: z.string().optional(),
+  model: z.string().optional(),
+  display_name: z.string().optional(),
+  mode: z.enum(["subagent", "primary", "all"]).optional(),
+  fallback_models: z.array(z.string()).optional(),
+  category: z.enum(["exploration", "specialist", "advisor", "utility"]).optional(),
+  cost: z.enum(["FREE", "CHEAP", "EXPENSIVE"]).optional(),
+  temperature: z.number().min(0).max(2).optional(),
+  top_p: z.number().min(0).max(1).optional(),
+  maxTokens: z.number().optional(),
+  tools: z.record(z.string(), z.boolean()).optional(),
+  skills: z.array(z.string()).optional(),
+  triggers: z.array(DelegationTriggerSchema).optional(),
+  description: z.string().optional()
+});
+var CustomAgentsConfigSchema = z.record(z.string(), CustomAgentConfigSchema);
+var AnalyticsConfigSchema = z.object({
+  enabled: z.boolean().optional()
+});
 var WeaveConfigSchema = z.object({
   $schema: z.string().optional(),
   agents: AgentOverridesSchema.optional(),
+  custom_agents: CustomAgentsConfigSchema.optional(),
   categories: CategoriesConfigSchema.optional(),
   disabled_hooks: z.array(z.string()).optional(),
   disabled_tools: z.array(z.string()).optional(),
   disabled_agents: z.array(z.string()).optional(),
   disabled_skills: z.array(z.string()).optional(),
   background: BackgroundConfigSchema.optional(),
+  analytics: AnalyticsConfigSchema.optional(),
   tmux: TmuxConfigSchema.optional(),
   experimental: ExperimentalConfigSchema.optional()
 });
@@ -88,6 +118,7 @@ function mergeConfigs(user, project) {
     ...user,
     ...project,
     agents: user.agents || project.agents ? deepMergeObjects(user.agents ?? {}, project.agents ?? {}) : undefined,
+    custom_agents: user.custom_agents || project.custom_agents ? deepMergeObjects(user.custom_agents ?? {}, project.custom_agents ?? {}) : undefined,
     categories: user.categories || project.categories ? deepMergeObjects(user.categories ?? {}, project.categories ?? {}) : undefined,
     disabled_hooks: mergeStringArrays(user.disabled_hooks, project.disabled_hooks),
     disabled_tools: mergeStringArrays(user.disabled_tools, project.disabled_tools),
@@ -173,6 +204,26 @@ var AGENT_DISPLAY_NAMES = {
   warp: "warp",
   weft: "weft"
 };
+var BUILTIN_CONFIG_KEYS = new Set(Object.keys(AGENT_DISPLAY_NAMES));
+var reverseDisplayNames = null;
+function getReverseDisplayNames() {
+  if (reverseDisplayNames === null) {
+    reverseDisplayNames = Object.fromEntries(Object.entries(AGENT_DISPLAY_NAMES).map(([key, displayName]) => [displayName.toLowerCase(), key]));
+  }
+  return reverseDisplayNames;
+}
+function registerAgentDisplayName(configKey, displayName) {
+  if (BUILTIN_CONFIG_KEYS.has(configKey)) {
+    throw new Error(`Cannot register display name for "${configKey}": it is a built-in agent name`);
+  }
+  const reverse = getReverseDisplayNames();
+  const existingKey = reverse[displayName.toLowerCase()];
+  if (existingKey !== undefined && BUILTIN_CONFIG_KEYS.has(existingKey)) {
+    throw new Error(`Display name "${displayName}" is reserved for built-in agent "${existingKey}"`);
+  }
+  AGENT_DISPLAY_NAMES[configKey] = displayName;
+  reverseDisplayNames = null;
+}
 function getAgentDisplayName(configKey) {
   const exactMatch = AGENT_DISPLAY_NAMES[configKey];
   if (exactMatch !== undefined)
@@ -184,7 +235,6 @@ function getAgentDisplayName(configKey) {
   }
   return configKey;
 }
-var REVERSE_DISPLAY_NAMES = Object.fromEntries(Object.entries(AGENT_DISPLAY_NAMES).map(([key, displayName]) => [displayName.toLowerCase(), key]));
 
 // src/features/builtin-commands/templates/start-work.ts
 var START_WORK_TEMPLATE = `You are being activated by the /start-work command to execute a Weave plan.
@@ -467,17 +517,65 @@ class SkillMcpManager {
   }
 }
 
-// src/agents/loom/default.ts
-var LOOM_DEFAULTS = {
-  temperature: 0.1,
-  description: "Loom (Main Orchestrator)",
-  prompt: `<Role>
+// src/agents/dynamic-prompt-builder.ts
+function buildDelegationTable(agents) {
+  const rows = [
+    "### Delegation Table:",
+    ""
+  ];
+  for (const agent of agents) {
+    for (const trigger of agent.metadata.triggers) {
+      rows.push(`- **${trigger.domain}** → \`${agent.name}\` — ${trigger.trigger}`);
+    }
+  }
+  return rows.join(`
+`);
+}
+function buildProjectContextSection(fingerprint) {
+  if (!fingerprint)
+    return "";
+  const parts = [];
+  if (fingerprint.primaryLanguage || fingerprint.packageManager) {
+    const lang = fingerprint.primaryLanguage ?? "unknown";
+    const pm = fingerprint.packageManager;
+    const desc = pm ? `a ${lang} project using ${pm}` : `a ${lang} project`;
+    parts.push(`This is ${desc}.`);
+  }
+  const highConfidence = fingerprint.stack.filter((s) => s.confidence === "high");
+  if (highConfidence.length > 0) {
+    const names = highConfidence.map((s) => s.name).join(", ");
+    parts.push(`Detected stack: ${names}.`);
+  }
+  if (fingerprint.isMonorepo) {
+    parts.push("Monorepo structure detected.");
+  }
+  if (fingerprint.os) {
+    const archSuffix = fingerprint.arch ? ` (${fingerprint.arch})` : "";
+    parts.push(`Platform: ${fingerprint.os}${archSuffix}.`);
+  }
+  if (parts.length === 0)
+    return "";
+  return `<ProjectContext>
+${parts.join(`
+`)}
+</ProjectContext>`;
+}
+
+// src/agents/prompt-utils.ts
+function isAgentEnabled(name, disabled) {
+  return !disabled.has(name);
+}
+
+// src/agents/loom/prompt-composer.ts
+function buildRoleSection() {
+  return `<Role>
 Loom — main orchestrator for Weave.
 Plan tasks, coordinate work, and delegate to specialized agents.
 You are the team lead. Understand the request, break it into tasks, delegate intelligently.
-</Role>
-
-<Discipline>
+</Role>`;
+}
+function buildDisciplineSection() {
+  return `<Discipline>
 TODO OBSESSION (NON-NEGOTIABLE):
 - 2+ steps → todowrite FIRST, atomic breakdown
 - Mark in_progress before starting (ONE at a time)
@@ -485,9 +583,10 @@ TODO OBSESSION (NON-NEGOTIABLE):
 - NEVER batch completions
 
 No todos on multi-step work = INCOMPLETE WORK.
-</Discipline>
-
-<SidebarTodos>
+</Discipline>`;
+}
+function buildSidebarTodosSection() {
+  return `<SidebarTodos>
 The user sees a Todo sidebar (~35 char width). Use todowrite strategically:
 
 WHEN PLANNING (multi-step work):
@@ -510,20 +609,60 @@ FORMAT RULES:
 - in_progress = yellow highlight — use for ACTIVE work only
 - Prefix delegations with agent name
 - After all work done: mark everything completed (sidebar hides)
-</SidebarTodos>
-
-<Delegation>
-- Use thread for fast codebase exploration (read-only, cheap)
-- Use spindle for external docs and research (read-only)
-- Use pattern for detailed planning before complex implementations
-- Use /start-work to hand off to Tapestry for todo-list driven execution of multi-step plans
-- Use shuttle for category-specific specialized work
-- Use Weft for reviewing completed work or validating plans before execution
-  - MUST use Warp for security audits when changes touch auth, crypto, certificates, tokens, signatures, input validation, secrets, passwords, sessions, CORS, CSP, .env files, or OAuth/OIDC/SAML flows — not optional. When in doubt, invoke Warp — false positives (fast APPROVE) are cheap.
-- Delegate aggressively to keep your context lean
-</Delegation>
-
-<DelegationNarration>
+</SidebarTodos>`;
+}
+function buildDelegationSection(disabled) {
+  const lines = [];
+  if (isAgentEnabled("thread", disabled)) {
+    lines.push("- Use thread for fast codebase exploration (read-only, cheap)");
+  }
+  if (isAgentEnabled("spindle", disabled)) {
+    lines.push("- Use spindle for external docs and research (read-only)");
+  }
+  if (isAgentEnabled("pattern", disabled)) {
+    lines.push("- Use pattern for detailed planning before complex implementations");
+  }
+  if (isAgentEnabled("tapestry", disabled)) {
+    lines.push("- Use /start-work to hand off to Tapestry for todo-list driven execution of multi-step plans");
+  }
+  if (isAgentEnabled("shuttle", disabled)) {
+    lines.push("- Use shuttle for category-specific specialized work");
+  }
+  if (isAgentEnabled("weft", disabled)) {
+    let weftLine = "- Use Weft for reviewing completed work or validating plans before execution";
+    if (isAgentEnabled("warp", disabled)) {
+      weftLine += `
+  - MUST use Warp for security audits when changes touch auth, crypto, certificates, tokens, signatures, input validation, secrets, passwords, sessions, CORS, CSP, .env files, or OAuth/OIDC/SAML flows — not optional. When in doubt, invoke Warp — false positives (fast APPROVE) are cheap.`;
+    }
+    lines.push(weftLine);
+  } else if (isAgentEnabled("warp", disabled)) {
+    lines.push("- MUST use Warp for security audits when changes touch auth, crypto, certificates, tokens, signatures, input validation, secrets, passwords, sessions, CORS, CSP, .env files, or OAuth/OIDC/SAML flows — not optional.");
+  }
+  lines.push("- Delegate aggressively to keep your context lean");
+  return `<Delegation>
+${lines.join(`
+`)}
+</Delegation>`;
+}
+function buildDelegationNarrationSection(disabled = new Set) {
+  const hints = [];
+  if (isAgentEnabled("pattern", disabled)) {
+    hints.push('- Pattern (planning): "This may take a moment — Pattern is researching the codebase and writing a detailed plan..."');
+  }
+  if (isAgentEnabled("spindle", disabled)) {
+    hints.push('- Spindle (web research): "Spindle is fetching external docs — this may take a moment..."');
+  }
+  if (isAgentEnabled("weft", disabled) || isAgentEnabled("warp", disabled)) {
+    hints.push('- Weft/Warp (review): "Running review — this will take a moment..."');
+  }
+  if (isAgentEnabled("thread", disabled)) {
+    hints.push("- Thread (exploration): Fast — no duration hint needed.");
+  }
+  const hintsBlock = hints.length > 0 ? `
+DURATION HINTS — tell the user when something takes time:
+${hints.join(`
+`)}` : "";
+  return `<DelegationNarration>
 EVERY delegation MUST follow this pattern — no exceptions:
 
 1. BEFORE delegating: Write a brief message to the user explaining what you're about to do:
@@ -541,49 +680,80 @@ EVERY delegation MUST follow this pattern — no exceptions:
    - "Spindle confirmed the library supports streaming — docs at [url]"
 
 4. Mark the delegation todo as "completed" after summarizing results.
-
-DURATION HINTS — tell the user when something takes time:
-- Pattern (planning): "This may take a moment — Pattern is researching the codebase and writing a detailed plan..."
-- Spindle (web research): "Spindle is fetching external docs — this may take a moment..."
-- Weft/Warp (review): "Running review — this will take a moment..."
-- Thread (exploration): Fast — no duration hint needed.
+${hintsBlock}
 
 The user should NEVER see a blank pause with no explanation. If you're about to call Task, WRITE SOMETHING FIRST.
-</DelegationNarration>
-
-<PlanWorkflow>
-For complex tasks that benefit from structured planning before execution:
-
-1. PLAN: Delegate to Pattern to produce a plan saved to \`.weave/plans/{name}.md\`
+</DelegationNarration>`;
+}
+function buildPlanWorkflowSection(disabled) {
+  const hasWeft = isAgentEnabled("weft", disabled);
+  const hasWarp = isAgentEnabled("warp", disabled);
+  const hasTapestry = isAgentEnabled("tapestry", disabled);
+  const hasPattern = isAgentEnabled("pattern", disabled);
+  const steps = [];
+  if (hasPattern) {
+    steps.push(`1. PLAN: Delegate to Pattern to produce a plan saved to \`.weave/plans/{name}.md\`
    - Pattern researches the codebase, produces a structured plan with \`- [ ]\` checkboxes
-   - Pattern ONLY writes .md files in .weave/ — it never writes code
-2. REVIEW: Delegate to Weft to validate the plan before execution
-   - TRIGGER: Plan touches 3+ files OR has 5+ tasks — Weft review is mandatory
-   - SKIP ONLY IF: User explicitly says "skip review"
-   - Weft reads the plan, verifies file references, checks executability
-   - If Weft rejects, send issues back to Pattern for revision
-   - MANDATORY: If the plan touches security-relevant areas (crypto, auth, certificates, tokens, signatures, or input validation) → also run Warp on the plan
-3. EXECUTE: Tell the user to run \`/start-work\` to begin execution
+   - Pattern ONLY writes .md files in .weave/ — it never writes code`);
+  }
+  if (hasWeft || hasWarp) {
+    const reviewParts = [];
+    if (hasWeft) {
+      reviewParts.push(`   - TRIGGER: Plan touches 3+ files OR has 5+ tasks — Weft review is mandatory`, `   - SKIP ONLY IF: User explicitly says "skip review"`, `   - Weft reads the plan, verifies file references, checks executability`, `   - If Weft rejects, send issues back to Pattern for revision`);
+    }
+    if (hasWarp) {
+      reviewParts.push(`   - MANDATORY: If the plan touches security-relevant areas (crypto, auth, certificates, tokens, signatures, or input validation) → also run Warp on the plan`);
+    }
+    const stepNum = hasPattern ? 2 : 1;
+    const reviewerName = hasWeft ? "Weft" : "Warp";
+    steps.push(`${stepNum}. REVIEW: Delegate to ${reviewerName} to validate the plan before execution
+${reviewParts.join(`
+`)}`);
+  }
+  const execStepNum = steps.length + 1;
+  if (hasTapestry) {
+    steps.push(`${execStepNum}. EXECUTE: Tell the user to run \`/start-work\` to begin execution
    - /start-work loads the plan, creates work state at \`.weave/state.json\`, and switches to Tapestry
-   - Tapestry reads the plan and works through tasks, marking checkboxes as it goes
-4. RESUME: If work was interrupted, \`/start-work\` resumes from the last unchecked task
-
-Note: Tapestry runs Weft and Warp reviews directly after completing all tasks — Loom does not need to gate this.
-
-When to use this workflow vs. direct execution:
+   - Tapestry reads the plan and works through tasks, marking checkboxes as it goes`);
+  }
+  const resumeStepNum = steps.length + 1;
+  steps.push(`${resumeStepNum}. RESUME: If work was interrupted, \`/start-work\` resumes from the last unchecked task`);
+  const notes = [];
+  if (hasTapestry && (hasWeft || hasWarp)) {
+    notes.push(`Note: Tapestry runs Weft and Warp reviews directly after completing all tasks — Loom does not need to gate this.`);
+  }
+  notes.push(`When to use this workflow vs. direct execution:
 - USE plan workflow: Large features, multi-file refactors, anything with 5+ steps or architectural decisions
-- SKIP plan workflow: Quick fixes, single-file changes, simple questions
-</PlanWorkflow>
+- SKIP plan workflow: Quick fixes, single-file changes, simple questions`);
+  return `<PlanWorkflow>
+For complex tasks that benefit from structured planning before execution:
+
+${steps.join(`
+`)}
 
-<ReviewWorkflow>
-Two review modes — different rules for each:
+${notes.join(`
 
+`)}
+</PlanWorkflow>`;
+}
+function buildReviewWorkflowSection(disabled) {
+  const hasWeft = isAgentEnabled("weft", disabled);
+  const hasWarp = isAgentEnabled("warp", disabled);
+  const hasTapestry = isAgentEnabled("tapestry", disabled);
+  if (!hasWeft && !hasWarp)
+    return "";
+  const parts = [];
+  parts.push("Two review modes — different rules for each:");
+  if (hasTapestry) {
+    parts.push(`
 **Post-Plan-Execution Review:**
 - Handled directly by Tapestry — Tapestry invokes Weft and Warp after completing all tasks.
-- Loom does not need to intervene.
-
-**Ad-Hoc Review (non-plan work):**
-- Delegate to Weft to review the changes
+- Loom does not need to intervene.`);
+  }
+  parts.push(`
+**Ad-Hoc Review (non-plan work):**`);
+  if (hasWeft) {
+    parts.push(`- Delegate to Weft to review the changes
 - Weft is read-only and approval-biased — it rejects only for real problems
 - If Weft approves: proceed confidently
 - If Weft rejects: address the specific blocking issues, then re-review
@@ -596,25 +766,83 @@ When to invoke ad-hoc Weft:
 When to skip ad-hoc Weft:
 - Single-file trivial changes
 - User explicitly says "skip review"
-- Simple question-answering (no code changes)
-
+- Simple question-answering (no code changes)`);
+  }
+  if (hasWarp) {
+    parts.push(`
 MANDATORY — If ANY changed file touches crypto, auth, certificates, tokens, signatures, or input validation:
 → MUST run Warp in parallel with Weft. This is NOT optional.
 → Failure to invoke Warp for security-relevant changes is a workflow violation.
 - Warp is read-only and skeptical-biased — it rejects when security is at risk
 - Warp self-triages: if no security-relevant changes, it fast-exits with APPROVE
-- If Warp rejects: address the specific security issues before shipping
-</ReviewWorkflow>
-
-<Style>
+- If Warp rejects: address the specific security issues before shipping`);
+  }
+  return `<ReviewWorkflow>
+${parts.join(`
+`)}
+</ReviewWorkflow>`;
+}
+function buildStyleSection() {
+  return `<Style>
 - Start immediately. No preamble acknowledgments (e.g., "Sure!", "Great question!").
 - Delegation narration is NOT an acknowledgment — always narrate before/after delegating.
 - Dense > verbose.
 - Match user's communication style.
-</Style>`
+</Style>`;
+}
+function buildCustomAgentDelegationSection(customAgents, disabled) {
+  const enabledAgents = customAgents.filter((a) => isAgentEnabled(a.name, disabled));
+  if (enabledAgents.length === 0)
+    return "";
+  const table = buildDelegationTable(enabledAgents);
+  return `<CustomDelegation>
+Custom agents available for delegation:
+
+${table}
+
+Delegate to these agents when their domain matches the task. Use the same delegation pattern as built-in agents.
+</CustomDelegation>`;
+}
+function composeLoomPrompt(options = {}) {
+  const disabled = options.disabledAgents ?? new Set;
+  const fingerprint = options.fingerprint;
+  const customAgents = options.customAgents ?? [];
+  const sections = [
+    buildRoleSection(),
+    buildProjectContextSection(fingerprint),
+    buildDisciplineSection(),
+    buildSidebarTodosSection(),
+    buildDelegationSection(disabled),
+    buildDelegationNarrationSection(disabled),
+    buildCustomAgentDelegationSection(customAgents, disabled),
+    buildPlanWorkflowSection(disabled),
+    buildReviewWorkflowSection(disabled),
+    buildStyleSection()
+  ].filter((s) => s.length > 0);
+  return sections.join(`
+
+`);
+}
+
+// src/agents/loom/default.ts
+var LOOM_DEFAULTS = {
+  temperature: 0.1,
+  description: "Loom (Main Orchestrator)",
+  prompt: composeLoomPrompt()
 };
 
 // src/agents/loom/index.ts
+function createLoomAgentWithOptions(model, disabledAgents, fingerprint, customAgents) {
+  if ((!disabledAgents || disabledAgents.size === 0) && !fingerprint && (!customAgents || customAgents.length === 0)) {
+    return { ...LOOM_DEFAULTS, model, mode: "primary" };
+  }
+  return {
+    ...LOOM_DEFAULTS,
+    prompt: composeLoomPrompt({ disabledAgents, fingerprint, customAgents }),
+    model,
+    mode: "primary"
+  };
+}
 var createLoomAgent = (model) => ({
   ...LOOM_DEFAULTS,
   model,
@@ -622,21 +850,17 @@ var createLoomAgent = (model) => ({
 });
 createLoomAgent.mode = "primary";
 
-// src/agents/tapestry/default.ts
-var TAPESTRY_DEFAULTS = {
-  temperature: 0.1,
-  description: "Tapestry (Execution Orchestrator)",
-  tools: {
-    call_weave_agent: false
-  },
-  prompt: `<Role>
+// src/agents/tapestry/prompt-composer.ts
+function buildTapestryRoleSection() {
+  return `<Role>
 Tapestry — execution orchestrator for Weave.
 You manage todo-list driven execution of multi-step plans.
 Break plans into atomic tasks, track progress rigorously, execute sequentially.
 You do NOT spawn subagents — you execute directly.
-</Role>
-
-<Discipline>
+</Role>`;
+}
+function buildTapestryDisciplineSection() {
+  return `<Discipline>
 TODO OBSESSION (NON-NEGOTIABLE):
 - Load existing todos first — never re-plan if a plan exists
 - Mark in_progress before starting EACH task (ONE at a time)
@@ -644,9 +868,10 @@ TODO OBSESSION (NON-NEGOTIABLE):
 - NEVER skip steps, NEVER batch completions
 
 Execution without todos = lost work.
-</Discipline>
-
-<SidebarTodos>
+</Discipline>`;
+}
+function buildTapestrySidebarTodosSection() {
+  return `<SidebarTodos>
 The user sees a Todo sidebar (~35 char width). Use todowrite to keep it useful:
 
 WHEN STARTING A PLAN:
@@ -674,9 +899,12 @@ FORMAT RULES:
 - Summary todo always present during execution
 - Max 5 visible todos (1 summary + 1 in_progress + 2-3 pending)
 - in_progress = yellow highlight — use for CURRENT task only
-</SidebarTodos>
-
-<PlanExecution>
+</SidebarTodos>`;
+}
+function buildTapestryPlanExecutionSection(disabled = new Set) {
+  const hasWeft = isAgentEnabled("weft", disabled);
+  const verifySuffix = hasWeft ? " If uncertain about quality, note that Loom should invoke Weft for formal review." : "";
+  return `<PlanExecution>
 When activated by /start-work with a plan file:
 
 1. READ the plan file first — understand the full scope
@@ -684,16 +912,17 @@ When activated by /start-work with a plan file:
 3. For each task:
    a. Read the task description, files, and acceptance criteria
    b. Execute the work (write code, run commands, create files)
-   c. Verify: Follow the <Verification> protocol below — ALL checks must pass before marking complete. If uncertain about quality, note that Loom should invoke Weft for formal review.
+   c. Verify: Follow the <Verification> protocol below — ALL checks must pass before marking complete.${verifySuffix}
    d. Mark complete: use Edit tool to change \`- [ ]\` to \`- [x]\` in the plan file
    e. Report: "Completed task N/M: [title]"
 4. CONTINUE to the next unchecked task
 5. When ALL checkboxes are checked, follow the <PostExecutionReview> protocol below before reporting final summary.
 
 NEVER stop mid-plan unless explicitly told to or completely blocked.
-</PlanExecution>
-
-<Verification>
+</PlanExecution>`;
+}
+function buildTapestryVerificationSection() {
+  return `<Verification>
 After completing work for each task — BEFORE marking \`- [ ]\` → \`- [x]\`:
 
 1. **Inspect changes**:
@@ -711,39 +940,100 @@ After completing work for each task — BEFORE marking \`- [ ]\` → \`- [x]\`:
    - Before starting the NEXT task, read the learnings file for context from previous tasks
 
 **Gate**: Only mark complete when ALL checks pass. If ANY check fails, fix first.
-</Verification>
+</Verification>`;
+}
+function buildTapestryPostExecutionReviewSection(disabled) {
+  const hasWeft = isAgentEnabled("weft", disabled);
+  const hasWarp = isAgentEnabled("warp", disabled);
+  if (!hasWeft && !hasWarp) {
+    return `<PostExecutionReview>
+After ALL plan tasks are checked off:
 
-<PostExecutionReview>
+1. Identify all changed files:
+   - If a **Start SHA** was provided in the session context, run \`git diff --name-only <start-sha>..HEAD\` to get the complete list of changed files (this captures all changes including intermediate commits)
+   - If no Start SHA is available (non-git workspace), use the plan's \`**Files**:\` fields as the review scope
+2. Report the summary of all changes to the user.
+</PostExecutionReview>`;
+  }
+  const reviewerLines = [];
+  if (hasWeft) {
+    reviewerLines.push(`   - Weft: subagent_type "weft" — reviews code quality`);
+  }
+  if (hasWarp) {
+    reviewerLines.push(`   - Warp: subagent_type "warp" — audits security (self-triages; fast-exits with APPROVE if no security-relevant changes)`);
+  }
+  const reviewerNames = [hasWeft && "Weft", hasWarp && "Warp"].filter(Boolean).join(" and ");
+  return `<PostExecutionReview>
 After ALL plan tasks are checked off, run this mandatory review gate:
 
 1. Identify all changed files:
    - If a **Start SHA** was provided in the session context, run \`git diff --name-only <start-sha>..HEAD\` to get the complete list of changed files (this captures all changes including intermediate commits)
    - If no Start SHA is available (non-git workspace), use the plan's \`**Files**:\` fields as the review scope
-2. Delegate to Weft (quality review) AND Warp (security audit) in parallel using the Task tool:
-   - Weft: subagent_type "weft" — reviews code quality
-   - Warp: subagent_type "warp" — audits security (self-triages; fast-exits with APPROVE if no security-relevant changes)
+2. Delegate to ${reviewerNames} in parallel using the Task tool:
+${reviewerLines.join(`
+`)}
    - Include the list of changed files in your prompt to each reviewer
 3. Report the review results to the user:
-   - Summarize Weft's and Warp's findings (APPROVE or REJECT with details)
+   - Summarize ${reviewerNames}'s findings (APPROVE or REJECT with details)
    - If either reviewer REJECTS, present the blocking issues to the user for decision — do NOT attempt to fix them yourself
    - Tapestry follows the plan; review findings require user approval before any further changes
-</PostExecutionReview>
-
-<Execution>
+</PostExecutionReview>`;
+}
+function buildTapestryExecutionSection() {
+  return `<Execution>
 - Work through tasks top to bottom
 - Verify each step before marking complete
 - If blocked: document reason, move to next unblocked task
 - Report completion with evidence (test output, file paths, commands run)
-</Execution>
-
-<Style>
+</Execution>`;
+}
+function buildTapestryStyleSection() {
+  return `<Style>
 - Terse status updates only
 - No meta-commentary
 - Dense > verbose
-</Style>`
+</Style>`;
+}
+function composeTapestryPrompt(options = {}) {
+  const disabled = options.disabledAgents ?? new Set;
+  const sections = [
+    buildTapestryRoleSection(),
+    buildTapestryDisciplineSection(),
+    buildTapestrySidebarTodosSection(),
+    buildTapestryPlanExecutionSection(disabled),
+    buildTapestryVerificationSection(),
+    buildTapestryPostExecutionReviewSection(disabled),
+    buildTapestryExecutionSection(),
+    buildTapestryStyleSection()
+  ];
+  return sections.join(`
+
+`);
+}
+
+// src/agents/tapestry/default.ts
+var TAPESTRY_DEFAULTS = {
+  temperature: 0.1,
+  description: "Tapestry (Execution Orchestrator)",
+  tools: {
+    call_weave_agent: false
+  },
+  prompt: composeTapestryPrompt()
 };
 
 // src/agents/tapestry/index.ts
+function createTapestryAgentWithOptions(model, disabledAgents) {
+  if (!disabledAgents || disabledAgents.size === 0) {
+    return { ...TAPESTRY_DEFAULTS, tools: { ...TAPESTRY_DEFAULTS.tools }, model, mode: "primary" };
+  }
+  return {
+    ...TAPESTRY_DEFAULTS,
+    tools: { ...TAPESTRY_DEFAULTS.tools },
+    prompt: composeTapestryPrompt({ disabledAgents }),
+    model,
+    mode: "primary"
+  };
+}
 var createTapestryAgent = (model) => ({
   ...TAPESTRY_DEFAULTS,
   tools: { ...TAPESTRY_DEFAULTS.tools },
@@ -1295,7 +1585,7 @@ var AGENT_MODEL_REQUIREMENTS = {
   }
 };
 function resolveAgentModel(agentName, options) {
-  const { availableModels, agentMode, uiSelectedModel, categoryModel, overrideModel, systemDefaultModel } = options;
+  const { availableModels, agentMode, uiSelectedModel, categoryModel, overrideModel, systemDefaultModel, customFallbackChain } = options;
   const requirement = AGENT_MODEL_REQUIREMENTS[agentName];
   if (overrideModel)
     return overrideModel;
@@ -1304,21 +1594,27 @@ function resolveAgentModel(agentName, options) {
   }
   if (categoryModel && availableModels.has(categoryModel))
     return categoryModel;
-  for (const entry of requirement.fallbackChain) {
-    for (const provider of entry.providers) {
-      const qualified = `${provider}/${entry.model}`;
-      if (availableModels.has(qualified))
-        return qualified;
-      if (availableModels.has(entry.model))
-        return entry.model;
+  const fallbackChain = requirement?.fallbackChain ?? customFallbackChain;
+  if (fallbackChain) {
+    for (const entry of fallbackChain) {
+      for (const provider of entry.providers) {
+        const qualified = `${provider}/${entry.model}`;
+        if (availableModels.has(qualified))
+          return qualified;
+        if (availableModels.has(entry.model))
+          return entry.model;
+      }
     }
   }
   if (systemDefaultModel)
     return systemDefaultModel;
-  const first = requirement.fallbackChain[0];
-  if (first && first.providers.length > 0) {
-    return `${first.providers[0]}/${first.model}`;
+  if (fallbackChain && fallbackChain.length > 0) {
+    const first = fallbackChain[0];
+    if (first.providers.length > 0) {
+      return `${first.providers[0]}/${first.model}`;
+    }
   }
+  console.warn(`[weave] No model resolved for agent "${agentName}" — falling back to default github-copilot/claude-opus-4.6`);
   return "github-copilot/claude-opus-4.6";
 }
 
@@ -1328,6 +1624,41 @@ function isFactory(source) {
 }
 
 // src/agents/agent-builder.ts
+var AGENT_NAME_VARIANTS = {
+  thread: ["thread", "Thread"],
+  spindle: ["spindle", "Spindle"],
+  weft: ["weft", "Weft"],
+  warp: ["warp", "Warp"],
+  pattern: ["pattern", "Pattern"],
+  shuttle: ["shuttle", "Shuttle"],
+  loom: ["loom", "Loom"],
+  tapestry: ["tapestry", "Tapestry"]
+};
+function registerAgentNameVariants(name, variants) {
+  if (AGENT_NAME_VARIANTS[name])
+    return;
+  const titleCase = name.charAt(0).toUpperCase() + name.slice(1);
+  AGENT_NAME_VARIANTS[name] = variants ?? [name, titleCase];
+}
+function stripDisabledAgentReferences(prompt, disabled) {
+  if (disabled.size === 0)
+    return prompt;
+  const disabledVariants = [];
+  for (const name of disabled) {
+    const variants = AGENT_NAME_VARIANTS[name];
+    if (variants) {
+      disabledVariants.push(...variants);
+    }
+  }
+  if (disabledVariants.length === 0)
+    return prompt;
+  const pattern = new RegExp(`\\b(${disabledVariants.map((v) => v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})\\b`);
+  const lines = prompt.split(`
+`);
+  const filtered = lines.filter((line) => !pattern.test(line));
+  return filtered.join(`
+`);
+}
 function buildAgent(source, model, options) {
   const base = isFactory(source) ? source(model) : { ...source };
   if (base.category && options?.categories) {
@@ -1352,6 +1683,9 @@ function buildAgent(source, model, options) {
 ` + base.prompt : "");
     }
   }
+  if (options?.disabledAgents && options.disabledAgents.size > 0 && base.prompt) {
+    base.prompt = stripDisabledAgentReferences(base.prompt, options.disabledAgents);
+  }
   return base;
 }
 
@@ -1366,6 +1700,10 @@ var AGENT_FACTORIES = {
   weft: createWeftAgent,
   warp: createWarpAgent
 };
+var CUSTOM_AGENT_METADATA = {};
+function registerCustomAgentMetadata(name, metadata) {
+  CUSTOM_AGENT_METADATA[name] = metadata;
+}
 function createBuiltinAgents(options = {}) {
   const {
     disabledAgents = [],
@@ -1375,7 +1713,9 @@ function createBuiltinAgents(options = {}) {
     systemDefaultModel,
     availableModels = new Set,
     disabledSkills,
-    resolveSkills
+    resolveSkills,
+    fingerprint,
+    customAgentMetadata
   } = options;
   const disabledSet = new Set(disabledAgents);
   const result = {};
@@ -1391,11 +1731,19 @@ function createBuiltinAgents(options = {}) {
       systemDefaultModel,
       overrideModel
     });
-    const built = buildAgent(factory, resolvedModel, {
-      categories,
-      disabledSkills,
-      resolveSkills
-    });
+    let built;
+    if (name === "loom") {
+      built = createLoomAgentWithOptions(resolvedModel, disabledSet, fingerprint, customAgentMetadata);
+    } else if (name === "tapestry") {
+      built = createTapestryAgentWithOptions(resolvedModel, disabledSet);
+    } else {
+      built = buildAgent(factory, resolvedModel, {
+        categories,
+        disabledSkills,
+        resolveSkills,
+        disabledAgents: disabledSet
+      });
+    }
     if (override) {
       if (override.skills?.length && resolveSkills) {
         const skillContent = resolveSkills(override.skills, disabledSkills);
@@ -1419,14 +1767,152 @@ function createBuiltinAgents(options = {}) {
   return result;
 }
 
+// src/agents/prompt-loader.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { resolve, isAbsolute, normalize } 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) {
+    return null;
+  }
+  if (!existsSync2(resolvedPath)) {
+    return null;
+  }
+  return readFileSync2(resolvedPath, "utf-8").trim();
+}
+
+// src/agents/custom-agent-factory.ts
+var KNOWN_TOOL_NAMES = new Set([
+  "write",
+  "edit",
+  "bash",
+  "glob",
+  "grep",
+  "read",
+  "task",
+  "call_weave_agent",
+  "webfetch",
+  "todowrite",
+  "skill"
+]);
+var AGENT_NAME_PATTERN = /^[a-z][a-z0-9_-]*$/;
+function parseFallbackModels(models) {
+  return models.map((m) => {
+    if (m.includes("/")) {
+      const [provider, model] = m.split("/", 2);
+      return { providers: [provider], model };
+    }
+    return { providers: ["github-copilot"], model: m };
+  });
+}
+function buildCustomAgent(name, config, options = {}) {
+  if (!AGENT_NAME_PATTERN.test(name)) {
+    throw new Error(`Invalid custom agent name "${name}": must be lowercase alphanumeric, starting with a letter, using only hyphens and underscores`);
+  }
+  const { resolveSkills, disabledSkills, availableModels = new Set, systemDefaultModel, uiSelectedModel, configDir } = options;
+  let prompt = config.prompt ?? "";
+  if (config.prompt_file) {
+    const fileContent = loadPromptFile(config.prompt_file, configDir);
+    if (fileContent) {
+      prompt = fileContent;
+    }
+  }
+  if (config.skills?.length && resolveSkills) {
+    const skillContent = resolveSkills(config.skills, disabledSkills);
+    if (skillContent) {
+      prompt = skillContent + (prompt ? `
+
+` + prompt : "");
+    }
+  }
+  const mode = config.mode ?? "subagent";
+  const customFallbackChain = config.fallback_models?.length ? parseFallbackModels(config.fallback_models) : undefined;
+  const model = resolveAgentModel(name, {
+    availableModels,
+    agentMode: mode,
+    overrideModel: config.model,
+    systemDefaultModel,
+    uiSelectedModel,
+    customFallbackChain
+  });
+  const displayName = config.display_name ?? name;
+  registerAgentDisplayName(name, displayName);
+  registerAgentNameVariants(name, displayName !== name ? [name, displayName] : undefined);
+  const agentConfig = {
+    model,
+    prompt: prompt || undefined,
+    description: config.description ?? displayName,
+    mode
+  };
+  if (config.temperature !== undefined)
+    agentConfig.temperature = config.temperature;
+  if (config.top_p !== undefined)
+    agentConfig.top_p = config.top_p;
+  if (config.maxTokens !== undefined)
+    agentConfig.maxTokens = config.maxTokens;
+  if (config.tools) {
+    const unknownTools = Object.keys(config.tools).filter((t) => !KNOWN_TOOL_NAMES.has(t));
+    if (unknownTools.length > 0) {
+      throw new Error(`Custom agent "${name}" specifies unknown tool(s): ${unknownTools.join(", ")}. ` + `Known tools: ${[...KNOWN_TOOL_NAMES].join(", ")}`);
+    }
+    agentConfig.tools = config.tools;
+  }
+  return agentConfig;
+}
+function buildCustomAgentMetadata(name, config) {
+  return {
+    category: config.category ?? "utility",
+    cost: config.cost ?? "CHEAP",
+    triggers: config.triggers ?? [
+      { domain: "Custom", trigger: `Tasks delegated to ${config.display_name ?? name}` }
+    ]
+  };
+}
+
 // src/create-managers.ts
 function createManagers(options) {
-  const { pluginConfig, resolveSkills } = options;
+  const { pluginConfig, resolveSkills, fingerprint, configDir } = options;
+  const customAgentMetadata = [];
+  if (pluginConfig.custom_agents) {
+    const disabledSet = new Set(pluginConfig.disabled_agents ?? []);
+    for (const [name, customConfig] of Object.entries(pluginConfig.custom_agents)) {
+      if (disabledSet.has(name))
+        continue;
+      const metadata = buildCustomAgentMetadata(name, customConfig);
+      customAgentMetadata.push({
+        name,
+        description: customConfig.description ?? customConfig.display_name ?? name,
+        metadata
+      });
+    }
+  }
   const agents = createBuiltinAgents({
     disabledAgents: pluginConfig.disabled_agents,
     agentOverrides: pluginConfig.agents,
-    resolveSkills
+    resolveSkills,
+    fingerprint,
+    customAgentMetadata
   });
+  if (pluginConfig.custom_agents) {
+    const disabledSet = new Set(pluginConfig.disabled_agents ?? []);
+    for (const [name, customConfig] of Object.entries(pluginConfig.custom_agents)) {
+      if (disabledSet.has(name))
+        continue;
+      if (agents[name] !== undefined)
+        continue;
+      agents[name] = buildCustomAgent(name, customConfig, {
+        resolveSkills,
+        disabledSkills: pluginConfig.disabled_skills ? new Set(pluginConfig.disabled_skills) : undefined,
+        configDir
+      });
+      const metadata = buildCustomAgentMetadata(name, customConfig);
+      registerCustomAgentMetadata(name, metadata);
+    }
+  }
   const configHandler = new ConfigHandler({ pluginConfig });
   const backgroundManager = new BackgroundManager({
     maxConcurrent: pluginConfig.background?.defaultConcurrency ?? 5
@@ -1873,7 +2359,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 existsSync5, readFileSync as readFileSync4, writeFileSync, unlinkSync, mkdirSync, readdirSync as readdirSync2, statSync } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync, unlinkSync, mkdirSync, readdirSync as readdirSync2, statSync } from "fs";
 import { join as join6, basename } from "path";
 import { execSync } from "child_process";
 var UNCHECKED_RE = /^[-*]\s*\[\s*\]/gm;
@@ -1881,9 +2367,9 @@ var CHECKED_RE = /^[-*]\s*\[[xX]\]/gm;
 function readWorkState(directory) {
   const filePath = join6(directory, WEAVE_DIR, WORK_STATE_FILE);
   try {
-    if (!existsSync5(filePath))
+    if (!existsSync6(filePath))
       return null;
-    const raw = readFileSync4(filePath, "utf-8");
+    const raw = readFileSync5(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
       return null;
@@ -1900,7 +2386,7 @@ function readWorkState(directory) {
 function writeWorkState(directory, state) {
   try {
     const dir = join6(directory, WEAVE_DIR);
-    if (!existsSync5(dir)) {
+    if (!existsSync6(dir)) {
       mkdirSync(dir, { recursive: true });
     }
     writeFileSync(join6(dir, WORK_STATE_FILE), JSON.stringify(state, null, 2), "utf-8");
@@ -1912,7 +2398,7 @@ function writeWorkState(directory, state) {
 function clearWorkState(directory) {
   const filePath = join6(directory, WEAVE_DIR, WORK_STATE_FILE);
   try {
-    if (existsSync5(filePath)) {
+    if (existsSync6(filePath)) {
       unlinkSync(filePath);
     }
     return true;
@@ -1956,7 +2442,7 @@ function getHeadSha(directory) {
 function findPlans(directory) {
   const plansDir = join6(directory, PLANS_DIR);
   try {
-    if (!existsSync5(plansDir))
+    if (!existsSync6(plansDir))
       return [];
     const files = readdirSync2(plansDir).filter((f) => f.endsWith(".md")).map((f) => {
       const fullPath = join6(plansDir, f);
@@ -1969,11 +2455,11 @@ function findPlans(directory) {
   }
 }
 function getPlanProgress(planPath) {
-  if (!existsSync5(planPath)) {
+  if (!existsSync6(planPath)) {
     return { total: 0, completed: 0, isComplete: true };
   }
   try {
-    const content = readFileSync4(planPath, "utf-8");
+    const content = readFileSync5(planPath, "utf-8");
     const unchecked = content.match(UNCHECKED_RE) || [];
     const checked = content.match(CHECKED_RE) || [];
     const total = unchecked.length + checked.length;
@@ -1990,14 +2476,28 @@ function getPlanProgress(planPath) {
 function getPlanName(planPath) {
   return basename(planPath, ".md");
 }
+function pauseWork(directory) {
+  const state = readWorkState(directory);
+  if (!state)
+    return false;
+  state.paused = true;
+  return writeWorkState(directory, state);
+}
+function resumeWork(directory) {
+  const state = readWorkState(directory);
+  if (!state)
+    return false;
+  state.paused = false;
+  return writeWorkState(directory, state);
+}
 // src/features/work-state/validation.ts
-import { readFileSync as readFileSync5, existsSync as existsSync6 } from "fs";
-import { resolve as resolve2, sep } from "path";
+import { readFileSync as readFileSync6, existsSync as existsSync7 } from "fs";
+import { resolve as resolve3, sep } from "path";
 function validatePlan(planPath, projectDir) {
   const errors = [];
   const warnings = [];
-  const resolvedPlanPath = resolve2(planPath);
-  const allowedDir = resolve2(projectDir, PLANS_DIR);
+  const resolvedPlanPath = resolve3(planPath);
+  const allowedDir = resolve3(projectDir, PLANS_DIR);
   if (!resolvedPlanPath.startsWith(allowedDir + sep) && resolvedPlanPath !== allowedDir) {
     errors.push({
       severity: "error",
@@ -2006,7 +2506,7 @@ function validatePlan(planPath, projectDir) {
     });
     return { valid: false, errors, warnings };
   }
-  if (!existsSync6(resolvedPlanPath)) {
+  if (!existsSync7(resolvedPlanPath)) {
     errors.push({
       severity: "error",
       category: "structure",
@@ -2014,7 +2514,7 @@ function validatePlan(planPath, projectDir) {
     });
     return { valid: false, errors, warnings };
   }
-  const content = readFileSync5(resolvedPlanPath, "utf-8");
+  const content = readFileSync6(resolvedPlanPath, "utf-8");
   validateStructure(content, errors, warnings);
   validateCheckboxes(content, errors, warnings);
   validateFileReferences(content, projectDir, warnings);
@@ -2176,8 +2676,8 @@ function validateFileReferences(content, projectDir, warnings) {
         });
         continue;
       }
-      const resolvedProject = resolve2(projectDir);
-      const absolutePath = resolve2(projectDir, filePath);
+      const resolvedProject = resolve3(projectDir);
+      const absolutePath = resolve3(projectDir, filePath);
       if (!absolutePath.startsWith(resolvedProject + sep) && absolutePath !== resolvedProject) {
         warnings.push({
           severity: "warning",
@@ -2186,7 +2686,7 @@ function validateFileReferences(content, projectDir, warnings) {
         });
         continue;
       }
-      if (!existsSync6(absolutePath)) {
+      if (!existsSync7(absolutePath)) {
         warnings.push({
           severity: "warning",
           category: "file-references",
@@ -2299,6 +2799,7 @@ 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 {
@@ -2505,19 +3006,45 @@ Keep each todo under 35 chars. ${remaining} task${remaining !== 1 ? "s" : ""} re
 }
 
 // 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 };
   }
+  if (state.paused) {
+    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: `You have an active work plan with incomplete tasks. Continue working.
+    continuationPrompt: `${CONTINUATION_MARKER}
+You have an active work plan with incomplete tasks. Continue working.
 
 **Plan**: ${state.plan_name}
 **File**: ${state.active_plan}
@@ -2559,7 +3086,7 @@ Only mark complete when ALL checks pass.`
 
 // src/hooks/create-hooks.ts
 function createHooks(args) {
-  const { pluginConfig, isHookEnabled, directory } = args;
+  const { pluginConfig, isHookEnabled, directory, analyticsEnabled = false } = args;
   const writeGuardState = createWriteGuardState();
   const writeGuard = createWriteGuard(writeGuardState);
   const contextWindowThresholds = {
@@ -2576,7 +3103,8 @@ function createHooks(args) {
     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
+    verificationReminder: isHookEnabled("verification-reminder") ? buildVerificationReminder : null,
+    analyticsEnabled
   };
 }
 // src/hooks/session-token-state.ts
@@ -2605,8 +3133,7 @@ function clearSession2(sessionId) {
 }
 // src/plugin/plugin-interface.ts
 function createPluginInterface(args) {
-  const { pluginConfig, hooks, tools, configHandler, agents, client } = args;
-  let pendingInterrupt = false;
+  const { pluginConfig, hooks, tools, configHandler, agents, client, directory = "", tracker } = args;
   return {
     tool: tools,
     config: async (config) => {
@@ -2660,6 +3187,20 @@ ${result.contextInjection}`;
           }
         }
       }
+      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 state = readWorkState(directory);
+          if (state && !state.paused) {
+            pauseWork(directory);
+            log("[work-continuation] Auto-paused: user message received during active plan", { sessionId: sessionID });
+          }
+        }
+      }
     },
     "chat.params": async (_input, _output) => {
       const input = _input;
@@ -2686,6 +3227,13 @@ ${result.contextInjection}`;
       if (event.type === "session.deleted") {
         const evt = event;
         clearSession2(evt.properties.info.id);
+        if (tracker && hooks.analyticsEnabled) {
+          try {
+            tracker.endSession(evt.properties.info.id);
+          } catch (err) {
+            log("[analytics] Failed to end session (non-fatal)", { error: String(err) });
+          }
+        }
       }
       if (event.type === "message.updated" && hooks.checkContextWindow) {
         const evt = event;
@@ -2715,41 +3263,36 @@ ${result.contextInjection}`;
       if (event.type === "tui.command.execute") {
         const evt = event;
         if (evt.properties?.command === "session.interrupt") {
-          pendingInterrupt = true;
-          log("[work-continuation] User interrupt detected — will suppress next continuation");
+          pauseWork(directory);
+          log("[work-continuation] User interrupt detected — work paused");
         }
       }
       if (hooks.workContinuation && event.type === "session.idle") {
-        if (pendingInterrupt) {
-          pendingInterrupt = false;
-          log("[work-continuation] Skipping continuation — session was interrupted by user");
-        } else {
-          const evt = event;
-          const sessionId = evt.properties?.sessionID ?? "";
-          if (sessionId) {
-            const result = hooks.workContinuation(sessionId);
-            if (result.continuationPrompt && client) {
-              try {
-                await client.session.promptAsync({
-                  path: { id: sessionId },
-                  body: {
-                    parts: [{ type: "text", text: result.continuationPrompt }]
-                  }
-                });
-                log("[work-continuation] Injected continuation prompt", { sessionId });
-              } catch (err) {
-                log("[work-continuation] Failed to inject continuation", { sessionId, error: String(err) });
-              }
-            } else if (result.continuationPrompt) {
-              log("[work-continuation] continuationPrompt available but no client", { sessionId });
+        const evt = event;
+        const sessionId = evt.properties?.sessionID ?? "";
+        if (sessionId) {
+          const result = hooks.workContinuation(sessionId);
+          if (result.continuationPrompt && client) {
+            try {
+              await client.session.promptAsync({
+                path: { id: sessionId },
+                body: {
+                  parts: [{ type: "text", text: result.continuationPrompt }]
+                }
+              });
+              log("[work-continuation] Injected continuation prompt", { sessionId });
+            } catch (err) {
+              log("[work-continuation] Failed to inject continuation", { sessionId, error: String(err) });
             }
+          } else if (result.continuationPrompt) {
+            log("[work-continuation] continuationPrompt available but no client", { sessionId });
           }
         }
       }
     },
     "tool.execute.before": async (input, _output) => {
-      const args2 = _output.args;
-      const filePath = args2?.file_path ?? args2?.path ?? "";
+      const toolArgs = _output.args;
+      const filePath = toolArgs?.file_path ?? toolArgs?.path ?? "";
       if (filePath && hooks.shouldInjectRules && hooks.getRulesForFile) {
         if (hooks.shouldInjectRules(input.tool)) {
           hooks.getRulesForFile(filePath);
@@ -2769,8 +3312,8 @@ ${result.contextInjection}`;
           }
         }
       }
-      if (input.tool === "task" && args2) {
-        const agentArg = args2.subagent_type ?? args2.description ?? "unknown";
+      if (input.tool === "task" && toolArgs) {
+        const agentArg = toolArgs.subagent_type ?? toolArgs.description ?? "unknown";
         logDelegation({
           phase: "start",
           agent: agentArg,
@@ -2778,6 +3321,10 @@ ${result.contextInjection}`;
           toolCallId: input.callID
         });
       }
+      if (tracker && hooks.analyticsEnabled) {
+        const agentArg = input.tool === "task" && toolArgs ? toolArgs.subagent_type ?? toolArgs.description ?? "unknown" : undefined;
+        tracker.trackToolStart(input.sessionID, input.tool, input.callID, agentArg);
+      }
     },
     "tool.execute.after": async (input, _output) => {
       if (input.tool === "task") {
@@ -2790,25 +3337,417 @@ ${result.contextInjection}`;
           toolCallId: input.callID
         });
       }
+      if (tracker && hooks.analyticsEnabled) {
+        const inputArgs = input.args;
+        const agentArg = input.tool === "task" && inputArgs ? inputArgs.subagent_type ?? inputArgs.description ?? "unknown" : undefined;
+        tracker.trackToolEnd(input.sessionID, input.tool, input.callID, agentArg);
+      }
     }
   };
 }
 
+// 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 readFileSync8, readdirSync as readdirSync3 } from "fs";
+import { join as join8 } from "path";
+import { arch } from "os";
+var STACK_MARKERS = [
+  {
+    name: "typescript",
+    files: ["tsconfig.json", "tsconfig.build.json"],
+    confidence: "high",
+    evidence: (f) => `${f} exists`
+  },
+  {
+    name: "bun",
+    files: ["bun.lockb", "bunfig.toml"],
+    confidence: "high",
+    evidence: (f) => `${f} exists`
+  },
+  {
+    name: "node",
+    files: ["package.json"],
+    confidence: "high",
+    evidence: (f) => `${f} exists`
+  },
+  {
+    name: "npm",
+    files: ["package-lock.json"],
+    confidence: "high",
+    evidence: (f) => `${f} exists`
+  },
+  {
+    name: "yarn",
+    files: ["yarn.lock"],
+    confidence: "high",
+    evidence: (f) => `${f} exists`
+  },
+  {
+    name: "pnpm",
+    files: ["pnpm-lock.yaml"],
+    confidence: "high",
+    evidence: (f) => `${f} exists`
+  },
+  {
+    name: "react",
+    files: [],
+    confidence: "medium",
+    evidence: () => "react in package.json dependencies"
+  },
+  {
+    name: "next",
+    files: ["next.config.js", "next.config.ts", "next.config.mjs"],
+    confidence: "high",
+    evidence: (f) => `${f} exists`
+  },
+  {
+    name: "python",
+    files: ["pyproject.toml", "setup.py", "requirements.txt", "Pipfile"],
+    confidence: "high",
+    evidence: (f) => `${f} exists`
+  },
+  {
+    name: "go",
+    files: ["go.mod"],
+    confidence: "high",
+    evidence: (f) => `${f} exists`
+  },
+  {
+    name: "rust",
+    files: ["Cargo.toml"],
+    confidence: "high",
+    evidence: (f) => `${f} exists`
+  },
+  {
+    name: "dotnet",
+    files: ["global.json", "Directory.Build.props", "Directory.Packages.props"],
+    confidence: "high",
+    evidence: (f) => `${f} exists`
+  },
+  {
+    name: "docker",
+    files: ["Dockerfile", "docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"],
+    confidence: "high",
+    evidence: (f) => `${f} exists`
+  }
+];
+var MONOREPO_MARKERS = [
+  "lerna.json",
+  "nx.json",
+  "turbo.json",
+  "pnpm-workspace.yaml",
+  "rush.json"
+];
+function detectStack(directory) {
+  const detected = [];
+  for (const marker of STACK_MARKERS) {
+    for (const file of marker.files) {
+      if (existsSync9(join8(directory, file))) {
+        detected.push({
+          name: marker.name,
+          confidence: marker.confidence,
+          evidence: marker.evidence(file)
+        });
+        break;
+      }
+    }
+  }
+  try {
+    const pkgPath = join8(directory, "package.json");
+    if (existsSync9(pkgPath)) {
+      const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (deps.react) {
+        detected.push({
+          name: "react",
+          confidence: "medium",
+          evidence: "react in package.json dependencies"
+        });
+      }
+    }
+  } catch {}
+  if (!detected.some((d) => d.name === "dotnet")) {
+    try {
+      const entries = readdirSync3(directory);
+      const dotnetFile = entries.find((e) => e.endsWith(".csproj") || e.endsWith(".fsproj") || e.endsWith(".sln"));
+      if (dotnetFile) {
+        detected.push({
+          name: "dotnet",
+          confidence: "high",
+          evidence: `${dotnetFile} found`
+        });
+      }
+    } catch {}
+  }
+  const seen = new Set;
+  return detected.filter((entry) => {
+    if (seen.has(entry.name))
+      return false;
+    seen.add(entry.name);
+    return true;
+  });
+}
+function detectPackageManager(directory) {
+  if (existsSync9(join8(directory, "bun.lockb")))
+    return "bun";
+  if (existsSync9(join8(directory, "pnpm-lock.yaml")))
+    return "pnpm";
+  if (existsSync9(join8(directory, "yarn.lock")))
+    return "yarn";
+  if (existsSync9(join8(directory, "package-lock.json")))
+    return "npm";
+  if (existsSync9(join8(directory, "package.json")))
+    return "npm";
+  return;
+}
+function detectMonorepo(directory) {
+  for (const marker of MONOREPO_MARKERS) {
+    if (existsSync9(join8(directory, marker)))
+      return true;
+  }
+  try {
+    const pkgPath = join8(directory, "package.json");
+    if (existsSync9(pkgPath)) {
+      const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+      if (pkg.workspaces)
+        return true;
+    }
+  } catch {}
+  return false;
+}
+function detectPrimaryLanguage(stack) {
+  const languages = ["typescript", "python", "go", "rust", "dotnet"];
+  for (const lang of languages) {
+    if (stack.some((s) => s.name === lang))
+      return lang;
+  }
+  if (stack.some((s) => s.name === "node"))
+    return "javascript";
+  return;
+}
+function generateFingerprint(directory) {
+  const stack = detectStack(directory);
+  return {
+    generatedAt: new Date().toISOString(),
+    stack,
+    isMonorepo: detectMonorepo(directory),
+    packageManager: detectPackageManager(directory),
+    primaryLanguage: detectPrimaryLanguage(stack),
+    os: process.platform,
+    arch: arch()
+  };
+}
+function fingerprintProject(directory) {
+  try {
+    const fingerprint = generateFingerprint(directory);
+    writeFingerprint(directory, fingerprint);
+    log("[analytics] Project fingerprinted", {
+      stack: fingerprint.stack.map((s) => s.name),
+      primaryLanguage: fingerprint.primaryLanguage,
+      packageManager: fingerprint.packageManager
+    });
+    return fingerprint;
+  } catch (err) {
+    log("[analytics] Fingerprinting failed (non-fatal)", { error: String(err) });
+    return null;
+  }
+}
+function getOrCreateFingerprint(directory) {
+  try {
+    const existing = readFingerprint(directory);
+    if (existing)
+      return existing;
+    return fingerprintProject(directory);
+  } catch (err) {
+    log("[analytics] getOrCreateFingerprint failed (non-fatal)", { error: String(err) });
+    return null;
+  }
+}
+// src/features/analytics/session-tracker.ts
+class SessionTracker {
+  sessions = new Map;
+  directory;
+  constructor(directory) {
+    this.directory = directory;
+  }
+  startSession(sessionId) {
+    const existing = this.sessions.get(sessionId);
+    if (existing)
+      return existing;
+    const session = {
+      sessionId,
+      startedAt: new Date().toISOString(),
+      toolCounts: {},
+      delegations: [],
+      inFlight: {}
+    };
+    this.sessions.set(sessionId, session);
+    return session;
+  }
+  trackToolStart(sessionId, toolName, callId, agent) {
+    const session = this.startSession(sessionId);
+    session.toolCounts[toolName] = (session.toolCounts[toolName] ?? 0) + 1;
+    const inFlight = {
+      tool: toolName,
+      startedAt: Date.now()
+    };
+    if (agent) {
+      inFlight.agent = agent;
+    }
+    session.inFlight[callId] = inFlight;
+  }
+  trackToolEnd(sessionId, toolName, callId, agent) {
+    const session = this.sessions.get(sessionId);
+    if (!session)
+      return;
+    const inFlight = session.inFlight[callId];
+    delete session.inFlight[callId];
+    if (toolName === "task") {
+      const delegation = {
+        agent: agent ?? inFlight?.agent ?? "unknown",
+        toolCallId: callId
+      };
+      if (inFlight) {
+        delegation.durationMs = Date.now() - inFlight.startedAt;
+      }
+      session.delegations.push(delegation);
+    }
+  }
+  endSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session)
+      return null;
+    const now = new Date;
+    const startedAt = new Date(session.startedAt);
+    const durationMs = now.getTime() - startedAt.getTime();
+    const toolUsage = Object.entries(session.toolCounts).map(([tool, count]) => ({ tool, count }));
+    const totalToolCalls = toolUsage.reduce((sum, entry) => sum + entry.count, 0);
+    const summary = {
+      sessionId,
+      startedAt: session.startedAt,
+      endedAt: now.toISOString(),
+      durationMs,
+      toolUsage,
+      delegations: session.delegations,
+      totalToolCalls,
+      totalDelegations: session.delegations.length
+    };
+    try {
+      appendSessionSummary(this.directory, summary);
+      log("[analytics] Session summary persisted", {
+        sessionId,
+        totalToolCalls,
+        totalDelegations: session.delegations.length
+      });
+    } catch (err) {
+      log("[analytics] Failed to persist session summary (non-fatal)", {
+        sessionId,
+        error: String(err)
+      });
+    }
+    this.sessions.delete(sessionId);
+    return summary;
+  }
+  isTracking(sessionId) {
+    return this.sessions.has(sessionId);
+  }
+  getSession(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+  get activeSessionCount() {
+    return this.sessions.size;
+  }
+}
+function createSessionTracker(directory) {
+  return new SessionTracker(directory);
+}
+// src/features/analytics/index.ts
+function createAnalytics(directory, fingerprint) {
+  const tracker = createSessionTracker(directory);
+  const resolvedFingerprint = fingerprint ?? getOrCreateFingerprint(directory);
+  return { tracker, fingerprint: resolvedFingerprint };
+}
+
 // src/index.ts
 var WeavePlugin = async (ctx) => {
   const pluginConfig = loadWeaveConfig(ctx.directory, 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 = join9(ctx.directory, ".opencode");
   const toolsResult = await createTools({ ctx, pluginConfig });
-  const managers = createManagers({ ctx, pluginConfig, resolveSkills: toolsResult.resolveSkillsFn });
-  const hooks = createHooks({ pluginConfig, isHookEnabled, directory: ctx.directory });
+  const managers = createManagers({ ctx, pluginConfig, resolveSkills: toolsResult.resolveSkillsFn, fingerprint, configDir });
+  const hooks = createHooks({ pluginConfig, isHookEnabled, directory: ctx.directory, analyticsEnabled });
+  const analytics = analyticsEnabled ? createAnalytics(ctx.directory, fingerprint) : null;
   return createPluginInterface({
     pluginConfig,
     hooks,
     tools: toolsResult.tools,
     configHandler: managers.configHandler,
     agents: managers.agents,
-    client: ctx.client
+    client: ctx.client,
+    directory: ctx.directory,
+    tracker: analytics?.tracker
   });
 };
 var src_default = WeavePlugin;