pikiclaw 0.3.78 → 0.3.79

package/dist/agent/drivers/claude-tui.js

@@ -45,7 +45,7 @@ import { encodePathAsDirName, getHome, whichSync } from '../../core/platform.js'
 import { createRetainedLogSink } from '../../core/logging.js';
 import { stripAnsiEscapes } from '../../core/utils.js';
 import { AGENT_STREAM_HARD_KILL_GRACE_MS, CLAUDE_TUI_STALL_QUIET_MS, CLAUDE_TUI_STALL_PENDING_TOOL_MS, CLAUDE_TUI_STALL_PTY_DEAD_MS, CLAUDE_TUI_STOP_HOLD_QUIET_TTL_MS, } from '../../core/constants.js';
-import { claudeParse, createClaudeStreamState, claudeContextWindowFromModel, claudeEffectiveContextWindow, registerClaudeBackgroundAgentLaunch, pendingClaudeBackgroundAgentCount, registerClaudeBackgroundBashLaunch, pendingClaudeBackgroundBashCount, extractClaudeBackgroundTaskId, extractClaudeWorkflowRunId, claudeEffortAndWorkflowArgs, } from './claude.js';
+import { claudeParse, createClaudeStreamState, claudeContextWindowFromModel, claudeEffectiveContextWindow, registerClaudeBackgroundAgentLaunch, pendingClaudeBackgroundAgentCount, registerClaudeBackgroundBashLaunch, pendingClaudeBackgroundBashCount, extractClaudeBackgroundTaskId, extractClaudeWorkflowRunId, claudeEffortAndWorkflowArgs, scrubClaudeSessionContextEnv, } from './claude.js';
 // ---------------------------------------------------------------------------
 // Stall diagnostics (capture-only)
 // ---------------------------------------------------------------------------
@@ -956,12 +956,16 @@ export async function doClaudeTuiStream(opts) {
         // PATH inside the claude TUI's hook subprocess on every distro.
         const nodeBin = Q(process.execPath);
         const hookCmd = (event) => `${nodeBin} ${Q(hookPath)} ${event} ${Q(statePath)} ${Q(toolEventsPath)}`;
-        // Pre/PostToolUse hooks give us a live event stream. Claude Code 2.x
-        // buffers the JSONL transcript and only flushes it when Stop fires, so
-        // without these hooks the dashboard / IM see absolutely no progress
-        // during a 30s+ turn. The hook script writes to tool-events.jsonl via
-        // atomic appends, sidestepping the read-modify-write race that affects
-        // the shared state.json file.
+        // Pre/PostToolUse hooks give us a live tool-event stream. The transcript
+        // JSONL is itself written incrementally (events land ~0.2–1.2s after they
+        // happen — measured on 2.1.173), but the hooks still earn their keep:
+        // PreToolUse fires the instant a tool *starts* (the JSONL tool_use only
+        // proves it was requested; a long-running Bash would otherwise sit
+        // invisible), they carry agent_id for sub-agent attribution, and they are
+        // the registration point for run_in_background launches that the Stop
+        // gating in decideClaudeTuiStop depends on. The hook script writes to
+        // tool-events.jsonl via atomic appends, sidestepping the
+        // read-modify-write race that affects the shared state.json file.
         // Pre/PostToolUse require an explicit `matcher` field — without it Claude
         // Code's hook dispatcher silently never fires the hook (the lifecycle
         // hooks below don't need a matcher because they aren't tool-scoped).
@@ -1157,9 +1161,13 @@ export async function doClaudeTuiStream(opts) {
         if (typeof v === 'string')
             spawnEnv[k] = v;
     }
-    // CLAUDECODE is set automatically by the parent claude process when calling
-    // children — clear it so this is treated as a fresh top-level invocation.
-    delete spawnEnv.CLAUDECODE;
+    // Strip the session-context markers a parent claude process exports to its
+    // subprocesses (CLAUDECODE, CLAUDE_CODE_CHILD_SESSION, …). Inherited e.g.
+    // when an agent restarted the pikiclaw daemon from inside a Claude Code
+    // session, they flip this spawn into child-session mode — the transcript
+    // JSONL (our only text source) is then never written locally and the turn
+    // streams nothing. See CLAUDE_SESSION_CONTEXT_ENV_KEYS in claude.ts.
+    scrubClaudeSessionContextEnv(spawnEnv);
     // Critical: leaving ANTHROPIC_API_KEY set would route TUI through API
     // billing too, defeating the whole point. Strip it unless the user
     // explicitly opts back in.
@@ -1416,11 +1424,69 @@ export async function doClaudeTuiStream(opts) {
     let lastClearedStopAt = 0;
     /** Hook-reported tools still executing: PreToolUse seen, no PostToolUse. */
     const pendingHookToolIds = new Set();
+    // Incremental main-JSONL drain — the canonical text/thinking/usage feed.
+    // Used by both the 200ms poll tick and the post-exit final drain. Returns
+    // true when any line was consumed so callers can emit().
+    const drainMainJsonl = () => {
+        if (!fs.existsSync(activeJsonlPath))
+            return false;
+        const inc = readJsonlIncrement(activeJsonlPath, jsonlReadOffset);
+        jsonlReadOffset = inc.offset;
+        let touched = false;
+        for (const line of inc.lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed[0] !== '{')
+                continue;
+            lineCount++;
+            let ev;
+            try {
+                ev = JSON.parse(trimmed);
+            }
+            catch {
+                continue;
+            }
+            // Ignore sub-agent sidecar events — they belong to a child agent's
+            // stream and would re-enter the parent's accumulator. claudeParse's
+            // own sub-agent routing handles them.
+            const isSubAgentEvent = typeof ev.parent_tool_use_id === 'string' && ev.parent_tool_use_id;
+            if (!isSubAgentEvent && ev.type === 'assistant') {
+                const notice = detectClaudeTuiTerminalLimitNotice(ev.message);
+                if (notice) {
+                    // A synthetic limit banner is not substantive progress — skip the
+                    // liveness/type bookkeeping below so the limit arbitration and the
+                    // stall watchdog don't mistake it for a live model segment.
+                    noteTerminalLimitNotice(notice);
+                    touched = true;
+                    continue;
+                }
+                applyAssistantStreaming(s, ev.message, streamBuf);
+                applyAssistantUsage(s, ev.message);
+                if (ev.message?.model && ev.message.model !== '<synthetic>' && typeof ev.message.model === 'string') {
+                    lastAssistantEventAt = Date.now();
+                    s.model = ev.message.model;
+                    applyModelContextWindow(s);
+                }
+            }
+            try {
+                callClaudeParseForTui(ev, s);
+            }
+            catch (e) {
+                agentWarn(`[claude-tui] claudeParse threw on line: ${e?.message || e}`);
+            }
+            touched = true;
+            lastMainJsonlEventAt = Date.now();
+            if (typeof ev.version === 'string' && ev.version)
+                observedClaudeVersion = ev.version;
+            if (!isSubAgentEvent)
+                lastMainJsonlType = classifyClaudeJsonlEvent(ev);
+        }
+        return touched;
+    };
     // Append-only tool-events log fed by PreToolUse / PostToolUse hooks. We
-    // tail it with the same incremental reader the JSONL transcript uses, so
-    // tool calls + plan changes surface live during the turn even while the
-    // canonical JSONL stays empty (Claude Code 2.x buffers the whole transcript
-    // until the Stop hook fires).
+    // tail it with the same incremental reader the JSONL transcript uses. Hook
+    // events usually beat their JSONL counterpart by a second or so (and
+    // PreToolUse fires before the tool even runs); whichever feed arrives first
+    // wins, the other dedups via seenClaudeToolIds / seenClaudeToolResultIds.
     let toolEventsReadOffset = 0;
     const drainToolEvents = () => {
         if (!fs.existsSync(toolEventsPath))
@@ -1604,69 +1670,18 @@ export async function doClaudeTuiStream(opts) {
             agentLog(`[claude-tui] prompt-submit nudge sent (no UserPromptSubmit after ${PROMPT_SUBMIT_NUDGE_MS}ms)`);
         }
         // JSONL tail.
-        if (fs.existsSync(activeJsonlPath)) {
-            const inc = readJsonlIncrement(activeJsonlPath, jsonlReadOffset);
-            jsonlReadOffset = inc.offset;
-            let touched = false;
-            for (const line of inc.lines) {
-                const trimmed = line.trim();
-                if (!trimmed || trimmed[0] !== '{')
-                    continue;
-                lineCount++;
-                let ev;
-                try {
-                    ev = JSON.parse(trimmed);
-                }
-                catch {
-                    continue;
-                }
-                // Ignore sub-agent sidecar events — they belong to a child agent's
-                // stream and would re-enter the parent's accumulator. claudeParse's
-                // own sub-agent routing handles them.
-                const isSubAgentEvent = typeof ev.parent_tool_use_id === 'string' && ev.parent_tool_use_id;
-                if (!isSubAgentEvent && ev.type === 'assistant') {
-                    const notice = detectClaudeTuiTerminalLimitNotice(ev.message);
-                    if (notice) {
-                        noteTerminalLimitNotice(notice);
-                        touched = true;
-                        continue;
-                    }
-                    applyAssistantStreaming(s, ev.message, streamBuf);
-                    applyAssistantUsage(s, ev.message);
-                    if (ev.message?.model && ev.message.model !== '<synthetic>' && typeof ev.message.model === 'string') {
-                        lastAssistantEventAt = Date.now();
-                        s.model = ev.message.model;
-                        applyModelContextWindow(s);
-                    }
-                }
-                try {
-                    callClaudeParseForTui(ev, s);
-                }
-                catch (e) {
-                    agentWarn(`[claude-tui] claudeParse threw on line: ${e?.message || e}`);
-                }
-                touched = true;
-                lastMainJsonlEventAt = Date.now();
-                if (typeof ev.version === 'string' && ev.version)
-                    observedClaudeVersion = ev.version;
-                if (!isSubAgentEvent)
-                    lastMainJsonlType = classifyClaudeJsonlEvent(ev);
-            }
-            if (touched) {
-                // Emit immediately so non-text changes (tool_use, plan, activity,
-                // thinking, usage) reach the dashboard without waiting for the
-                // chunked stream tick. The streaming timer separately advances
-                // s.text from the buffer over the next few ticks.
-                emit();
-                scheduleStreamTick();
-            }
+        if (drainMainJsonl()) {
+            // Emit immediately so non-text changes (tool_use, plan, activity,
+            // thinking, usage) reach the dashboard without waiting for the
+            // chunked stream tick. The streaming timer separately advances
+            // s.text from the buffer over the next few ticks.
+            emit();
+            scheduleStreamTick();
         }
-        // Live tool-events stream — fed by Pre/PostToolUse hooks.  Order matters:
-        // we drain hooks BEFORE the JSONL tail above already ran so any hook
-        // events that beat their JSONL counterpart are recorded in
-        // seenClaudeToolIds first; subsequent JSONL pass deduplicates naturally.
-        // In practice JSONL doesn't land until Stop, so this is the only signal
-        // that fires during a normal turn.
+        // Live tool-events stream — fed by Pre/PostToolUse hooks. Hook and JSONL
+        // feeds race per tool call; both record into seenClaudeToolIds /
+        // seenClaudeToolResultIds so whichever lands first wins and the other
+        // pass dedups naturally.
         if (drainToolEvents())
             emit();
         // Sub-agent sidecar discovery + pump. Order matters: discovery first so a
@@ -1882,47 +1897,8 @@ export async function doClaudeTuiStream(opts) {
     opts.abortSignal?.removeEventListener('abort', abortStream);
     // 11. Final drain — pick up anything written between the last poll and
     // process exit. Claude flushes its remaining JSONL events on shutdown.
-    if (fs.existsSync(activeJsonlPath)) {
-        const inc = readJsonlIncrement(activeJsonlPath, jsonlReadOffset);
-        jsonlReadOffset = inc.offset;
-        let touched = false;
-        for (const line of inc.lines) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed[0] !== '{')
-                continue;
-            lineCount++;
-            let ev;
-            try {
-                ev = JSON.parse(trimmed);
-            }
-            catch {
-                continue;
-            }
-            const isSubAgentEvent = typeof ev.parent_tool_use_id === 'string' && ev.parent_tool_use_id;
-            if (!isSubAgentEvent && ev.type === 'assistant') {
-                const notice = detectClaudeTuiTerminalLimitNotice(ev.message);
-                if (notice) {
-                    noteTerminalLimitNotice(notice);
-                    touched = true;
-                    continue;
-                }
-                applyAssistantStreaming(s, ev.message, streamBuf);
-                applyAssistantUsage(s, ev.message);
-                if (ev.message?.model && ev.message.model !== '<synthetic>' && typeof ev.message.model === 'string') {
-                    lastAssistantEventAt = Date.now();
-                    s.model = ev.message.model;
-                    applyModelContextWindow(s);
-                }
-            }
-            try {
-                callClaudeParseForTui(ev, s);
-            }
-            catch { }
-            touched = true;
-        }
-        if (touched)
-            emit();
-    }
+    if (drainMainJsonl())
+        emit();
     // Final tool-events drain — any PreToolUse / PostToolUse hooks that fired
     // between the last poll tick and process exit.
     if (drainToolEvents())

package/dist/agent/drivers/claude.js

@@ -65,6 +65,39 @@ export function claudeEffortAndWorkflowArgs(o) {
         args.push('--disallowed-tools', 'Workflow');
     return args;
 }
+/**
+ * Env keys the claude CLI exports to its own subprocesses (Bash tool, hooks)
+ * to mark them as children of a running session. If pikiclaw itself was
+ * launched from inside a Claude Code session — agent-driven `npm run dev`
+ * restarts, `! npx pikiclaw` typed into the TUI, the self-bootstrap path —
+ * these leak into the daemon's environment and every claude it spawns
+ * inherits them. A claude started with `CLAUDE_CODE_CHILD_SESSION` set runs
+ * in child-session mode: it mirrors transcript persistence to its (absent)
+ * SDK parent instead of writing `~/.claude/projects/<dir>/<id>.jsonl`.
+ * The TUI driver tails that JSONL as its only text source, so a contaminated
+ * spawn streams nothing, returns "(no textual response)", and loses the whole
+ * turn on SIGTERM. Verified on 2.1.173: with these vars set the transcript
+ * never grows past the ai-title line; with them scrubbed every event lands
+ * 0.2–1.2s after it happens.
+ *
+ * Deliberately a closed list: config-style vars users set on purpose
+ * (CLAUDE_CODE_USE_BEDROCK, CLAUDE_CODE_MAX_OUTPUT_TOKENS, …) must survive.
+ * Shared by both spawn paths (`claude -p` here and the PTY/TUI driver).
+ */
+const CLAUDE_SESSION_CONTEXT_ENV_KEYS = [
+    'CLAUDECODE',
+    'CLAUDE_CODE_CHILD_SESSION',
+    'CLAUDE_CODE_ENTRYPOINT',
+    'CLAUDE_CODE_EXECPATH',
+    'CLAUDE_CODE_SESSION_ID',
+    'CLAUDE_CODE_SSE_PORT',
+    'CLAUDE_EFFORT',
+    'CLAUDE_PERMISSION_MODE',
+];
+export function scrubClaudeSessionContextEnv(env) {
+    for (const key of CLAUDE_SESSION_CONTEXT_ENV_KEYS)
+        delete env[key];
+}
 // ---------------------------------------------------------------------------
 // Command & parser
 // ---------------------------------------------------------------------------
@@ -1001,7 +1034,7 @@ async function doClaudeInteractiveStream(opts) {
     agentLog(`[spawn] timeout: ${opts.timeout}s session: ${opts.sessionId || '(new)'}`);
     agentLog(`[spawn] prompt (stdin): "${opts.prompt.slice(0, 300)}${opts.prompt.length > 300 ? '…' : ''}"`);
     const spawnEnv = { ...process.env, ...(opts.extraEnv || {}) };
-    delete spawnEnv.CLAUDECODE;
+    scrubClaudeSessionContextEnv(spawnEnv);
     const proc = spawn(shellCmd, {
         cwd: opts.workdir,
         env: spawnEnv,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pikiclaw",
-  "version": "0.3.78",
+  "version": "0.3.79",
   "description": "Put the world's smartest AI agents in your pocket. Command local Claude & Gemini via IM. | 让最好用的 IM 变成你电脑上的顶级 Agent 控制台",
   "type": "module",
   "bin": {