@opencode_weave/weave 0.3.2 → 0.4.0

package/dist/index.js

@@ -118,6 +118,15 @@ function log(message, data) {
     fs.appendFileSync(LOG_FILE, entry);
   } catch {}
 }
+function logDelegation(event) {
+  const prefix = `[delegation:${event.phase}]`;
+  log(`${prefix} agent=${event.agent}`, {
+    sessionId: event.sessionId,
+    toolCallId: event.toolCallId,
+    durationMs: event.durationMs,
+    summary: event.summary
+  });
+}
 
 // src/config/loader.ts
 function readJsoncFile(filePath) {
@@ -167,7 +176,8 @@ var AGENT_DISPLAY_NAMES = {
   pattern: "pattern",
   thread: "thread",
   spindle: "spindle",
-  warp: "warp"
+  warp: "warp",
+  weft: "weft"
 };
 function getAgentDisplayName(configKey) {
   const exactMatch = AGENT_DISPLAY_NAMES[configKey];
@@ -491,8 +501,9 @@ WHEN PLANNING (multi-step work):
 - When plan ready: mark completed, add "Plan ready — /start-work"
 
 WHEN DELEGATING TO AGENTS:
-- Create "in_progress": "[agent]: [task]" (e.g. "thread: scan models")
-- Mark "completed" when agent returns results
+- FIRST: Create "in_progress": "[agent]: [task]" (e.g. "thread: scan models")
+- The todowrite call MUST come BEFORE the Task/call_weave_agent tool call in your response
+- Mark "completed" AFTER summarizing what the agent returned
 - If multiple delegations: one todo per active agent
 
 WHEN DOING QUICK TASKS (no plan needed):
@@ -518,6 +529,34 @@ FORMAT RULES:
 - Delegate aggressively to keep your context lean
 </Delegation>
 
+<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:
+   - "Delegating to Thread to explore the authentication module..."
+   - "Asking Pattern to create an implementation plan for the new feature..."
+   - "Sending to Spindle to research the library's API docs..."
+
+2. BEFORE the Task tool call: Create/update a sidebar todo (in_progress) for the delegation.
+   The todowrite call MUST appear BEFORE the Task tool call in your response.
+   This ensures the sidebar updates immediately, not after the subagent finishes.
+
+3. AFTER the agent returns: Write a brief summary of what was found/produced:
+   - "Thread found 3 files related to auth: src/auth/login.ts, src/auth/session.ts, src/auth/middleware.ts"
+   - "Pattern saved the plan to .weave/plans/feature-x.md with 7 tasks"
+   - "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.
+
+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:
 
@@ -563,7 +602,8 @@ For security-relevant changes, also delegate to Warp:
 </ReviewWorkflow>
 
 <Style>
-- Start immediately. No acknowledgments.
+- 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>`
@@ -2057,7 +2097,7 @@ function createHooks(args) {
 
 // src/plugin/plugin-interface.ts
 function createPluginInterface(args) {
-  const { pluginConfig, hooks, tools, configHandler, agents } = args;
+  const { pluginConfig, hooks, tools, configHandler, agents, client } = args;
   return {
     tool: tools,
     config: async (config) => {
@@ -2138,7 +2178,21 @@ ${result.contextInjection}`;
         const sessionId = evt.properties?.sessionID ?? "";
         if (sessionId) {
           const result = hooks.workContinuation(sessionId);
-          if (result.continuationPrompt) {}
+          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 });
+          }
         }
       }
     },
@@ -2164,8 +2218,28 @@ ${result.contextInjection}`;
           }
         }
       }
+      if (input.tool === "task" && args2) {
+        const agentArg = args2.agent ?? args2.description ?? "unknown";
+        logDelegation({
+          phase: "start",
+          agent: agentArg,
+          sessionId: input.sessionID,
+          toolCallId: input.callID
+        });
+      }
     },
-    "tool.execute.after": async (_input, _output) => {}
+    "tool.execute.after": async (input, _output) => {
+      if (input.tool === "task") {
+        const inputArgs = input.args;
+        const agentArg = inputArgs?.agent ?? "unknown";
+        logDelegation({
+          phase: "complete",
+          agent: agentArg,
+          sessionId: input.sessionID,
+          toolCallId: input.callID
+        });
+      }
+    }
   };
 }
 
@@ -2182,7 +2256,8 @@ var WeavePlugin = async (ctx) => {
     hooks,
     tools: toolsResult.tools,
     configHandler: managers.configHandler,
-    agents: managers.agents
+    agents: managers.agents,
+    client: ctx.client
   });
 };
 var src_default = WeavePlugin;

package/dist/managers/background-manager.d.ts

@@ -24,6 +24,26 @@ export interface TaskRecord {
  * v1 tracks tasks in memory only — no real session spawning, polling, or
  * tmux integration.  Real concurrency control and SDK integration are
  * deferred to a future release.
+ *
+ * ## Planned Delegation Tracking Integration
+ *
+ * Once a UI consumer exists (e.g. a `/status` slash command), this class
+ * should be wired into `plugin-interface.ts` as follows:
+ *
+ * 1. **`tool.execute.before`** — when `input.tool === "task"`, call
+ *    `backgroundManager.spawn({ agentName: args.agent, prompt: args.description })`
+ *    and store the returned task ID keyed by `input.callID`.
+ *
+ * 2. **`tool.execute.after`** — look up the task ID by `input.callID` and
+ *    transition its status:
+ *    - On success: set `status = "completed"` and `completedAt = new Date()`
+ *    - On error: set `status = "failed"` and `error = err.message`
+ *
+ * 3. **`/status` command** — call `list({ status: "running" })` to surface
+ *    all in-flight delegations to the user in real time.
+ *
+ * This is deferred until there is an OpenCode API to read task status back
+ * out of the plugin (e.g. a query hook or TUI panel).
  */
 export declare class BackgroundManager {
     private readonly tasks;

package/dist/plugin/plugin-interface.d.ts

@@ -3,10 +3,12 @@ import type { AgentConfig } from "@opencode-ai/sdk";
 import type { WeaveConfig } from "../config/schema";
 import type { ConfigHandler } from "../managers/config-handler";
 import type { CreatedHooks } from "../hooks/create-hooks";
+import type { PluginContext } from "./types";
 export declare function createPluginInterface(args: {
     pluginConfig: WeaveConfig;
     hooks: CreatedHooks;
     tools: ToolsRecord;
     configHandler: ConfigHandler;
     agents: Record<string, AgentConfig>;
+    client?: PluginContext["client"];
 }): PluginInterface;

package/dist/shared/index.d.ts

@@ -1,3 +1,4 @@
 export type { DeepPartial, Brand } from "./types";
-export { log, getLogFilePath } from "./log";
+export { log, getLogFilePath, logDelegation } from "./log";
+export type { DelegationEvent } from "./log";
 export { AGENT_DISPLAY_NAMES, getAgentDisplayName, getAgentConfigKey, } from "./agent-display-names";

package/dist/shared/log.d.ts

@@ -1,2 +1,11 @@
 export declare function log(message: string, data?: unknown): void;
 export declare function getLogFilePath(): string;
+export interface DelegationEvent {
+    phase: "start" | "complete" | "error";
+    agent: string;
+    sessionId?: string;
+    toolCallId?: string;
+    durationMs?: number;
+    summary?: string;
+}
+export declare function logDelegation(event: DelegationEvent): void;

package/package.json

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