@capstone-nomos/cli 0.1.15 → 0.1.16

package/dist/bridge/nomos-client.js

@@ -29,6 +29,7 @@ export class NomosClient {
     baseUrl;
     fetchImpl;
     onTokensChanged;
+    onApiError;
     current;
     // 진단용. 통합 테스트가 "정확히 한 번만 재발급했는가"를 확인한다.
     refreshCount = 0;
@@ -36,6 +37,7 @@ export class NomosClient {
         this.baseUrl = options.baseUrl.replace(/\/$/, '');
         this.fetchImpl = options.fetchImpl ?? fetch;
         this.onTokensChanged = options.onTokensChanged;
+        this.onApiError = options.onApiError;
         this.current = options.tokens;
     }
     get tokens() {
@@ -154,6 +156,22 @@ export class NomosClient {
         await this.request('POST', `/api/pm/jobs/${jobId}/failure`, { message });
     }
     async request(method, path, body) {
+        try {
+            return await this.requestOnce(method, path, body);
+        }
+        catch (err) {
+            if (err instanceof NomosApiError) {
+                try {
+                    this.onApiError?.(err);
+                }
+                catch {
+                    // 알림이 실패해도 원래 에러를 그대로 던진다.
+                }
+            }
+            throw err;
+        }
+    }
+    async requestOnce(method, path, body) {
         const first = await this.send(method, path, body);
         if (!needsRefresh(first))
             return unwrap(first);

package/dist/executor/background.js

@@ -26,6 +26,11 @@ export function isAlive(pid) {
         return err.code === 'EPERM';
     }
 }
+// 이 프로세스가 백그라운드 connect 자신이면 daemon.json을 지운다 — 연결 해제로 스스로 끝날 때(cli.ts) status가 바로 "돌고 있지 않음"을 보이게.
+export function clearDaemonIfSelf() {
+    if (readDaemon()?.pid === process.pid)
+        rmSync(daemonFile(), { force: true });
+}
 // 살아 있는 백그라운드 connect. 죽었는데 파일만 남았으면 지우고 null.
 export function runningDaemon() {
     const info = readDaemon();

package/dist/executor/cli.js

@@ -27,7 +27,8 @@ import { credentialsPath, readCredentials, updateAccessToken, writeCredentials,
 import { NomosApiError, NomosClient } from '../bridge/nomos-client.js';
 import { ActivityReporter, ActivityTracker, RunObserver } from './activity.js';
 import { accountLine, connect, DEFAULT_SERVER, serverCalls } from './connect.js';
-import { runningDaemon, startDaemon, stopDaemon, tailLog } from './background.js';
+import { clearDaemonIfSelf, runningDaemon, startDaemon, stopDaemon, tailLog } from './background.js';
+import { agentStop, DISCONNECTED_EXIT_CODE, DISCONNECTED_MESSAGE } from './stop.js';
 import { deviceLogin } from './device-login.js';
 import { cliVersion, mcpServerPath } from './paths.js';
 import { checkTools } from './preflight.js';
@@ -46,6 +47,24 @@ const POLL_INTERVAL_MS = 10_000;
 function log(line) {
     process.stdout.write(`[nomos] ${line}\n`);
 }
+// 돌고 있는 일(태스크 실행·상담·계약 초안) — 연결 해제로 멈출 때 다 끝나기를 기다린 뒤 프로세스를 끝낸다.
+const running = new Set();
+function track(work) {
+    const p = work().finally(() => running.delete(p));
+    running.add(p);
+    return p;
+}
+// 연결 해제로 멈출 때, 이미 끝내라고 한(트리째 종료) 실행들이 정리되기를 잠시 기다린다. 오래 걸려도 프로세스는 끝낸다.
+async function settleRunning(timeoutMs = 15_000) {
+    await Promise.race([Promise.allSettled([...running]), new Promise((r) => setTimeout(r, timeoutMs).unref())]);
+}
+// 연결 해제로 끝난다 — 0이 아닌 코드. 백그라운드(--background)로 돌던 것이면 daemon.json도 지워 status가 "돌고 있지 않음"을 보이게 한다.
+// 남은 타이머(폴링 대기 등)가 프로세스를 붙잡지 않게 바로 끝낸다.
+function exitDisconnected() {
+    log(DISCONNECTED_MESSAGE);
+    clearDaemonIfSelf();
+    process.exit(DISCONNECTED_EXIT_CODE);
+}
 function createClient() {
     const credentials = readCredentials();
     if (!credentials) {
@@ -56,6 +75,11 @@ function createClient() {
         tokens: { accessToken: credentials.accessToken, refreshToken: credentials.refreshToken },
         // 재발급 결과를 파일에 되돌려 쓴다. 없으면 다음 실행이 또 401로 시작한다.
         onTokensChanged: (tokens) => updateAccessToken(tokens.accessToken),
+        // 어느 요청에서든 AGENT_DISCONNECTED를 받으면 실행 중인 Claude를 모두 멈춘다(stop.ts).
+        onApiError: (err) => {
+            if (!agentStop.stopped && agentStop.noteError(err))
+                log(DISCONNECTED_MESSAGE);
+        },
     });
 }
 // 지금 돌고 있는 태스크의 작업공간 — 상담 실행이 진행 중인 작업(커밋 안 된 파일 포함)을 읽으려고 둔다.
@@ -72,7 +96,7 @@ async function consultPending(client, role) {
     if (!job)
         return;
     consulting.add(job.id);
-    void (async () => {
+    track(async () => {
         try {
             const active = [...activeWorkspaces.values()].find((w) => repos.some((r) => r.fullName === w.repo));
             const repo = active ? { fullName: active.repo } : repos[0];
@@ -80,18 +104,20 @@ async function consultPending(client, role) {
                 throw new Error('이 역할이 소유한 레포가 프로젝트에 없다');
             const dir = active ? active.dir : ensureRepo({ fullName: repo.fullName, cloneUrl: repos[0].cloneUrl }, { log }).path;
             log(`상담 실행: ${job.askerRole}의 질문 ${job.questions.length}개 — ${repo.fullName}${active ? ' (진행 중인 작업공간)' : ''}`);
-            const draft = await runConsult({ dir, role, repoName: repo.fullName, question: job });
+            const draft = await runConsult({ dir, role, repoName: repo.fullName, question: job, signal: agentStop.signal });
             const result = await client.submitDraft(job.id, draft);
             log(result.status === 'agent_answered' ? '  초안 올림 — 전부 코드에 정해져 있어 바로 답이 됐다(사람 확인 대기)' : '  초안 올림 — 정해지지 않은 결정이 있어 담당자에게 넘어갔다');
         }
         catch (err) {
             consultGaveUp.add(job.id);
-            log(`  상담 실패 — 담당자가 직접 답한다: ${err instanceof Error ? err.message : String(err)}`);
+            // 연결 해제로 멈췄으면 사유는 이미 남겼다(그 뒤의 보고는 401이라 보내지 않는다).
+            if (!agentStop.stopped)
+                log(`  상담 실패 — 담당자가 직접 답한다: ${err instanceof Error ? err.message : String(err)}`);
         }
         finally {
             consulting.delete(job.id);
         }
-    })();
+    });
 }
 // 계약 작성(023) — BACKEND 노트북만. 기능 명세에 API가 필요하면 BE 레포를 읽기만 해서 계약 초안을 올린다(본인 구독).
 // 한 번에 한 묶음씩. 첫 회차가 둘 이상이면 한 번의 실행으로 함께 쓰고(레포를 한 번만 읽는다 — contract.ts), 레포 최신화도 묶음당 한 번이다.
@@ -107,7 +133,7 @@ async function contractPending(client) {
     if (jobs.length === 0)
         return;
     drafting = true;
-    void (async () => {
+    track(async () => {
         try {
             const active = [...activeWorkspaces.values()].find((w) => repos.some((r) => r.fullName === w.repo));
             const repo = active ? repos.find((r) => r.fullName === active.repo) : repos[0];
@@ -124,7 +150,7 @@ async function contractPending(client) {
             if (firsts.length >= 2) {
                 log(`계약 묶음 작성: ${firsts.map((j) => j.featureKey).join(', ')} (${firsts.length}개, 1회차) — ${repo.fullName}`);
                 try {
-                    batched = await runContractBatch({ dir, repoName: repo.fullName, jobs: firsts, approved });
+                    batched = await runContractBatch({ dir, repoName: repo.fullName, jobs: firsts, approved, signal: agentStop.signal });
                     const missing = firsts.filter((j) => !batched.has(j.featureKey)).map((j) => j.featureKey);
                     if (missing.length > 0)
                         log(`  묶음에서 빠진 기능 ${missing.join(', ')} — 하나씩 다시 쓴다`);
@@ -134,11 +160,13 @@ async function contractPending(client) {
                 }
             }
             for (const job of jobs) {
+                if (agentStop.stopped)
+                    break;
                 try {
                     const ready = batched.get(job.featureKey);
                     if (!ready)
                         log(`계약 작성: ${job.featureKey} ${job.specTitle} (${job.attempt}회차) — ${repo.fullName}`);
-                    let draft = ready ?? (await runContractDraft({ dir, repoName: repo.fullName, job, approved }));
+                    let draft = ready ?? (await runContractDraft({ dir, repoName: repo.fullName, job, approved, signal: agentStop.signal }));
                     try {
                         await client.submitContractDraft(job.id, { attempt: job.attempt, ...draft });
                     }
@@ -147,7 +175,7 @@ async function contractPending(client) {
                             throw err;
                         const problems = Array.isArray(err.details) ? err.details.map(String) : [err.message];
                         log(`  ${job.featureKey} 형식 위반 ${problems.length}개 — 한 번 고쳐 쓴다`);
-                        draft = await runContractDraft({ dir, repoName: repo.fullName, job, approved, problems });
+                        draft = await runContractDraft({ dir, repoName: repo.fullName, job, approved, problems, signal: agentStop.signal });
                         await client.submitContractDraft(job.id, { attempt: job.attempt, ...draft });
                     }
                     log(`  ${job.featureKey} 초안 올림 — BE 담당이 웹에서 확정하거나 수정을 요청한다`);
@@ -160,10 +188,13 @@ async function contractPending(client) {
         finally {
             drafting = false;
         }
-    })();
+    });
 }
 async function reportContractFailure(client, job, err) {
     contractGaveUp.add(`${job.id}:${job.attempt}`);
+    // 연결 해제로 멈췄다 — 실패 보고는 401이라 보내지 않는다. 서버에서는 BE 담당이 다시 요청할 수 있다.
+    if (agentStop.stopped)
+        return;
     // 그 사이 수정 요청이 와서 회차가 바뀌었다 — 새 회차는 다음 확인에서 다시 쓴다.
     if (err instanceof NomosApiError && err.code === 'CONTRACT_STALE') {
         log(`  ${job.featureKey} — 그 사이 계약이 바뀌었다, 이 회차는 버린다`);
@@ -213,6 +244,9 @@ async function handleTask(client, projectId, task) {
     const tracker = new ActivityTracker(workspace.dir);
     // 의존성은 모델이 아니라 여기서 설치한다(설치 스크립트 끔). 실패해도 진행한다 — 프롬프트에 결과를 적는다.
     const setup = await prepareDependencies(workspace.dir, log);
+    // 준비하는 사이 연결이 해제됐으면 Claude를 띄우지 않는다.
+    if (agentStop.stopped)
+        return;
     const before = headSha(workspace.dir);
     const result = await runClaude({
         workspaceDir: workspace.dir,
@@ -225,7 +259,15 @@ async function handleTask(client, projectId, task) {
             observer.observe(line);
             reporter?.push(tracker.observe(line));
         },
+        signal: agentStop.signal,
     });
+    // 연결이 해제돼 멈췄다 — 서버가 열린 실행을 이미 닫았고(outcome disconnected) 종료 보고는 401이라 보내지 않는다.
+    // 작업공간은 지우지 않는다(남기는 규칙 그대로).
+    if (result.outcome === 'aborted') {
+        await reporter?.close().catch(() => { });
+        log(`태스크 ${task.id} 실행을 멈췄다(연결 해제). 작업공간은 남긴다: ${workspace.dir}`);
+        return;
+    }
     const committed = headSha(workspace.dir) !== before;
     if (reporter) {
         reporter.push(tracker.finish());
@@ -320,19 +362,29 @@ async function start() {
         },
         fallback: () => pollingTaskSource(client).nextTasks(Number.MAX_SAFE_INTEGER),
         log,
+        // 서버가 연결 해제로 스트림을 닫았다(4401 AGENT_DISCONNECTED) — 실행 중인 Claude를 멈춘다.
+        onAgentDisconnected: () => agentStop.stop(),
     });
     log(`시작 — 프로젝트 ${self.projectId}, 역할 ${self.teamRole}, 동시 실행 ${self.maxConcurrent} (${source.kind})`);
     const inFlight = new Set();
     // 태스크 하나가 끝나면 자리가 난다 — 다음 푸시나 간격을 기다리지 않고 바로 다시 본다.
     let finished = () => { };
+    // 연결 해제 — 실행 중인 것은 이미 트리째 끝내라고 했다(stop.ts). 정리를 기다린 뒤 멈춘다.
+    const stopDisconnected = async () => {
+        source.close();
+        await settleRunning();
+        return 'disconnected';
+    };
     for (;;) {
+        if (agentStop.stopped)
+            return stopDisconnected();
         try {
             const capacity = self.maxConcurrent - inFlight.size;
             if (capacity > 0) {
                 // 처리 중인 것도 목록에 남아 있을 수 있으니(수령 전) 그만큼 더 받아 거른다.
                 for (const task of (await source.nextTasks(capacity + inFlight.size)).filter((t) => !inFlight.has(t.id)).slice(0, capacity)) {
                     inFlight.add(task.id);
-                    void handleTask(client, self.projectId, task)
+                    void track(() => handleTask(client, self.projectId, task))
                         .catch((err) => log(`태스크 ${task.id} 실패: ${err instanceof Error ? err.message : String(err)}`))
                         .finally(() => {
                         inFlight.delete(task.id);
@@ -345,9 +397,8 @@ async function start() {
         catch (err) {
             // 대표나 본인이 웹에서 이 에이전트의 연결을 해제했다(서버 021) — 계속 물어도 같은 답이니 이유를 알리고 멈춘다.
             if (err instanceof NomosApiError && err.code === 'AGENT_DISCONNECTED') {
-                log('이 에이전트는 연결이 해제됐다 — 다시 쓰려면 connect를 실행하라');
-                source.close();
-                return 'disconnected';
+                agentStop.stop();
+                return stopDisconnected();
             }
             // 배정이 풀렸다(대표의 해제·프로젝트 중단, 서버 021). 같은 목록을 계속 물어도 거부된다.
             if (err instanceof NomosApiError && err.code === 'NOT_PROJECT_MEMBER' && inFlight.size === 0) {
@@ -376,7 +427,7 @@ async function start() {
             if (!(err instanceof NomosApiError && err.status === 404))
                 log(`계약 작업 목록 실패: ${err instanceof Error ? err.message : String(err)}`);
         }
-        await Promise.race([source.waitForChange(POLL_INTERVAL_MS), new Promise((resolve) => (finished = resolve))]);
+        await Promise.race([source.waitForChange(POLL_INTERVAL_MS), new Promise((resolve) => (finished = resolve)), agentStop.whenStopped()]);
     }
 }
 // 토큰이 헤더로 다니므로 원격은 https만 받는다. 로컬 개발 서버만 예외다.
@@ -522,8 +573,9 @@ async function connectCommand(argv) {
             sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
             log,
         });
-        if ((await start()) !== 'unassigned')
-            return;
+        const reason = await start();
+        if (reason === 'disconnected')
+            exitDisconnected();
         log('다시 배정을 기다린다');
     }
 }
@@ -626,7 +678,8 @@ async function main() {
     if (command === 'once')
         return once();
     if (command === 'start') {
-        await start();
+        if ((await start()) === 'disconnected')
+            exitDisconnected();
         return;
     }
     if (command === 'pm-worker')

package/dist/executor/consult.js

@@ -2,6 +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 { killOnAbort } from './stop.js';
 import { claudeEnv, resolveClaudeCommand } from './runner.js';
 // 상담 응답의 형식(구조화 출력). 모든 객체는 additionalProperties: false + 전 필드 required.
 export const CONSULT_JSON_SCHEMA = {
@@ -63,6 +64,7 @@ export function consultArgs(prompt, emptyMcpPath) {
     return readOnlyClaudeArgs(prompt, emptyMcpPath, CONSULT_JSON_SCHEMA);
 }
 // 읽기 전용 Claude를 한 번 돌려 구조화 출력을 돌려준다(없으면 result 문자열).
+// signal이 멈추면(연결 해제 — stop.ts) claude를 트리째 끝내고 그 사유로 실패한다.
 export async function runReadOnlyClaude(input) {
     const scratch = path.join(tmpdir(), 'nomos-consult');
     mkdirSync(scratch, { recursive: true });
@@ -76,14 +78,20 @@ export async function runReadOnlyClaude(input) {
             child.kill();
             reject(new Error(`${input.label} 시간 초과`));
         }, input.timeoutMs);
+        const unwatch = killOnAbort(child, input.signal);
         child.stdout.on('data', (d) => (stdout += d));
         child.once('error', (err) => {
             clearTimeout(timer);
+            unwatch();
             reject(err);
         });
         child.on('close', () => {
             clearTimeout(timer);
-            resolve(stdout);
+            unwatch();
+            if (input.signal?.aborted)
+                reject(input.signal.reason instanceof Error ? input.signal.reason : new Error(`${input.label} 중단`));
+            else
+                resolve(stdout);
         });
         child.stdin.end(input.prompt);
     });
@@ -124,6 +132,7 @@ export async function runConsult(input) {
         schema: CONSULT_JSON_SCHEMA,
         timeoutMs: input.timeoutMs ?? 5 * 60_000,
         label: '상담 실행',
+        ...(input.signal ? { signal: input.signal } : {}),
     });
     return parseConsultDraft(output, input.question.questions.map((q) => q.question));
 }

package/dist/executor/contract.js

@@ -80,6 +80,7 @@ export async function runContractDraft(input) {
         // 계약은 레포를 넓게 읽는다(라우트·에러 형식·인증) — 상담(5분)보다 길게 둔다.
         timeoutMs: input.timeoutMs ?? 10 * 60_000,
         label: '계약 작성',
+        ...(input.signal ? { signal: input.signal } : {}),
     });
     return parseContractDraft(output);
 }
@@ -170,6 +171,7 @@ export async function runContractBatch(input) {
         // 레포는 한 번 읽지만 쓸 양은 기능 수만큼 는다. 기본 10분 + 기능당 2분, 최대 30분.
         timeoutMs: input.timeoutMs ?? Math.min(30, 10 + 2 * input.jobs.length) * 60_000,
         label: '계약 묶음 작성',
+        ...(input.signal ? { signal: input.signal } : {}),
     });
     return parseContractBatch(output, input.jobs);
 }

package/dist/executor/runner.js

@@ -2,6 +2,7 @@ import { spawn } from 'node:child_process';
 import { existsSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { buildClaudeArgs } from '../bridge/claude-args.js';
+import { killOnAbort } from './stop.js';
 export const DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
 // 모델 출력(stream-json)이 이만큼 없으면 응답이 끊긴 것으로 보고 끊는다. 30분을 다 기다리지 않고, 사유도 "오래 일함"과 구분된다.
 // 실측: 도구 결과를 받은 뒤 다음 모델 응답이 오지 않은 채 20분 넘게 멈춘 실행이 있었다(같은 조건 재실행은 정상).
@@ -111,14 +112,20 @@ export async function runClaude(input) {
                 child.kill();
             }
         }, Math.min(30_000, Math.max(50, Math.floor(idleMs / 4))));
+        const unwatch = killOnAbort(child, input.signal);
         child.on('close', (code) => {
             clearTimeout(timer);
             clearInterval(idleCheck);
-            writeFileSync(logPath, stalled ? `${chunks.join('')}
-[executor] ${Math.round(idleMs / 60_000)}분 동안 모델 출력이 없어 실행을 끊었다
-` : chunks.join(''));
+            unwatch();
+            const aborted = input.signal?.aborted === true;
+            const note = aborted
+                ? '\n[executor] 에이전트 연결이 해제돼 실행을 멈췄다\n'
+                : stalled
+                    ? `\n[executor] ${Math.round(idleMs / 60_000)}분 동안 모델 출력이 없어 실행을 끊었다\n`
+                    : '';
+            writeFileSync(logPath, `${chunks.join('')}${note}`);
             resolve({
-                outcome: stalled ? 'stalled' : timedOut ? 'timeout' : code === 0 ? 'completed' : 'failed',
+                outcome: aborted ? 'aborted' : stalled ? 'stalled' : timedOut ? 'timeout' : code === 0 ? 'completed' : 'failed',
                 exitCode: code,
                 durationMs: Date.now() - startedAt,
                 logPath,
@@ -127,6 +134,7 @@ export async function runClaude(input) {
         child.on('error', (err) => {
             clearTimeout(timer);
             clearInterval(idleCheck);
+            unwatch();
             writeFileSync(logPath, `${chunks.join('')}\n[executor] spawn 실패: ${err.message}\n`);
             resolve({ outcome: 'failed', exitCode: null, durationMs: Date.now() - startedAt, logPath });
         });

package/dist/executor/stop.js

@@ -0,0 +1,66 @@
+import { spawn } from 'node:child_process';
+// 이 에이전트의 연결이 해제됐다(서버 021 — 웹에서 본인·대표가 해제, 조직 탈퇴·해산). 알게 되는 곳이 여러 군데라 한 곳에 모은다:
+// 폴링·브리핑·활동 보고 같은 HTTP 응답(NomosClient의 onApiError), 태스크 스트림의 4401 AGENT_DISCONNECTED 종료.
+// 알게 되면 실행 중인 Claude(태스크 실행·상담·계약 초안)를 모두 멈춘다 — 해제 뒤에는 무엇을 해도 서버가 받지 않고(401),
+// 실행이 끝까지 가면 룸에 "생각 중"만 남았다. 서버는 해제하면서 열린 실행을 이미 닫는다(outcome disconnected) — 그래서 종료 보고도 보내지 않는다.
+export const AGENT_DISCONNECTED = 'AGENT_DISCONNECTED';
+export const DISCONNECTED_MESSAGE = '이 에이전트의 연결이 해제돼 실행 중인 작업을 멈췄다 — 다시 쓰려면 connect를 실행하라';
+// connect·start가 연결 해제로 끝날 때의 종료 코드(0이 아니다 — 스크립트·백그라운드 감시가 정상 종료와 가를 수 있게).
+export const DISCONNECTED_EXIT_CODE = 3;
+export function isAgentDisconnected(err) {
+    return typeof err === 'object' && err !== null && err.code === AGENT_DISCONNECTED;
+}
+// 프로세스 전체에서 하나 — 연결 해제는 에이전트 단위라 실행마다 따로 둘 이유가 없다.
+export class AgentStop {
+    controller = new AbortController();
+    get signal() {
+        return this.controller.signal;
+    }
+    get stopped() {
+        return this.controller.signal.aborted;
+    }
+    // 에러가 연결 해제면 멈춘다. 멈췄으면 true(이미 멈춘 경우도).
+    noteError(err) {
+        if (isAgentDisconnected(err))
+            this.stop();
+        return this.stopped;
+    }
+    stop() {
+        if (!this.controller.signal.aborted)
+            this.controller.abort(new Error(DISCONNECTED_MESSAGE));
+    }
+    // 멈출 때 풀리는 약속 — 대기(waitForChange)와 경주시킨다.
+    whenStopped() {
+        if (this.stopped)
+            return Promise.resolve();
+        return new Promise((resolve) => this.controller.signal.addEventListener('abort', () => resolve(), { once: true }));
+    }
+}
+export const agentStop = new AgentStop();
+// 자식 프로세스를 트리째 끝낸다. claude는 MCP 서버·Bash 도구(시험 실행 등)를 자식으로 띄운다.
+// - Windows: claude를 node로 cli-wrapper를 거쳐 띄우므로(runner.ts의 resolveClaudeCommand) 그 node만 죽이면 실제 claude가 남는다 —
+//   taskkill /T(트리) /F로 끝낸다. taskkill을 못 띄우면 직접 kill로 내려간다.
+// - 그 밖: SIGTERM을 claude에 보낸다. MCP 서버는 stdin(파이프)이 닫히면 함께 끝난다. 프로세스 그룹째(detached + kill(-pid)) 죽이지 않는 이유:
+//   detached로 띄우면 터미널의 Ctrl+C가 claude에 닿지 않아, connect를 끄면 claude가 고아로 남는다.
+export function killProcessTree(child) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    if (process.platform === 'win32' && child.pid !== undefined) {
+        const killer = spawn('taskkill', ['/pid', String(child.pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true });
+        killer.once('error', () => child.kill());
+        return;
+    }
+    child.kill('SIGTERM');
+}
+// signal이 멈추면 자식을 트리째 끝낸다. 돌려주는 함수로 구독을 푼다(자식이 먼저 끝나면 부른다).
+export function killOnAbort(child, signal) {
+    if (!signal)
+        return () => { };
+    const onAbort = () => killProcessTree(child);
+    if (signal.aborted) {
+        onAbort();
+        return () => { };
+    }
+    signal.addEventListener('abort', onAbort, { once: true });
+    return () => signal.removeEventListener('abort', onAbort);
+}

package/dist/executor/stream-source.js

@@ -89,6 +89,12 @@ export function streamTaskSource(deps) {
                 wake();
                 return;
             }
+            if (ev.code === 4401 && ev.reason === 'AGENT_DISCONNECTED') {
+                deps.log('서버가 이 에이전트의 연결 해제로 푸시를 닫았다');
+                deps.onAgentDisconnected?.();
+                wake();
+                return;
+            }
             if (ev.code === 4401 && !refreshedInARow) {
                 refreshedInARow = true;
                 deps

package/package.json

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