@magclaw/cli-core 0.1.33 → 0.1.35

package/src/cli.js

@@ -2,8 +2,8 @@ import http from 'node:http';
 import https from 'node:https';
 import crypto from 'node:crypto';
 import { spawn, spawnSync } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { chmod, copyFile, cp, lstat, mkdir, open, readFile, readdir, readlink, realpath, rm, stat, symlink, unlink, writeFile } from 'node:fs/promises';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { chmod, copyFile, cp, lstat, mkdir, open, readFile, readdir, readlink, realpath, rename, rm, stat, symlink, unlink, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -61,6 +61,79 @@ function now() {
   return new Date().toISOString();
 }
 
+function claudeStreamEvents(raw) {
+  if (!raw || typeof raw !== 'object') return [];
+  const event = raw;
+  const output = [];
+  if (event.type === 'system' && event.subtype === 'init') {
+    output.push({
+      type: 'system',
+      sessionId: event.session_id || event.sessionId || '',
+      model: event.model || '',
+      cwd: event.cwd || '',
+    });
+    return output;
+  }
+  const content = Array.isArray(event.message?.content) ? event.message.content : [];
+  if (event.type === 'assistant') {
+    for (const block of content) {
+      if (block?.type === 'text' && typeof block.text === 'string' && block.text) {
+        output.push({ type: 'text', delta: block.text });
+      } else if (block?.type === 'thinking' && typeof block.thinking === 'string' && block.thinking) {
+        output.push({ type: 'thinking', delta: block.thinking });
+      } else if (block?.type === 'tool_use' && block.id && block.name) {
+        output.push({ type: 'tool_use', id: block.id, name: block.name, input: block.input });
+      }
+    }
+    return output;
+  }
+  if (event.type === 'user') {
+    for (const block of content) {
+      if (block?.type === 'tool_result' && block.tool_use_id) {
+        output.push({
+          type: 'tool_result',
+          id: block.tool_use_id,
+          output: typeof block.content === 'string' ? block.content : JSON.stringify(block.content),
+          isError: block.is_error === true,
+        });
+      }
+    }
+    return output;
+  }
+  if (event.type === 'result') {
+    if (event.usage) {
+      output.push({
+        type: 'usage',
+        inputTokens: event.usage.input_tokens,
+        outputTokens: event.usage.output_tokens,
+        costUsd: event.total_cost_usd,
+      });
+    }
+    output.push({ type: 'done', sessionId: event.session_id || event.sessionId || '' });
+  }
+  return output;
+}
+
+function claudeToolActivityDetail(event) {
+  if (!event || typeof event !== 'object') return 'Claude Code activity';
+  if (event.type === 'tool_use') return `Claude Code using ${event.name || 'tool'}`;
+  if (event.type === 'tool_result') return event.isError ? 'Claude Code tool returned an error' : 'Claude Code tool completed';
+  if (event.type === 'thinking') return 'Claude Code thinking';
+  if (event.type === 'usage') return `Claude Code usage input=${event.inputTokens || 0} output=${event.outputTokens || 0}`;
+  return 'Claude Code activity';
+}
+
+function codexStderrRuntimeError(text = '') {
+  const detail = String(text || '').trim();
+  if (!detail) return '';
+  const lower = detail.toLowerCase();
+  if (lower.includes('responses_websocket') && lower.includes('error')) return detail.slice(0, 2000);
+  if (lower.includes('failed to connect to websocket') && lower.includes('/v1/responses')) return detail.slice(0, 2000);
+  if (lower.includes('authentication') && lower.includes('openai')) return detail.slice(0, 2000);
+  if (lower.includes('not logged in') || lower.includes('login is required')) return detail.slice(0, 2000);
+  return '';
+}
+
 function packageInfoFromSpec(packageSpec = '') {
   const match = String(packageSpec || '').trim().match(/^(@magclaw\/(?:daemon|computer))(?:@(.+))?$/);
   return {
@@ -489,6 +562,38 @@ export async function activeComputerLock(env = process.env) {
   return activeLockFile(paths.lockFile, { scope: 'computer' });
 }
 
+function readJsonFileSync(file, fallback = {}) {
+  if (!existsSync(file)) return fallback;
+  try {
+    return JSON.parse(readFileSync(file, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJsonFileSync(file, value) {
+  mkdirSync(path.dirname(file), { recursive: true });
+  writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function readServiceStateSync(profile = DEFAULT_PROFILE, env = process.env) {
+  const paths = profilePaths(profile, env);
+  return readJsonFileSync(paths.service, {});
+}
+
+function activeDaemonLockSync(profile = DEFAULT_PROFILE, env = process.env) {
+  const paths = profilePaths(profile, env);
+  const lock = readJsonFileSync(paths.lockFile, null);
+  if (lock?.pid && pidIsRunning(lock.pid)) {
+    return {
+      profile: paths.profile,
+      ...lock,
+      lockFile: paths.lockFile,
+    };
+  }
+  return null;
+}
+
 async function writeLockFile(file, lock) {
   const handle = await open(file, 'wx');
   try {
@@ -730,7 +835,7 @@ function renderComputerHelp(subcommand = '') {
       '  --dry-run                  Preview upgrade actions',
       '  --channel <name>           latest | alpha | pinned:<semver>',
       '  --target-version <semver>  Explicit target version',
-      '  --force                    Accepted for Slock parity; currently maps to the normal upgrade path',
+      '  --force                    Accepted for MagClaw compatibility; currently maps to the normal upgrade path',
     ],
   };
   if (command && usage[command]) return `${usage[command].join('\n')}\n`;
@@ -873,10 +978,24 @@ function backgroundServiceModeForPlatform(platform = process.platform) {
   return 'foreground';
 }
 
+function normalizeBackgroundServiceMode(value = '') {
+  const mode = String(value || '').trim().toLowerCase();
+  if (['container', 'k8s', 'kubernetes', 'pod'].includes(mode)) return 'container';
+  if (['launchd', 'systemd', 'schtasks', 'foreground'].includes(mode)) return mode;
+  return '';
+}
+
+function requestedBackgroundServiceMode(env = process.env, platform = process.platform) {
+  return normalizeBackgroundServiceMode(env.MAGCLAW_DAEMON_SERVICE_MODE)
+    || normalizeBackgroundServiceMode(env.MAGCLAW_DAEMON_BACKGROUND_MODE)
+    || backgroundServiceModeForPlatform(platform);
+}
+
 export function serviceStatePatchForDaemonRun(service = {}, env = process.env, platform = process.platform) {
   if (daemonRunLaunchedByBackgroundService(env)) {
+    const serviceMode = normalizeBackgroundServiceMode(service.mode);
     return {
-      mode: service.mode || backgroundServiceModeForPlatform(platform),
+      mode: serviceMode && serviceMode !== 'foreground' ? serviceMode : requestedBackgroundServiceMode(env, platform),
       background: true,
     };
   }
@@ -1675,6 +1794,60 @@ function contextSnippet(value, limit = 240) {
   return text.length >= limit ? `${text.slice(0, Math.max(0, limit - 3)).trim()}...` : text;
 }
 
+function contextImageMimeFromName(value = '') {
+  const name = String(value || '').toLowerCase().split(/[?#]/)[0];
+  if (name.endsWith('.png')) return 'image/png';
+  if (name.endsWith('.jpg') || name.endsWith('.jpeg')) return 'image/jpeg';
+  if (name.endsWith('.webp')) return 'image/webp';
+  if (name.endsWith('.gif')) return 'image/gif';
+  if (name.endsWith('.svg')) return 'image/svg+xml';
+  return '';
+}
+
+function contextDataImageUrl(value = '') {
+  const text = String(value || '').trim();
+  return /^data:image\//i.test(text) ? text : '';
+}
+
+function contextImageType(reference = {}) {
+  const explicit = String(reference.type || reference.mime || reference.mimeType || '').toLowerCase();
+  if (explicit.startsWith('image/')) return explicit;
+  const data = contextDataImageUrl(reference.dataUrl || reference.url || reference.downloadUrl);
+  if (data) return data.match(/^data:([^;,]+)[;,]/i)?.[1]?.toLowerCase() || 'image';
+  return contextImageMimeFromName(reference.name || reference.filename || reference.url || reference.downloadUrl || reference.path || reference.description);
+}
+
+function isContextImageReference(reference = {}) {
+  return contextImageType(reference).startsWith('image/');
+}
+
+function remoteImageUrl(value = '', serverUrl = '', fallbackPath = '') {
+  const raw = String(value || '').trim();
+  if (contextDataImageUrl(raw)) return raw;
+  const base = String(serverUrl || DEFAULT_SERVER_URL).replace(/\/+$/, '');
+  const candidate = raw || String(fallbackPath || '').trim();
+  if (!candidate) return '';
+  if (candidate.startsWith('/')) {
+    try {
+      return new URL(candidate, base).toString();
+    } catch {
+      return '';
+    }
+  }
+  if (/^https?:\/\//i.test(candidate)) {
+    try {
+      const parsed = new URL(candidate);
+      if (['0.0.0.0', '127.0.0.1', 'localhost', '::1'].includes(parsed.hostname) && base) {
+        return new URL(`${parsed.pathname}${parsed.search}${parsed.hash}`, base).toString();
+      }
+      return parsed.toString();
+    } catch {
+      return '';
+    }
+  }
+  return '';
+}
+
 function contextActorName(pack, id) {
   const value = String(id || '').trim();
   if (!value) return 'unknown';
@@ -1721,6 +1894,50 @@ function renderContextTasks(pack) {
   }).join('\n');
 }
 
+function renderContextAttachments(pack) {
+  const attachments = contextArray(pack?.attachments);
+  if (!attachments.length) return '- (none)';
+  return attachments.map((item) => {
+    const details = [
+      item.id ? `id=${item.id}` : '',
+      item.messageId ? `from msg=${item.messageId}` : '',
+      item.source ? `source=${item.source}` : '',
+      item.path ? `path=${item.path}` : '',
+      item.url ? `url=${item.url}` : '',
+      item.id ? `tool=read_attachment(attachmentId="${item.id}")` : '',
+    ].filter(Boolean).join(', ');
+    return `- ${item.name || item.filename || item.id || 'attachment'} ${item.type || item.mime || 'file'} ${Number(item.bytes || item.sizeBytes || 0)} bytes${details ? ` (${details})` : ''}`;
+  }).join('\n');
+}
+
+function renderContextTargetAgentAvatar(pack) {
+  const avatar = pack?.targetAgent?.avatar;
+  if (!avatar || avatar.kind === 'none') return '';
+  const description = avatar.description ? ` (${avatar.description})` : '';
+  if (avatar.visualInput !== false && isContextImageReference(avatar)) {
+    return `- Your profile avatar: image supplied as visual input${description}. Use it when the user asks what your avatar shows.`;
+  }
+  return `- Your profile avatar: ${avatar.description || 'configured'}, but no visual input is available.`;
+}
+
+function contextParticipantAvatarVisualInputs(pack, targetAgentId = '') {
+  return compactContextParticipants(pack, targetAgentId).selected.filter((item) => (
+    item.id !== targetAgentId
+    && item.type === 'agent'
+    && item.avatar
+    && item.avatar.kind !== 'none'
+    && item.avatar.visualInput !== false
+    && isContextImageReference(item.avatar)
+  ));
+}
+
+function renderContextParticipantAvatarInputs(pack, targetAgentId = '') {
+  const visible = contextParticipantAvatarVisualInputs(pack, targetAgentId);
+  if (!visible.length) return '';
+  const names = visible.map((item) => `@${item.name || item.id}`).join(', ');
+  return `- Participant avatar visual inputs: ${names}. Use these when comparing an uploaded image to another Agent avatar; call read_agent_avatar if the relevant Agent is omitted.`;
+}
+
 function renderContextEventMembers(pack, event = {}) {
   const ids = [
     ...contextArray(event.memberIds),
@@ -1843,6 +2060,8 @@ function renderRemoteAgentContextPack(pack, targetAgentId = '') {
     `- Space: ${pack.space?.type || 'space'} (${pack.space?.visibility || 'public'}${pack.space?.defaultChannel ? ', default workspace channel' : ''})`,
     pack.space?.description ? `- Channel description: ${contextSnippet(pack.space.description, 180)}` : '',
     `- Participants shown: ${participants.selected.map((item) => renderContextParticipant(item, targetAgentId)).join(', ') || '(none)'}`,
+    renderContextTargetAgentAvatar(pack),
+    renderContextParticipantAvatarInputs(pack, targetAgentId),
     participants.omitted ? `- Participants omitted: ${participants.omitted}. Use list_agents/read_agent_profile or search_agent_memory when a broader roster or specialties matter.` : '',
     pack.space?.type === 'channel' && !pack.space?.defaultChannel ? renderContextSuggestedMembers(pack) : '',
     '',
@@ -1871,9 +2090,12 @@ function renderRemoteAgentContextPack(pack, targetAgentId = '') {
     'Relevant tasks:',
     renderContextTasks(pack),
     '',
+    'Visible attachment metadata and original-file tools:',
+    renderContextAttachments(pack),
+    '',
     renderContextPeerMemory(pack),
     '',
-    'Progressive context tools: list_agents, read_agent_profile, read_history, search_messages, search_agent_memory, read_agent_memory, read_agent_file, and list_tasks are available through MagClaw MCP.',
+    'Progressive context tools: list_agents, read_agent_profile, read_agent_avatar, read_history, search_messages, list_attachments, read_attachment, search_agent_memory, read_agent_memory, read_agent_file, and list_tasks are available through MagClaw MCP.',
     'For "who can we bring in" or agent suitability questions, use the server member list above first; call list_agents without a target for the server-wide agent roster, because target filters to the current channel.',
     'For agent capability or specialty questions, use peer memory first; if memory is empty or weak, search_messages/read_history for earlier user role assignments before saying the fact is unknown.',
     'Use this compact snapshot first. Call the tools only when the answer depends on omitted participants, deeper history, memory, or task details.',
@@ -1974,11 +2196,14 @@ function canonicalMagClawToolName(name) {
     'send_message',
     'read_history',
     'search_messages',
+    'list_attachments',
+    'read_attachment',
     'search_agent_memory',
     'read_agent_memory',
     'read_agent_file',
     'list_agents',
     'read_agent_profile',
+    'read_agent_avatar',
     'write_memory',
     'list_tasks',
     'create_tasks',
@@ -2153,32 +2378,152 @@ async function globalSkillRoots() {
   return roots;
 }
 
-async function syncGlobalSkillsIntoAgentHome(codexHome, workspace) {
+function pathIsWithinResolvedRoots(resolvedPath, roots = []) {
+  const cleanPath = path.resolve(resolvedPath);
+  return roots.some((root) => cleanPath === root || cleanPath.startsWith(`${root}${path.sep}`));
+}
+
+async function resolvedRoots(roots = []) {
+  const resolved = [];
+  for (const root of roots) {
+    const logical = path.resolve(root);
+    if (!resolved.includes(logical)) resolved.push(logical);
+    const physical = await realpath(root).catch(() => logical);
+    if (!resolved.includes(physical)) resolved.push(physical);
+  }
+  return resolved;
+}
+
+async function ensureWorkspaceSkillsDir(workspace, codexHome = '', agent = {}) {
+  const workspaceSkills = path.join(workspace, 'skills');
+  const legacyGeneratedSkills = codexHome ? path.join(codexHome, 'skills') : '';
+  await mkdir(path.dirname(workspaceSkills), { recursive: true });
+  try {
+    const existing = await lstat(workspaceSkills);
+    if (existing.isSymbolicLink()) {
+      const current = await readlink(workspaceSkills);
+      const resolved = path.resolve(path.dirname(workspaceSkills), current);
+      if (legacyGeneratedSkills && resolved === path.resolve(legacyGeneratedSkills)) {
+        await unlink(workspaceSkills);
+        await mkdir(workspaceSkills, { recursive: true });
+        logInfo('skills', `Repaired workspace skills directory for agent ${agent.id || 'unknown'}.`);
+      } else {
+        logWarning('skills', `Workspace skills path for agent ${agent.id || 'unknown'} is a custom symlink; leaving it untouched.`);
+      }
+    } else if (!existing.isDirectory()) {
+      logWarning('skills', `Workspace skills path for agent ${agent.id || 'unknown'} is not a directory; leaving it untouched.`);
+      return null;
+    }
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+    await mkdir(workspaceSkills, { recursive: true });
+  }
+  return workspaceSkills;
+}
+
+async function migrateLegacyAgentSkills(codexHome, workspaceSkills, globalResolvedRoots, agent = {}) {
+  const codexSkillsRoot = path.join(codexHome, 'skills');
+  if (!workspaceSkills || !existsSync(codexSkillsRoot)) return;
+  const entries = await readdir(codexSkillsRoot, { withFileTypes: true }).catch(() => []);
+  for (const entry of entries) {
+    if (entry.name.startsWith('.') || entry.name === '.system') continue;
+    const source = path.join(codexSkillsRoot, entry.name);
+    const target = path.join(workspaceSkills, entry.name);
+    if (existsSync(target)) continue;
+    const sourceInfo = await lstat(source).catch(() => null);
+    if (!sourceInfo) continue;
+    try {
+      if (sourceInfo.isSymbolicLink()) {
+        const current = await readlink(source);
+        const resolved = path.resolve(path.dirname(source), current);
+        if (pathIsWithinResolvedRoots(resolved, globalResolvedRoots)) continue;
+        const realTarget = await realpath(resolved).catch(() => resolved);
+        if (pathIsWithinResolvedRoots(realTarget, globalResolvedRoots)) continue;
+        const targetInfo = await stat(realTarget).catch(() => null);
+        if (!targetInfo) continue;
+        await symlink(realTarget, target, targetInfo.isDirectory() ? 'dir' : 'file');
+        await unlink(source);
+      } else {
+        await rename(source, target);
+      }
+      logInfo('skills', `Migrated legacy local skill ${entry.name} for agent ${agent.id || 'unknown'}.`);
+    } catch (error) {
+      logWarning('skills', `Could not migrate legacy local skill ${entry.name} for agent ${agent.id || 'unknown'}: ${error.message}`);
+    }
+  }
+}
+
+async function linkRuntimeSkillEntry(source, target, agent = {}) {
+  const linked = await linkPathEntry(source, target);
+  if (linked) return true;
+  const existing = await lstat(target).catch(() => null);
+  if (existing && !existing.isSymbolicLink() && path.resolve(source) !== path.resolve(target)) {
+    logWarning('skills', `Could not link skill ${path.basename(target)} for agent ${agent.id || 'unknown'} because the runtime path is not a symlink.`);
+  }
+  return false;
+}
+
+async function linkSkillRootEntries(sourceRoot, targetRoot, agent = {}, { includeSystem = false } = {}) {
+  const desired = new Set();
+  if (!sourceRoot || !existsSync(sourceRoot)) return desired;
+  const entries = await readdir(sourceRoot, { withFileTypes: true }).catch(() => []);
+  for (const entry of entries) {
+    if (entry.name.startsWith('.') && !(includeSystem && entry.name === '.system')) continue;
+    const source = path.join(sourceRoot, entry.name);
+    if (includeSystem && entry.name === '.system' && (entry.isDirectory() || entry.isSymbolicLink())) {
+      desired.add(entry.name);
+      const targetSystemRoot = path.join(targetRoot, '.system');
+      await mkdir(targetSystemRoot, { recursive: true });
+      const systemEntries = await readdir(source, { withFileTypes: true }).catch(() => []);
+      for (const systemEntry of systemEntries) {
+        if (!systemEntry.isDirectory() && !systemEntry.isSymbolicLink() && !systemEntry.isFile()) continue;
+        const systemSource = path.join(source, systemEntry.name);
+        const systemTarget = path.join(targetSystemRoot, systemEntry.name);
+        await linkRuntimeSkillEntry(systemSource, systemTarget, agent).catch((error) => {
+          logWarning('skills', `Could not link system skill ${systemEntry.name} for agent ${agent.id || 'unknown'}: ${error.message}`);
+        });
+      }
+      continue;
+    }
+    if (!entry.isDirectory() && !entry.isSymbolicLink() && !entry.isFile()) continue;
+    desired.add(entry.name);
+    const target = path.join(targetRoot, entry.name);
+    await linkRuntimeSkillEntry(source, target, agent).catch((error) => {
+      logWarning('skills', `Could not link skill ${entry.name} for agent ${agent.id || 'unknown'}: ${error.message}`);
+    });
+  }
+  return desired;
+}
+
+async function pruneGeneratedSkillLinks(targetSkillsRoot, desiredNames, agent = {}) {
+  const entries = await readdir(targetSkillsRoot, { withFileTypes: true }).catch(() => []);
+  for (const entry of entries) {
+    if (entry.name.startsWith('.') && entry.name !== '.system') continue;
+    if (desiredNames.has(entry.name)) continue;
+    const target = path.join(targetSkillsRoot, entry.name);
+    const existing = await lstat(target).catch(() => null);
+    if (!existing) continue;
+    if (existing.isSymbolicLink()) {
+      await unlink(target);
+    } else if (entry.name !== '.system') {
+      logWarning('skills', `Stale runtime skill ${entry.name} for agent ${agent.id || 'unknown'} was not removed because it is not a symlink.`);
+    }
+  }
+}
+
+async function syncGlobalSkillsIntoAgentHome(codexHome, workspace, agent = {}) {
   const targetSkillsRoot = path.join(codexHome, 'skills');
   await mkdir(targetSkillsRoot, { recursive: true });
   const roots = await globalSkillRoots();
+  const globalResolvedRoots = await resolvedRoots(roots);
+  const workspaceSkills = await ensureWorkspaceSkillsDir(workspace, codexHome, agent);
+  await migrateLegacyAgentSkills(codexHome, workspaceSkills, globalResolvedRoots, agent);
+  const desiredNames = new Set();
   for (const sourceSkillsRoot of [...roots].reverse()) {
-    const entries = await readdir(sourceSkillsRoot, { withFileTypes: true }).catch(() => []);
-    for (const entry of entries) {
-      const source = path.join(sourceSkillsRoot, entry.name);
-      if (entry.name === '.system' && (entry.isDirectory() || entry.isSymbolicLink())) {
-        const targetSystemRoot = path.join(targetSkillsRoot, '.system');
-        await mkdir(targetSystemRoot, { recursive: true });
-        const systemEntries = await readdir(source, { withFileTypes: true }).catch(() => []);
-        for (const systemEntry of systemEntries) {
-          const systemSource = path.join(source, systemEntry.name);
-          const systemTarget = path.join(targetSystemRoot, systemEntry.name);
-          await linkPathEntry(systemSource, systemTarget).catch(() => {});
-        }
-        continue;
-      }
-      if (!entry.isDirectory() && !entry.isSymbolicLink() && !entry.isFile()) continue;
-      await linkPathEntry(source, path.join(targetSkillsRoot, entry.name)).catch(() => {});
-    }
+    for (const name of await linkSkillRootEntries(sourceSkillsRoot, targetSkillsRoot, agent, { includeSystem: true })) desiredNames.add(name);
   }
-
-  const workspaceSkillsLink = path.join(workspace, 'skills');
-  await linkPathEntry(targetSkillsRoot, workspaceSkillsLink).catch(() => {});
+  for (const name of await linkSkillRootEntries(workspaceSkills, targetSkillsRoot, agent)) desiredNames.add(name);
+  await pruneGeneratedSkillLinks(targetSkillsRoot, desiredNames, agent);
 }
 
 function firstFrontmatterValue(content, keys) {
@@ -2231,11 +2576,12 @@ function shortenSkillPath(absPath, { agentRoot = '', codexHome = '' } = {}) {
 async function parseSkillFile(filePath, scope, context = {}) {
   const content = await readFile(filePath, 'utf8').catch(() => '');
   const resolvedFilePath = await realpath(filePath).catch(() => filePath);
+  const logicalFilePath = path.resolve(filePath);
   const name = firstFrontmatterValue(content, ['name', 'title']) || skillNameFromPath(filePath);
   const description = firstFrontmatterValue(content, ['description', 'summary', 'short_description', 'short-description'])
     || firstMarkdownParagraph(content)
     || 'No description provided.';
-  const shortPath = shortenSkillPath(resolvedFilePath, context);
+  const shortPath = shortenSkillPath(logicalFilePath, context);
   return {
     id: `${scope}:${shortPath}`,
     name,
@@ -2326,15 +2672,6 @@ async function findPluginSkillFiles(root, { maxEntries = 400 } = {}) {
   return found;
 }
 
-async function resolvedRoots(paths) {
-  const roots = [];
-  for (const item of paths) {
-    if (!item || !existsSync(item)) continue;
-    roots.push(await realpath(item).catch(() => path.resolve(item)));
-  }
-  return roots;
-}
-
 function uniqueSkills(items) {
   const seen = new Set();
   return items.filter((item) => {
@@ -2350,11 +2687,14 @@ function daemonSkillTools() {
     'send_message',
     'read_history',
     'search_messages',
+    'list_attachments',
+    'read_attachment',
     'search_agent_memory',
     'read_agent_memory',
     'read_agent_file',
     'list_agents',
     'read_agent_profile',
+    'read_agent_avatar',
     'write_memory',
     'list_tasks',
     'create_tasks',
@@ -2366,6 +2706,35 @@ function daemonSkillTools() {
   ];
 }
 
+async function listDaemonAgentSkills({ agent, agentDir, workspace, codexHome = '' }) {
+  const context = { agentRoot: agentDir, codexHome };
+  const roots = await globalSkillRoots();
+  const globalSkills = [];
+  for (const root of roots) globalSkills.push(...await scanSkillsDir(root, 'global', context));
+  const agentRoots = [
+    path.join(workspace, 'skills'),
+    path.join(agentDir, '.codex', 'skills'),
+    path.join(agentDir, '.agents', 'skills'),
+  ];
+  const agentSkills = [];
+  for (const root of agentRoots) agentSkills.push(...await scanSkillsDir(root, 'agent', context));
+  const pluginFiles = await findPluginSkillFiles(path.join(SOURCE_CODEX_HOME, 'plugins', 'cache'));
+  const pluginSkills = [];
+  for (const file of pluginFiles) pluginSkills.push(await parseSkillFile(file, 'plugin', context));
+  return {
+    agent: {
+      id: agent.id,
+      name: agent.name || agent.id,
+      codexHome: codexHome || undefined,
+      workspacePath: workspace,
+    },
+    global: uniqueSkills(globalSkills),
+    workspace: uniqueSkills(agentSkills),
+    plugin: uniqueSkills(pluginSkills),
+    tools: daemonSkillTools(),
+  };
+}
+
 const DAEMON_PROGRESSIVE_DISCLOSURE_SECTION = [
   '## 渐进式披露',
   '- 其他 Agent 默认只会先读取本文件；不要假设它们已经看到 `notes/` 或 `workspace/` 中的详细文件。',
@@ -2621,9 +2990,12 @@ class CodexAgentSession {
     this.completedToolCallIds = new Set();
     this.activeTurnToolSignatures = new Set();
     this.activeTurnUsedSendMessage = false;
+    this.activeTurnSawResponseDelta = false;
+    this.activeTurnDeltaItemIds = new Set();
     this.codexMessageQueue = Promise.resolve();
     this.streamActivityTimer = null;
     this.pendingStreamActivity = null;
+    this.lastRuntimeError = '';
     this.trajectoryCoalesceMs = envInteger(this.env, 'MAGCLAW_DAEMON_TRAJECTORY_COALESCE_MS', DEFAULT_TRAJECTORY_COALESCE_MS, { min: 0, max: 5_000 });
   }
 
@@ -2650,7 +3022,7 @@ class CodexAgentSession {
       codexHome: this.codexHome(),
       runtimeKind: 'codex',
     });
-    await syncGlobalSkillsIntoAgentHome(this.codexHome(), this.workspace());
+    await syncGlobalSkillsIntoAgentHome(this.codexHome(), this.workspace(), this.agent);
     await writeFile(path.join(this.codexHome(), 'config.toml'), [
       'wire_api = "responses"',
       '',
@@ -2668,8 +3040,8 @@ class CodexAgentSession {
       '',
       'This workspace is isolated for a MagClaw cloud-connected agent.',
       'Do not assume files from the user localhost MagClaw instance are present here.',
-      'Global Codex skills are linked into `./skills` for read-only reuse when available.',
       'Agent-specific skills can be installed under `./skills/<skill-name>/SKILL.md`; this path belongs to this agent only.',
+      'Runtime-generated adapter directories are not skill install targets.',
       '',
     ].join('\n'));
   }
@@ -2684,40 +3056,12 @@ class CodexAgentSession {
 
   async listSkills() {
     await this.prepare();
-    const context = {
-      agentRoot: this.agentDir(),
+    return listDaemonAgentSkills({
+      agent: this.agent,
+      agentDir: this.agentDir(),
+      workspace: this.workspace(),
       codexHome: this.codexHome(),
-    };
-    const roots = await globalSkillRoots();
-    const globalSkills = [];
-    for (const root of roots) globalSkills.push(...await scanSkillsDir(root, 'global', context));
-    const globalResolvedRoots = await resolvedRoots(roots);
-    const agentRoots = [
-      path.join(this.codexHome(), 'skills'),
-      path.join(this.agentDir(), '.codex', 'skills'),
-      path.join(this.agentDir(), '.agents', 'skills'),
-    ];
-    const agentSkills = [];
-    for (const root of agentRoots) agentSkills.push(...await scanSkillsDir(root, 'agent', context));
-    const workspaceSkills = agentSkills.filter((skill) => {
-      const resolved = path.resolve(skill.absolutePath);
-      return !globalResolvedRoots.some((root) => resolved === root || resolved.startsWith(`${root}${path.sep}`));
     });
-    const pluginFiles = await findPluginSkillFiles(path.join(SOURCE_CODEX_HOME, 'plugins', 'cache'));
-    const pluginSkills = [];
-    for (const file of pluginFiles) pluginSkills.push(await parseSkillFile(file, 'plugin', context));
-    return {
-      agent: {
-        id: this.agent.id,
-        name: this.agent.name || this.agent.id,
-        codexHome: this.codexHome(),
-        workspacePath: this.workspace(),
-      },
-      global: uniqueSkills(globalSkills),
-      workspace: uniqueSkills(workspaceSkills),
-      plugin: uniqueSkills(pluginSkills),
-      tools: daemonSkillTools(),
-    };
   }
 
   sendStatus(status, activity = null) {
@@ -2801,6 +3145,38 @@ class CodexAgentSession {
     if (payload) this.send(payload);
   }
 
+  async reportRuntimeError(errorText, rawText = '') {
+    const error = String(errorText || rawText || 'Codex runtime error.').trim().slice(0, 2000);
+    if (!error) return;
+    if (this.status === 'error' && this.lastRuntimeError === error) return;
+    this.lastRuntimeError = error;
+    const activity = {
+      source: 'codex-stderr',
+      error,
+      text: String(rawText || error).trim().slice(0, 2000),
+      at: now(),
+    };
+    this.send({
+      type: 'agent:error',
+      commandId: this.activeDeliveryId || undefined,
+      deliveryId: this.activeDeliveryId || null,
+      agentId: this.agent.id,
+      error,
+    });
+    if (this.activeDeliveryId) {
+      await this.markDelivery(this.activeDeliveryId, 'failed', {
+        agentId: this.agent.id,
+        sessionKey: this.sessionKey || null,
+        messageId: this.lastSourceMessage?.id || null,
+        workItemId: this.lastSourceMessage?.workItemId || null,
+        error,
+      }).catch((markError) => {
+        logWarning('daemon', `Failed to mark delivery ${this.activeDeliveryId} failed after Codex runtime error: ${markError.message}`);
+      });
+    }
+    this.sendStatus('error', activity);
+  }
+
   async requestMagClawTool(pathname, { method = 'GET', query = {}, body = null } = {}) {
     const url = new URL(`${this.serverUrl.replace(/\/+$/, '')}${pathname}`);
     for (const [key, value] of Object.entries(query || {})) {
@@ -2839,6 +3215,92 @@ class CodexAgentSession {
     }
   }
 
+  async readAttachmentImageInput(reference = {}) {
+    const attachmentId = String(reference.id || reference.attachmentId || reference.attachment_id || '').trim();
+    if (!attachmentId) return null;
+    try {
+      const data = await this.requestMagClawTool('/api/agent-tools/attachments/read', {
+        query: {
+          agentId: this.agent.id,
+          attachmentId,
+          maxBytes: 8 * 1024 * 1024,
+        },
+      });
+      const dataUrl = contextDataImageUrl(data?.dataUrl);
+      if (!dataUrl || data?.file?.truncated) return null;
+      return {
+        key: `attachment:${attachmentId}`,
+        input: { type: 'image', url: dataUrl },
+      };
+    } catch (error) {
+      logWarning('attachments', `Could not read image attachment ${attachmentId} for agent ${this.agent.id}: ${error.message}`);
+      return null;
+    }
+  }
+
+  async imageInputFromContextReference(reference = {}, { preferReadAttachment = false } = {}) {
+    if (!isContextImageReference(reference)) return null;
+    if (preferReadAttachment) {
+      const resolved = await this.readAttachmentImageInput(reference);
+      if (resolved) return resolved;
+    }
+    const dataUrl = contextDataImageUrl(reference.dataUrl || reference.url || reference.downloadUrl);
+    if (dataUrl) {
+      return {
+        key: `url:${dataUrl}`,
+        input: { type: 'image', url: dataUrl },
+      };
+    }
+    const url = remoteImageUrl(reference.url || reference.downloadUrl || '', this.serverUrl, reference.description);
+    if (url) {
+      return {
+        key: `url:${url}`,
+        input: { type: 'image', url },
+      };
+    }
+    const filePath = String(reference.path || '').trim();
+    if (filePath && existsSync(filePath)) {
+      return {
+        key: `path:${filePath}`,
+        input: { type: 'localImage', path: filePath },
+      };
+    }
+    return null;
+  }
+
+  async imageInputsForDelivery(message = {}) {
+    const inputs = [];
+    const seen = new Set();
+    const pack = message?.contextPack || {};
+    const attachments = contextArray(pack.attachments);
+    for (const attachment of attachments) {
+      const resolved = await this.imageInputFromContextReference(attachment, { preferReadAttachment: true });
+      if (!resolved || seen.has(resolved.key)) continue;
+      seen.add(resolved.key);
+      inputs.push(resolved.input);
+    }
+    const avatar = pack?.targetAgent?.avatar || null;
+    if (avatar?.visualInput !== false) {
+      const resolved = await this.imageInputFromContextReference(avatar);
+      if (resolved && !seen.has(resolved.key)) {
+        seen.add(resolved.key);
+        inputs.push(resolved.input);
+      }
+    }
+    const targetAgentId = String(pack?.targetAgentId || pack?.targetAgent?.id || this.agent.id || '');
+    for (const participant of contextArray(pack.participants)) {
+      if (participant?.type !== 'agent') continue;
+      if (targetAgentId && String(participant.id || '') === targetAgentId) continue;
+      const participantAvatar = participant.avatar || null;
+      if (!participantAvatar || participantAvatar.visualInput === false || !isContextImageReference(participantAvatar)) continue;
+      const resolved = await this.imageInputFromContextReference(participantAvatar);
+      if (!resolved || seen.has(resolved.key)) continue;
+      seen.add(resolved.key);
+      inputs.push(resolved.input);
+    }
+    return inputs;
+  }
+
   async executeMagClawTool(name, rawArgs = {}) {
     const args = { ...rawArgs, agentId: rawArgs.agentId || this.agent.id };
     switch (name) {
@@ -2876,6 +3338,25 @@ class CodexAgentSession {
             limit: args.limit,
           },
         });
+      case 'list_attachments':
+        return this.requestMagClawTool('/api/agent-tools/attachments', {
+          query: {
+            agentId: args.agentId,
+            target: args.target || args.channel,
+            workItemId: args.workItemId || args.work_item_id,
+            messageId: args.messageId || args.message_id,
+            limit: args.limit,
+          },
+        });
+      case 'read_attachment':
+        return this.requestMagClawTool('/api/agent-tools/attachments/read', {
+          query: {
+            agentId: args.agentId,
+            attachmentId: args.attachmentId || args.attachment_id || args.id,
+            maxBytes: args.maxBytes || args.max_bytes,
+            format: args.format,
+          },
+        });
       case 'search_agent_memory':
         return this.requestMagClawTool('/api/agent-tools/memory/search', {
           query: {
@@ -2917,6 +3398,14 @@ class CodexAgentSession {
             targetAgentId: args.targetAgentId || args.targetAgent,
           },
         });
+      case 'read_agent_avatar':
+        return this.requestMagClawTool('/api/agent-tools/agents/avatar/read', {
+          query: {
+            agentId: args.agentId,
+            targetAgentId: args.targetAgentId || args.targetAgent,
+            maxBytes: args.maxBytes || args.max_bytes,
+          },
+        });
       case 'write_memory':
         {
           const local = await writeDaemonLocalMemory(this.agentDir(), this.agent, args);
@@ -3002,6 +3491,18 @@ class CodexAgentSession {
     }
   }
 
+  appendCompletedAgentText(text = '', { hadDelta = false } = {}) {
+    const value = String(text || '');
+    if (!value) return;
+    if (hadDelta) {
+      if (this.responseBuffer.endsWith(value) || this.responseBuffer.includes(value)) return;
+      if (value.startsWith(this.responseBuffer)) this.responseBuffer = value;
+      else this.responseBuffer += value;
+      return;
+    }
+    if (!this.responseBuffer.includes(value)) this.responseBuffer += value;
+  }
+
   async executeCodexToolItem(item = {}, requestId = null, params = {}) {
     const callId = codexToolCallId(item) || String(params.callId || params.call_id || '');
     const name = canonicalMagClawToolName(codexToolName(item));
@@ -3098,10 +3599,18 @@ class CodexAgentSession {
     this.child.stderr.on('data', (chunk) => {
       const text = chunk.toString().trim();
       if (!text) return;
+      const runtimeError = codexStderrRuntimeError(text);
+      if (runtimeError) {
+        this.reportRuntimeError(runtimeError, text).catch((error) => {
+          logWarning('daemon', `Failed to report Codex runtime error for ${this.agent.id}: ${error.message}`);
+        });
+        return;
+      }
       this.send({
         type: 'agent:activity',
         agentId: this.agent.id,
         status: this.status || 'working',
+        deliveryId: this.activeDeliveryId || null,
         activity: { source: 'codex-stderr', text: text.slice(0, 2000), at: now() },
       });
     });
@@ -3142,19 +3651,23 @@ class CodexAgentSession {
       this.pendingPrompts.push({ prompt, message, workItem, deliveryId });
       return;
     }
-    this.startTurn(prompt, message, workItem, deliveryId);
+    await this.startTurn(prompt, message, workItem, deliveryId);
   }
 
-  startTurn(prompt, message = {}, workItem = null, deliveryId = '') {
+  async startTurn(prompt, message = {}, workItem = null, deliveryId = '') {
     if (!this.threadId) return false;
     this.activeDeliveryId = deliveryId || '';
     this.activeTurnToolSignatures = new Set();
     this.activeTurnUsedSendMessage = false;
+    this.activeTurnSawResponseDelta = false;
+    this.activeTurnDeltaItemIds = new Set();
+    this.lastRuntimeError = '';
     const model = this.agent.model || undefined;
     const effort = this.agent.reasoningEffort || undefined;
+    const imageInputs = await this.imageInputsForDelivery(message);
     const params = {
       threadId: this.threadId,
-      input: [{ type: 'text', text: prompt }],
+      input: [{ type: 'text', text: prompt }, ...imageInputs],
       approvalPolicy: codexApprovalPolicy(this.env),
       ...(model ? { model } : {}),
       ...(effort ? { effort } : {}),
@@ -3223,7 +3736,7 @@ class CodexAgentSession {
         this.send({ type: 'agent:session', agentId: this.agent.id, status: 'idle', sessionId: this.threadId, sessionKey: this.sessionKey || null });
         this.sendStatus('idle', { source: '@magclaw/daemon', detail: 'Codex session ready', at: now() });
         const queued = this.pendingPrompts.splice(0);
-        for (const item of queued) this.startTurn(item.prompt, item.message, item.workItem, item.deliveryId);
+        for (const item of queued) await this.startTurn(item.prompt, item.message, item.workItem, item.deliveryId);
       } else if (pending?.method === 'turn/start' || pending?.method === 'turn/steer') {
         this.activeTurnId = message.result?.turn?.id || message.result?.turnId || this.activeTurnId;
       }
@@ -3259,6 +3772,9 @@ class CodexAgentSession {
     }
     if (method === 'item/agentMessage/delta' || method === 'response/output_text/delta') {
       this.responseBuffer += String(params.delta || params.text || '');
+      const itemId = String(params.itemId || params.item_id || params.item?.id || '');
+      if (itemId) this.activeTurnDeltaItemIds.add(itemId);
+      this.activeTurnSawResponseDelta = true;
       this.queueCodexStreamActivity();
       return;
     }
@@ -3266,7 +3782,10 @@ class CodexAgentSession {
       const item = params.item || {};
       if (await this.executeCodexToolItem(item, null, params)) return;
       const text = item?.text || item?.message || params.text || '';
-      if (text) this.responseBuffer += String(text);
+      const itemId = String(item?.id || item?.itemId || item?.item_id || '');
+      this.appendCompletedAgentText(text, {
+        hadDelta: Boolean((itemId && this.activeTurnDeltaItemIds.has(itemId)) || this.activeTurnSawResponseDelta),
+      });
       return;
     }
     if (method === 'turn/completed' || method === 'turn/failed') {
@@ -3298,6 +3817,8 @@ class CodexAgentSession {
       this.responseBuffer = '';
       this.activeTurnId = '';
       this.activeTurnUsedSendMessage = false;
+      this.activeTurnSawResponseDelta = false;
+      this.activeTurnDeltaItemIds.clear();
       this.sendStatus(method === 'turn/completed' ? 'idle' : 'error', {
         source: '@magclaw/daemon',
         detail: method === 'turn/completed' ? 'Turn completed' : 'Turn failed',
@@ -3336,6 +3857,11 @@ class ClaudeAgentSession {
     this.status = 'offline';
     this.started = false;
     this.activeDeliveryId = '';
+    this.responseBuffer = '';
+    this.lastSourceMessage = null;
+    this.pendingMessageDelta = null;
+    this.messageDeltaTimer = null;
+    this.trajectoryCoalesceMs = envInteger(this.env, 'MAGCLAW_DAEMON_TRAJECTORY_COALESCE_MS', DEFAULT_TRAJECTORY_COALESCE_MS, { min: 0, max: 5_000 });
   }
 
   agentDir() {
@@ -3348,6 +3874,7 @@ class ClaudeAgentSession {
 
   async prepare() {
     await mkdir(this.workspace(), { recursive: true });
+    await ensureWorkspaceSkillsDir(this.workspace(), path.join(this.agentDir(), 'codex-home'), this.agent);
     await ensureDaemonAgentWorkspaceRoot(this.agentDir(), this.agent);
     await prepareRuntimeHooks({
       agentDir: this.agentDir(),
@@ -3358,6 +3885,8 @@ class ClaudeAgentSession {
       '# MagClaw Remote Claude Agent Workspace',
       '',
       'This workspace is isolated for a MagClaw cloud-connected Claude Code agent.',
+      'Agent-specific skills can be installed under `./skills/<skill-name>/SKILL.md`; this path belongs to this agent only.',
+      'Runtime-generated adapter directories are not skill install targets.',
       '',
     ].join('\n'));
   }
@@ -3370,6 +3899,15 @@ class ClaudeAgentSession {
     return readDaemonAgentWorkspaceFile(this.agentDir(), this.agent, relPath);
   }
 
+  async listSkills() {
+    await this.prepare();
+    return listDaemonAgentSkills({
+      agent: this.agent,
+      agentDir: this.agentDir(),
+      workspace: this.workspace(),
+    });
+  }
+
   sendStatus(status, activity = null) {
     this.status = status;
     this.onStatusChange(this, status);
@@ -3387,6 +3925,87 @@ class ClaudeAgentSession {
     });
   }
 
+  queueMessageDelta(delta = '') {
+    const body = this.responseBuffer.trim();
+    if (!body) return;
+    this.pendingMessageDelta = {
+      type: 'agent:message_delta',
+      agentId: this.agent.id,
+      deliveryId: this.activeDeliveryId || null,
+      payload: {
+        body,
+        delta: String(delta || ''),
+        message: this.lastSourceMessage || null,
+        sourceMessage: this.lastSourceMessage || null,
+        spaceType: this.lastSourceMessage?.spaceType || 'channel',
+        spaceId: this.lastSourceMessage?.spaceId || 'chan_all',
+        parentMessageId: this.lastSourceMessage?.parentMessageId || null,
+        idempotencyKey: this.activeDeliveryId || null,
+      },
+    };
+    if (this.trajectoryCoalesceMs <= 0) {
+      this.flushMessageDelta();
+      return;
+    }
+    if (this.messageDeltaTimer) return;
+    this.messageDeltaTimer = setTimeout(() => {
+      this.messageDeltaTimer = null;
+      this.flushMessageDelta();
+    }, this.trajectoryCoalesceMs);
+    this.messageDeltaTimer.unref?.();
+  }
+
+  flushMessageDelta() {
+    if (this.messageDeltaTimer) {
+      clearTimeout(this.messageDeltaTimer);
+      this.messageDeltaTimer = null;
+    }
+    const payload = this.pendingMessageDelta;
+    this.pendingMessageDelta = null;
+    if (payload) this.send(payload);
+  }
+
+  handleClaudeStreamEvent(event) {
+    if (event.type === 'system') {
+      if (event.sessionId) {
+        this.send({
+          type: 'agent:session',
+          agentId: this.agent.id,
+          status: this.status,
+          sessionId: event.sessionId,
+          sessionKey: null,
+        });
+      }
+      return;
+    }
+    if (event.type === 'text') {
+      this.responseBuffer += String(event.delta || '');
+      this.queueMessageDelta(event.delta || '');
+      this.send({
+        type: 'agent:activity',
+        agentId: this.agent.id,
+        status: 'working',
+        deliveryId: this.activeDeliveryId || null,
+        activity: { source: 'claude-code-stream', chars: this.responseBuffer.length, at: now() },
+      });
+      return;
+    }
+    if (event.type === 'thinking' || event.type === 'tool_use' || event.type === 'tool_result' || event.type === 'usage') {
+      this.send({
+        type: 'agent:activity',
+        agentId: this.agent.id,
+        status: event.type === 'thinking' ? 'thinking' : 'working',
+        deliveryId: this.activeDeliveryId || null,
+        activity: {
+          source: 'claude-code-stream',
+          phase: event.type,
+          detail: claudeToolActivityDetail(event),
+          at: now(),
+        },
+      });
+    }
+  }
+
   async start() {
     if (this.started) return;
     await this.prepare();
@@ -3397,11 +4016,12 @@ class ClaudeAgentSession {
   async deliver(message = {}, workItem = null, deliveryId = '') {
     await this.start();
     this.activeDeliveryId = deliveryId || '';
+    this.responseBuffer = '';
+    this.lastSourceMessage = message || null;
     const prompt = deliveryPrompt(this.agent, message, workItem);
     const claudeCommand = this.env.CLAUDE_PATH || 'claude';
-    const args = ['--print'];
+    const args = ['-p', prompt, '--output-format', 'stream-json', '--verbose'];
     if (this.agent.model) args.push('--model', String(this.agent.model));
-    args.push(prompt);
     const timeoutMs = Number(this.env.MAGCLAW_DAEMON_RUNTIME_TIMEOUT_MS || 10 * 60 * 1000);
     if (this.activeDeliveryId) {
       await this.markDelivery(this.activeDeliveryId, 'started', {
@@ -3412,31 +4032,33 @@ class ClaudeAgentSession {
     }
     this.sendStatus('thinking', { source: 'claude-code', detail: 'Claude Code turn started', at: now() });
     await new Promise((resolve) => {
-      let stdout = '';
       let stderr = '';
+      let stdoutBuffer = '';
       let settled = false;
+      const finalMessageFrame = (body) => ({
+        type: 'agent:message',
+        agentId: this.agent.id,
+        deliveryId: this.activeDeliveryId || null,
+        payload: {
+          body,
+          message,
+          sourceMessage: message,
+          spaceType: message.spaceType || 'channel',
+          spaceId: message.spaceId || 'chan_all',
+          parentMessageId: message.parentMessageId || null,
+          idempotencyKey: this.activeDeliveryId || null,
+        },
+      });
       const finish = (status, detail) => {
         if (settled) return;
         settled = true;
         clearTimeout(timer);
+        this.flushMessageDelta();
         this.child = null;
+        const body = this.responseBuffer.trim();
         if (status === 'idle') {
-          const body = stdout.trim();
           if (body) {
-            const frame = {
-              type: 'agent:message',
-              agentId: this.agent.id,
-              deliveryId: this.activeDeliveryId || null,
-              payload: {
-                body,
-                message,
-                sourceMessage: message,
-                spaceType: message.spaceType || 'channel',
-                spaceId: message.spaceId || 'chan_all',
-                parentMessageId: message.parentMessageId || null,
-                idempotencyKey: this.activeDeliveryId || null,
-              },
-            };
+            const frame = finalMessageFrame(body);
             this.send(frame);
             this.markDelivery(this.activeDeliveryId, 'completed', { resultFrame: frame }).catch(() => {});
           }
@@ -3444,8 +4066,10 @@ class ClaudeAgentSession {
           this.sendStatus('idle', { source: 'claude-code', detail: detail || 'Claude Code turn completed', at: now() });
         } else {
           const error = detail || stderr.trim() || 'Claude Code failed.';
+          const frame = body ? finalMessageFrame(body) : null;
+          if (frame) this.send(frame);
           this.send({ type: 'agent:error', commandId: this.activeDeliveryId || undefined, deliveryId: this.activeDeliveryId || null, agentId: this.agent.id, error });
-          this.markDelivery(this.activeDeliveryId, 'failed', { error }).catch(() => {});
+          this.markDelivery(this.activeDeliveryId, 'failed', { error, ...(frame ? { resultFrame: frame } : {}) }).catch(() => {});
           this.sendStatus('error', { source: 'claude-code', error, at: now() });
         }
         this.activeDeliveryId = '';
@@ -3468,19 +4092,40 @@ class ClaudeAgentSession {
         finish('error', 'Claude Code session timed out.');
       }, timeoutMs);
       this.child.stdout.on('data', (chunk) => {
-        stdout += chunk.toString();
-        this.send({
-          type: 'agent:activity',
-          agentId: this.agent.id,
-          status: 'working',
-          activity: { source: 'claude-code', chars: stdout.length, at: now() },
-        });
+        stdoutBuffer += chunk.toString();
+        const lines = stdoutBuffer.split(/\r?\n/);
+        stdoutBuffer = lines.pop() || '';
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const raw = JSON.parse(line);
+            for (const event of claudeStreamEvents(raw)) this.handleClaudeStreamEvent(event);
+          } catch (error) {
+            stderr += `${line}\n`;
+            this.send({
+              type: 'agent:activity',
+              agentId: this.agent.id,
+              status: 'working',
+              deliveryId: this.activeDeliveryId || null,
+              activity: { source: 'claude-code-stream', error: `Invalid stream JSON: ${error.message}`, at: now() },
+            });
+          }
+        }
       });
       this.child.stderr.on('data', (chunk) => {
         stderr += chunk.toString();
       });
       this.child.on('error', (error) => finish('error', error.message));
       this.child.on('close', (code, signal) => {
+        if (stdoutBuffer.trim()) {
+          try {
+            const raw = JSON.parse(stdoutBuffer.trim());
+            for (const event of claudeStreamEvents(raw)) this.handleClaudeStreamEvent(event);
+          } catch (error) {
+            stderr += `${stdoutBuffer}\n`;
+          }
+          stdoutBuffer = '';
+        }
         if (code === 0) finish('idle');
         else finish('error', stderr.trim() || `Claude Code exited with code ${code ?? 'unknown'}${signal ? ` (${signal})` : ''}.`);
       });
@@ -3489,6 +4134,7 @@ class ClaudeAgentSession {
 
   stop() {
     this.status = 'stopping';
+    this.flushMessageDelta();
     if (this.child) this.child.kill('SIGTERM');
     this.started = false;
   }
@@ -4725,8 +5371,12 @@ async function writeLauncher(profile, env = process.env) {
       || previousService.packageBin
       || packageBinForPackageName(packageName),
   ).trim() || packageBinForPackageName(packageName);
+  const envServiceMode = normalizeBackgroundServiceMode(env.MAGCLAW_DAEMON_SERVICE_MODE)
+    || normalizeBackgroundServiceMode(env.MAGCLAW_DAEMON_BACKGROUND_MODE);
+  const previousMode = normalizeBackgroundServiceMode(previousService.mode);
+  const serviceMode = envServiceMode || (previousMode && previousMode !== 'foreground' ? previousMode : backgroundServiceModeForPlatform(process.platform));
   const service = await writeServiceState(paths.profile, {
-    mode: process.platform === 'darwin' ? 'launchd' : process.platform === 'linux' ? 'systemd' : process.platform === 'win32' ? 'schtasks' : 'foreground',
+    mode: serviceMode,
     background: true,
     launcher,
     packageSpec,
@@ -4809,6 +5459,72 @@ async function writeLauncher(profile, env = process.env) {
   return launcher;
 }
 
+async function writeContainerSupervisor(profile, launcher, env = process.env) {
+  const paths = profilePaths(profile, env);
+  await mkdir(paths.runDir, { recursive: true });
+  await mkdir(paths.logDir, { recursive: true });
+  const supervisor = path.join(paths.runDir, 'container-supervisor.js');
+  const restartSec = Math.max(1, Math.min(60, Number(env.MAGCLAW_DAEMON_CONTAINER_RESTART_SEC || 3) || 3));
+  const code = [
+    '#!/usr/bin/env node',
+    "const { spawn } = require('node:child_process');",
+    "const fs = require('node:fs');",
+    "const path = require('node:path');",
+    `const launcher = ${JSON.stringify(launcher)};`,
+    `const serviceFile = ${JSON.stringify(paths.service)};`,
+    `const logDir = ${JSON.stringify(paths.logDir)};`,
+    `const restartMs = ${JSON.stringify(restartSec * 1000)};`,
+    'let child = null;',
+    'let stopping = false;',
+    'function readService() {',
+    "  try { return JSON.parse(fs.readFileSync(serviceFile, 'utf8')); } catch { return {}; }",
+    '}',
+    'function shouldStop() {',
+    '  const service = readService();',
+    '  return Boolean(service.remoteClosed || service.containerSupervisorDisabled);',
+    '}',
+    'function openLog(name) {',
+    '  fs.mkdirSync(logDir, { recursive: true });',
+    "  return fs.openSync(path.join(logDir, name), 'a');",
+    '}',
+    'function sleep(ms) { return new Promise((resolve) => setTimeout(resolve, ms)); }',
+    'function stop(signal) {',
+    '  stopping = true;',
+    "  if (child && child.exitCode === null && child.signalCode === null) child.kill(signal || 'SIGTERM');",
+    '  setTimeout(() => process.exit(0), 5000).unref?.();',
+    '}',
+    "process.once('SIGINT', () => stop('SIGINT'));",
+    "process.once('SIGTERM', () => stop('SIGTERM'));",
+    '(async () => {',
+    '  while (!stopping) {',
+    '    if (shouldStop()) break;',
+    "    const out = openLog('daemon.log');",
+    "    const err = openLog('daemon.err.log');",
+    '    child = spawn(process.execPath, [launcher], {',
+    "      stdio: ['ignore', out, err],",
+    '      env: {',
+    '        ...process.env,',
+    "        MAGCLAW_DAEMON_SERVICE_MODE: 'container',",
+    '      },',
+    '    });',
+    "    await new Promise((resolve) => child.once('exit', resolve));",
+    '    fs.closeSync(out);',
+    '    fs.closeSync(err);',
+    '    child = null;',
+    '    if (stopping || shouldStop()) break;',
+    '    await sleep(restartMs);',
+    '  }',
+    '})().catch((error) => {',
+    "  console.error(`[magclaw-container-supervisor] ${error && error.stack ? error.stack : error}`);",
+    '  process.exit(1);',
+    '});',
+    '',
+  ].join('\n');
+  await writeFile(supervisor, code);
+  await chmod(supervisor, 0o755).catch(() => {});
+  return supervisor;
+}
+
 function launchAgentLabel(profile) {
   return `ai.magclaw.daemon.${safeProfileName(profile)}`;
 }
@@ -4824,6 +5540,61 @@ async function ensureExecutable(file) {
   await chmod(file, 0o755).catch(() => {});
 }
 
+async function startContainerBackground(profile, env = process.env) {
+  const paths = profilePaths(profile, env);
+  await mkdir(paths.logDir, { recursive: true });
+  const launcher = await writeLauncher(paths.profile, { ...env, MAGCLAW_DAEMON_SERVICE_MODE: 'container' });
+  await ensureExecutable(launcher);
+  const supervisor = await writeContainerSupervisor(paths.profile, launcher, env);
+  await ensureExecutable(supervisor);
+  await writeServiceState(paths.profile, {
+    mode: 'container',
+    background: true,
+    launcher,
+    containerSupervisor: supervisor,
+    containerSupervisorDisabled: false,
+  }, env);
+  const current = backgroundServiceStatus(paths.profile, env);
+  if (current.active) {
+    return {
+      ok: true,
+      mode: 'container',
+      active: true,
+      alreadyRunning: true,
+      pid: current.pid || null,
+      supervisorPid: current.supervisorPid || null,
+      file: supervisor,
+      launcher,
+      status: current.status || 'running',
+    };
+  }
+  const child = spawn(process.execPath, [supervisor], {
+    cwd: process.cwd(),
+    detached: true,
+    stdio: 'ignore',
+    env: {
+      ...env,
+      MAGCLAW_DAEMON_SERVICE_MODE: 'container',
+    },
+  });
+  child.unref();
+  await writeServiceState(paths.profile, {
+    mode: 'container',
+    background: true,
+    launcher,
+    containerSupervisor: supervisor,
+    containerSupervisorPid: child.pid || null,
+  }, env);
+  return {
+    ok: true,
+    mode: 'container',
+    active: true,
+    supervisorPid: child.pid || null,
+    file: supervisor,
+    launcher,
+  };
+}
+
 async function startMacBackground(profile, env = process.env) {
   const paths = profilePaths(profile, env);
   const label = launchAgentLabel(paths.profile);
@@ -4934,6 +5705,11 @@ async function startWindowsBackground(profile, env = process.env) {
 }
 
 async function startBackground(profile, env = process.env) {
+  const service = await readServiceState(profile, env);
+  const mode = normalizeBackgroundServiceMode(env.MAGCLAW_DAEMON_SERVICE_MODE)
+    || normalizeBackgroundServiceMode(env.MAGCLAW_DAEMON_BACKGROUND_MODE)
+    || normalizeBackgroundServiceMode(service.mode);
+  if (mode === 'container') return startContainerBackground(profile, env);
   if (process.platform === 'darwin') return startMacBackground(profile, env);
   if (process.platform === 'linux') return startLinuxBackground(profile, env);
   if (process.platform === 'win32') return startWindowsBackground(profile, env);
@@ -4961,6 +5737,25 @@ export function parseLaunchdPrintStatus(result = {}) {
 
 function backgroundServiceStatus(profile, env = process.env) {
   const paths = profilePaths(profile, env);
+  const serviceState = readServiceStateSync(paths.profile, env);
+  const requestedMode = normalizeBackgroundServiceMode(env.MAGCLAW_DAEMON_SERVICE_MODE)
+    || normalizeBackgroundServiceMode(env.MAGCLAW_DAEMON_BACKGROUND_MODE);
+  if (requestedMode === 'container' || normalizeBackgroundServiceMode(serviceState.mode) === 'container') {
+    const lock = activeDaemonLockSync(paths.profile, env);
+    const supervisorPid = Number(serviceState.containerSupervisorPid || 0);
+    const supervisorRunning = Number.isInteger(supervisorPid) && supervisorPid > 0 && pidIsRunning(supervisorPid);
+    const daemonRunning = Boolean(lock?.pid);
+    return {
+      mode: 'container',
+      active: daemonRunning || supervisorRunning,
+      pid: lock?.pid || null,
+      supervisorPid: supervisorRunning ? supervisorPid : null,
+      file: serviceState.containerSupervisor || '',
+      launcher: serviceState.launcher || '',
+      status: daemonRunning ? 'running' : supervisorRunning ? 'supervising' : 'inactive',
+      error: '',
+    };
+  }
   if (process.platform === 'darwin') {
     const label = launchAgentLabel(paths.profile);
     const result = spawnSync('launchctl', ['print', `gui/${process.getuid()}/${label}`], { encoding: 'utf8' });
@@ -5081,9 +5876,77 @@ async function stopActiveDaemon(profile, env = process.env) {
   return { ok: stopped, running: !stopped, pid, signal };
 }
 
+function waitForPidExitSync(pid, timeoutMs = 2000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!pidIsRunning(pid)) return true;
+    sleepSync(100);
+  }
+  return !pidIsRunning(pid);
+}
+
+function stopPidSync(pid, { allowCurrent = false, timeoutMs = 2000 } = {}) {
+  const value = Number(pid);
+  if (!Number.isInteger(value) || value <= 0) return { ok: true, running: false };
+  if (!allowCurrent && value === process.pid) {
+    return { ok: true, running: true, pid: value, skippedCurrent: true };
+  }
+  try {
+    process.kill(value, 'SIGTERM');
+  } catch (error) {
+    if (error?.code === 'ESRCH') return { ok: true, running: false, pid: value, stale: true };
+    return { ok: false, running: true, pid: value, error: error.message };
+  }
+  if (waitForPidExitSync(value, timeoutMs)) return { ok: true, running: false, pid: value, signal: 'SIGTERM' };
+  try {
+    process.kill(value, 'SIGKILL');
+  } catch (error) {
+    if (error?.code === 'ESRCH') return { ok: true, running: false, pid: value, signal: 'SIGKILL' };
+    return { ok: false, running: true, pid: value, signal: 'SIGKILL', error: error.message };
+  }
+  const stopped = waitForPidExitSync(value, 1000);
+  return { ok: stopped, running: !stopped, pid: value, signal: 'SIGKILL' };
+}
+
+function stopContainerBackground(profile, env = process.env, options = {}) {
+  const paths = profilePaths(profile, env);
+  const state = readServiceStateSync(paths.profile, env);
+  const lock = activeDaemonLockSync(paths.profile, env);
+  const supervisor = stopPidSync(state.containerSupervisorPid);
+  const daemon = stopPidSync(lock?.pid);
+  if (options.disable) {
+    writeJsonFileSync(paths.service, {
+      ...state,
+      version: 1,
+      profile: paths.profile,
+      mode: 'container',
+      background: true,
+      containerSupervisorDisabled: true,
+      updatedAt: now(),
+    });
+  }
+  return {
+    ok: Boolean(supervisor.ok && daemon.ok),
+    mode: 'container',
+    supervisorPid: state.containerSupervisorPid || null,
+    pid: lock?.pid || null,
+    supervisor,
+    process: daemon,
+    file: state.containerSupervisor || '',
+    launcher: state.launcher || '',
+    disabled: Boolean(options.disable),
+  };
+}
+
 function stopBackground(profile, env = process.env, options = {}) {
+  const paths = profilePaths(profile, env);
+  const state = readServiceStateSync(paths.profile, env);
+  const requestedMode = normalizeBackgroundServiceMode(env.MAGCLAW_DAEMON_SERVICE_MODE)
+    || normalizeBackgroundServiceMode(env.MAGCLAW_DAEMON_BACKGROUND_MODE);
+  if (requestedMode === 'container' || normalizeBackgroundServiceMode(state.mode) === 'container') {
+    return stopContainerBackground(paths.profile, env, options);
+  }
   if (process.platform === 'darwin') {
-    const paths = profilePaths(profile, env);
     const label = launchAgentLabel(paths.profile);
     const serviceTarget = `gui/${process.getuid()}/${label}`;
     const plist = path.join(os.homedir(), 'Library', 'LaunchAgents', `${label}.plist`);
@@ -5570,7 +6433,10 @@ async function runUpgradeWorker(flags, env = process.env) {
 
     await emitProgress({ status: 'upgrading', phase: 'stage_service', progress: 45, message: 'Staging service launcher.' });
     await writeServiceState(profile, {
-      mode: serviceBefore.mode || (process.platform === 'darwin' ? 'launchd' : process.platform === 'linux' ? 'systemd' : process.platform === 'win32' ? 'schtasks' : 'foreground'),
+      mode: normalizeBackgroundServiceMode(env.MAGCLAW_DAEMON_SERVICE_MODE)
+        || normalizeBackgroundServiceMode(env.MAGCLAW_DAEMON_BACKGROUND_MODE)
+        || normalizeBackgroundServiceMode(serviceBefore.mode)
+        || backgroundServiceModeForPlatform(process.platform),
       background: true,
       packageSpec,
       packageName,