@synergenius/flow-weaver-pack-weaver 0.9.0 → 0.9.4

package/src/mcp-tools.ts

@@ -206,8 +206,8 @@ export async function registerMcpTools(mcp: McpServer): Promise<void> {
       switch (args.action) {
         case 'add': {
           if (!args.task) return { content: [{ type: 'text', text: 'Error: task instruction required' }] };
-          const id = await queue.add({ instruction: args.task as string, priority: 0 });
-          return { content: [{ type: 'text', text: `Task added: ${id}` }] };
+          const { id, duplicate } = await queue.add({ instruction: args.task as string, priority: 0 });
+          return { content: [{ type: 'text', text: duplicate ? `Task already queued (${id})` : `Task added: ${id}` }] };
         }
         case 'list':
           return { content: [{ type: 'text', text: JSON.stringify(await queue.list(), null, 2) }] };

package/src/node-types/abort-task.ts

@@ -13,17 +13,18 @@ import type { WeaverContext } from '../bot/types.js';
  */
 export function weaverAbortTask(ctx: string): { ctx: string } {
   const context = JSON.parse(ctx) as WeaverContext;
-  const task = JSON.parse(context.taskJson!) as { instruction?: string };
+  const task = context.taskJson ? JSON.parse(context.taskJson) as { instruction?: string } : {};
+  const reason = context.rejectionReason ?? 'no reason given';
   const result = {
     success: false,
     outcome: 'aborted',
-    summary: `Task aborted: ${context.rejectionReason}`,
-    instruction: task.instruction,
+    summary: `Task aborted: ${reason}`,
+    instruction: (task as { instruction?: string }).instruction,
     filesModified: [],
     filesCreated: [],
   };
 
-  console.log(`\x1b[33m→ Task aborted: ${context.rejectionReason}\x1b[0m`);
+  console.log(`\x1b[33m→ Task aborted: ${reason}\x1b[0m`);
 
   context.resultJson = JSON.stringify(result);
   context.filesModified = '[]';

package/src/node-types/agent-execute.ts

@@ -0,0 +1,303 @@
+import type { WeaverContext } from '../bot/types.js';
+import {
+  runAgentLoop,
+  createAnthropicProvider,
+  getOrCreateCliSession,
+  killAllCliSessions,
+  type AgentProvider,
+  type AgentMessage,
+  type ToolDefinition,
+  type StreamEvent,
+  type StreamOptions,
+  type ToolEvent,
+} from '@synergenius/flow-weaver/agent';
+import { WEAVER_TOOLS, createWeaverExecutor } from '../bot/weaver-tools.js';
+import { auditEmit } from '../bot/audit-logger.js';
+import { withRetry, getErrorGuidance } from '../bot/error-classifier.js';
+import { CostTracker } from '../bot/cost-tracker.js';
+
+// Clean up persistent sessions on process exit
+let cleanupRegistered = false;
+function registerCleanup(): void {
+  if (cleanupRegistered) return;
+  cleanupRegistered = true;
+  const cleanup = () => { try { killAllCliSessions(); } catch (err) { if (process.env.WEAVER_VERBOSE) console.error('[agent-execute] session cleanup failed:', err); } };
+  process.on('exit', cleanup);
+  process.on('SIGTERM', cleanup);
+  process.on('SIGINT', cleanup);
+}
+
+/**
+ * Adapter: wraps a persistent CliSession as an AgentProvider.
+ * The agent loop sends full message history each iteration;
+ * we only forward the latest user/tool messages since the session
+ * maintains its own conversation state.
+ */
+class CliSessionProvider implements AgentProvider {
+  private sentCount = 0;
+
+  constructor(
+    private session: { ready: boolean; spawn: () => Promise<void>; send: (msg: string, systemPrompt?: string) => AsyncGenerator<StreamEvent> },
+  ) {}
+
+  async *stream(
+    messages: AgentMessage[],
+    _tools: ToolDefinition[],
+    options?: StreamOptions,
+  ): AsyncGenerator<StreamEvent> {
+    if (!this.session.ready) await this.session.spawn();
+
+    // Only send new messages (session has history of previous ones)
+    const newMessages = messages.slice(this.sentCount);
+    this.sentCount = messages.length;
+
+    // Format new messages into a prompt string
+    const prompt = newMessages
+      .map((m) => {
+        if (m.role === 'user') return typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
+        if (m.role === 'tool') return `Tool result (${m.toolCallId}): ${typeof m.content === 'string' ? m.content : JSON.stringify(m.content)}`;
+        return '';
+      })
+      .filter(Boolean)
+      .join('\n');
+
+    if (!prompt) return;
+
+    // Only pass system prompt on the first call
+    const systemPrompt = this.sentCount <= messages.length ? options?.systemPrompt : undefined;
+    yield* this.session.send(prompt, systemPrompt);
+  }
+
+  /** Reset for a new task (new conversation context) */
+  resetForNewTask(): void {
+    this.sentCount = 0;
+  }
+}
+
+// Test-only export (tree-shaken in production bundles)
+export { CliSessionProvider };
+
+// Re-use StepLogEntry shape from the bot types
+type LocalStepLogEntry = { step: string; status: string; detail: string };
+
+/**
+ * Tool-use agent execution. Claude drives the entire task via tool calls
+ * (validate, read-file, patch-file, run-shell, etc.) in a single continuous
+ * conversation. No separate plan or retry loop needed.
+ *
+ * @flowWeaver nodeType
+ * @label Agent Execute
+ * @input ctx [order:0] - Weaver context (JSON)
+ * @output ctx [order:0] - Weaver context with results (JSON)
+ * @output onSuccess [order:-2] - On Success
+ * @output onFailure [order:-1] [hidden] - On Failure
+ */
+export async function weaverAgentExecute(
+  execute: boolean,
+  ctx: string,
+): Promise<{
+  onSuccess: boolean; onFailure: boolean;
+  ctx: string;
+}> {
+  const context = JSON.parse(ctx) as WeaverContext;
+  const { env } = context;
+
+  if (!execute) {
+    context.resultJson = JSON.stringify({ success: true, toolCallCount: 0 });
+    context.validationResultJson = '[]';
+    context.filesModified = '[]';
+    context.stepLogJson = '[]';
+    context.allValid = true;
+    return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
+  }
+
+  const { providerInfo: pInfo, projectDir } = env;
+  const task = JSON.parse(context.taskJson!);
+
+  // Build system prompt
+  let systemPrompt: string;
+  try {
+    const mod = await import('../bot/system-prompt.js');
+    const basePrompt = await mod.buildSystemPrompt();
+    let cliCommands: { name: string; description: string; botCompatible?: boolean; options?: { flags: string; arg?: string; description: string }[] }[] = [];
+    try {
+      const docMeta = await import('@synergenius/flow-weaver/doc-metadata');
+      cliCommands = docMeta.CLI_COMMANDS ?? [];
+    } catch (err) { if (process.env.WEAVER_VERBOSE) console.error('[agent-execute] doc-metadata unavailable (older fw):', err); }
+    const botPrompt = mod.buildBotSystemPrompt(context.contextBundle, cliCommands, projectDir);
+    systemPrompt = basePrompt + '\n\n' + botPrompt;
+  } catch (err) {
+    if (process.env.WEAVER_VERBOSE) console.error('[agent-execute] system prompt build failed, using fallback:', err);
+    systemPrompt = 'You are Weaver, an AI workflow bot. Use the provided tools to complete tasks.';
+  }
+
+  const taskPrompt = `Task: ${task.instruction}\nProject directory: ${projectDir}\n${task.targets ? 'Target files: ' + task.targets.join(', ') : ''}`;
+
+  // Create renderer — single source of all terminal output
+  const { TerminalRenderer } = await import('../bot/terminal-renderer.js');
+  const renderer = new TerminalRenderer({ verbose: !!process.env.WEAVER_VERBOSE });
+
+  auditEmit('run-start', { task: task.instruction });
+
+  try {
+    const provider = createProvider(pInfo, projectDir);
+    const executor = createWeaverExecutor(projectDir);
+
+    const filesModified: string[] = [];
+    const stepLog: LocalStepLogEntry[] = [];
+    const taskStart = Date.now();
+
+    // Route tool events through renderer + track state
+    const onToolEvent = (event: ToolEvent) => {
+      renderer.onToolEvent(event);
+
+      if (event.type === 'tool_call_result') {
+        stepLog.push({
+          step: event.name,
+          status: event.isError ? 'error' : 'ok',
+          detail: event.isError ? (event.result ?? '').slice(0, 200) : event.name,
+        });
+        if ((event.name === 'patch_file' || event.name === 'write_file') && !event.isError && event.args?.file) {
+          filesModified.push(event.args.file as string);
+        }
+      }
+    };
+
+    const onStreamEvent = (event: StreamEvent) => renderer.onStreamEvent(event);
+
+    const result = await withRetry(
+      () => runAgentLoop(
+        provider,
+        WEAVER_TOOLS,
+        executor,
+        [{ role: 'user', content: taskPrompt }],
+        { systemPrompt, maxIterations: 15, onToolEvent, onStreamEvent },
+      ),
+      {
+        maxRetries: 3,
+        baseDelayMs: 5_000,
+        onRetry: (attempt, delay, err) => {
+          renderer.warn(`Transient error, retrying in ${delay / 1000}s (attempt ${attempt}/3): ${err.message.slice(0, 80)}`);
+        },
+      },
+    );
+
+    const usage = result.usage;
+    const model = pInfo.model ?? 'claude-sonnet-4-6';
+    const estimatedCost = CostTracker.estimateCost(model, {
+      inputTokens: usage.promptTokens,
+      outputTokens: usage.completionTokens,
+    });
+
+    // Post-agent validation gate: don't trust the AI's self-assessment
+    const uniqueFiles = [...new Set(filesModified)];
+    let validationPassed = result.success;
+    if (uniqueFiles.length > 0) {
+      try {
+        const { weaverValidateGate } = await import('./validate-gate.js');
+        const gateCtx: WeaverContext = { ...context, filesModified: JSON.stringify(uniqueFiles) };
+        const gateResult = weaverValidateGate(JSON.stringify(gateCtx));
+        const gateData = JSON.parse(gateResult.ctx) as WeaverContext;
+        if (!gateData.allValid) {
+          validationPassed = false;
+          renderer.warn('Post-agent validation found errors — task marked as failed');
+        }
+        context.validationResultJson = gateData.validationResultJson;
+      } catch (err) { if (process.env.WEAVER_VERBOSE) console.error('[agent-execute] validate-gate unavailable, skipping:', err); }
+    }
+
+    context.resultJson = JSON.stringify({
+      success: validationPassed,
+      summary: result.summary,
+      toolCallCount: result.toolCallCount,
+      usage: { inputTokens: usage.promptTokens, outputTokens: usage.completionTokens, estimatedCost },
+    });
+    context.filesModified = JSON.stringify(uniqueFiles);
+    context.stepLogJson = JSON.stringify(stepLog);
+    context.allValid = validationPassed;
+
+    auditEmit('run-complete', {
+      success: validationPassed,
+      toolCalls: result.toolCallCount,
+      filesModified: uniqueFiles.length,
+      tokens: { in: usage.promptTokens, out: usage.completionTokens },
+      estimatedCost,
+    });
+
+    renderer.taskEnd(validationPassed, {
+      toolCalls: result.toolCallCount,
+      inputTokens: usage.promptTokens,
+      outputTokens: usage.completionTokens,
+      estimatedCost,
+      filesModified: uniqueFiles.length,
+      elapsed: Date.now() - taskStart,
+    });
+
+    return { onSuccess: validationPassed, onFailure: !validationPassed, ctx: JSON.stringify(context) };
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    let errorDetail = msg;
+    const guidance = getErrorGuidance(msg);
+    if (guidance) errorDetail = `${msg}\n  Hint: ${guidance}`;
+    renderer.error('Agent error', errorDetail);
+
+    context.resultJson = JSON.stringify({ success: false, error: msg });
+    context.filesModified = '[]';
+    context.stepLogJson = '[]';
+    context.allValid = false;
+
+    return { onSuccess: false, onFailure: true, ctx: JSON.stringify(context) };
+  }
+}
+
+/**
+ * Create an AgentProvider from pack-weaver's ProviderInfo.
+ */
+function createProvider(
+  pInfo: { type: string; apiKey?: string; model?: string; maxTokens?: number },
+  projectDir?: string,
+): AgentProvider {
+  const type = pInfo.type ?? 'auto';
+
+  // Explicit Anthropic API
+  if (type === 'anthropic' && pInfo.apiKey) {
+    return createAnthropicProvider({
+      apiKey: pInfo.apiKey,
+      model: pInfo.model,
+      maxTokens: pInfo.maxTokens,
+    });
+  }
+
+  // Claude CLI — use persistent session for warm start
+  if (type === 'claude-cli') {
+    return createSessionProvider(pInfo.model, projectDir);
+  }
+
+  // Auto mode: try Anthropic API key from env, then fall back to Claude CLI
+  if (type === 'auto') {
+    if (process.env.ANTHROPIC_API_KEY) {
+      return createAnthropicProvider({
+        apiKey: process.env.ANTHROPIC_API_KEY,
+        model: pInfo.model,
+        maxTokens: pInfo.maxTokens,
+      });
+    }
+    // No API key — use Claude CLI with persistent session
+    return createSessionProvider(pInfo.model, projectDir);
+  }
+
+  throw new Error(
+    `Unsupported provider type: ${type}. Use 'anthropic', 'claude-cli', or 'auto'.`,
+  );
+}
+
+function createSessionProvider(model?: string, projectDir?: string): CliSessionProvider {
+  registerCleanup();
+  const key = projectDir ?? process.cwd();
+  const session = getOrCreateCliSession(key, {
+    binPath: 'claude',
+    cwd: key,
+    model: model ?? 'claude-sonnet-4-6',
+  });
+  return new CliSessionProvider(session);
+}

package/src/node-types/bot-report.ts

@@ -1,11 +1,15 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
 import type { WeaverContext } from '../bot/types.js';
+import { withFileLock } from '../bot/file-lock.js';
 
 /**
  * Generates the final bot session report. Receives context from any
  * of the three paths: read-only, main execution, or abort.
+ * Also marks the queue task as completed or failed.
  *
  * @flowWeaver nodeType
- * @expression
  * @label Bot Report
  * @executeWhen DISJUNCTION
  * @input [mainCtx] [order:0] - Context from main path (JSON, optional)
@@ -15,20 +19,21 @@ import type { WeaverContext } from '../bot/types.js';
  * @output reportJson [order:1] [hidden] - Full report (JSON)
  * @output onFailure [hidden]
  */
-export function weaverBotReport(
+export async function weaverBotReport(
+  execute: boolean,
   mainCtx?: string,
   readCtx?: string,
   abortCtx?: string,
-): { summary: string; reportJson: string } {
+): Promise<{ onSuccess: boolean; onFailure: boolean; summary: string; reportJson: string }> {
   const ctxStr = mainCtx ?? readCtx ?? abortCtx;
 
-  if (!ctxStr) {
+  if (!execute || !ctxStr) {
     const report = { task: {}, path: 'unknown', result: null, filesModified: [], gitResult: null, timestamp: Date.now() };
-    return { summary: '', reportJson: JSON.stringify(report) };
+    return { onSuccess: true, onFailure: false, summary: '', reportJson: JSON.stringify(report) };
   }
 
   const context = JSON.parse(ctxStr) as WeaverContext;
-  const task = context.taskJson ? JSON.parse(context.taskJson) as { instruction?: string; mode?: string } : {};
+  const task = context.taskJson ? JSON.parse(context.taskJson) as { instruction?: string; mode?: string; queueId?: string } : {};
   const files: string[] = context.filesModified ? JSON.parse(context.filesModified) : [];
   const gitResult = context.gitResultJson ? JSON.parse(context.gitResultJson) : null;
 
@@ -52,8 +57,10 @@ export function weaverBotReport(
     parts.push(`Task: ${task.instruction}`);
   }
 
+  const success = result?.success !== false && pathName !== 'abort';
+
   if (result) {
-    parts.push(`Outcome: ${result.outcome ?? (result.success ? 'completed' : 'failed')}`);
+    parts.push(`Outcome: ${result.outcome ?? (success ? 'completed' : 'failed')}`);
     if (result.summary) parts.push(`Summary: ${result.summary}`);
   }
 
@@ -67,6 +74,13 @@ export function weaverBotReport(
 
   const summary = parts.join(' | ');
 
+  // Mark queue task as completed or failed
+  if (task.queueId) {
+    try {
+      await markQueueTask(task.queueId, success ? 'completed' : 'failed');
+    } catch (err) { if (process.env.WEAVER_VERBOSE) console.error('[bot-report] queue update failed:', err); }
+  }
+
   const report = {
     task,
     path: pathName,
@@ -76,7 +90,24 @@ export function weaverBotReport(
     timestamp: Date.now(),
   };
 
-  console.log(`\n\x1b[1m${result?.success !== false ? '\x1b[32m' : '\x1b[31m'}Bot Report: ${summary}\x1b[0m\n`);
+  console.log(`\n\x1b[1m${success ? '\x1b[32m' : '\x1b[31m'}Bot Report: ${summary}\x1b[0m\n`);
+
+  return { onSuccess: success, onFailure: !success, summary, reportJson: JSON.stringify(report) };
+}
+
+async function markQueueTask(id: string, status: 'completed' | 'failed'): Promise<void> {
+  const queuePath = path.join(os.homedir(), '.weaver', 'task-queue.ndjson');
+  if (!fs.existsSync(queuePath)) return;
 
-  return { summary, reportJson: JSON.stringify(report) };
+  await withFileLock(queuePath, () => {
+    const content = fs.readFileSync(queuePath, 'utf-8').trim();
+    if (!content) return;
+    const tasks = content.split('\n').filter(Boolean).map(l => JSON.parse(l));
+    const task = tasks.find((t: { id: string }) => t.id === id);
+    if (task) {
+      task.status = status;
+      fs.writeFileSync(queuePath, tasks.map((t: unknown) => JSON.stringify(t)).join('\n') + '\n', 'utf-8');
+      console.log(`\x1b[36m→ Queue task ${id}: ${status}\x1b[0m`);
+    }
+  });
 }

package/src/node-types/build-context.ts

@@ -4,9 +4,9 @@ import * as path from 'node:path';
 import type { WeaverContext } from '../bot/types.js';
 
 /**
- * Builds the knowledge bundle the AI needs for planning. Calls
- * flow-weaver context authoring for the base knowledge, and
- * appends target file sources for modify tasks.
+ * Builds the knowledge bundle the AI needs for planning.
+ * Adaptive: for modify tasks, includes only grammar + referenced node types.
+ * For create tasks, includes full authoring context + templates.
  *
  * @flowWeaver nodeType
  * @expression
@@ -21,31 +21,81 @@ export function weaverBuildContext(ctx: string): { ctx: string } {
   const task = JSON.parse(context.taskJson!) as { mode?: string; targets?: string[] };
   const sections: string[] = [];
 
+  if (task.mode === 'modify' && task.targets?.length) {
+    // Adaptive context: minimal grammar + target files + referenced node types
+    sections.push(...buildModifyContext(projectDir, task.targets));
+  } else {
+    // Full context for create tasks or unknown modes
+    sections.push(...buildFullContext(projectDir, task.mode));
+  }
+
+  const bundle = sections.join('\n\n---\n\n');
+  // Output handled by session renderer; keep a dim line for debugging
+  if (process.env.WEAVER_VERBOSE) process.stderr.write(`\x1b[2m  Context: ${bundle.length} chars\x1b[0m\n`);
+
+  context.contextBundle = bundle;
+  return { ctx: JSON.stringify(context) };
+}
+
+/** Minimal context for modify tasks: grammar + annotations + target sources + referenced node types. */
+function buildModifyContext(projectDir: string, targets: string[]): string[] {
+  const sections: string[] = [];
+
+  // Minimal grammar (jsdoc-grammar + advanced-annotations only — skip concepts/scaffold/patterns)
   try {
-    const ctxOutput = execFileSync('flow-weaver', ['context', 'authoring', '--profile', 'assistant'], {
-      encoding: 'utf-8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-      timeout: 30_000,
-      cwd: projectDir,
-    }).trim();
+    const ctxOutput = execFileSync(
+      'flow-weaver',
+      ['context', '--topics', 'jsdoc-grammar,advanced-annotations', '--profile', 'assistant'],
+      { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 30_000, cwd: projectDir },
+    ).trim();
     if (ctxOutput) sections.push(ctxOutput);
-  } catch {
+  } catch (err) {
+    if (process.env.WEAVER_VERBOSE) console.error('[build-context] modify context unavailable:', err);
     sections.push('(flow-weaver context not available)');
   }
 
-  if (task.mode === 'modify' && task.targets) {
-    for (const target of task.targets) {
-      const filePath = path.isAbsolute(target) ? target : path.resolve(projectDir, target);
-      try {
-        if (fs.existsSync(filePath)) {
-          const source = fs.readFileSync(filePath, 'utf-8');
-          sections.push(`## Current Source: ${target}\n\n\`\`\`typescript\n${source}\n\`\`\``);
+  // Target file sources + referenced node type sources
+  const includedFiles = new Set<string>();
+  for (const target of targets) {
+    const filePath = path.isAbsolute(target) ? target : path.resolve(projectDir, target);
+    try {
+      if (!fs.existsSync(filePath)) continue;
+      const source = fs.readFileSync(filePath, 'utf-8');
+      sections.push(`## Target: ${target}\n\n\`\`\`typescript\n${source}\n\`\`\``);
+      includedFiles.add(filePath);
+
+      // Extract import paths to find referenced node type files
+      const nodeTypeSources = extractReferencedNodeTypes(filePath, source, projectDir);
+      for (const [relPath, ntSource] of nodeTypeSources) {
+        const absPath = path.resolve(projectDir, relPath);
+        if (!includedFiles.has(absPath)) {
+          includedFiles.add(absPath);
+          sections.push(`## Node Type: ${relPath}\n\n\`\`\`typescript\n${ntSource}\n\`\`\``);
         }
-      } catch { /* skip unreadable files */ }
-    }
+      }
+    } catch (err) { if (process.env.WEAVER_VERBOSE) console.error('[build-context] unreadable file:', err); }
+  }
+
+  return sections;
+}
+
+/** Full context for create tasks: full authoring preset + templates. */
+function buildFullContext(projectDir: string, mode?: string): string[] {
+  const sections: string[] = [];
+
+  try {
+    const ctxOutput = execFileSync(
+      'flow-weaver',
+      ['context', 'authoring', '--profile', 'assistant'],
+      { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 30_000, cwd: projectDir },
+    ).trim();
+    if (ctxOutput) sections.push(ctxOutput);
+  } catch (err) {
+    if (process.env.WEAVER_VERBOSE) console.error('[build-context] full context unavailable:', err);
+    sections.push('(flow-weaver context not available)');
   }
 
-  if (task.mode === 'create') {
+  if (mode === 'create') {
     try {
       const templates = execFileSync('flow-weaver', ['list', 'templates'], {
         encoding: 'utf-8',
@@ -54,12 +104,49 @@ export function weaverBuildContext(ctx: string): { ctx: string } {
         cwd: projectDir,
       }).trim();
       if (templates) sections.push(`## Available Templates\n\n${templates}`);
-    } catch { /* templates not available */ }
+    } catch (err) { if (process.env.WEAVER_VERBOSE) console.error('[build-context] templates not available:', err); }
   }
 
-  const bundle = sections.join('\n\n---\n\n');
-  console.log(`\x1b[36m→ Context bundle: ${bundle.length} chars\x1b[0m`);
+  return sections;
+}
 
-  context.contextBundle = bundle;
-  return { ctx: JSON.stringify(context) };
+/**
+ * Extract node type file sources referenced by a workflow file's imports.
+ * Parses import statements to find relative imports from node-types directories.
+ */
+function extractReferencedNodeTypes(
+  filePath: string,
+  source: string,
+  projectDir: string,
+): Array<[relPath: string, source: string]> {
+  const results: Array<[string, string]> = [];
+  const dir = path.dirname(filePath);
+
+  // Match: import { ... } from '../node-types/foo.js' or './node-types/bar'
+  const importRegex = /import\s+(?:type\s+)?{[^}]+}\s+from\s+['"]([^'"]+)['"]/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = importRegex.exec(source)) !== null) {
+    const importPath = match[1];
+    // Only include relative imports that look like node type files
+    if (!importPath.startsWith('.') && !importPath.startsWith('/')) continue;
+    if (!importPath.includes('node-type') && !importPath.includes('node_type')) continue;
+
+    // Resolve the import to an absolute path
+    let resolved = path.resolve(dir, importPath);
+    // Try with .ts extension if no extension
+    if (!fs.existsSync(resolved)) {
+      if (fs.existsSync(resolved + '.ts')) resolved = resolved + '.ts';
+      else if (fs.existsSync(resolved.replace(/\.js$/, '.ts'))) resolved = resolved.replace(/\.js$/, '.ts');
+      else continue;
+    }
+
+    try {
+      const ntSource = fs.readFileSync(resolved, 'utf-8');
+      const relPath = path.relative(projectDir, resolved);
+      results.push([relPath, ntSource]);
+    } catch (err) { if (process.env.WEAVER_VERBOSE) console.error('[build-context] unreadable node type:', err); }
+  }
+
+  return results;
 }

package/src/node-types/detect-provider.ts

@@ -1,5 +1,5 @@
 import { execFileSync } from 'node:child_process';
-import type { WeaverConfig, WeaverEnv, ProviderInfo } from '../bot/types.js';
+import type { BotConfig, WeaverEnv, ProviderInfo } from '../bot/types.js';
 
 const WHICH_CMD = process.platform === 'win32' ? 'where' : 'which';
 
@@ -23,7 +23,7 @@ function whichSafe(cmd: string, cwd: string): string {
  * @output env [order:0] - Weaver environment bundle
  * @output onFailure [hidden]
  */
-export function weaverDetectProvider(projectDir: string, config: WeaverConfig): {
+export function weaverDetectProvider(projectDir: string, config: BotConfig): {
   env: WeaverEnv;
 } {
   const providerSetting = config.provider ?? 'auto';
@@ -69,7 +69,8 @@ export function weaverDetectProvider(projectDir: string, config: WeaverConfig):
   }
 
   const label = providerInfo.model ? `${type} (${providerInfo.model})` : type;
-  console.log(`\x1b[36m→ Provider: ${label}\x1b[0m`);
+  // Provider info now shown by session renderer; keep for verbose/debug
+  if (process.env.WEAVER_VERBOSE) process.stderr.write(`\x1b[2m  Provider: ${label}\x1b[0m\n`);
 
   return {
     env: { projectDir, config, providerType: type, providerInfo },