@capstone-nomos/cli 0.1.7 → 0.1.9

package/dist/executor/activity.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 const MAX_TARGET = 300;
+const MAX_SAY = 500;
 function clip(text) {
     const oneLine = text.split(/\r?\n/)[0].trim();
     return oneLine.length > MAX_TARGET ? `${oneLine.slice(0, MAX_TARGET - 1)}…` : oneLine;
@@ -26,6 +27,38 @@ function hideWorkspace(command, cwd) {
     }
     return out;
 }
+function countLines(text) {
+    if (typeof text !== 'string')
+        return null;
+    const body = text.replace(/\r?\n$/, '');
+    return body === '' ? 0 : body.split(/\r?\n/).length;
+}
+// 수정·작성의 줄 수(내용은 보내지 않는다). Edit은 old/new, MultiEdit은 합, Write는 새 내용.
+function lineCounts(tool, input) {
+    if (tool === 'Write') {
+        const added = countLines(input.content);
+        return added === null ? {} : { added };
+    }
+    const edits = tool === 'MultiEdit' && Array.isArray(input.edits) ? input.edits : [input];
+    let added = 0;
+    let removed = 0;
+    for (const e of edits) {
+        const a = countLines(e.new_string);
+        const r = countLines(e.old_string);
+        if (a === null || r === null)
+            return {};
+        added += a;
+        removed += r;
+    }
+    return { added, removed };
+}
+// 에이전트의 말 — 작업공간 경로를 지우고, 빈 줄을 줄이고, 500자에서 자른다.
+export function toSay(text, cwd) {
+    const cleaned = hideWorkspace(text, cwd).replace(/\r\n/g, '\n').replace(/\n{3,}/g, '\n\n').trim();
+    if (!cleaned)
+        return null;
+    return { kind: 'say', target: cleaned.length > MAX_SAY ? `${cleaned.slice(0, MAX_SAY - 1)}…` : cleaned };
+}
 // 도구 하나 → 활동 한 줄. 룸에 보일 필요가 없는 것(NOMOS 도구 — 제출·노트는 서버 이벤트로 이미 보인다, 할 일 목록)은 null.
 export function toActivity(tool, input, cwd) {
     // ToolSearch는 Claude Code가 도구 정의를 불러오는 내부 동작이다(실측: 실행마다 첫 줄로 찍혔다).
@@ -65,31 +98,64 @@ export function toActivity(tool, input, cwd) {
         default:
             item = { kind: 'other', target: tool };
     }
-    return item ? { kind: item.kind, target: clip(item.target) } : null;
+    if (!item)
+        return null;
+    const counts = item.kind === 'edit' || item.kind === 'write' ? lineCounts(tool, input) : {};
+    return { kind: item.kind, target: clip(item.target), ...counts };
 }
-// stream-json 한 줄 → 그 줄에 든 도구 호출들. 형식이 다르거나 깨진 줄은 조용히 건너뛴다(룸 표시가 실행을 막으면 안 된다).
-export function activityFromStreamLine(line, cwd) {
-    const trimmed = line.trim();
-    if (!trimmed.startsWith('{'))
-        return [];
-    let msg;
-    try {
-        msg = JSON.parse(trimmed);
-    }
-    catch {
-        return [];
-    }
-    if (msg.type !== 'assistant' || !Array.isArray(msg.message?.content))
-        return [];
-    const items = [];
-    for (const block of msg.message.content) {
-        if (block.type !== 'tool_use' || typeof block.name !== 'string')
-            continue;
-        const item = toActivity(block.name, (block.input ?? {}), cwd);
-        if (item)
-            items.push(item);
-    }
-    return items;
+// 실행 하나의 stream-json을 따라가며 룸에 보낼 줄을 낸다. 도구 줄은 **결과가 온 뒤** 성공 여부를 붙여 낸다(tool_use_id로 짝짓기).
+// 결과를 못 받은 도구는 finish()에서 성공 여부 없이 낸다. 형식이 다르거나 깨진 줄은 조용히 건너뛴다(룸 표시가 실행을 막으면 안 된다).
+export class ActivityTracker {
+    cwd;
+    pending = new Map();
+    constructor(cwd) {
+        this.cwd = cwd;
+    }
+    observe(line) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('{'))
+            return [];
+        let msg;
+        try {
+            msg = JSON.parse(trimmed);
+        }
+        catch {
+            return [];
+        }
+        if (!Array.isArray(msg.message?.content))
+            return [];
+        const out = [];
+        for (const block of msg.message.content) {
+            if (msg.type === 'assistant' && block.type === 'text' && typeof block.text === 'string') {
+                const say = toSay(block.text, this.cwd);
+                if (say)
+                    out.push(say);
+            }
+            else if (msg.type === 'assistant' && block.type === 'tool_use' && typeof block.name === 'string') {
+                const item = toActivity(block.name, (block.input ?? {}), this.cwd);
+                if (!item)
+                    continue;
+                if (typeof block.id === 'string')
+                    this.pending.set(block.id, item);
+                else
+                    out.push(item);
+            }
+            else if (msg.type === 'user' && block.type === 'tool_result' && typeof block.tool_use_id === 'string') {
+                const item = this.pending.get(block.tool_use_id);
+                if (!item)
+                    continue;
+                this.pending.delete(block.tool_use_id);
+                out.push({ ...item, ok: block.is_error !== true });
+            }
+        }
+        return out;
+    }
+    // 실행이 끝났다 — 결과를 못 받은 도구도 낸다.
+    finish() {
+        const rest = [...this.pending.values()];
+        this.pending.clear();
+        return rest;
+    }
 }
 // 활동을 모아 2초마다 한 번에 보낸다. 보내기 실패는 기록만 하고 넘어간다 — 룸 표시가 태스크 실행을 멈추면 안 된다.
 export class ActivityReporter {
@@ -100,6 +166,8 @@ export class ActivityReporter {
     timer = null;
     sending = Promise.resolve();
     warned = false;
+    // 옛 서버(020 전)는 say·성공 여부·줄 수를 400으로 거부한다 — 한 번 거부되면 그 실행 동안은 예전 형식(도구·대상만)으로 낮춰 보낸다.
+    legacy = false;
     constructor(client, taskId, log, intervalMs = 2_000) {
         this.client = client;
         this.taskId = taskId;
@@ -115,7 +183,7 @@ export class ActivityReporter {
             while (this.queue.length > 0) {
                 const batch = this.queue.splice(0, 50);
                 try {
-                    await this.client.postActivity(this.taskId, batch);
+                    await this.send(batch);
                 }
                 catch (err) {
                     if (!this.warned) {
@@ -127,6 +195,24 @@ export class ActivityReporter {
         });
         return this.sending;
     }
+    async send(batch) {
+        if (this.legacy)
+            return this.sendLegacy(batch);
+        try {
+            await this.client.postActivity(this.taskId, batch);
+        }
+        catch (err) {
+            if (err.status !== 400)
+                throw err;
+            this.legacy = true;
+            await this.sendLegacy(batch);
+        }
+    }
+    async sendLegacy(batch) {
+        const items = batch.filter((i) => i.kind !== 'say').map((i) => ({ kind: i.kind, target: i.target }));
+        if (items.length > 0)
+            await this.client.postActivity(this.taskId, items);
+    }
     async close() {
         if (this.timer)
             clearInterval(this.timer);

package/dist/executor/cli.js

@@ -25,14 +25,14 @@ import { ALLOWED_BASH_PREFIXES, buildMcpConfig } from '../bridge/claude-args.js'
 import { prepareDependencies } from './setup.js';
 import { credentialsPath, readCredentials, updateAccessToken, writeCredentials, } from '../bridge/credentials.js';
 import { NomosApiError, NomosClient } from '../bridge/nomos-client.js';
-import { ActivityReporter, activityFromStreamLine, RunObserver } from './activity.js';
+import { ActivityReporter, ActivityTracker, RunObserver } from './activity.js';
 import { connect, DEFAULT_SERVER, serverCalls } from './connect.js';
 import { deviceLogin } from './device-login.js';
 import { cliVersion, mcpServerPath } from './paths.js';
 import { checkTools } from './preflight.js';
 import { handleNextPmJob } from './pm-worker.js';
 import { buildTaskPrompt } from './prompt.js';
-import { runClaude } from './runner.js';
+import { DEFAULT_IDLE_MS, runClaude } from './runner.js';
 import { streamTaskSource } from './stream-source.js';
 import { pollingTaskSource } from './task-source.js';
 import { runLint, runSpecTests } from './verify.js';
@@ -128,6 +128,7 @@ async function handleTask(client, projectId, task) {
     });
     const reporter = runOpen ? new ActivityReporter(client, task.id, log) : null;
     const observer = new RunObserver(workspace.dir);
+    const tracker = new ActivityTracker(workspace.dir);
     // 의존성은 모델이 아니라 여기서 설치한다(설치 스크립트 끔). 실패해도 진행한다 — 프롬프트에 결과를 적는다.
     const setup = await prepareDependencies(workspace.dir, log);
     const before = headSha(workspace.dir);
@@ -140,15 +141,26 @@ async function handleTask(client, projectId, task) {
         questionRelay: briefing.questionRelay === true,
         onStdoutLine: (line) => {
             observer.observe(line);
-            reporter?.push(activityFromStreamLine(line, workspace.dir));
+            reporter?.push(tracker.observe(line));
         },
     });
     const committed = headSha(workspace.dir) !== before;
     if (reporter) {
+        reporter.push(tracker.finish());
         await reporter.close();
         // 제출했는지는 서버가 태스크 상태로 판단해 룸에 남긴다("끝났지만 제출하지 않았다"가 대표에게 보인다).
+        // 응답 없음(stalled)은 서버에 timeout으로 보고하고 사유 문장으로 구분한다 — 옛 서버는 outcome에 stalled를 모른다.
+        const summary = observer.summary();
+        const stalledNote = `[응답 없음] ${Math.round(DEFAULT_IDLE_MS / 60_000)}분 동안 모델 출력이 없어 Executor가 실행을 끊었다`;
         await client
-            .endRun(task.id, { outcome: result.outcome, committed, durationMs: result.durationMs, exitCode: result.exitCode, ...observer.summary() })
+            .endRun(task.id, {
+            outcome: result.outcome === 'stalled' ? 'timeout' : result.outcome,
+            committed,
+            durationMs: result.durationMs,
+            exitCode: result.exitCode,
+            ...summary,
+            ...(result.outcome === 'stalled' ? { lastMessage: (summary.lastMessage ? `${stalledNote} — 마지막 말: ${summary.lastMessage}` : stalledNote).slice(0, 2000) } : {}),
+        })
             .then((r) => {
             if (r.blocked)
                 log('제출 없이 끝나 태스크가 멈춤(BLOCKED)으로 바뀌었다 — 대표가 원인을 해결하고 재개하면 다시 가져간다');
@@ -164,6 +176,9 @@ async function handleTask(client, projectId, task) {
     else if (result.outcome === 'completed') {
         log(`정상 종료했지만 커밋이 없다. 태스크는 그대로 둔다. 로그: ${result.logPath}`);
     }
+    else if (result.outcome === 'stalled') {
+        log(`${Math.round(DEFAULT_IDLE_MS / 60_000)}분 동안 모델 출력이 없어 끊었다(응답 없음). 재시도하지 않는다. 로그: ${result.logPath}`);
+    }
     else if (result.outcome === 'timeout') {
         log(`30분 초과로 종료했다. 재시도하지 않는다. 로그: ${result.logPath}`);
     }

package/dist/executor/consult.js

@@ -2,7 +2,7 @@ import { spawn } from 'node:child_process';
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
-import { resolveClaudeCommand } from './runner.js';
+import { claudeEnv, resolveClaudeCommand } from './runner.js';
 // 상담 응답의 형식(구조화 출력). 모든 객체는 additionalProperties: false + 전 필드 required.
 export const CONSULT_JSON_SCHEMA = {
     type: 'object',
@@ -91,7 +91,7 @@ export async function runConsult(input) {
     writeFileSync(emptyMcp, JSON.stringify({ mcpServers: {} }));
     const { command, commandArgs } = resolveClaudeCommand(consultArgs(buildConsultPrompt(input), emptyMcp));
     const out = await new Promise((resolve, reject) => {
-        const child = spawn(command, commandArgs, { cwd: input.dir, stdio: ['ignore', 'pipe', 'pipe'] });
+        const child = spawn(command, commandArgs, { cwd: input.dir, stdio: ['ignore', 'pipe', 'pipe'], env: claudeEnv() });
         let stdout = '';
         const timer = setTimeout(() => {
             child.kill();

package/dist/executor/pm-worker.js

@@ -2,7 +2,7 @@ import { spawn } from 'node:child_process';
 import { mkdtempSync, writeFileSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { resolveClaudeCommand } from './runner.js';
+import { claudeEnv, resolveClaudeCommand } from './runner.js';
 import { removeQuietly } from './cleanup.js';
 // 지침·프롬프트는 길어서(이전 초안이 붙는 수정 요청) 명령줄로 넘기지 않는다 — Windows 명령줄은 32k자에서 잘린다.
 // 지침은 파일, 프롬프트는 stdin. 도구는 전부 끄고(--tools ""), 사용자 MCP·세션 기록도 쓰지 않는다.
@@ -54,7 +54,7 @@ const spawnClaude = (args, stdin, cwd) => {
     const { command, commandArgs } = resolveClaudeCommand(args);
     return new Promise((resolve, reject) => {
         // shell을 쓰지 않는다 — 인자가 명령으로 해석되지 않게(runner.ts와 같은 이유).
-        const child = spawn(command, commandArgs, { cwd, stdio: ['pipe', 'pipe', 'pipe'] });
+        const child = spawn(command, commandArgs, { cwd, stdio: ['pipe', 'pipe', 'pipe'], env: claudeEnv() });
         let stdout = '';
         let stderr = '';
         child.stdout.on('data', (c) => (stdout += c.toString()));

package/dist/executor/runner.js

@@ -3,6 +3,40 @@ import { existsSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { buildClaudeArgs } from '../bridge/claude-args.js';
 export const DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
+// 모델 출력(stream-json)이 이만큼 없으면 응답이 끊긴 것으로 보고 끊는다. 30분을 다 기다리지 않고, 사유도 "오래 일함"과 구분된다.
+// 실측: 도구 결과를 받은 뒤 다음 모델 응답이 오지 않은 채 20분 넘게 멈춘 실행이 있었다(같은 조건 재실행은 정상).
+// 정상적인 무출력 구간보다 길어야 한다 — 질문 답 대기(실행 안 3분)·시험 실행(Bash 기본 2분, 최대 10분)·긴 생각.
+export const DEFAULT_IDLE_MS = 15 * 60 * 1000;
+// Executor가 띄우는 claude에 넘기지 않는 환경변수 — 띄운 쪽 Claude Code 세션과 묶는 값들이다.
+// Claude Code 안에서(예: "nomos connect 실행해 줘") CLI를 띄우면 이 값이 그대로 넘어가 태스크 실행이 그 대화 세션의
+// 하위 세션이 된다(진입점이 claude-vscode로 기록되고, 부모 세션의 토큰 잔량 알림이 모델 맥락에 끼어들었다 — 실측).
+// 인증·설정용 변수(CLAUDE_CODE_OAUTH_TOKEN, CLAUDE_CODE_GIT_BASH_PATH, CLAUDE_CODE_USE_BEDROCK 등)는 건드리지 않는다.
+export const SESSION_ENV_KEYS = [
+    'CLAUDECODE',
+    'CLAUDE_PID',
+    'CLAUDE_EFFORT',
+    'CLAUDE_AGENT_SDK_VERSION',
+    'CLAUDE_CODE_ENTRYPOINT',
+    'CLAUDE_CODE_EXECPATH',
+    'CLAUDE_CODE_SESSION_ID',
+    'CLAUDE_CODE_CHILD_SESSION',
+    'CLAUDE_CODE_SESSION_ATTENDED',
+    'CLAUDE_CODE_MESSAGING_SOCKET',
+    'CLAUDE_CODE_MESSAGING_TOKEN',
+    'CLAUDE_CODE_SSE_PORT',
+    'CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING',
+    'CLAUDE_CODE_ENABLE_TASKS',
+    'CLAUDE_CODE_EMIT_STARTUP_TIMING',
+    'CLAUDE_CODE_QUESTION_PREVIEW_FORMAT',
+];
+export function claudeEnv(base = process.env) {
+    const env = { ...base };
+    for (const key of Object.keys(env)) {
+        if (SESSION_ENV_KEYS.includes(key.toUpperCase()))
+            delete env[key];
+    }
+    return env;
+}
 // ⚠️ Windows에서 spawn('claude', args, { shell: true })를 쓰면 안 된다.
 // shell:true는 인자를 이스케이프 없이 이어붙여서 따옴표·괄호가 든 프롬프트가 셸에 먹힌다
 // (스파이크에서 도구 호출이 한 번도 안 일어났다). .cmd 셰이퍼는 shell 없이 못 돌리므로
@@ -28,7 +62,7 @@ export async function runClaude(input) {
         ...(input.model === undefined ? {} : { model: input.model }),
         ...(input.questionRelay === undefined ? {} : { questionRelay: input.questionRelay }),
     });
-    const { command, commandArgs } = resolveClaudeCommand(args);
+    const { command, commandArgs } = input.command ?? resolveClaudeCommand(args);
     const logPath = path.join(input.workspaceDir, '.nomos-run.log');
     const startedAt = Date.now();
     return new Promise((resolve) => {
@@ -36,7 +70,7 @@ export async function runClaude(input) {
         const child = spawn(command, commandArgs, {
             cwd: input.workspaceDir,
             stdio: ['ignore', 'pipe', 'pipe'],
-            ...(input.pathPrepend ? { env: withPathPrepended(process.env, input.pathPrepend) } : {}),
+            env: input.pathPrepend ? withPathPrepended(claudeEnv(), input.pathPrepend) : claudeEnv(),
         });
         const chunks = [];
         const collect = (c) => chunks.push(c.toString());
@@ -56,7 +90,9 @@ export async function runClaude(input) {
                 }
             }
         };
+        let lastOutputAt = Date.now();
         child.stdout.on('data', (c) => {
+            lastOutputAt = Date.now();
             collect(c);
             emitLines(c);
         });
@@ -66,11 +102,23 @@ export async function runClaude(input) {
             timedOut = true;
             child.kill();
         }, input.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+        // 출력 없는 시간 감지. 마지막 출력 시각만 보므로 도구가 오래 돌아도 그 사이 다른 출력이 있으면 끊지 않는다.
+        const idleMs = input.idleMs ?? DEFAULT_IDLE_MS;
+        let stalled = false;
+        const idleCheck = setInterval(() => {
+            if (Date.now() - lastOutputAt >= idleMs) {
+                stalled = true;
+                child.kill();
+            }
+        }, Math.min(30_000, Math.max(50, Math.floor(idleMs / 4))));
         child.on('close', (code) => {
             clearTimeout(timer);
-            writeFileSync(logPath, chunks.join(''));
+            clearInterval(idleCheck);
+            writeFileSync(logPath, stalled ? `${chunks.join('')}
+[executor] ${Math.round(idleMs / 60_000)}분 동안 모델 출력이 없어 실행을 끊었다
+` : chunks.join(''));
             resolve({
-                outcome: timedOut ? 'timeout' : code === 0 ? 'completed' : 'failed',
+                outcome: stalled ? 'stalled' : timedOut ? 'timeout' : code === 0 ? 'completed' : 'failed',
                 exitCode: code,
                 durationMs: Date.now() - startedAt,
                 logPath,
@@ -78,6 +126,7 @@ export async function runClaude(input) {
         });
         child.on('error', (err) => {
             clearTimeout(timer);
+            clearInterval(idleCheck);
             writeFileSync(logPath, `${chunks.join('')}\n[executor] spawn 실패: ${err.message}\n`);
             resolve({ outcome: 'failed', exitCode: null, durationMs: Date.now() - startedAt, logPath });
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capstone-nomos/cli",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "NOMOS 에이전트 CLI — 노트북의 Claude Code를 NOMOS 서버에 연결하고 배정된 태스크를 실행한다",
   "type": "module",
   "bin": {