@opencode_weave/weave 0.5.2 → 0.6.1

package/dist/config/loader.d.ts

@@ -1,2 +1,2 @@
 import { type WeaveConfig } from "./schema";
-export declare function loadWeaveConfig(directory: string, _ctx?: unknown): WeaveConfig;
+export declare function loadWeaveConfig(directory: string, _ctx?: unknown, _homeDir?: string): WeaveConfig;

package/dist/config/schema.d.ts

@@ -78,10 +78,6 @@ export declare const TmuxConfigSchema: z.ZodObject<{
     }>>;
     main_pane_size: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
-export declare const SkillsConfigSchema: z.ZodObject<{
-    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    recursive: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
 export declare const ExperimentalConfigSchema: z.ZodObject<{
     plugin_load_timeout_ms: z.ZodOptional<z.ZodNumber>;
     context_window_warning_threshold: z.ZodOptional<z.ZodNumber>;
@@ -141,10 +137,6 @@ export declare const WeaveConfigSchema: z.ZodObject<{
         }>>;
         main_pane_size: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    skills: z.ZodOptional<z.ZodObject<{
-        paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        recursive: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
     experimental: z.ZodOptional<z.ZodObject<{
         plugin_load_timeout_ms: z.ZodOptional<z.ZodNumber>;
         context_window_warning_threshold: z.ZodOptional<z.ZodNumber>;
@@ -157,6 +149,5 @@ export type CategoryConfig = z.infer<typeof CategoryConfigSchema>;
 export type CategoriesConfig = z.infer<typeof CategoriesConfigSchema>;
 export type BackgroundConfig = z.infer<typeof BackgroundConfigSchema>;
 export type TmuxConfig = z.infer<typeof TmuxConfigSchema>;
-export type SkillsConfig = z.infer<typeof SkillsConfigSchema>;
 export type ExperimentalConfig = z.infer<typeof ExperimentalConfigSchema>;
 export type WeaveConfig = z.infer<typeof WeaveConfigSchema>;

package/dist/features/skill-loader/index.d.ts

@@ -1,7 +1,6 @@
 export { loadSkills } from "./loader";
 export type { LoadSkillsOptions } from "./loader";
 export { createResolveSkillsFn, createSkillResolver, resolveMultipleSkills, resolveSkill } from "./resolver";
+export { fetchSkillsFromOpenCode } from "./opencode-client";
 export { scanDirectory, parseFrontmatter } from "./discovery";
-export { mergeSkills } from "./merger";
-export { createBuiltinSkills } from "./builtin-skills";
 export type { SkillScope, SkillMetadata, LoadedSkill, SkillDiscoveryResult } from "./types";

package/dist/features/skill-loader/loader.d.ts

@@ -1,6 +1,7 @@
 import type { SkillDiscoveryResult } from './types';
 export interface LoadSkillsOptions {
+    serverUrl: string | URL;
     directory?: string;
     disabledSkills?: string[];
 }
-export declare function loadSkills(options?: LoadSkillsOptions): SkillDiscoveryResult;
+export declare function loadSkills(options: LoadSkillsOptions): Promise<SkillDiscoveryResult>;

package/dist/features/skill-loader/opencode-client.d.ts

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

package/dist/features/skill-loader/types.d.ts

@@ -4,19 +4,12 @@ export interface SkillMetadata {
     description?: string;
     model?: string;
     tools?: string | string[];
-    mcp?: {
-        name: string;
-        type: "stdio" | "http";
-        command?: string;
-        args?: string[];
-        url?: string;
-    };
 }
 export interface LoadedSkill {
     name: string;
     description: string;
     content: string;
-    scope: SkillScope;
+    scope?: SkillScope;
     path?: string;
     model?: string;
 }

package/dist/features/work-state/index.d.ts

@@ -1,5 +1,5 @@
 export type { WorkState, PlanProgress } from "./types";
 export type { ValidationResult, ValidationIssue, ValidationSeverity, ValidationCategory } from "./validation-types";
 export { WEAVE_DIR, WORK_STATE_FILE, WORK_STATE_PATH, PLANS_DIR } from "./constants";
-export { readWorkState, writeWorkState, clearWorkState, appendSessionId, createWorkState, findPlans, getPlanProgress, getPlanName, } from "./storage";
+export { readWorkState, writeWorkState, clearWorkState, appendSessionId, createWorkState, findPlans, getPlanProgress, getPlanName, getHeadSha, } from "./storage";
 export { validatePlan } from "./validation";

package/dist/features/work-state/storage.d.ts

@@ -21,7 +21,12 @@ export declare function appendSessionId(directory: string, sessionId: string): W
 /**
  * Create a fresh WorkState for a plan file.
  */
-export declare function createWorkState(planPath: string, sessionId: string, agent?: string): WorkState;
+export declare function createWorkState(planPath: string, sessionId: string, agent?: string, directory?: string): WorkState;
+/**
+ * Get the current HEAD SHA of the git repo at the given directory.
+ * Returns undefined if not a git repo or git is unavailable.
+ */
+export declare function getHeadSha(directory: string): string | undefined;
 /**
  * Find all plan files in .weave/plans/, sorted by modification time (newest first).
  * Returns absolute paths.

package/dist/features/work-state/types.d.ts

@@ -13,6 +13,8 @@ export interface WorkState {
     plan_name: string;
     /** Agent type to use when resuming (e.g., "tapestry") */
     agent?: string;
+    /** Git HEAD SHA at the time work started (absent if not a git repo) */
+    start_sha?: string;
 }
 /**
  * Progress snapshot from counting checkboxes in a plan file.

package/dist/index.js

@@ -46,10 +46,6 @@ var TmuxConfigSchema = z.object({
   layout: z.enum(["main-horizontal", "main-vertical", "tiled", "even-horizontal", "even-vertical"]).optional(),
   main_pane_size: z.number().optional()
 });
-var SkillsConfigSchema = z.object({
-  paths: z.array(z.string()).optional(),
-  recursive: z.boolean().optional()
-});
 var ExperimentalConfigSchema = z.object({
   plugin_load_timeout_ms: z.number().min(1000).optional(),
   context_window_warning_threshold: z.number().min(0).max(1).optional(),
@@ -65,7 +61,6 @@ var WeaveConfigSchema = z.object({
   disabled_skills: z.array(z.string()).optional(),
   background: BackgroundConfigSchema.optional(),
   tmux: TmuxConfigSchema.optional(),
-  skills: SkillsConfigSchema.optional(),
   experimental: ExperimentalConfigSchema.optional()
 });
 
@@ -100,7 +95,6 @@ function mergeConfigs(user, project) {
     disabled_skills: mergeStringArrays(user.disabled_skills, project.disabled_skills),
     background: project.background ?? user.background,
     tmux: project.tmux ?? user.tmux,
-    skills: project.skills ?? user.skills,
     experimental: user.experimental || project.experimental ? { ...user.experimental, ...project.experimental } : undefined
   };
 }
@@ -152,8 +146,8 @@ function detectConfigFile(basePath) {
     return jsonPath;
   return null;
 }
-function loadWeaveConfig(directory, _ctx) {
-  const userBasePath = join2(homedir(), ".config", "opencode", "weave-opencode");
+function loadWeaveConfig(directory, _ctx, _homeDir) {
+  const userBasePath = join2(_homeDir ?? homedir(), ".config", "opencode", "weave-opencode");
   const projectBasePath = join2(directory, ".opencode", "weave-opencode");
   const userConfigPath = detectConfigFile(userBasePath);
   const projectConfigPath = detectConfigFile(projectBasePath);
@@ -573,15 +567,8 @@ For complex tasks that benefit from structured planning before 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
-5. POST-EXECUTION REVIEW (MANDATORY — NO SKIP CONDITIONS):
-   After Tapestry reports all tasks complete, you MUST run this gate before reporting success to the user:
-   a. Run \`git diff --stat\` to identify all changed files
-   b. Delegate to Weft (quality review) AND Warp (security audit) in parallel
-   c. Warp self-triages: if no security-relevant changes, it fast-exits with APPROVE — so always invoke it
-   d. If Weft or Warp REJECT → address blocking issues, then re-run the rejecting reviewer
-   e. Only report success to the user after BOTH Weft and Warp APPROVE
-   - This step has NO skip conditions. Not for small changes, not for user request, not for time pressure.
-   - Skipping this step is a workflow violation.
+
+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:
 - USE plan workflow: Large features, multi-file refactors, anything with 5+ steps or architectural decisions
@@ -591,11 +578,9 @@ When to use this workflow vs. direct execution:
 <ReviewWorkflow>
 Two review modes — different rules for each:
 
-**Post-Plan-Execution Review (after PlanWorkflow Step 5):**
-- ALWAYS mandatory. No skip conditions. See PlanWorkflow Step 5 for the full protocol.
-- ALWAYS delegate to BOTH Weft (quality) AND Warp (security) in parallel
-- Warp self-triages: fast-exits with APPROVE if no security-relevant changes detected
-- Both must APPROVE before reporting success to the user
+**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
@@ -642,7 +627,6 @@ var TAPESTRY_DEFAULTS = {
   temperature: 0.1,
   description: "Tapestry (Execution Orchestrator)",
   tools: {
-    task: false,
     call_weave_agent: false
   },
   prompt: `<Role>
@@ -700,16 +684,51 @@ 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: Read changed files, run tests, check acceptance criteria. 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. If uncertain about quality, note that Loom should invoke Weft for formal review.
    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, report final summary and include:
-   "All tasks complete. **Post-execution review required** — Loom must run Weft and Warp before reporting success."
+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>
+After completing work for each task — BEFORE marking \`- [ ]\` → \`- [x]\`:
+
+1. **Inspect changes**:
+   - Review your Edit/Write tool call history to identify all files you modified
+   - Read EVERY changed file to confirm correctness
+   - Cross-check: does the code actually implement what the task required?
+
+2. **Validate acceptance criteria**:
+   - Re-read the task's acceptance criteria from the plan
+   - Verify EACH criterion is met — exactly, not approximately
+   - If any criterion is unmet: address it, then re-verify
+
+3. **Accumulate learnings** (if \`.weave/learnings/{plan-name}.md\` exists or plan has multiple tasks):
+   - After verification passes, append 1-3 bullet points of key findings
+   - 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>
+
+<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)
+   - 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)
+   - 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>
 - Work through tasks top to bottom
 - Verify each step before marking complete
@@ -1378,6 +1397,14 @@ function createBuiltinAgents(options = {}) {
       resolveSkills
     });
     if (override) {
+      if (override.skills?.length && resolveSkills) {
+        const skillContent = resolveSkills(override.skills, disabledSkills);
+        if (skillContent) {
+          built.prompt = skillContent + (built.prompt ? `
+
+` + built.prompt : "");
+        }
+      }
       if (override.prompt_append) {
         built.prompt = (built.prompt ? built.prompt + `
 
@@ -1412,6 +1439,55 @@ function createManagers(options) {
 import * as path3 from "path";
 import * as os2 from "os";
 
+// src/features/skill-loader/opencode-client.ts
+function deriveScope(location) {
+  if (location.includes(".opencode"))
+    return "project";
+  return "user";
+}
+async function fetchSkillsFromOpenCode(serverUrl, directory) {
+  const base = serverUrl.toString().replace(/\/$/, "");
+  const url = `${base}/skill?directory=${encodeURIComponent(directory)}`;
+  let response;
+  try {
+    response = await fetch(url, { signal: AbortSignal.timeout(3000) });
+  } catch (err) {
+    log("Failed to fetch skills from OpenCode — skills will not be loaded", { url, error: String(err) });
+    return [];
+  }
+  if (!response.ok) {
+    log("OpenCode /skill endpoint returned non-OK status — skills will not be loaded", {
+      url,
+      status: response.status
+    });
+    return [];
+  }
+  let data;
+  try {
+    data = await response.json();
+  } catch (err) {
+    log("Failed to parse skills response from OpenCode", { url, error: String(err) });
+    return [];
+  }
+  if (!Array.isArray(data)) {
+    log("Unexpected skills response shape from OpenCode — expected array", { url });
+    return [];
+  }
+  const skills = [];
+  for (const item of data) {
+    if (!item.name)
+      continue;
+    skills.push({
+      name: item.name,
+      description: item.description ?? "",
+      content: item.content ?? "",
+      scope: deriveScope(item.location ?? ""),
+      path: item.location
+    });
+  }
+  return skills;
+}
+
 // src/features/skill-loader/discovery.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
@@ -1535,38 +1611,40 @@ function loadSkillFile(filePath, scope) {
   return { name: metadata.name, description: metadata.description ?? "", content, scope, path: filePath, model: metadata.model };
 }
 
-// src/features/skill-loader/merger.ts
-var SCOPE_PRIORITY = { project: 3, user: 2, builtin: 1 };
-function mergeSkills(skills) {
-  const skillMap = new Map;
-  for (const skill of skills) {
-    const existing = skillMap.get(skill.name);
-    if (!existing || (SCOPE_PRIORITY[skill.scope] ?? 0) > (SCOPE_PRIORITY[existing.scope] ?? 0)) {
-      skillMap.set(skill.name, skill);
-    }
-  }
-  return Array.from(skillMap.values());
-}
-
-// src/features/skill-loader/builtin-skills.ts
-function createBuiltinSkills() {
-  return [];
-}
-
 // src/features/skill-loader/loader.ts
-function loadSkills(options = {}) {
-  const { directory, disabledSkills = [] } = options;
-  const projectDir = path3.join(directory ?? process.cwd(), ".opencode", "skills");
-  const userDir = path3.join(os2.homedir(), ".config", "opencode", "weave-opencode", "skills");
-  const projectSkills = scanDirectory({ directory: projectDir, scope: "project" });
+function scanFilesystemSkills(directory) {
+  const userDir = path3.join(os2.homedir(), ".config", "opencode", "skills");
+  const projectDir = path3.join(directory, ".opencode", "skills");
   const userSkills = scanDirectory({ directory: userDir, scope: "user" });
-  const builtinSkills = createBuiltinSkills();
-  const all = [...projectSkills, ...userSkills, ...builtinSkills];
-  const merged = mergeSkills(all);
+  const projectSkills = scanDirectory({ directory: projectDir, scope: "project" });
+  return [...projectSkills, ...userSkills];
+}
+function mergeSkillSources(apiSkills, fsSkills) {
+  const seen = new Set(apiSkills.map((s) => s.name));
+  const merged = [...apiSkills];
+  for (const skill of fsSkills) {
+    if (!seen.has(skill.name)) {
+      merged.push(skill);
+      seen.add(skill.name);
+    }
+  }
+  return merged;
+}
+async function loadSkills(options) {
+  const { serverUrl, directory = process.cwd(), disabledSkills = [] } = options;
+  const apiSkills = await fetchSkillsFromOpenCode(serverUrl, directory);
+  const fsSkills = scanFilesystemSkills(directory);
+  const skills = mergeSkillSources(apiSkills, fsSkills);
+  if (apiSkills.length === 0 && fsSkills.length > 0) {
+    log("OpenCode API returned no skills — using filesystem fallback", {
+      fsSkillCount: fsSkills.length,
+      fsSkillNames: fsSkills.map((s) => s.name)
+    });
+  }
   if (disabledSkills.length === 0)
-    return { skills: merged };
+    return { skills };
   const disabledSet = new Set(disabledSkills);
-  return { skills: merged.filter((s) => !disabledSet.has(s.name)) };
+  return { skills: skills.filter((s) => !disabledSet.has(s.name)) };
 }
 // src/features/skill-loader/resolver.ts
 function resolveSkill(name, result) {
@@ -1596,7 +1674,8 @@ function createSkillResolver(discovered) {
 // src/create-tools.ts
 async function createTools(options) {
   const { ctx, pluginConfig } = options;
-  const skillResult = loadSkills({
+  const skillResult = await loadSkills({
+    serverUrl: ctx.serverUrl,
     directory: ctx.directory,
     disabledSkills: pluginConfig.disabled_skills ?? []
   });
@@ -1796,6 +1875,7 @@ 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 { join as join6, basename } from "path";
+import { execSync } from "child_process";
 var UNCHECKED_RE = /^[-*]\s*\[\s*\]/gm;
 var CHECKED_RE = /^[-*]\s*\[[xX]\]/gm;
 function readWorkState(directory) {
@@ -1850,15 +1930,29 @@ function appendSessionId(directory, sessionId) {
   }
   return state;
 }
-function createWorkState(planPath, sessionId, agent) {
+function createWorkState(planPath, sessionId, agent, directory) {
+  const startSha = directory ? getHeadSha(directory) : undefined;
   return {
     active_plan: planPath,
     started_at: new Date().toISOString(),
     session_ids: [sessionId],
     plan_name: getPlanName(planPath),
-    ...agent !== undefined ? { agent } : {}
+    ...agent !== undefined ? { agent } : {},
+    ...startSha !== undefined ? { start_sha: startSha } : {}
   };
 }
+function getHeadSha(directory) {
+  try {
+    const sha = execSync("git rev-parse HEAD", {
+      cwd: directory,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return sha || undefined;
+  } catch {
+    return;
+  }
+}
 function findPlans(directory) {
   const plansDir = join6(directory, PLANS_DIR);
   try {
@@ -2205,7 +2299,7 @@ Tell the user to fix the plan file and run /start-work again.`
         };
       }
       appendSessionId(directory, sessionId);
-      const resumeContext = buildResumeContext(existingState.active_plan, existingState.plan_name, progress);
+      const resumeContext = buildResumeContext(existingState.active_plan, existingState.plan_name, progress, existingState.start_sha);
       if (validation.warnings.length > 0) {
         return {
           switchAgent: "tapestry",
@@ -2269,9 +2363,9 @@ Tell the user to fix these issues in the plan file and try again.`
     };
   }
   clearWorkState(directory);
-  const state = createWorkState(matched, sessionId, "tapestry");
+  const state = createWorkState(matched, sessionId, "tapestry", directory);
   writeWorkState(directory, state);
-  const freshContext = buildFreshContext(matched, getPlanName(matched), progress);
+  const freshContext = buildFreshContext(matched, getPlanName(matched), progress, state.start_sha);
   if (validation.warnings.length > 0) {
     return {
       switchAgent: "tapestry",
@@ -2317,9 +2411,9 @@ ${formatValidationResults(validation)}
 Tell the user to fix these issues in the plan file and try again.`
       };
     }
-    const state = createWorkState(plan, sessionId, "tapestry");
+    const state = createWorkState(plan, sessionId, "tapestry", directory);
     writeWorkState(directory, state);
-    const freshContext = buildFreshContext(plan, getPlanName(plan), progress);
+    const freshContext = buildFreshContext(plan, getPlanName(plan), progress, state.start_sha);
     if (validation.warnings.length > 0) {
       return {
         switchAgent: "tapestry",
@@ -2375,10 +2469,12 @@ function formatValidationResults(result) {
   return lines.join(`
 `);
 }
-function buildFreshContext(planPath, planName, progress) {
+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
+**Progress**: ${progress.completed}/${progress.total} tasks completed${shaLine}
 
 Read the plan file now and begin executing from the first unchecked \`- [ ]\` task.
 
@@ -2389,12 +2485,14 @@ Before starting any work, use todowrite to populate the sidebar:
 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) {
+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.
+**Status**: RESUMING — continuing from where the previous session left off.${shaLine}
 
 Read the plan file now and continue from the first unchecked \`- [ ]\` task.
 
@@ -2508,6 +2606,7 @@ function clearSession2(sessionId) {
 // src/plugin/plugin-interface.ts
 function createPluginInterface(args) {
   const { pluginConfig, hooks, tools, configHandler, agents, client } = args;
+  let pendingInterrupt = false;
   return {
     tool: tools,
     config: async (config) => {
@@ -2613,25 +2712,37 @@ ${result.contextInjection}`;
           }
         }
       }
-      if (hooks.workContinuation && event.type === "session.idle") {
+      if (event.type === "tui.command.execute") {
         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) });
+        if (evt.properties?.command === "session.interrupt") {
+          pendingInterrupt = true;
+          log("[work-continuation] User interrupt detected — will suppress next continuation");
+        }
+      }
+      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 });
             }
-          } else if (result.continuationPrompt) {
-            log("[work-continuation] continuationPrompt available but no client", { sessionId });
           }
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode_weave/weave",
-  "version": "0.5.2",
+  "version": "0.6.1",
   "description": "Weave — lean OpenCode plugin with multi-agent orchestration",
   "author": "Weave",
   "license": "MIT",

package/dist/features/skill-loader/builtin-skills.d.ts

@@ -1,2 +0,0 @@
-import type { LoadedSkill } from "./types";
-export declare function createBuiltinSkills(): LoadedSkill[];

package/dist/features/skill-loader/merger.d.ts

@@ -1,2 +0,0 @@
-import type { LoadedSkill } from './types';
-export declare function mergeSkills(skills: LoadedSkill[]): LoadedSkill[];