@dotsetlabs/dotclaw 1.5.2 → 1.7.0

package/container/agent-runner/src/index.ts

@@ -26,7 +26,7 @@ import {
   MemoryConfig,
   Message
 } from './memory.js';
-import { loadPromptPackWithCanary, formatTaskExtractionPack, formatResponseQualityPack, formatToolCallingPack, formatToolOutcomePack, formatMemoryPolicyPack, formatMemoryRecallPack, PromptPack } from './prompt-packs.js';
+import { loadPromptPackWithCanary, formatPromptPack, PromptPack } from './prompt-packs.js';
 
 type OpenRouterResult = ReturnType<OpenRouter['callModel']>;
 
@@ -40,6 +40,9 @@ const AVAILABLE_GROUPS_PATH = '/workspace/ipc/available_groups.json';
 const GROUP_CLAUDE_PATH = path.join(GROUP_DIR, 'CLAUDE.md');
 const GLOBAL_CLAUDE_PATH = path.join(GLOBAL_DIR, 'CLAUDE.md');
 const CLAUDE_NOTES_MAX_CHARS = 4000;
+const SKILL_NOTES_MAX_FILES = 16;
+const SKILL_NOTES_MAX_CHARS = 3000;
+const SKILL_NOTES_TOTAL_MAX_CHARS = 18_000;
 
 const agentConfig = loadAgentConfig();
 const agent = agentConfig.agent;
@@ -71,72 +74,64 @@ function log(message: string): void {
   console.error(`[agent-runner] ${message}`);
 }
 
-function coerceTextFromContent(content: unknown): string {
-  if (!content) return '';
-  if (typeof content === 'string') return content;
-  if (Array.isArray(content)) {
-    return content.map(part => {
-      if (!part) return '';
-      if (typeof part === 'string') return part;
-      if (typeof part === 'object') {
-        const record = part as { text?: unknown; content?: unknown; value?: unknown };
-        if (typeof record.text === 'string') return record.text;
-        if (typeof record.content === 'string') return record.content;
-        if (typeof record.value === 'string') return record.value;
-      }
-      return '';
-    }).join('');
-  }
-  if (typeof content === 'object') {
-    const record = content as { text?: unknown; content?: unknown; value?: unknown };
-    if (typeof record.text === 'string') return record.text;
-    if (typeof record.content === 'string') return record.content;
-    if (typeof record.value === 'string') return record.value;
-  }
-  return '';
+// ── Response extraction pipeline ─────────────────────────────────────
+// OpenRouter SDK v0.3.x returns raw response IDs (gen-*, resp-*, etc.) instead
+// of text for fast reasoning models (GPT-5-mini/nano). Reasoning tokens consume
+// the output budget, leaving nothing for actual text. This multi-layer pipeline
+// works around that:
+//   1. isLikelyResponseId — detect leaked IDs so we never surface them
+//   2. extractTextFromRawResponse — walk raw response fields ourselves
+//   3. getTextWithFallback — try SDK getText(), fall back to raw extraction
+//   4. chatCompletionsFallback — retry via /chat/completions when all else fails
+// Remove this pipeline once the SDK reliably returns text for reasoning models.
+
+const RESPONSE_ID_PREFIXES = ['gen-', 'resp-', 'resp_', 'chatcmpl-', 'msg_'];
+
+function isLikelyResponseId(value: string): boolean {
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.includes(' ') || trimmed.includes('\n')) return false;
+  return RESPONSE_ID_PREFIXES.some(prefix => trimmed.startsWith(prefix));
+}
+
+function isValidText(value: unknown): value is string {
+  return typeof value === 'string' && value.trim().length > 0 && !isLikelyResponseId(value);
 }
 
-function extractTextFallbackFromResponse(response: unknown): string {
+function extractTextFromRawResponse(response: unknown): string {
   if (!response || typeof response !== 'object') return '';
-  const record = response as {
-    outputText?: unknown;
-    output_text?: unknown;
-    output?: unknown;
-    choices?: unknown;
-  };
+  const record = response as Record<string, unknown>;
 
-  if (typeof record.outputText === 'string' && record.outputText.trim()) {
-    return record.outputText;
-  }
-  if (typeof record.output_text === 'string' && record.output_text.trim()) {
-    return record.output_text;
-  }
+  // 1. SDK-parsed camelCase field
+  if (isValidText(record.outputText)) return record.outputText;
+
+  // 2. Raw API snake_case field
+  if (isValidText(record.output_text)) return record.output_text;
 
+  // 3. Walk response.output[] for message/output_text items
   if (Array.isArray(record.output)) {
-    const outputTexts: string[] = [];
+    const parts: string[] = [];
     for (const item of record.output) {
       if (!item || typeof item !== 'object') continue;
-      const typed = item as { type?: unknown; content?: unknown; text?: unknown };
-      const type = typeof typed.type === 'string' ? typed.type : '';
-      if (type === 'message') {
-        const text = coerceTextFromContent(typed.content);
-        if (text.trim()) outputTexts.push(text);
-      } else if (type === 'output_text' && typeof typed.text === 'string' && typed.text.trim()) {
-        outputTexts.push(typed.text);
+      const typed = item as { type?: string; content?: unknown; text?: string };
+      if (typed.type === 'message' && Array.isArray(typed.content)) {
+        for (const part of typed.content as Array<{ type?: string; text?: string }>) {
+          if (part?.type === 'output_text' && isValidText(part.text)) {
+            parts.push(part.text);
+          }
+        }
+      } else if (typed.type === 'output_text' && isValidText(typed.text)) {
+        parts.push(typed.text);
       }
     }
-    const joined = outputTexts.join('');
+    const joined = parts.join('');
     if (joined.trim()) return joined;
   }
 
+  // 4. OpenAI chat completions compat
   if (Array.isArray(record.choices) && record.choices.length > 0) {
-    const choice = record.choices[0] as { message?: { content?: unknown }; text?: unknown } | null | undefined;
-    if (choice?.message) {
-      const text = coerceTextFromContent(choice.message.content);
-      if (text.trim()) return text;
-    }
-    if (typeof choice?.text === 'string' && choice.text.trim()) {
-      return choice.text;
+    const choice = record.choices[0] as { message?: { content?: unknown } } | null | undefined;
+    if (choice?.message && isValidText(choice.message.content)) {
+      return choice.message.content;
     }
   }
 
@@ -144,22 +139,103 @@ function extractTextFallbackFromResponse(response: unknown): string {
 }
 
 async function getTextWithFallback(result: OpenRouterResult, context: string): Promise<string> {
-  const text = await result.getText();
-  if (text && text.trim()) {
-    return text;
+  // 1. Try the SDK's proper getText() first — this handles tool execution and
+  //    extracts text from the final response via the SDK's own logic.
+  try {
+    const text = await result.getText();
+    if (isValidText(text)) {
+      return text;
+    }
+    if (text && isLikelyResponseId(text)) {
+      log(`Ignored response id from getText (${context}): ${String(text).slice(0, 60)}`);
+    }
+  } catch (err) {
+    log(`getText failed (${context}): ${err instanceof Error ? err.message : String(err)}`);
   }
+
+  // 2. Fall back to raw response extraction — walk known fields ourselves
   try {
     const response = await result.getResponse();
-    const fallbackText = extractTextFallbackFromResponse(response);
-    if (fallbackText && fallbackText.trim()) {
-      log(`Recovered empty response text from payload (${context})`);
+    const fallbackText = extractTextFromRawResponse(response);
+    if (fallbackText) {
+      log(`Recovered text from raw response (${context})`);
       return fallbackText;
     }
-    log(`Model returned empty response and fallback extraction failed (${context})`);
+    const r = response as Record<string, unknown>;
+    const outputLen = Array.isArray(r.output) ? (r.output as unknown[]).length : 0;
+    log(`No text in raw response (${context}): id=${String(r.id ?? 'none').slice(0, 40)} status=${String(r.status ?? '?')} outputs=${outputLen}`);
   } catch (err) {
-    log(`Failed to recover empty response text (${context}): ${err instanceof Error ? err.message : String(err)}`);
+    log(`Raw response extraction failed (${context}): ${err instanceof Error ? err.message : String(err)}`);
   }
-  return text;
+
+  // 3. Never return a response ID
+  return '';
+}
+
+/**
+ * Direct Chat Completions API fallback.
+ * When the Responses API returns a gen-ID instead of text (common with fast
+ * models like gpt-5-nano/mini via OpenRouter), retry using the standard
+ * /chat/completions endpoint which reliably returns text content.
+ */
+async function chatCompletionsFallback(params: {
+  model: string;
+  instructions: string;
+  messages: Array<{ role: string; content: string }>;
+  maxOutputTokens: number;
+  temperature: number;
+}): Promise<string> {
+  const apiKey = process.env.OPENROUTER_API_KEY;
+  if (!apiKey) return '';
+
+  const headers: Record<string, string> = {
+    'Authorization': `Bearer ${apiKey}`,
+    'Content-Type': 'application/json'
+  };
+  if (agent.openrouter.siteUrl) {
+    headers['HTTP-Referer'] = agent.openrouter.siteUrl;
+  }
+  if (agent.openrouter.siteName) {
+    headers['X-Title'] = agent.openrouter.siteName;
+  }
+
+  const chatMessages = [
+    { role: 'system', content: params.instructions },
+    ...params.messages
+  ];
+
+  log(`Chat Completions fallback: model=${params.model}, messages=${chatMessages.length}`);
+  const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({
+      model: params.model,
+      messages: chatMessages,
+      max_completion_tokens: params.maxOutputTokens,
+      temperature: params.temperature,
+      reasoning_effort: 'low'
+    }),
+    signal: AbortSignal.timeout(agent.openrouter.timeoutMs)
+  });
+
+  const bodyText = await response.text();
+  if (!response.ok) {
+    log(`Chat Completions fallback HTTP ${response.status}: ${bodyText.slice(0, 300)}`);
+    return '';
+  }
+
+  try {
+    const data = JSON.parse(bodyText);
+    const content = data?.choices?.[0]?.message?.content;
+    if (isValidText(content)) {
+      log(`Chat Completions fallback recovered text (${String(content).length} chars)`);
+      return content;
+    }
+    log(`Chat Completions fallback returned no text: ${JSON.stringify(data).slice(0, 300)}`);
+  } catch (err) {
+    log(`Chat Completions fallback parse error: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  return '';
 }
 
 function writeOutput(output: ContainerOutput): void {
@@ -397,6 +473,7 @@ function buildSystemInstructions(params: {
   assistantName: string;
   groupNotes?: string | null;
   globalNotes?: string | null;
+  skillNotes?: SkillNote[];
   memorySummary: string;
   memoryFacts: string[];
   sessionRecall: string[];
@@ -429,7 +506,19 @@ function buildSystemInstructions(params: {
     '- `GitClone`: clone git repositories into the workspace.',
     '- `NpmInstall`: install npm dependencies in the workspace.',
     '- `mcp__dotclaw__send_message`: send Telegram messages.',
-    '- `mcp__dotclaw__schedule_task`: schedule tasks.',
+    '- `mcp__dotclaw__send_file`: send a file/document.',
+    '- `mcp__dotclaw__send_photo`: send a photo with compression.',
+    '- `mcp__dotclaw__send_voice`: send a voice message (.ogg format).',
+    '- `mcp__dotclaw__send_audio`: send an audio file (mp3, m4a, etc.).',
+    '- `mcp__dotclaw__send_location`: send a map pin (latitude/longitude).',
+    '- `mcp__dotclaw__send_contact`: send a contact card (phone + name).',
+    '- `mcp__dotclaw__send_poll`: create a Telegram poll.',
+    '- `mcp__dotclaw__send_buttons`: send a message with inline keyboard buttons.',
+    '- `mcp__dotclaw__edit_message`: edit a previously sent message.',
+    '- `mcp__dotclaw__delete_message`: delete a message.',
+    '- `mcp__dotclaw__download_url`: download a URL to the workspace as a file.',
+    '- Users may send photos, documents, voice messages, and videos. These are downloaded to `/workspace/group/inbox/` and referenced as `<attachment>` tags in messages. Process them with Read/Bash/Python tools.',
+    '- `mcp__dotclaw__schedule_task`: schedule tasks (set `timezone` for locale-specific schedules).',
     '- `mcp__dotclaw__run_task`: run a scheduled task immediately.',
     '- `mcp__dotclaw__list_tasks`, `mcp__dotclaw__pause_task`, `mcp__dotclaw__resume_task`, `mcp__dotclaw__cancel_task`.',
     '- `mcp__dotclaw__update_task`: update a task (state, prompt, schedule, status).',
@@ -479,6 +568,7 @@ function buildSystemInstructions(params: {
 
   const groupNotes = params.groupNotes ? `Group notes:\n${params.groupNotes}` : '';
   const globalNotes = params.globalNotes ? `Global notes:\n${params.globalNotes}` : '';
+  const skillNotes = formatSkillNotes(params.skillNotes || []);
 
   const toolReliability = params.toolReliability && params.toolReliability.length > 0
     ? params.toolReliability
@@ -536,53 +626,15 @@ function buildSystemInstructions(params: {
     ? `Job artifacts directory: /workspace/group/jobs/${params.jobId}`
     : '';
 
-  const taskExtractionBlock = params.taskExtractionPack
-    ? formatTaskExtractionPack({
-      pack: params.taskExtractionPack,
-      maxDemos: PROMPT_PACKS_MAX_DEMOS,
-      maxChars: PROMPT_PACKS_MAX_CHARS
-    })
-    : '';
-
-  const responseQualityBlock = params.responseQualityPack
-    ? formatResponseQualityPack({
-      pack: params.responseQualityPack,
-      maxDemos: PROMPT_PACKS_MAX_DEMOS,
-      maxChars: PROMPT_PACKS_MAX_CHARS
-    })
-    : '';
+  const fmtPack = (label: string, pack: PromptPack | null | undefined) =>
+    pack ? formatPromptPack({ label, pack, maxDemos: PROMPT_PACKS_MAX_DEMOS, maxChars: PROMPT_PACKS_MAX_CHARS }) : '';
 
-  const toolCallingBlock = params.toolCallingPack
-    ? formatToolCallingPack({
-      pack: params.toolCallingPack,
-      maxDemos: PROMPT_PACKS_MAX_DEMOS,
-      maxChars: PROMPT_PACKS_MAX_CHARS
-    })
-    : '';
-
-  const toolOutcomeBlock = params.toolOutcomePack
-    ? formatToolOutcomePack({
-      pack: params.toolOutcomePack,
-      maxDemos: PROMPT_PACKS_MAX_DEMOS,
-      maxChars: PROMPT_PACKS_MAX_CHARS
-    })
-    : '';
-
-  const memoryPolicyBlock = params.memoryPolicyPack
-    ? formatMemoryPolicyPack({
-      pack: params.memoryPolicyPack,
-      maxDemos: PROMPT_PACKS_MAX_DEMOS,
-      maxChars: PROMPT_PACKS_MAX_CHARS
-    })
-    : '';
-
-  const memoryRecallBlock = params.memoryRecallPack
-    ? formatMemoryRecallPack({
-      pack: params.memoryRecallPack,
-      maxDemos: PROMPT_PACKS_MAX_DEMOS,
-      maxChars: PROMPT_PACKS_MAX_CHARS
-    })
-    : '';
+  const taskExtractionBlock = fmtPack('Task Extraction Guidelines', params.taskExtractionPack);
+  const responseQualityBlock = fmtPack('Response Quality Guidelines', params.responseQualityPack);
+  const toolCallingBlock = fmtPack('Tool Calling Guidelines', params.toolCallingPack);
+  const toolOutcomeBlock = fmtPack('Tool Outcome Guidelines', params.toolOutcomePack);
+  const memoryPolicyBlock = fmtPack('Memory Policy Guidelines', params.memoryPolicyPack);
+  const memoryRecallBlock = fmtPack('Memory Recall Guidelines', params.memoryRecallPack);
 
   return [
     `You are ${params.assistantName}, a personal assistant running inside DotClaw.`,
@@ -594,6 +646,7 @@ function buildSystemInstructions(params: {
     browserAutomation,
     groupNotes,
     globalNotes,
+    skillNotes,
     timezoneNote,
     params.planBlock || '',
     toolCallingBlock,
@@ -655,6 +708,123 @@ function loadClaudeNotes(): { group: string | null; global: string | null } {
   };
 }
 
+export type SkillNote = {
+  scope: 'group' | 'global';
+  path: string;
+  content: string;
+};
+
+function collectSkillFiles(rootDir: string, maxFiles: number): string[] {
+  const files: string[] = [];
+  const seen = new Set<string>();
+  const addFile = (filePath: string) => {
+    const normalized = path.resolve(filePath);
+    if (seen.has(normalized)) return;
+    if (!fs.existsSync(normalized)) return;
+    let stat: fs.Stats;
+    try {
+      stat = fs.statSync(normalized);
+    } catch {
+      return;
+    }
+    if (!stat.isFile()) return;
+    if (!normalized.toLowerCase().endsWith('.md')) return;
+    seen.add(normalized);
+    files.push(normalized);
+  };
+
+  addFile(path.join(rootDir, 'SKILL.md'));
+
+  const skillsDir = path.join(rootDir, 'skills');
+  if (fs.existsSync(skillsDir)) {
+    const stack = [skillsDir];
+    while (stack.length > 0 && files.length < maxFiles) {
+      const current = stack.pop();
+      if (!current) continue;
+      let entries: fs.Dirent[];
+      try {
+        entries = fs.readdirSync(current, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      entries.sort((a, b) => a.name.localeCompare(b.name));
+      for (const entry of entries) {
+        const nextPath = path.join(current, entry.name);
+        if (entry.isSymbolicLink()) continue;
+        if (entry.isDirectory()) {
+          stack.push(nextPath);
+          continue;
+        }
+        if (entry.isFile()) {
+          addFile(nextPath);
+        }
+        if (files.length >= maxFiles) break;
+      }
+    }
+  }
+
+  files.sort((a, b) => a.localeCompare(b));
+  return files.slice(0, maxFiles);
+}
+
+export function loadSkillNotesFromRoots(params: {
+  groupDir: string;
+  globalDir: string;
+  maxFiles?: number;
+  maxCharsPerFile?: number;
+  maxTotalChars?: number;
+}): SkillNote[] {
+  const maxFiles = Number.isFinite(params.maxFiles) ? Math.max(1, Math.floor(params.maxFiles!)) : SKILL_NOTES_MAX_FILES;
+  const maxCharsPerFile = Number.isFinite(params.maxCharsPerFile)
+    ? Math.max(200, Math.floor(params.maxCharsPerFile!))
+    : SKILL_NOTES_MAX_CHARS;
+  const maxTotalChars = Number.isFinite(params.maxTotalChars)
+    ? Math.max(maxCharsPerFile, Math.floor(params.maxTotalChars!))
+    : SKILL_NOTES_TOTAL_MAX_CHARS;
+
+  const notes: SkillNote[] = [];
+  let consumedChars = 0;
+
+  const appendScopeNotes = (scope: 'group' | 'global', rootDir: string) => {
+    const skillFiles = collectSkillFiles(rootDir, maxFiles);
+    for (const filePath of skillFiles) {
+      if (notes.length >= maxFiles) break;
+      if (consumedChars >= maxTotalChars) break;
+      const content = readTextFileLimited(filePath, maxCharsPerFile);
+      if (!content) continue;
+      const remaining = maxTotalChars - consumedChars;
+      const truncated = content.length > remaining
+        ? `${content.slice(0, remaining)}\n\n[Truncated for total skill budget]`
+        : content;
+      const relativePath = path.relative(rootDir, filePath).split(path.sep).join('/');
+      notes.push({
+        scope,
+        path: relativePath || path.basename(filePath),
+        content: truncated
+      });
+      consumedChars += truncated.length;
+      if (consumedChars >= maxTotalChars) break;
+    }
+  };
+
+  appendScopeNotes('group', params.groupDir);
+  appendScopeNotes('global', params.globalDir);
+  return notes;
+}
+
+function formatSkillNotes(notes: SkillNote[]): string {
+  if (!notes || notes.length === 0) return '';
+  const lines: string[] = [
+    'Skill instructions (loaded from SKILL.md / skills/*.md):',
+    'When a task matches a skill, follow that skill workflow first and keep output concise.'
+  ];
+  for (const note of notes) {
+    lines.push(`[${note.scope}] ${note.path}`);
+    lines.push(note.content);
+  }
+  return lines.join('\n\n');
+}
+
 function extractQueryFromPrompt(prompt: string): string {
   if (!prompt) return '';
   const messageMatches = [...prompt.matchAll(/<message[^>]*>([\s\S]*?)<\/message>/g)];
@@ -670,6 +840,7 @@ function decodeXml(value: string): string {
     .replace(/&lt;/g, '<')
     .replace(/&gt;/g, '>')
     .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
     .replace(/&amp;/g, '&');
 }
 
@@ -712,7 +883,8 @@ async function updateMemorySummary(params: {
     instructions: prompt.instructions,
     input: prompt.input,
     maxOutputTokens: params.maxOutputTokens,
-    temperature: 0.1
+    temperature: 0.1,
+    reasoning: { effort: 'low' as const }
   });
   const text = await getTextWithFallback(result, 'summary');
   return parseSummaryResponse(text);
@@ -726,7 +898,8 @@ function buildMemoryExtractionPrompt(params: {
   memoryPolicyPack?: PromptPack | null;
 }): { instructions: string; input: string } {
   const policyBlock = params.memoryPolicyPack
-    ? formatMemoryPolicyPack({
+    ? formatPromptPack({
+      label: 'Memory Policy Guidelines',
       pack: params.memoryPolicyPack,
       maxDemos: PROMPT_PACKS_MAX_DEMOS,
       maxChars: PROMPT_PACKS_MAX_CHARS
@@ -853,7 +1026,8 @@ async function validateResponseQuality(params: {
     instructions: prompt.instructions,
     input: prompt.input,
     maxOutputTokens: params.maxOutputTokens,
-    temperature: params.temperature
+    temperature: params.temperature,
+    reasoning: { effort: 'low' as const }
   });
   const text = await getTextWithFallback(result, 'response_validation');
   return parseResponseValidation(text);
@@ -959,29 +1133,15 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
   const responseValidateMinPromptTokens = agent.responseValidation.minPromptTokens || 0;
   const responseValidateMinResponseTokens = agent.responseValidation.minResponseTokens || 0;
   const maxContextMessageTokens = agent.context.maxContextMessageTokens;
-  const streamingEnabled = Boolean(input.streaming?.enabled && typeof input.streaming?.draftId === 'number');
-  const streamingDraftId = streamingEnabled ? input.streaming?.draftId : undefined;
-  const streamingMinIntervalMs = Math.max(
-    0,
-    Math.floor(
-      typeof input.streaming?.minIntervalMs === 'number'
-        ? input.streaming.minIntervalMs
-        : agent.streaming.minIntervalMs
-    )
-  );
-  const streamingMinChars = Math.max(
-    1,
-    Math.floor(
-      typeof input.streaming?.minChars === 'number'
-        ? input.streaming.minChars
-        : agent.streaming.minChars
-    )
-  );
 
   const openrouter = getCachedOpenRouter(apiKey, openrouterOptions);
   const tokenEstimate = resolveTokenEstimate(input, agentConfig);
   const availableGroups = loadAvailableGroups();
   const claudeNotes = loadClaudeNotes();
+  const skillNotes = loadSkillNotesFromRoots({
+    groupDir: GROUP_DIR,
+    globalDir: GLOBAL_DIR
+  });
 
   const { ctx: sessionCtx, isNew } = createSessionContext(SESSION_ROOT, input.sessionId);
   const toolCalls: ToolCallRecord[] = [];
@@ -1008,21 +1168,6 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
     }
   });
 
-  let streamLastSentAt = 0;
-  let streamLastSentLength = 0;
-  const sendStreamUpdate = (text: string, force = false) => {
-    if (!streamingEnabled || !streamingDraftId) return;
-    if (!text || !text.trim()) return;
-    const now = Date.now();
-    if (!force) {
-      if (now - streamLastSentAt < streamingMinIntervalMs) return;
-      if (text.length - streamLastSentLength < streamingMinChars) return;
-    }
-    streamLastSentAt = now;
-    streamLastSentLength = text.length;
-    void ipc.sendDraft(text, streamingDraftId).catch(() => undefined);
-  };
-
   if (process.env.DOTCLAW_SELF_CHECK === '1') {
     try {
       const details = await runSelfCheck({ model });
@@ -1047,6 +1192,16 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
   if (input.isScheduledTask) {
     prompt = `[SCHEDULED TASK - You are running automatically, not in response to a user message. Use mcp__dotclaw__send_message if needed to communicate with the user.]\n\n${input.prompt}`;
   }
+  if (Array.isArray(input.attachments) && input.attachments.length > 0) {
+    const attachmentSummary = input.attachments.map(attachment => {
+      const parts = [`type=${attachment.type}`, `path=${attachment.path}`];
+      if (attachment.file_name) parts.push(`filename=${attachment.file_name}`);
+      if (attachment.mime_type) parts.push(`mime=${attachment.mime_type}`);
+      if (Number.isFinite(attachment.file_size)) parts.push(`size=${attachment.file_size}`);
+      return `- ${parts.join(' ')}`;
+    }).join('\n');
+    prompt = `${prompt}\n\n<latest_attachments>\n${attachmentSummary}\n</latest_attachments>`;
+  }
 
   appendHistory(sessionCtx, 'user', prompt);
   let history = loadHistory(sessionCtx);
@@ -1177,6 +1332,7 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
     assistantName,
     groupNotes: claudeNotes.group,
     globalNotes: claudeNotes.global,
+    skillNotes,
     memorySummary: sessionCtx.state.summary,
     memoryFacts: sessionCtx.state.facts,
     sessionRecall,
@@ -1225,7 +1381,8 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
         instructions: plannerPrompt.instructions,
         input: plannerPrompt.input,
         maxOutputTokens: plannerMaxOutputTokens,
-        temperature: plannerTemperature
+        temperature: plannerTemperature,
+        reasoning: { effort: 'low' as const }
       });
       const plannerText = await getTextWithFallback(plannerResult, 'planner');
       const plan = parsePlannerResponse(plannerText);
@@ -1282,6 +1439,16 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
       + estimateMessagesTokens(contextMessages, tokenEstimate.tokensPerChar, tokenEstimate.tokensPerMessage)
       + tokenEstimate.tokensPerRequest;
 
+    const safeLimit = Math.floor(config.maxContextTokens * 0.9);
+    if (resolvedPromptTokens > safeLimit && contextMessages.length > 2) {
+      log(`Estimated ${resolvedPromptTokens} tokens exceeds safe limit ${safeLimit}, truncating`);
+      while (contextMessages.length > 2) {
+        const currentTokens = resolvedInstructionTokens + estimateMessagesTokens(contextMessages, tokenEstimate.tokensPerChar, tokenEstimate.tokensPerMessage) + tokenEstimate.tokensPerRequest;
+        if (currentTokens <= safeLimit) break;
+        contextMessages.splice(0, 1);
+      }
+    }
+
     log('Starting OpenRouter call...');
     const startedAt = Date.now();
     const callParams = {
@@ -1292,47 +1459,39 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
       stopWhen: stepCountIs(maxToolSteps),
       maxOutputTokens: config.maxOutputTokens,
       temperature: config.temperature,
-      stream: streamingEnabled
+      reasoning: { effort: 'low' as const }
     };
-    const result = await openrouter.callModel(callParams as Parameters<typeof openrouter.callModel>[0]);
+    const result = await openrouter.callModel(callParams);
     const localLatencyMs = Date.now() - startedAt;
+
+    // Get the complete response text via the SDK's proper getText() path
+    let localResponseText = await getTextWithFallback(result, 'completion');
+
     const toolCallsFromModel = await result.getToolCalls();
     if (toolCallsFromModel.length > 0) {
       log(`Model made ${toolCallsFromModel.length} tool call(s): ${toolCallsFromModel.map(t => t.name).join(', ')}`);
     }
 
-    let localResponseText = '';
-    let streamed = false;
-    if (streamingEnabled && typeof (result as { getTextStream?: () => AsyncIterable<unknown> }).getTextStream === 'function') {
-      try {
-        const stream = (result as { getTextStream: () => AsyncIterable<unknown> }).getTextStream();
-        for await (const chunk of stream) {
-          const delta = typeof chunk === 'string'
-            ? chunk
-            : (typeof (chunk as { text?: unknown })?.text === 'string' ? (chunk as { text?: string }).text || '' : '');
-          if (!delta) continue;
-          localResponseText += delta;
-          sendStreamUpdate(localResponseText);
-        }
-        if (localResponseText) {
-          sendStreamUpdate(localResponseText, true);
-        }
-        streamed = true;
-      } catch (err) {
-        log(`Streaming failed, falling back to full response: ${err instanceof Error ? err.message : String(err)}`);
-      }
-    }
-    if (!streamed || !localResponseText || !localResponseText.trim()) {
-      localResponseText = await getTextWithFallback(result, 'completion');
-      if (localResponseText && localResponseText.trim()) {
-        sendStreamUpdate(localResponseText, true);
-      }
-    }
     if (!localResponseText || !localResponseText.trim()) {
       if (toolCallsFromModel.length > 0) {
         localResponseText = 'I started running tool calls but did not get a final response. If you want me to continue, please ask a narrower subtask or say "continue".';
+      } else {
+        // Responses API likely returned a gen-ID; retry with Chat Completions API
+        try {
+          localResponseText = await chatCompletionsFallback({
+            model,
+            instructions: resolvedInstructions,
+            messages: messagesToOpenRouter(contextMessages),
+            maxOutputTokens: config.maxOutputTokens,
+            temperature: config.temperature
+          });
+        } catch (err) {
+          log(`Chat Completions fallback error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+      if (!localResponseText || !localResponseText.trim()) {
+        log(`Warning: Model returned empty/whitespace response after all fallbacks. tool calls: ${toolCallsFromModel.length}`);
       }
-      log(`Warning: Model returned empty/whitespace response. Raw length: ${localResponseText?.length ?? 0}, tool calls: ${toolCallsFromModel.length}`);
     } else {
       log(`Model returned text response (${localResponseText.length} chars)`);
     }
@@ -1360,8 +1519,9 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
       && completionTokens >= responseValidateMinResponseTokens
       && (responseValidateAllowToolCalls || modelToolCalls.length === 0);
     if (shouldValidate) {
+      const MAX_VALIDATION_ITERATIONS = 5;
       let retriesLeft = responseValidateMaxRetries;
-      while (true) {
+      for (let _validationIter = 0; _validationIter < MAX_VALIDATION_ITERATIONS; _validationIter++) {
         if (!responseValidateAllowToolCalls && modelToolCalls.length > 0) {
           break;
         }
@@ -1392,8 +1552,6 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
         }
         retriesLeft -= 1;
         log(`Response validation failed; retrying (${retriesLeft} retries left)`);
-        streamLastSentAt = 0;
-        streamLastSentLength = 0;
         const retryGuidance = buildRetryGuidance(validationResult);
         const retryAttempt = await runCompletion(retryGuidance);
         responseText = retryAttempt.responseText;
@@ -1464,7 +1622,8 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
       instructions: extractionPrompt.instructions,
       input: extractionPrompt.input,
       maxOutputTokens: memoryExtractionMaxOutputTokens,
-      temperature: 0.1
+      temperature: 0.1,
+      reasoning: { effort: 'low' as const }
     });
     const extractionText = await getTextWithFallback(extractionResult, 'memory_extraction');
     const extractedItems = parseMemoryExtraction(extractionText);
@@ -1501,16 +1660,25 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
   };
 
   if (memoryExtractionEnabled && (!input.isScheduledTask || memoryExtractScheduled)) {
+    const runMemoryExtractionWithRetry = async (maxRetries = 2): Promise<void> => {
+      for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+          await runMemoryExtraction();
+          return;
+        } catch (err) {
+          log(`Memory extraction attempt ${attempt + 1} failed: ${err instanceof Error ? err.message : String(err)}`);
+          if (attempt < maxRetries) {
+            await new Promise(r => setTimeout(r, 1000 * Math.pow(2, attempt)));
+          }
+        }
+      }
+      log('Memory extraction failed after all retries');
+    };
+
     if (memoryExtractionAsync && isDaemon) {
-      void runMemoryExtraction().catch(err => {
-        log(`Memory extraction failed: ${err instanceof Error ? err.message : String(err)}`);
-      });
+      void runMemoryExtractionWithRetry().catch(() => {});
     } else {
-      try {
-        await runMemoryExtraction();
-      } catch (err) {
-        log(`Memory extraction failed: ${err instanceof Error ? err.message : String(err)}`);
-      }
+      await runMemoryExtractionWithRetry();
     }
   }