dsh-thoughtdag 0.4.10 → 0.4.12

package/lib/runtime/agents/claude.cjs

@@ -0,0 +1,303 @@
+// Claude Code as an agent runtime: one `claude -p` process per turn, spoken
+// to in stream-json both ways. The turn's text and thinking arrive as
+// content-block deltas, tool calls as tool_use blocks with their
+// tool_result, permission prompts as control requests answered on stdin
+// (`--permission-prompt-tool stdio`), the end as a result message. A session
+// continues with `--resume`, branches with `--fork-session`. Claude Code
+// keeps its session files under ~/.claude/projects, its login and its model
+// aliases; the shell only asks. Same event kinds as the other runtimes.
+'use strict';
+
+const { spawn, execFile } = require('node:child_process');
+const path = require('node:path');
+const fs = require('node:fs');
+const os = require('node:os');
+const { randomUUID } = require('node:crypto');
+const { snapshotDir, diffSnapshots } = require('./fs-diff.cjs');
+
+const fsp = fs.promises;
+const CANDIDATE_DIRS = ['/opt/homebrew/bin', '/usr/local/bin', '/usr/bin', path.join(os.homedir(), '.local', 'bin'), path.join(os.homedir(), '.claude', 'local'), path.join(os.homedir(), '.npm-global', 'bin'), path.join(os.homedir(), '.bun', 'bin')];
+
+async function executable(p) { try { await fsp.access(p, fs.constants.X_OK); return true; } catch { return false; } }
+async function findClaude() {
+  const names = process.platform === 'win32' ? ['claude.cmd', 'claude.exe', 'claude'] : ['claude'];
+  const dirs = [...(process.env.PATH || '').split(path.delimiter), ...CANDIDATE_DIRS].filter(Boolean);
+  for (const d of dirs) for (const n of names) { const p = path.join(d, n); if (await executable(p)) return p; }
+  return null;
+}
+function childEnv() {
+  const seen = new Set((process.env.PATH || '').split(path.delimiter).filter(Boolean));
+  return { ...process.env, PATH: [...seen, ...CANDIDATE_DIRS.filter((d) => !seen.has(d))].join(path.delimiter) };
+}
+
+/** Claude Code has no model list; its aliases resolve to the newest model
+ *  of each family inside the CLI, so they never go stale. The CLI's own
+ *  "default" is not offered: which model it means lives in the CLI's settings
+ *  and can change under the person, so the picker names families only. */
+/** The effort levels this CLI accepts, in its own words, read from its own
+ *  `--help` (the `--effort <level>` entry lists them in parentheses) — so a
+ *  CLI that adds a level shows it without a change here. Empty when the
+ *  CLI has no such flag. Read once per launch. */
+let effortsPromise = null;
+function effortsOf(bin) {
+  if (!effortsPromise) effortsPromise = new Promise((resolve) => {
+    execFile(bin, ['--help'], { env: childEnv(), timeout: 8000, maxBuffer: 1 << 20 }, (_err, stdout) => {
+      const help = String(stdout || '');
+      const at = help.indexOf('--effort');
+      if (at < 0) return resolve([]);
+      const next = help.indexOf('\n  --', at + 1);
+      const m = help.slice(at, next > 0 ? next : undefined).match(/\(([a-z0-9_, \n-]+)\)/i);
+      resolve(m ? m[1].split(',').map((s) => s.trim()).filter(Boolean) : []);
+    });
+  });
+  return effortsPromise;
+}
+
+const MODELS = [
+  { provider: 'claude-code', id: 'fable', name: 'Fable', reasoning: true, vision: true },
+  { provider: 'claude-code', id: 'opus', name: 'Opus', reasoning: true, vision: true },
+  { provider: 'claude-code', id: 'sonnet', name: 'Sonnet', reasoning: true, vision: true },
+  { provider: 'claude-code', id: 'haiku', name: 'Haiku', reasoning: true, vision: true },
+];
+
+/** The effort a turn ran at, as the transcript records it on every
+ *  assistant entry (`effort`) — the CLI's own setting when the canvas named none. */
+async function turnEffortOf(file) {
+  if (!file) return null;
+  try {
+    const lines = (await fsp.readFile(file, 'utf8')).split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+      if (!lines[i].includes('"effort"')) continue;
+      try { const o = JSON.parse(lines[i]); if (o.type === 'assistant' && typeof o.effort === 'string') return o.effort; } catch { /* torn line */ }
+    }
+  } catch { /* no file */ }
+  return null;
+}
+
+/** The CLI's configured effort (`effortLevel` in ~/.claude/settings.json), when set. */
+async function configuredEffort() {
+  try { const s = JSON.parse(await fsp.readFile(path.join(os.homedir(), '.claude', 'settings.json'), 'utf8')); return typeof s.effortLevel === 'string' ? s.effortLevel : null; } catch { return null; }
+}
+
+/** ~/.claude/projects/<slug>/<sessionId>.jsonl. The slug is the cwd with
+ *  '/' and '.' turned into '-', but a long path is cut and given a short
+ *  suffix by Claude Code itself — so the file is found by its id across the
+ *  project directories when the computed name is not there. */
+const PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
+async function sessionFileFor(cwd, sessionId) {
+  const guess = path.join(PROJECTS_DIR, cwd.replace(/[/.]/g, '-'), `${sessionId}.jsonl`);
+  if (await fsp.access(guess).then(() => true, () => false)) return guess;
+  try {
+    const dirs = await fsp.readdir(PROJECTS_DIR, { withFileTypes: true });
+    for (const d of dirs) {
+      if (!d.isDirectory()) continue;
+      const candidate = path.join(PROJECTS_DIR, d.name, `${sessionId}.jsonl`);
+      if (await fsp.access(candidate).then(() => true, () => false)) return candidate;
+    }
+  } catch { /* no projects yet */ }
+  return null;
+}
+// the session id is the file's name; a directory on the way may carry a
+// UUID of its own (a project path that names a session), so take the LAST
+const sessionIdOf = (sessionPath) => { const all = String(sessionPath ?? '').match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi); return all && all.length ? all[all.length - 1] : null; };
+
+/** The guard file the canvas writes per working directory, as a permission mode. */
+async function permissionModeFor(cwd) {
+  try {
+    const raw = JSON.parse(await fsp.readFile(path.join(cwd, '.thoughtdag', 'guard.json'), 'utf8'));
+    if (raw?.mode === 'allow') return 'bypassPermissions';
+  } catch { /* default */ }
+  return 'default';
+}
+
+function createClaudeRuntime({ log } = {}) {
+  const say = log || (() => {});
+  const runs = new Map();     // runId → state
+  let binPromise = null;
+  const bin = () => { if (!binPromise) binPromise = findClaude(); return binPromise; };
+
+  return {
+    available: () => bin(),
+
+    async models() {
+      const b = await bin();
+      if (!b) return { installed: false, models: [], default: null };
+      const [efforts, defaultEffort] = await Promise.all([effortsOf(b), configuredEffort()]);
+      return { installed: true, models: MODELS.map((m) => ({ ...m, efforts, defaultEffort })), default: 'claude/claude-code/opus' };
+    },
+
+    async run(req, onEvent) {
+      const cwd = String(req.cwd || '');
+      if (!cwd || !path.isAbsolute(cwd)) throw new Error('run needs an absolute cwd');
+      await fsp.mkdir(cwd, { recursive: true });
+      const b = await bin();
+      if (!b) throw new Error('claude is not installed (no `claude` on PATH or in the usual places)');
+      const runId = randomUUID();
+      const emit = (event) => { try { onEvent({ runId, event }); } catch { /* renderer gone */ } };
+      const state = { runId, proc: null, asks: new Map(), text: '', final: null, sessionId: null, waiting: false, ended: false, aborted: false,
+        // what this conversation already allowed for good (see README: `rule`)
+        allowRules: new Set(Array.isArray(req.allowRules) ? req.allowRules.filter((s) => typeof s === 'string' && s.startsWith('claude:')) : []) };
+      runs.set(runId, state);
+
+      void (async () => {
+        const IDLE = Number(process.env.TD_AGENT_IDLE_MS) || 10 * 60 * 1000;
+        let lastEvent = Date.now();
+        const mark = (event) => { lastEvent = Date.now(); if (event.type === 'question') state.waiting = true; if (event.type === 'question_answered') state.waiting = false; emit(event); };
+        let watchdog = null;
+        const before = await snapshotDir(cwd).catch(() => null);
+        try {
+          const mode = await permissionModeFor(cwd);
+          const model = req.model && typeof req.model === 'object' && req.model.id && req.model.id !== 'default' ? req.model.id : null;
+          const resumeId = req.sessionPath ? sessionIdOf(req.sessionPath) : null;
+          const args = ['-p', '--output-format', 'stream-json', '--input-format', 'stream-json', '--verbose', '--include-partial-messages', '--permission-mode', mode];
+          if (mode !== 'bypassPermissions') args.push('--permission-prompt-tool', 'stdio');
+          if (model) args.push('--model', model);
+          // only a level the CLI itself lists; anything else means its default
+          if (req.effort && (await effortsOf(b)).includes(req.effort)) args.push('--effort', req.effort);
+          if (resumeId) { args.push('--resume', resumeId); if (req.forkEntryId) args.push('--fork-session'); }
+          const proc = spawn(b, args, { cwd, env: childEnv(), stdio: ['pipe', 'pipe', 'pipe'] });
+          state.proc = proc;
+          let buf = '';
+          const finished = new Promise((resolve) => {
+            const done = (how) => { if (state.ended) return; state.ended = true; resolve(how); };
+            proc.stdout.on('data', (d) => {
+              buf += d.toString();
+              let i;
+              while ((i = buf.indexOf('\n')) >= 0) {
+                const line = buf.slice(0, i); buf = buf.slice(i + 1);
+                if (!line.trim()) continue;
+                let m; try { m = JSON.parse(line); } catch { continue; }
+                handle(m, done);
+              }
+            });
+            proc.stderr.on('data', (d) => say('[claude stderr] ' + d.toString().trim().slice(0, 400)));
+            proc.on('error', (e) => { mark({ type: 'run_error', message: 'spawn error: ' + e.message }); done('error'); });
+            proc.on('exit', (code, signal) => { if (!state.ended) { if (!state.aborted && code) mark({ type: 'run_error', message: `claude exited (${signal || code})` }); done(state.aborted ? 'aborted' : (code ? 'error' : 'end')); } });
+          });
+          watchdog = setInterval(() => {
+            if (state.waiting || Date.now() - lastEvent < IDLE) return;
+            mark({ type: 'run_error', message: `no activity for ${IDLE >= 60000 ? Math.round(IDLE / 60000) + ' min' : Math.round(IDLE / 1000) + ' s'}; the turn was stopped` });
+            state.aborted = true; try { proc.kill(); } catch { /* gone */ }
+          }, 15000);
+
+          const handle = (m, done) => {
+            switch (m.type) {
+              case 'system':
+                if (m.subtype === 'init') {
+                  state.sessionId = m.session_id;
+                  // the file appears once the first lines are written; the
+                  // completion re-emits the session with its real path
+                  mark({ type: 'session', sessionId: m.session_id, sessionFile: null, model: model ? { provider: 'claude-code', id: model, name: model } : null, cwd });
+                } else if (m.subtype === 'permission_denied') {
+                  mark({ type: 'tool_execution_end', toolCallId: m.tool_use_id ?? '', toolName: m.tool_name ?? 'tool', result: 'permission denied', isError: true });
+                }
+                break;
+              case 'stream_event': {
+                const ev = m.event ?? {};
+                if (ev.type === 'content_block_delta') {
+                  const d = ev.delta ?? {};
+                  if (d.type === 'text_delta' && d.text) { state.text += d.text; mark({ type: 'message_update', assistantMessageEvent: { type: 'text_delta', delta: d.text } }); }
+                  else if (d.type === 'thinking_delta' && d.thinking) mark({ type: 'message_update', assistantMessageEvent: { type: 'thinking_delta', delta: d.thinking } });
+                }
+                break;
+              }
+              case 'assistant':
+                // the alias resolved to a real model inside the CLI; the final session event carries it
+                if (!state.resolvedModel && typeof m.message?.model === 'string') state.resolvedModel = m.message.model;
+                for (const b of m.message?.content ?? []) if (b.type === 'tool_use') mark({ type: 'tool_execution_start', toolCallId: b.id, toolName: b.name, args: b.input ?? {} });
+                break;
+              case 'user':
+                for (const b of m.message?.content ?? []) if (b.type === 'tool_result') mark({ type: 'tool_execution_end', toolCallId: b.tool_use_id, toolName: '', result: typeof b.content === 'string' ? b.content : JSON.stringify(b.content ?? null).slice(0, 4000), isError: !!b.is_error });
+                break;
+              case 'control_request': {
+                const r = m.request ?? {};
+                if (r.subtype !== 'can_use_tool') { write(proc, { type: 'control_response', response: { subtype: 'error', request_id: m.request_id, error: 'unsupported request' } }); break; }
+                const id = `q-${m.request_id}`;
+                const input = r.input ?? {};
+                const line = typeof input.command === 'string' ? input.command : (input.file_path ?? input.path ?? JSON.stringify(input).slice(0, 200));
+                // the CLI's own "don't ask again" suggestion names what a standing
+                // allowance covers; sent back scoped to the session, never to settings
+                const suggest = (Array.isArray(r.permission_suggestions) ? r.permission_suggestions : []).find((s) => s && s.type === 'addRules' && Array.isArray(s.rules) && s.rules.length);
+                const rule = suggest ? 'claude:' + JSON.stringify(suggest.rules.map((x) => ({ toolName: x.toolName, ...(x.ruleContent ? { ruleContent: x.ruleContent } : {}) }))) : null;
+                const allow = (forSession) => write(proc, { type: 'control_response', response: { subtype: 'success', request_id: m.request_id, response: { behavior: 'allow', updatedInput: input, ...(forSession && suggest ? { updatedPermissions: [{ ...suggest, destination: 'session' }] } : {}) } } });
+                const title = `${r.tool_name ?? 'tool'} needs approval`;
+                if (rule && state.allowRules.has(rule)) {
+                  allow(true);
+                  mark({ type: 'question_answered', id, outcome: 'allowed-session', value: null, auto: true, title, message: line, rule });
+                  break;
+                }
+                state.asks.set(id, (answer) => {
+                  const yes = !!answer?.confirmed;
+                  const forSession = yes && answer?.scope === 'session' && !!rule;
+                  if (forSession) state.allowRules.add(rule);
+                  if (yes) allow(forSession); else write(proc, { type: 'control_response', response: { subtype: 'success', request_id: m.request_id, response: { behavior: 'deny', message: 'the person did not allow this step' } } });
+                  mark({ type: 'question_answered', id, outcome: yes ? (forSession ? 'allowed-session' : 'allowed-once') : 'rejected', value: null, ...(forSession ? { rule } : {}) });
+                });
+                mark({ type: 'question', kind: 'confirm', id, rule, title, message: [line, r.description].filter(Boolean).join('\n'), options: [], placeholder: null, prefill: null, paths: [], suggest: null });
+                break;
+              }
+              case 'result':
+                state.final = typeof m.result === 'string' ? m.result : null;
+                if (m.subtype && m.subtype !== 'success') mark({ type: 'run_error', message: String(m.result ?? m.subtype) });
+                done(m.subtype === 'success' ? 'end' : 'error');
+                break;
+              default: break;
+            }
+          };
+
+          // the prompt goes in as one user message; stdin stays open for answers
+          const content = [{ type: 'text', text: String(req.prompt ?? '') }];
+          for (const img of Array.isArray(req.images) ? req.images : []) if (img && typeof img.data === 'string') content.push({ type: 'image', source: { type: 'base64', media_type: img.mimeType, data: img.data } });
+          write(proc, { type: 'user', message: { role: 'user', content } });
+
+          const how = await finished;
+          // let the CLI finish writing its transcript: it exits on its own
+          // after the result; a kill is only the fallback
+          await new Promise((resolve) => { if (proc.exitCode !== null || proc.signalCode) return resolve(); const t = setTimeout(() => { try { proc.kill(); } catch { /* gone */ } resolve(); }, 8000); proc.once('exit', () => { clearTimeout(t); resolve(); }); });
+          if (state.sessionId) {
+            const file = await sessionFileFor(cwd, state.sessionId);
+            const ran = await turnEffortOf(file);
+            mark({ type: 'session', effort: ran, sessionId: state.sessionId, sessionFile: file, model: { provider: 'claude-code', id: model ?? 'default', name: model ?? 'default', ...(state.resolvedModel ? { resolved: state.resolvedModel } : {}) }, cwd });
+          }
+          if (before) {
+            const after = await snapshotDir(cwd).catch(() => null);
+            if (after) { const d = diffSnapshots(before, after); if (d.changed.length || d.added.length || d.removed.length || d.truncated) mark({ type: 'fs_changes', ...d }); }
+          }
+          mark({ type: 'run_end', text: state.final ?? state.text, how });
+        } catch (e) {
+          mark({ type: 'run_error', message: e instanceof Error ? e.message : String(e) });
+          mark({ type: 'run_end', text: state.final ?? state.text, how: 'error' });
+        } finally {
+          if (watchdog) clearInterval(watchdog);
+          runs.delete(runId);
+        }
+      })();
+      return runId;
+    },
+
+    abort(runId) {
+      const r = runs.get(runId);
+      if (!r) return false;
+      r.aborted = true;
+      for (const [id, respond] of r.asks) { respond({ confirmed: false }); r.asks.delete(id); }
+      try { r.proc?.kill(); } catch { /* gone */ }
+      return true;
+    },
+
+    answer(runId, requestId, response) {
+      const r = runs.get(runId);
+      const respond = r?.asks.get(String(requestId));
+      if (!respond) return false;
+      r.asks.delete(String(requestId));
+      const a = response && typeof response === 'object' ? response : { confirmed: !!response };
+      respond(a.cancelled ? { confirmed: false } : a);
+      return true;
+    },
+
+    shutdown() { for (const r of runs.values()) { try { r.proc?.kill(); } catch { /* gone */ } } },
+  };
+}
+
+function write(proc, obj) { try { proc.stdin.write(JSON.stringify(obj) + '\n'); return true; } catch { return false; } }
+
+module.exports = { createClaudeRuntime, findClaude };

package/lib/runtime/agents/codex.cjs

@@ -40,9 +40,11 @@ async function policyFor(cwd) {
   return { approvalPolicy: 'on-request', sandbox: 'workspace-write' };
 }
 
+// the thread id is in the rollout's file name; take the LAST UUID in the
+// path in case a directory carries one of its own
 const threadIdOf = (sessionPath) => {
-  const m = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i.exec(String(sessionPath ?? ''));
-  return m ? m[1] : null;
+  const all = String(sessionPath ?? '').match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi);
+  return all && all.length ? all[all.length - 1] : null;
 };
 
 function createCodexRuntime({ log } = {}) {
@@ -61,12 +63,26 @@ function createCodexRuntime({ log } = {}) {
   const write = (obj) => { try { proc.stdin.write(JSON.stringify(obj) + '\n'); return true; } catch { return false; } };
   const send = (method, params, timeoutMs = RESPONSE_MS) => new Promise((resolve, reject) => {
     if (!proc) return reject(new Error('codex app-server is not running'));
+    lastUse = Date.now();
     const id = nextId++;
     const timer = setTimeout(() => { pending.delete(id); reject(new Error(`codex did not answer ${method} in ${timeoutMs / 1000}s`)); }, timeoutMs);
     pending.set(id, (msg) => { clearTimeout(timer); if (msg.error) reject(new Error(msg.error.message || `codex refused ${method}`)); else resolve(msg.result); });
     if (!write({ jsonrpc: '2.0', id, method, params })) { clearTimeout(timer); pending.delete(id); reject(new Error('codex stdin closed')); }
   });
 
+  // The app-server retires after SERVER_IDLE_MS without a run or a request:
+  // a catalog read at picker time must not pin a hundred megabytes for the
+  // rest of the launch. The next run starts it again.
+  const SERVER_IDLE_MS = Number(process.env.TD_AGENT_IDLE_MS) || 10 * 60 * 1000;
+  let lastUse = Date.now();
+  const retire = setInterval(() => {
+    if (!proc || runs.size || pending.size || Date.now() - lastUse < SERVER_IDLE_MS) return;
+    say('codex app-server idle; stopping it');
+    try { proc.kill(); } catch { /* gone */ }
+    proc = null; ready = null;
+  }, 30 * 1000);
+  retire.unref?.();
+
   const die = (reason) => {
     for (const p of pending.values()) p({ error: { message: reason } });
     pending.clear();
@@ -98,10 +114,35 @@ function createCodexRuntime({ log } = {}) {
     return ready;
   }
 
+  // the effort a turn ran at, as the rollout records it (turn_context.effort):
+  // the model's own default when the canvas named none
+  async function turnEffortOf(file) {
+    if (!file) return null;
+    try {
+      const lines = (await fsp.readFile(file, 'utf8')).split('\n');
+      for (let i = lines.length - 1; i >= 0; i--) {
+        if (!lines[i].includes('"turn_context"')) continue;
+        try { const o = JSON.parse(lines[i]); if (o.type === 'turn_context' && typeof o.payload?.effort === 'string') return o.payload.effort; } catch { /* torn line */ }
+      }
+    } catch { /* no file yet */ }
+    return null;
+  }
+
+  // ~/.codex/config.toml `model_reasoning_effort` overrides every model's own
+  // default; the picker's 'default' must name what a turn will actually use
+  async function configuredEffort() {
+    try {
+      const home = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+      const m = (await fsp.readFile(path.join(home, 'config.toml'), 'utf8')).match(/^\s*model_reasoning_effort\s*=\s*"([^"]+)"/m);
+      return m ? m[1] : null;
+    } catch { return null; }
+  }
+
   const runOf = (threadId) => { const id = byThread.get(threadId); return id ? runs.get(id) : undefined; };
 
   // ── the server speaks: responses, notifications, and its own requests ──
   function dispatch(msg) {
+    lastUse = Date.now();
     if (msg.id !== undefined && msg.method === undefined) { const p = pending.get(msg.id); if (p) { pending.delete(msg.id); p(msg); } return; }
     const params = msg.params ?? {};
     const run = runOf(params.threadId);
@@ -167,14 +208,37 @@ function createCodexRuntime({ log } = {}) {
       run.waiting = true;
       run.emit({ type: 'question', id, ...question });
     };
-    const decided = (id, outcome, value) => { run.waiting = false; run.emit({ type: 'question_answered', id, outcome, value: value ?? null }); };
+    const decided = (id, outcome, value, extra) => { run.waiting = false; run.emit({ type: 'question_answered', id, outcome, value: value ?? null, ...(extra ?? {}) }); };
+    // a yes/no the conversation may have settled already: `rule` names what a
+    // standing allowance covers; a match is accepted for the session without asking
+    const settle = (rule, title, message, respondYes) => {
+      if (rule && run.allowRules?.has(rule)) { respondYes(true); run.emit({ type: 'question_answered', id: `auto-${msg.id}`, outcome: 'allowed-session', value: null, auto: true, title, message, rule }); return true; }
+      return false;
+    };
+    const yesNo = (rule, respondYes, respondNo) => (a, id) => {
+      const yes = !!a?.confirmed; const forSession = yes && a?.scope === 'session' && !!rule;
+      if (forSession) run.allowRules?.add(rule);
+      if (yes) respondYes(forSession); else respondNo();
+      decided(id, yes ? (forSession ? 'allowed-session' : 'allowed-once') : 'rejected', null, forSession ? { rule } : undefined);
+    };
     switch (msg.method) {
-      case 'item/commandExecution/requestApproval':
-        return ask({ kind: 'confirm', title: 'command needs approval', message: [params.command, params.reason].filter(Boolean).join('\n'), options: [], placeholder: null, prefill: null, paths: [], suggest: null },
-          (a, id) => { const yes = !!a?.confirmed; reply({ decision: yes ? 'accept' : 'decline' }); decided(id, yes ? 'allowed-once' : 'rejected'); });
-      case 'item/fileChange/requestApproval':
-        return ask({ kind: 'confirm', title: 'file change needs approval', message: [params.reason, params.grantRoot].filter(Boolean).join('\n') || 'apply the proposed file changes', options: [], placeholder: null, prefill: null, paths: [], suggest: null },
-          (a, id) => { const yes = !!a?.confirmed; reply({ decision: yes ? 'accept' : 'decline' }); decided(id, yes ? 'allowed-once' : 'rejected'); });
+      case 'item/commandExecution/requestApproval': {
+        const cmd = Array.isArray(params.command) ? params.command.join(' ') : String(params.command ?? '');
+        const rule = cmd ? 'codex:cmd:' + cmd : null;
+        const title = 'command needs approval'; const message = [params.command, params.reason].filter(Boolean).join('\n');
+        const respondYes = (forSession) => reply({ decision: forSession ? 'acceptForSession' : 'accept' });
+        if (settle(rule, title, message, respondYes)) return;
+        return ask({ kind: 'confirm', title, message, rule, options: [], placeholder: null, prefill: null, paths: [], suggest: null },
+          yesNo(rule, respondYes, () => reply({ decision: 'decline' })));
+      }
+      case 'item/fileChange/requestApproval': {
+        const rule = 'codex:fileChange';
+        const title = 'file change needs approval'; const message = [params.reason, params.grantRoot].filter(Boolean).join('\n') || 'apply the proposed file changes';
+        const respondYes = (forSession) => reply({ decision: forSession ? 'acceptForSession' : 'accept' });
+        if (settle(rule, title, message, respondYes)) return;
+        return ask({ kind: 'confirm', title, message, rule, options: [], placeholder: null, prefill: null, paths: [], suggest: null },
+          yesNo(rule, respondYes, () => reply({ decision: 'decline' })));
+      }
       case 'item/permissions/requestApproval':
         return ask({ kind: 'confirm', title: 'more permissions requested', message: [params.reason, JSON.stringify(params.permissions ?? {})].filter(Boolean).join('\n'), options: [], placeholder: null, prefill: null, paths: [], suggest: null },
           (a, id) => { const yes = !!a?.confirmed; reply({ permissions: yes ? (params.permissions ?? {}) : {}, scope: 'turn' }); decided(id, yes ? 'allowed-once' : 'rejected'); });
@@ -196,14 +260,21 @@ function createCodexRuntime({ log } = {}) {
     }
   }
 
-  const modelEntry = (m) => ({ provider: 'codex', id: m.model ?? m.id, name: m.displayName ?? m.model ?? m.id, reasoning: true, vision: true });
+  const effortsIn = (m) => (m.supportedReasoningEfforts ?? []).map((e) => (e && typeof e === 'object' ? e.reasoningEffort : e)).filter((e) => typeof e === 'string');
+  const modelEntry = (m) => ({ provider: 'codex', id: m.model ?? m.id, name: m.displayName ?? m.model ?? m.id, reasoning: true, vision: true, efforts: effortsIn(m), defaultEffort: typeof m.defaultReasoningEffort === 'string' ? m.defaultReasoningEffort : null });
+  // model id → the reasoning efforts it advertises, from model/list
+  const effortsByModel = new Map();
+  const noteEfforts = (r) => { for (const m of r?.data ?? []) effortsByModel.set(m.model ?? m.id, effortsIn(m)); };
+  // only a level the model itself advertises, in Codex's own words; anything
+  // else means the model's default
+  const effortFor = (model, word) => { const offered = effortsByModel.get(model); return word && offered && offered.includes(word) ? word : null; };
   // the model a run uses when the canvas named none: the server's own
   // default from model/list, not the config file's — a config can name a
   // model this CLI version cannot run, and the list only carries runnable ones
   let defaultModel = null;
   async function defaultModelId() {
     if (defaultModel) return defaultModel;
-    try { const r = await send('model/list', {}); const d = (r?.data ?? []).find((m) => m.isDefault) ?? (r?.data ?? [])[0]; defaultModel = d ? (d.model ?? d.id) : null; } catch { /* leave it to the config */ }
+    try { const r = await send('model/list', {}); noteEfforts(r); const d = (r?.data ?? []).find((m) => m.isDefault) ?? (r?.data ?? [])[0]; defaultModel = d ? (d.model ?? d.id) : null; } catch { /* leave it to the config */ }
     return defaultModel;
   }
 
@@ -215,7 +286,9 @@ function createCodexRuntime({ log } = {}) {
       if (!b) return { installed: false, models: [], default: null };
       await ensureServer();
       const r = await send('model/list', {});
-      const models = (r?.data ?? []).filter((m) => !m.hidden).map(modelEntry);
+      noteEfforts(r);
+      const configured = await configuredEffort();
+      const models = (r?.data ?? []).filter((m) => !m.hidden).map(modelEntry).map((m) => (configured && m.efforts.includes(configured) ? { ...m, defaultEffort: configured } : m));
       const def = (r?.data ?? []).find((m) => m.isDefault);
       defaultModel = def ? (def.model ?? def.id) : defaultModel;
       return { installed: true, models, default: def ? `codex/${def.model ?? def.id}` : (models[0] ? `codex/${models[0].id}` : null) };
@@ -228,7 +301,9 @@ function createCodexRuntime({ log } = {}) {
       await ensureServer();
       const runId = randomUUID();
       const emit = (event) => { try { onEvent({ runId, event }); } catch { /* renderer gone */ } };
-      const state = { runId, threadId: null, turnId: null, text: '', final: null, waiting: false, emit, end: null, done: null };
+      const state = { runId, threadId: null, turnId: null, text: '', final: null, waiting: false, emit, end: null, done: null,
+        // what this conversation already allowed for good (see README: `rule`)
+        allowRules: new Set(Array.isArray(req.allowRules) ? req.allowRules.filter((s) => typeof s === 'string' && s.startsWith('codex:')) : []) };
       state.done = new Promise((resolve) => { state.end = (how) => { if (state.ended) return; state.ended = true; resolve(how); }; });
       runs.set(runId, state);
       void (async () => {
@@ -256,9 +331,12 @@ function createCodexRuntime({ log } = {}) {
           const before = await snapshotDir(cwd).catch(() => null);
           const input = [{ type: 'text', text: String(req.prompt ?? ''), text_elements: [] }];
           for (const img of Array.isArray(req.images) ? req.images : []) if (img && typeof img.data === 'string') input.push({ type: 'image', url: `data:${img.mimeType};base64,${img.data}` });
-          const started = await send('turn/start', { threadId: thread.id, input, ...(model ? { model } : {}) }, 60 * 1000);
+          const effort = req.effort && model ? effortFor(model, req.effort) : null;
+          const started = await send('turn/start', { threadId: thread.id, input, ...(model ? { model } : {}), ...(effort ? { effort } : {}) }, 60 * 1000);
           state.turnId = started?.turn?.id ?? null;
           const how = await state.done;
+          const ran = await turnEffortOf(thread.path);
+          if (ran) state.emit({ type: 'session', sessionId: thread.id, sessionFile: thread.path ?? null, model: model ? { provider: 'codex', id: model, name: model } : null, cwd, effort: ran });
           if (before) {
             const after = await snapshotDir(cwd).catch(() => null);
             if (after) { const d = diffSnapshots(before, after); if (d.changed.length || d.added.length || d.removed.length || d.truncated) state.emit({ type: 'fs_changes', ...d }); }
@@ -295,7 +373,7 @@ function createCodexRuntime({ log } = {}) {
       return true;
     },
 
-    shutdown() { try { proc?.kill(); } catch { /* gone */ } proc = null; ready = null; },
+    shutdown() { clearInterval(retire); try { proc?.kill(); } catch { /* gone */ } proc = null; ready = null; },
   };
 }
 

package/lib/runtime/agents/http.cjs

@@ -12,6 +12,7 @@ const terminal = require('../terminal.cjs');
 const RUNTIME_FACTORIES = {
   pi: (log) => require('./pi.cjs').createPiRuntime({ log }),
   codex: (log) => require('./codex.cjs').createCodexRuntime({ log }),
+  'claude-code': (log) => require('./claude.cjs').createClaudeRuntime({ log }),
 };
 
 function createAgentsHttp({ workspaceRoot = path.join(os.homedir(), '.thoughtdag', 'workspaces'), log = () => {} } = {}) {

package/lib/runtime/agents/pi.cjs

@@ -13,7 +13,7 @@
 
 'use strict';
 
-const { spawn } = require('node:child_process');
+const { spawn, execFile } = require('node:child_process');
 const path = require('node:path');
 const fs = require('node:fs');
 const os = require('node:os');
@@ -21,7 +21,7 @@ const { randomUUID } = require('node:crypto');
 
 const fsp = fs.promises;
 const GUARD = path.join(__dirname, 'pi-guard.mjs');
-const IDLE_MS = 10 * 60 * 1000;
+const IDLE_MS = Number(process.env.TD_AGENT_IDLE_MS) || 10 * 60 * 1000; // a Pi process (session or catalog) retires after this long without a listener
 const RESPONSE_MS = 30 * 1000;
 const CANDIDATE_DIRS = [
   '/opt/homebrew/bin', '/usr/local/bin', '/usr/bin',
@@ -192,6 +192,18 @@ function createPiRuntime({ log } = {}) {
   let binPromise = null;
 
   const bin = () => { if (!binPromise) binPromise = findPi(); return binPromise; };
+  // Pi's thinking levels in its own words, from its own `--help`
+  // (`--thinking <level>  Set thinking level: off, minimal, …`); read once
+  let levelsPromise = null;
+  const levelsOf = (b) => {
+    if (!levelsPromise) levelsPromise = new Promise((resolve) => {
+      execFile(b, ['--help'], { env: childEnv(), timeout: 8000, maxBuffer: 1 << 20 }, (_err, stdout) => {
+        const m = String(stdout || '').match(/--thinking[^\n]*?level:\s*([a-z0-9_, -]+)/i);
+        resolve(m ? m[1].split(',').map((s) => s.trim()).filter(Boolean) : []);
+      });
+    });
+    return levelsPromise;
+  };
 
   async function processFor(cwd) {
     const live = procs.get(cwd);
@@ -221,8 +233,9 @@ function createPiRuntime({ log } = {}) {
       let p = procs.get(key);
       if (!p || p.dead) { p = new PiProcess(b, os.homedir(), { log: say, noSession: true, onExit: (d) => { if (procs.get(key) === d) procs.delete(key); } }); procs.set(key, p); }
       return p.exclusive(async () => {
-        const [cat, state] = await Promise.all([p.send({ type: 'get_available_models' }), p.send({ type: 'get_state' })]);
-        const models = (cat?.models ?? []).map(modelEntry);
+        const [cat, state, levels] = await Promise.all([p.send({ type: 'get_available_models' }), p.send({ type: 'get_state' }), levelsOf(b)]);
+        const defaultEffort = typeof state?.thinkingLevel === 'string' ? state.thinkingLevel : null;
+        const models = (cat?.models ?? []).map((m) => ({ ...modelEntry(m), efforts: m.reasoning ? levels : [], defaultEffort: m.reasoning ? defaultEffort : null }));
         const cur = state?.model ? `${state.model.provider}/${state.model.id}` : null;
         return { installed: true, models, default: cur && models.some((m) => `${m.provider}/${m.id}` === cur) ? cur : (models[0] ? `${models[0].provider}/${models[0].id}` : null), thinkingLevel: state?.thinkingLevel ?? null };
       });
@@ -275,9 +288,11 @@ function createPiRuntime({ log } = {}) {
           if (req.forkEntryId) await proc.send({ type: 'fork', entryId: String(req.forkEntryId) });
           else if (!req.sessionPath) await proc.send({ type: 'new_session' });
           if (req.model && typeof req.model === 'object' && req.model.provider && req.model.id) await proc.send({ type: 'set_model', provider: req.model.provider, modelId: req.model.id });
-          if (req.thinkingLevel) await proc.send({ type: 'set_thinking_level', level: req.thinkingLevel });
+          // only a level Pi itself lists; an explicit thinkingLevel still wins
+          const level = req.thinkingLevel || (req.effort && (await levelsOf(await bin())).includes(req.effort) ? req.effort : null);
+          if (level) await proc.send({ type: 'set_thinking_level', level });
           const state = await proc.send({ type: 'get_state' });
-          emit({ type: 'session', sessionId: state?.sessionId ?? null, sessionFile: state?.sessionFile ?? null, model: state?.model ? { provider: state.model.provider, id: state.model.id, name: state.model.name } : null, cwd });
+          emit({ type: 'session', effort: typeof state?.thinkingLevel === 'string' ? state.thinkingLevel : null, sessionId: state?.sessionId ?? null, sessionFile: state?.sessionFile ?? null, model: state?.model ? { provider: state.model.provider, id: state.model.id, name: state.model.name } : null, cwd });
           const before = await snapshotDir(cwd).catch(() => null);
           if (aborter.aborted) { ended('aborted'); }
           else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-thoughtdag",
-  "version": "0.4.10",
+  "version": "0.4.12",
   "description": "ThoughtDAG for DeepSeek Harness: turn the current DSH session into an editable thought graph on an infinite canvas.",
   "author": "Xia Chen",
   "repository": {