@capstone-nomos/cli 0.1.14 → 0.1.16

package/dist/bridge/briefing-notes.js

@@ -3,29 +3,48 @@ import path from 'node:path';
 // 브리핑으로 프롬프트에 넣은 인계 노트의 id. 제출할 때 "이미 받은 노트"로 서버에 함께 보낸다.
 // 서버는 관련 노트를 전부 확인해야 제출을 받는다(NOTES_UNACKNOWLEDGED). 프롬프트로 전달된 노트는 확인한 것이므로
 // 모델이 id를 옮겨 적게 하지 않고 브릿지가 넣는다 — 모델이 직접 넣는 건 반려 뒤 새로 받은 노트뿐이다.
+// 질문으로 정해진 결정(decisions)도 같다 — 브리핑으로 받은 결정 id를 함께 남기고 제출 때 보낸다(DECISIONS_UNACKNOWLEDGED).
 // Executor가 작업공간에 쓰고(브리핑 직후), MCP 서버의 submit_artifact가 읽는다. 둘은 다른 프로세스다.
 export const BRIEFING_NOTES_FILE = '.nomos-briefing.json';
-export function writeBriefingNotes(workspaceDir, taskId, noteIds) {
-    writeFileSync(path.join(workspaceDir, BRIEFING_NOTES_FILE), `${JSON.stringify({ taskId, noteIds }, null, 2)}\n`);
+export function writeBriefingNotes(workspaceDir, taskId, noteIds, decisionIds = []) {
+    writeFileSync(path.join(workspaceDir, BRIEFING_NOTES_FILE), `${JSON.stringify({ taskId, noteIds, decisionIds }, null, 2)}\n`);
 }
-// 다른 태스크의 파일이거나 없으면 빈 목록 — 엉뚱한 태스크의 노트를 확인한 것으로 보내지 않는다.
-export function readBriefingNoteIds(workspaceDir, taskId) {
+// 다른 태스크의 파일이거나 없으면 빈 목록 — 엉뚱한 태스크의 노트·결정을 확인한 것으로 보내지 않는다.
+function readBriefingIds(workspaceDir, taskId, key) {
     const file = path.join(workspaceDir, BRIEFING_NOTES_FILE);
     if (!existsSync(file))
         return [];
     try {
         const parsed = JSON.parse(readFileSync(file, 'utf-8'));
-        if (parsed.taskId !== taskId || !Array.isArray(parsed.noteIds))
+        const ids = parsed[key];
+        if (parsed.taskId !== taskId || !Array.isArray(ids))
             return [];
-        return parsed.noteIds.filter((id) => typeof id === 'string');
+        return ids.filter((id) => typeof id === 'string');
     }
     catch {
         return [];
     }
 }
+export function readBriefingNoteIds(workspaceDir, taskId) {
+    return readBriefingIds(workspaceDir, taskId, 'noteIds');
+}
+export function readBriefingDecisionIds(workspaceDir, taskId) {
+    return readBriefingIds(workspaceDir, taskId, 'decisionIds');
+}
 export function mergeAcknowledged(briefed, fromModel) {
     return [...new Set([...briefed, ...(fromModel ?? [])])].sort();
 }
+// submit_artifact가 서버에 보내는 본문. 브리핑으로 받은 노트·결정과 모델이 반려 뒤 확인한 것을 합친다.
+// acknowledgedDecisionIds는 비어 있어도 **항상** 보낸다 — 서버는 이 필드가 없으면 옛 CLI(0.1.14 이하)로 보고 결정 확인을 건너뛴다.
+export function buildSubmitBody(input) {
+    const acknowledgedNoteIds = mergeAcknowledged(readBriefingNoteIds(input.workspaceDir, input.taskId), input.acknowledgedNoteIds);
+    return {
+        commitSha: input.commitSha,
+        changedPaths: input.changedPaths,
+        ...(acknowledgedNoteIds.length === 0 ? {} : { acknowledgedNoteIds }),
+        acknowledgedDecisionIds: mergeAcknowledged(readBriefingDecisionIds(input.workspaceDir, input.taskId), input.acknowledgedDecisionIds),
+    };
+}
 // 지금 작업공간의 태스크 id — 권한 도구가 AskUserQuestion을 어느 태스크의 질문으로 올릴지 정한다. 없으면 null.
 export function readBriefingTaskId(workspaceDir) {
     const file = path.join(workspaceDir, BRIEFING_NOTES_FILE);

package/dist/bridge/mcp-server.js

@@ -7,7 +7,7 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { z } from 'zod';
 import { readCredentials, updateAccessToken } from './credentials.js';
 import { NomosClient, PolicyStaleLoopError } from './nomos-client.js';
-import { mergeAcknowledged, readBriefingNoteIds, readBriefingTaskId } from './briefing-notes.js';
+import { buildSubmitBody, readBriefingTaskId } from './briefing-notes.js';
 import { PERMISSION_TOOL } from './claude-args.js';
 import { DENY_OTHER, denyUnanswered, handleAskUserQuestion, isHandled } from './permission.js';
 import { pushTaskBranch } from './push.js';
@@ -72,7 +72,7 @@ server.registerTool('claim_task', {
 const workspaceDir = process.env.NOMOS_WORKSPACE_DIR ?? process.cwd();
 server.registerTool('submit_artifact', {
     title: 'Submit an artifact',
-    description: 'Submit finished work for a task you have claimed. Commit your work on the task branch first, then provide the latest commit sha and every path changed on the task branch (including commits from earlier attempts on this branch). This tool pushes the task branch before submitting; if the push is refused (wrong branch, commit not on the task branch, remote has diverged) nothing is submitted and you get the reason. The server re-checks the paths against the ownership rules, so listing paths you did not change (or omitting ones you did) will be rejected or will fail verification later. If handover notes related to your task were published after you started, the submission is rejected with NOTES_UNACKNOWLEDGED and the notes are returned: read them, change and commit your work if they affect it, then submit again with their ids in acknowledged_note_ids. Notes that were already in your instructions are acknowledged automatically.',
+    description: 'Submit finished work for a task you have claimed. Commit your work on the task branch first, then provide the latest commit sha and every path changed on the task branch (including commits from earlier attempts on this branch). This tool pushes the task branch before submitting; if the push is refused (wrong branch, commit not on the task branch, remote has diverged) nothing is submitted and you get the reason. The server re-checks the paths against the ownership rules, so listing paths you did not change (or omitting ones you did) will be rejected or will fail verification later. If handover notes related to your task were published after you started, the submission is rejected with NOTES_UNACKNOWLEDGED and the notes are returned: read them, change and commit your work if they affect it, then submit again with their ids in acknowledged_note_ids. Notes that were already in your instructions are acknowledged automatically. Likewise, if decisions were made by answering other tasks\' questions after you started, the submission is rejected with DECISIONS_UNACKNOWLEDGED and the decisions are returned (with any new related notes): follow them, change and commit your work if it differs, then submit again with their ids in acknowledged_decision_ids (and the notes\' ids in acknowledged_note_ids). Decisions already in your instructions are acknowledged automatically.',
     inputSchema: {
         task_id: z.string().describe('The claimed task id'),
         commit_sha: z.string().describe('Commit sha containing the work'),
@@ -81,8 +81,12 @@ server.registerTool('submit_artifact', {
             .array(z.string())
             .optional()
             .describe('Ids of handover notes you read after a NOTES_UNACKNOWLEDGED rejection'),
+        acknowledged_decision_ids: z
+            .array(z.string())
+            .optional()
+            .describe('Ids of decisions you read after a DECISIONS_UNACKNOWLEDGED rejection'),
     },
-}, async ({ task_id, commit_sha, changed_paths, acknowledged_note_ids }) => run(async () => {
+}, async ({ task_id, commit_sha, changed_paths, acknowledged_note_ids, acknowledged_decision_ids }) => run(async () => {
     // push할 브랜치와 막을 브랜치는 서버가 정한다. 모델이 넘긴 값으로 고르지 않는다.
     const briefing = (await client.getBriefing(task_id));
     const push = await pushTaskBranch({
@@ -95,13 +99,15 @@ server.registerTool('submit_artifact', {
         process.stderr.write('[nomos-mcp] origin 없음 — push 건너뜀(서버가 mirror 모드로 로컬에서 읽는다)\n');
     }
     // push가 실패하면(PushRefused) 여기까지 오지 않는다 — 제출하지 않고 run()이 모델에게 사유를 돌려준다.
-    // 브리핑으로 프롬프트에 들어간 노트는 이미 받은 것이다 — Executor가 작업공간에 남긴 id를 함께 보낸다.
-    const acknowledgedNoteIds = mergeAcknowledged(readBriefingNoteIds(workspaceDir, task_id), acknowledged_note_ids);
-    const artifact = await client.submitArtifact(task_id, {
+    // 브리핑으로 프롬프트에 들어간 노트·결정은 이미 받은 것이다 — Executor가 작업공간에 남긴 id를 함께 보낸다.
+    const artifact = await client.submitArtifact(task_id, buildSubmitBody({
+        workspaceDir,
+        taskId: task_id,
         commitSha: commit_sha,
         changedPaths: changed_paths,
-        ...(acknowledgedNoteIds.length === 0 ? {} : { acknowledgedNoteIds }),
-    });
+        ...(acknowledged_note_ids === undefined ? {} : { acknowledgedNoteIds: acknowledged_note_ids }),
+        ...(acknowledged_decision_ids === undefined ? {} : { acknowledgedDecisionIds: acknowledged_decision_ids }),
+    }));
     return { ...artifact, push };
 }, 'submit_artifact'));
 server.registerTool('publish_note', {

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() {
@@ -44,7 +46,9 @@ export class NomosClient {
     async claimTask(taskId) {
         return (await this.request('POST', `/api/tasks/${taskId}/claim`));
     }
-    async submitArtifact(taskId, input) {
+    async submitArtifact(taskId, 
+    // acknowledgedDecisionIds: MCP submit_artifact는 비어 있어도 항상 보낸다(없으면 서버가 옛 CLI로 보고 결정 확인을 건너뛴다).
+    input) {
         return (await this.request('POST', `/api/tasks/${taskId}/artifacts`, input));
     }
     // 브릿지 단계(V2·V4) 보고. 서버가 판정하는 V1A·V1B·V3는 여기로 보낼 수 없다 — 403이 돌아온다.
@@ -152,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} — 그 사이 계약이 바뀌었다, 이 회차는 버린다`);
@@ -190,8 +221,8 @@ async function handleTask(client, projectId, task) {
     });
     log(`작업공간 ${workspace.dir} (브랜치 ${workspace.branch})`);
     activeWorkspaces.set(task.id, { dir: workspace.dir, repo: briefing.repo.fullName });
-    // 프롬프트에 넣는 노트 = 제출 때 "받은 노트"로 함께 보낼 노트. MCP 서버(submit_artifact)가 읽는다.
-    writeBriefingNotes(workspace.dir, task.id, (briefing.notes ?? []).map((n) => n.id));
+    // 프롬프트에 넣는 노트·결정 = 제출 때 "받은 것"으로 함께 보낼 노트·결정. MCP 서버(submit_artifact)가 읽는다.
+    writeBriefingNotes(workspace.dir, task.id, (briefing.notes ?? []).map((n) => n.id), (briefing.decisions ?? []).map((d) => d.id));
     if (workspace.createdBranch) {
         await client.reportBranch(task.id, workspace.branch);
     }
@@ -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/prompt.js

@@ -42,6 +42,16 @@ export function buildTaskPrompt(briefing, branch, environment) {
             '이 브랜치에 이전 작업이 남아 있으면 이어서 진행한다. 같은 질문을 다시 묻지 않는다.',
         ].join('\n'));
     }
+    // 다른 역할·PM이 질문에 답해 확정한 결정 — 이 태스크가 물은 것이 아니어도 프로젝트 전체가 따른다.
+    // 실행 중에는 끼워 넣지 않는다. 작업 중에 새로 정해진 결정은 제출 때 DECISIONS_UNACKNOWLEDGED로 온다.
+    if (briefing.decisions && briefing.decisions.length > 0) {
+        sections.push([
+            '# 질문으로 정해진 결정',
+            '다른 역할·PM이 질문에 답해 확정한 결정이다. 구현이 이 결정과 다르면 결정을 따른다.',
+            '결정 자체가 틀렸거나 바꿔야 한다고 보면 임의로 바꾸지 말고 AskUserQuestion으로 그 역할에 다시 묻는다.',
+            ...briefing.decisions.map((d) => `- [물은 쪽 ${d.askerRole} · 정한 쪽 ${d.targetRole}${d.decidedByName ? ` ${d.decidedByName}` : ''}] Q: ${d.question}\n  A: ${d.answer ?? ''}`),
+        ].join('\n'));
+    }
     // 사람(그 역할 담당·대표)이 룸에서 보낸 메시지 — 이번 실행이 시작되기 전에 온 것만 들어온다(실행 중에는 끼워 넣지 않는다).
     if (briefing.humanMessages && briefing.humanMessages.length > 0) {
         sections.push([
@@ -67,6 +77,7 @@ export function buildTaskPrompt(briefing, branch, environment) {
         '  바꾸지 않은 경로를 적거나 sha를 지어내지 않는다 — 서버가 제출 시점에 다시 검증한다.',
         '- 제출이 NOTES_UNACKNOWLEDGED로 반려되면, 작업 중에 새로 올라온 인계 노트가 함께 온다. 읽고, 작업에 영향이 있으면 고쳐서 커밋한 뒤',
         '  submit_artifact를 다시 부르며 그 노트 id를 acknowledged_note_ids에 넣는다. 위 [인계 노트]의 노트는 따로 넣지 않아도 된다.',
+        '- 제출이 DECISIONS_UNACKNOWLEDGED로 반려되면, 작업 중에 새로 정해진 결정이 함께 온다. 반영하고 그 id를 acknowledged_decision_ids에 넣어 다시 제출하라(함께 온 노트가 있으면 그 id는 acknowledged_note_ids에).',
         '- 다음 사람이 알아야 할 결정이나 함정이 있으면 publish_note로 남긴다. 다른 사람도 따라야 할 결정(계약·형식)은 DECIDED로 남긴다 — 프로젝트 전체에 전달된다.',
         // 실험(E6): 이 줄이 없으면 FE 에이전트가 명세에 없는 BE 계약을 스스로 정해 DECIDED로 발행했다 — 그 노트가 BE 브리핑에 "결정"으로 들어간다.
         `- 단, 다른 역할이 정해야 하는 계약(그 역할이 만드는 API의 응답 형식·상태 코드·필드 이름 등)은 DECIDED로 남기지 않는다 — 네 역할(${task.teamRole ?? '제한 없음'})이 정할 수 있는 것이 아니다.`,

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.14",
+  "version": "0.1.16",
   "description": "NOMOS 에이전트 CLI — 노트북의 Claude Code를 NOMOS 서버에 연결하고 배정된 태스크를 실행한다",
   "type": "module",
   "bin": {