@capstone-nomos/cli 0.1.0 → 0.1.2

package/dist/bridge/briefing-notes.js

@@ -0,0 +1,28 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+// 브리핑으로 프롬프트에 넣은 인계 노트의 id. 제출할 때 "이미 받은 노트"로 서버에 함께 보낸다.
+// 서버는 관련 노트를 전부 확인해야 제출을 받는다(NOTES_UNACKNOWLEDGED). 프롬프트로 전달된 노트는 확인한 것이므로
+// 모델이 id를 옮겨 적게 하지 않고 브릿지가 넣는다 — 모델이 직접 넣는 건 반려 뒤 새로 받은 노트뿐이다.
+// 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 readBriefingNoteIds(workspaceDir, taskId) {
+    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))
+            return [];
+        return parsed.noteIds.filter((id) => typeof id === 'string');
+    }
+    catch {
+        return [];
+    }
+}
+export function mergeAcknowledged(briefed, fromModel) {
+    return [...new Set([...briefed, ...(fromModel ?? [])])].sort();
+}

package/dist/bridge/claude-args.js

@@ -18,12 +18,32 @@ export function buildClaudeArgs(options) {
     if (options.model)
         args.push('--model', options.model);
     args.push('--mcp-config', options.mcpConfigPath, '--strict-mcp-config');
+    // 파일 편집은 작업 폴더 안에서 자동 승인한다 — settings.json의 deny(.env·contracts 등)는 여전히 이긴다.
+    // 없으면 모델이 계획만 세우고 "쓰기 권한을 승인해 달라"며 커밋 없이 끝난다(실제로 그랬다).
+    args.push('--permission-mode', 'acceptEdits');
     // 헤드리스에는 권한 프롬프트에 답할 사람이 없다. 이게 없으면 모델이 도구를 고른 뒤
     // "승인 대기"에서 멈춘다 — 도구를 못 찾는 것과 증상이 달라 헷갈리기 쉽다.
     // 가변 인자를 마지막에 두어 뒤에 아무것도 붙지 않게 한다.
-    args.push('--allowedTools', allowedToolNames().join(','));
+    args.push('--allowedTools', [...allowedToolNames(), ...allowedBashRules()].join(','));
     return args;
 }
+// 작업에 필요한 셸 명령만 접두사로 허용한다(커밋·시험 실행). **임의 셸을 열지 말 것** — 셸로 파일을 쓰면
+// settings.json의 Edit deny(.env·contracts 등)를 우회한다. 서버의 제출 검증(V3)이 최종 방어선이지만 로컬에서 먼저 막는다.
+export const ALLOWED_BASH_PREFIXES = [
+    'git status',
+    'git diff',
+    'git add',
+    'git commit',
+    'git log',
+    'git rev-parse',
+    'npm test',
+    'npm run test',
+    'npx vitest',
+    'node --test',
+];
+export function allowedBashRules() {
+    return ALLOWED_BASH_PREFIXES.map((prefix) => `Bash(${prefix}:*)`);
+}
 // 우리 MCP 서버 하나만 담은 설정. --mcp-config로 넘긴다.
 //
 // **토큰을 여기 넣지 않는다.** 이 파일은 Claude Code에 넘기는 설정이고, 자격 증명의 정본은

package/dist/bridge/mcp-server.js

@@ -7,6 +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 } from './briefing-notes.js';
 import { pushTaskBranch } from './push.js';
 // 자격 증명은 ~/.nomos/credentials가 정본이다(0600). 환경변수는 파일이 없을 때만 쓴다
 // (테스트·일회성 실행용). 둘을 섞으면 재발급 결과가 어디에 저장되는지 흐려진다.
@@ -69,13 +70,17 @@ 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 commit sha and every path you changed. 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.',
+    description: 'Submit finished work for a task you have claimed. Commit your work on the task branch first, then provide the commit sha and every path you changed. 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.',
     inputSchema: {
         task_id: z.string().describe('The claimed task id'),
         commit_sha: z.string().describe('Commit sha containing the work'),
         changed_paths: z.array(z.string()).describe('Repo-relative paths changed by this commit'),
+        acknowledged_note_ids: z
+            .array(z.string())
+            .optional()
+            .describe('Ids of handover notes you read after a NOTES_UNACKNOWLEDGED rejection'),
     },
-}, async ({ task_id, commit_sha, changed_paths }) => run(async () => {
+}, async ({ task_id, commit_sha, changed_paths, acknowledged_note_ids }) => run(async () => {
     // push할 브랜치와 막을 브랜치는 서버가 정한다. 모델이 넘긴 값으로 고르지 않는다.
     const briefing = (await client.getBriefing(task_id));
     const push = await pushTaskBranch({
@@ -88,7 +93,13 @@ server.registerTool('submit_artifact', {
         process.stderr.write('[nomos-mcp] origin 없음 — push 건너뜀(서버가 mirror 모드로 로컬에서 읽는다)\n');
     }
     // push가 실패하면(PushRefused) 여기까지 오지 않는다 — 제출하지 않고 run()이 모델에게 사유를 돌려준다.
-    const artifact = await client.submitArtifact(task_id, { commitSha: commit_sha, changedPaths: changed_paths });
+    // 브리핑으로 프롬프트에 들어간 노트는 이미 받은 것이다 — Executor가 작업공간에 남긴 id를 함께 보낸다.
+    const acknowledgedNoteIds = mergeAcknowledged(readBriefingNoteIds(workspaceDir, task_id), acknowledged_note_ids);
+    const artifact = await client.submitArtifact(task_id, {
+        commitSha: commit_sha,
+        changedPaths: changed_paths,
+        ...(acknowledgedNoteIds.length === 0 ? {} : { acknowledgedNoteIds }),
+    });
     return { ...artifact, push };
 }, 'submit_artifact'));
 server.registerTool('publish_note', {

package/dist/bridge/nomos-client.js

@@ -84,6 +84,11 @@ export class NomosClient {
         return data.tasks;
     }
     // 프롬프트와 .claude/settings.json을 만드는 데 필요한 것 한 번에.
+    // 지금 가져갈 수 있는 태스크(서버가 역할·선행·시작 여부로 거른 것). 웹소켓 푸시와 같은 목록이다.
+    async listClaimableTasks() {
+        const data = (await this.request('GET', '/api/agents/me/tasks'));
+        return data.tasks;
+    }
     async getBriefing(taskId) {
         return (await this.request('GET', `/api/tasks/${taskId}/briefing`));
     }
@@ -93,6 +98,17 @@ export class NomosClient {
     async reportBranch(taskId, branchName) {
         await this.request('PATCH', `/api/tasks/${taskId}/branch`, { branchName });
     }
+    // 중계 모드 PM 작업(대표 노트북의 pm-worker만).
+    async nextPmJob() {
+        const data = (await this.request('GET', '/api/pm/jobs/next'));
+        return data.job;
+    }
+    async submitPmJobResult(jobId, result) {
+        await this.request('POST', `/api/pm/jobs/${jobId}/result`, result);
+    }
+    async failPmJob(jobId, message) {
+        await this.request('POST', `/api/pm/jobs/${jobId}/failure`, { message });
+    }
     async request(method, path, body) {
         const first = await this.send(method, path, body);
         if (!needsRefresh(first))

package/dist/executor/cli.js

@@ -12,6 +12,7 @@
 //   executor once              READY 태스크 하나만 처리하고 종료 (개발·데모용)
 //   executor start             10초 폴링
 //   executor clean             worktree 정리
+//   nomos pm-worker            (대표 전용, 서버가 PM_PROVIDER=relay일 때) PM의 모델 호출을 이 노트북의 Claude Code로 대신 실행
 //
 // 서버를 옮길 때 baseUrl만 바꾸면 안 된다. 토큰은 발급한 서버의 서명 키와 그 DB의 agents 행에 묶여 있어
 // 다른 서버에서는 전부 401이다. 원격에 가입해 받은 연결 키로 login을 다시 해야 한다.
@@ -19,19 +20,23 @@ import { writeFileSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { createInterface } from 'node:readline/promises';
+import { writeBriefingNotes } from '../bridge/briefing-notes.js';
 import { buildMcpConfig } from '../bridge/claude-args.js';
 import { credentialsPath, readCredentials, updateAccessToken, writeCredentials, } from '../bridge/credentials.js';
-import { NomosClient } from '../bridge/nomos-client.js';
+import { NomosApiError, NomosClient } from '../bridge/nomos-client.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 { streamTaskSource } from './stream-source.js';
 import { pollingTaskSource } from './task-source.js';
 import { runLint, runSpecTests } from './verify.js';
 import { ensureRepo } from './repo-checkout.js';
 import { cleanWorkspaces, headSha, prepareWorkspace } from './workspace.js';
+// 푸시가 오지 않아도 이 간격으로 한 번씩 다시 본다(끊겼을 때는 이 간격으로 폴링한다).
 const POLL_INTERVAL_MS = 10_000;
 function log(line) {
     process.stdout.write(`[nomos] ${line}\n`);
@@ -64,6 +69,8 @@ async function handleTask(client, projectId, task) {
         policyHash: briefing.policyHash,
     });
     log(`작업공간 ${workspace.dir} (브랜치 ${workspace.branch})`);
+    // 프롬프트에 넣는 노트 = 제출 때 "받은 노트"로 함께 보낼 노트. MCP 서버(submit_artifact)가 읽는다.
+    writeBriefingNotes(workspace.dir, task.id, (briefing.notes ?? []).map((n) => n.id));
     if (workspace.createdBranch) {
         await client.reportBranch(task.id, workspace.branch);
     }
@@ -124,10 +131,10 @@ async function reportBridgeStages(client, taskId, workspaceDir, specTests) {
 async function once() {
     const client = createClient();
     const self = await client.describeSelf();
-    const source = pollingTaskSource(client, self.projectId);
+    const source = pollingTaskSource(client);
     const [task] = await source.nextTasks(1);
     if (!task) {
-        log('READY 태스크가 없다');
+        log('지금 가져갈 수 있는 태스크가 없다(프로젝트 시작 전이거나, 선행 태스크가 끝나지 않았거나, READY가 없다)');
         return;
     }
     await handleTask(client, self.projectId, task);
@@ -135,28 +142,42 @@ async function once() {
 async function start() {
     const client = createClient();
     const self = await client.describeSelf();
-    const source = pollingTaskSource(client, self.projectId);
+    // 서버 푸시(웹소켓)로 받는다. 끊겨 있는 동안은 같은 목록을 HTTP로 읽는다.
+    const source = streamTaskSource({
+        baseUrl: readCredentials().baseUrl,
+        accessToken: () => readCredentials().accessToken,
+        refresh: async () => {
+            if ((await serverCalls({ read: readCredentials, updateAccessToken }).refresh()) === 'rejected') {
+                throw new Error('refresh token이 거부됐다 — connect를 다시 실행하라');
+            }
+        },
+        fallback: () => pollingTaskSource(client).nextTasks(Number.MAX_SAFE_INTEGER),
+        log,
+    });
     log(`시작 — 프로젝트 ${self.projectId}, 역할 ${self.teamRole}, 동시 실행 ${self.maxConcurrent} (${source.kind})`);
     const inFlight = new Set();
+    // 태스크 하나가 끝나면 자리가 난다 — 다음 푸시나 간격을 기다리지 않고 바로 다시 본다.
+    let finished = () => { };
     for (;;) {
         try {
             const capacity = self.maxConcurrent - inFlight.size;
             if (capacity > 0) {
-                for (const task of await source.nextTasks(capacity)) {
-                    // 이미 처리 중인 태스크는 건너뛴다. 폴링은 같은 목록을 여러 번 준다.
-                    if (inFlight.has(task.id))
-                        continue;
+                // 처리 중인 것도 목록에 남아 있을 수 있으니(수령 전) 그만큼 더 받아 거른다.
+                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)
                         .catch((err) => log(`태스크 ${task.id} 실패: ${err instanceof Error ? err.message : String(err)}`))
-                        .finally(() => inFlight.delete(task.id));
+                        .finally(() => {
+                        inFlight.delete(task.id);
+                        finished();
+                    });
                 }
             }
         }
         catch (err) {
-            log(`폴링 실패: ${err instanceof Error ? err.message : String(err)}`);
+            log(`태스크 목록 실패: ${err instanceof Error ? err.message : String(err)}`);
         }
-        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+        await Promise.race([source.waitForChange(POLL_INTERVAL_MS), new Promise((resolve) => (finished = resolve))]);
     }
 }
 // 토큰이 헤더로 다니므로 원격은 https만 받는다. 로컬 개발 서버만 예외다.
@@ -311,6 +332,24 @@ async function refresh() {
         log(`재발급은 됐지만 아직 프로젝트에 배정되지 않은 것 같다: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
+const PM_POLL_INTERVAL_MS = 3_000;
+async function pmWorker() {
+    const client = createClient();
+    log('pm-worker 시작 — 대표가 PM에 계획을 요청하면 여기서 claude가 돈다 (Ctrl+C로 종료)');
+    for (;;) {
+        try {
+            if (await handleNextPmJob(client, log))
+                continue;
+        }
+        catch (err) {
+            // 설정이 틀린 경우는 기다려도 풀리지 않는다 — 바로 멈춘다.
+            if (err instanceof NomosApiError && (err.code === 'PM_RELAY_DISABLED' || err.code === 'NOT_REPRESENTATIVE'))
+                throw err;
+            log(`폴링 실패: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, PM_POLL_INTERVAL_MS));
+    }
+}
 async function main() {
     const command = process.argv[2];
     if (command === 'connect')
@@ -329,6 +368,8 @@ async function main() {
         return once();
     if (command === 'start')
         return start();
+    if (command === 'pm-worker')
+        return pmWorker();
     if (command === 'clean') {
         const { pruned, removed } = cleanWorkspaces();
         log(`worktree prune: ${pruned.join(', ') || '없음'} / 삭제: ${removed ?? '없음'}`);
@@ -340,6 +381,7 @@ async function main() {
         '  doctor                                       설치 상태 점검',
         '  login [주소] [--name 이름] [--connect-key]   로그인만',
         '  refresh | once | start | clean | --version',
+        '  pm-worker                                    (대표 전용, 서버가 PM_PROVIDER=relay일 때) PM 모델 호출을 이 노트북의 Claude Code로',
         '',
     ].join('\n'));
     process.exitCode = 1;

package/dist/executor/pm-worker.js

@@ -0,0 +1,110 @@
+import { spawn } from 'node:child_process';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { resolveClaudeCommand } from './runner.js';
+// 지침·프롬프트는 길어서(이전 초안이 붙는 수정 요청) 명령줄로 넘기지 않는다 — Windows 명령줄은 32k자에서 잘린다.
+// 지침은 파일, 프롬프트는 stdin. 도구는 전부 끄고(--tools ""), 사용자 MCP·세션 기록도 쓰지 않는다.
+export function buildPmClaudeArgs(job, systemPromptFile) {
+    return [
+        '-p',
+        '--output-format',
+        'json',
+        '--model',
+        job.request.model,
+        '--effort',
+        job.request.effort,
+        '--system-prompt-file',
+        systemPromptFile,
+        '--json-schema',
+        JSON.stringify(job.request.jsonSchema),
+        '--tools',
+        '',
+        '--strict-mcp-config',
+        '--no-session-persistence',
+    ];
+}
+// 출력 → 서버에 돌려줄 결과. 실패면 { error }.
+export function toJobResult(out, requestedModel) {
+    if (out.is_error)
+        return { error: `claude reported an error (${out.subtype ?? 'unknown'}): ${(out.result ?? '').slice(0, 500)}` };
+    const text = out.structured_output !== undefined && out.structured_output !== null
+        ? JSON.stringify(out.structured_output)
+        : (out.result ?? '');
+    if (!text)
+        return { error: 'claude returned no output' };
+    // 실제로 응답한 모델: 출력이 가장 많은 모델(부수 호출에 작은 모델이 섞일 수 있다).
+    const served = Object.entries(out.modelUsage ?? {}).sort((a, b) => (b[1].outputTokens ?? 0) - (a[1].outputTokens ?? 0))[0]?.[0] ?? requestedModel;
+    // stop_reason은 그대로 넘긴다. Claude Code는 구조화 출력을 도구 호출로 내므로 정상 완료도 'tool_use'로 온다(실측) —
+    // 서버는 refusal·max_tokens만 따로 다루므로 그대로 둬도 흐름은 같고, 기록은 실제 값이 남는다.
+    return {
+        stopReason: out.stop_reason ?? null,
+        servedModel: served,
+        text,
+        usage: {
+            inputTokens: out.usage?.input_tokens ?? 0,
+            outputTokens: out.usage?.output_tokens ?? 0,
+            cacheWriteTokens: out.usage?.cache_creation_input_tokens ?? 0,
+            cacheReadTokens: out.usage?.cache_read_input_tokens ?? 0,
+        },
+    };
+}
+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'] });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (c) => (stdout += c.toString()));
+        child.stderr.on('data', (c) => (stderr += c.toString()));
+        child.once('error', reject);
+        child.once('close', (exitCode) => resolve({ exitCode, stdout, stderr }));
+        child.stdin.end(stdin);
+    });
+};
+export async function runPmJob(job, run = spawnClaude) {
+    // 빈 임시 폴더에서 돈다 — 레포·CLAUDE.md를 읽지 않게. 끝나면 지운다(지침 사본이 남지 않게).
+    const dir = mkdtempSync(path.join(os.tmpdir(), 'nomos-pm-'));
+    try {
+        const systemFile = path.join(dir, 'system.md');
+        writeFileSync(systemFile, job.request.system, 'utf8');
+        const { exitCode, stdout, stderr } = await run(buildPmClaudeArgs(job, systemFile), job.request.user, dir);
+        let out;
+        try {
+            out = JSON.parse(stdout);
+        }
+        catch {
+            return { error: `claude exited ${exitCode} without JSON output: ${(stderr || stdout).slice(0, 500)}` };
+        }
+        return toJobResult(out, job.request.model);
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+// 작업 하나를 가져와 처리한다. 처리했으면 true.
+export async function handleNextPmJob(client, log, run = spawnClaude) {
+    const job = (await client.nextPmJob());
+    if (!job)
+        return false;
+    log(`PM 작업 ${job.id} (계획 ${job.planId}, ${job.purpose}) — claude 실행 중`);
+    const started = Date.now();
+    let result;
+    try {
+        result = await runPmJob(job, run);
+    }
+    catch (err) {
+        result = { error: err instanceof Error ? err.message : String(err) };
+    }
+    const sec = Math.round((Date.now() - started) / 1000);
+    if ('error' in result) {
+        log(`실패(${sec}s): ${result.error}`);
+        await client.failPmJob(job.id, result.error.slice(0, 2000));
+    }
+    else {
+        log(`완료(${sec}s, 출력 ${result.usage.outputTokens} 토큰) — 서버로 보냄`);
+        await client.submitPmJobResult(job.id, result);
+    }
+    return true;
+}

package/dist/executor/prompt.js

@@ -22,7 +22,9 @@ export function buildTaskPrompt(briefing, branch) {
         '- 위 목록 밖의 경로는 수정하지 않는다. 비밀 파일(.env, *.pem, *.key, secrets/)은 절대 건드리지 않는다.',
         '- 작업이 끝나면 커밋하고, submit_artifact에 **실제 커밋 sha와 실제로 바꾼 모든 경로**를 넣는다.',
         '  바꾸지 않은 경로를 적거나 sha를 지어내지 않는다 — 서버가 제출 시점에 다시 검증한다.',
-        '- 다음 사람이 알아야 할 결정이나 함정이 있으면 publish_note로 남긴다.',
+        '- 제출이 NOTES_UNACKNOWLEDGED로 반려되면, 작업 중에 새로 올라온 인계 노트가 함께 온다. 읽고, 작업에 영향이 있으면 고쳐서 커밋한 뒤',
+        '  submit_artifact를 다시 부르며 그 노트 id를 acknowledged_note_ids에 넣는다. 위 [인계 노트]의 노트는 따로 넣지 않아도 된다.',
+        '- 다음 사람이 알아야 할 결정이나 함정이 있으면 publish_note로 남긴다. 다른 사람도 따라야 할 결정(계약·형식)은 DECIDED로 남긴다 — 프로젝트 전체에 전달된다.',
         '- 다른 에이전트의 잘못을 노트에 적지 않는다. 그건 raise_dispute의 몫이다.',
     ].join('\n'));
     sections.push(`# 지금 할 일\n태스크 ${task.id}를 claim_task로 받고 위 규칙에 따라 진행하라.`);

package/dist/executor/stream-source.js

@@ -0,0 +1,114 @@
+export const AGENT_STREAM_PATH = '/api/agents/stream';
+export function streamUrl(baseUrl) {
+    const url = new URL(AGENT_STREAM_PATH, baseUrl);
+    url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+    return url.toString();
+}
+export function streamTaskSource(deps) {
+    const WS = deps.WebSocketImpl ?? globalThis.WebSocket;
+    const backoff = deps.backoff ?? { initialMs: 1000, maxMs: 30_000 };
+    let latest = [];
+    let connected = false;
+    let closed = false;
+    let delay = backoff.initialMs;
+    let refreshedInARow = false;
+    let ws = null;
+    let reconnectTimer = null;
+    const waiters = new Set();
+    const wake = () => {
+        for (const w of waiters)
+            w();
+        waiters.clear();
+    };
+    const schedule = () => {
+        if (closed)
+            return;
+        reconnectTimer = setTimeout(connect, delay);
+        delay = Math.min(delay * 2, backoff.maxMs);
+    };
+    function connect() {
+        reconnectTimer = null;
+        if (closed)
+            return;
+        const socket = new WS(streamUrl(deps.baseUrl));
+        ws = socket;
+        socket.onopen = () => socket.send(JSON.stringify({ type: 'auth', token: deps.accessToken() }));
+        socket.onmessage = (ev) => {
+            let msg;
+            try {
+                msg = JSON.parse(String(ev.data));
+            }
+            catch {
+                return;
+            }
+            if (msg.type === 'ready') {
+                connected = true;
+                delay = backoff.initialMs;
+                refreshedInARow = false;
+                deps.log(`서버 푸시 연결됨 — 프로젝트 ${msg.projectId ?? '?'}`);
+            }
+            else if (msg.type === 'tasks') {
+                latest = msg.tasks ?? [];
+                wake();
+            }
+            else if (msg.type === 'error') {
+                deps.log(`서버 푸시 거부: ${msg.code ?? '?'} ${msg.message ?? ''}`.trim());
+            }
+        };
+        socket.onerror = () => { };
+        socket.onclose = (ev) => {
+            const wasConnected = connected;
+            connected = false;
+            ws = null;
+            if (closed)
+                return;
+            if (ev.code === 4403) {
+                deps.log('이 에이전트는 프로젝트 멤버가 아니다 — 푸시를 멈춘다(폴링으로 계속 확인한다)');
+                wake();
+                return;
+            }
+            if (ev.code === 4401 && !refreshedInARow) {
+                refreshedInARow = true;
+                deps
+                    .refresh()
+                    .then(() => connect())
+                    .catch((err) => deps.log(`토큰 재발급 실패 — 푸시를 멈춘다: ${err instanceof Error ? err.message : String(err)}`));
+                return;
+            }
+            if (wasConnected)
+                deps.log(`서버 푸시 끊김(${ev.code}) — 다시 연결한다. 그동안은 폴링한다`);
+            wake();
+            schedule();
+        };
+    }
+    connect();
+    return {
+        kind: 'push',
+        get connected() {
+            return connected;
+        },
+        async nextTasks(limit) {
+            // 연결돼 있으면 받은 스냅샷, 아니면 같은 목록을 HTTP로.
+            const tasks = connected ? latest : await deps.fallback();
+            return tasks.slice(0, limit);
+        },
+        waitForChange(maxMs) {
+            return new Promise((resolve) => {
+                const done = () => {
+                    clearTimeout(timer);
+                    waiters.delete(done);
+                    resolve();
+                };
+                const timer = setTimeout(done, maxMs);
+                waiters.add(done);
+            });
+        },
+        close() {
+            closed = true;
+            if (reconnectTimer)
+                clearTimeout(reconnectTimer);
+            ws?.close(1000, 'bye');
+            wake();
+        },
+    };
+}

package/dist/executor/task-source.js

@@ -1,10 +1,12 @@
-// 서버가 에이전트 토큰을 보고 자기 역할로 필터해 준다 — 여기서 역할을 다시 거르지 않는다.
-export function pollingTaskSource(client, projectId) {
+// 서버가 이 에이전트의 역할·선행·프로젝트 시작 여부로 거른 목록(GET /api/agents/me/tasks)을 읽는다 — 여기서 다시 거르지 않는다.
+export function pollingTaskSource(client) {
     return {
         kind: 'polling',
         async nextTasks(limit) {
-            const rows = await client.listTasks(projectId, { state: 'READY', limit });
-            return rows;
+            const rows = await client.listClaimableTasks();
+            return rows.slice(0, limit);
         },
+        waitForChange: (maxMs) => new Promise((resolve) => setTimeout(resolve, maxMs)),
+        close: () => { },
     };
 }

package/dist/executor/workspace.js

@@ -43,6 +43,7 @@ export function prepareWorkspace(input) {
     const dir = workspaceDir(input.projectId, input.taskId);
     const branch = input.branchName ?? `task/${input.taskId}`;
     const existed = branchExists(input.repoPath, branch);
+    excludeNomosFiles(input.repoPath);
     if (!existsSync(dir)) {
         mkdirSync(path.dirname(dir), { recursive: true });
         const args = existed
@@ -57,6 +58,26 @@ export function prepareWorkspace(input) {
     writeFileSync(path.join(claudeDir, '.nomos-policy.json'), `${JSON.stringify({ policyHash: input.policyHash, taskId: input.taskId, generatedAt: new Date().toISOString() }, null, 2)}\n`);
     return { dir, branch, createdBranch: !existed, settingsPath };
 }
+// Executor가 작업공간에 쓰는 파일(MCP 설정·실행 로그·브리핑 노트·정책 표시·settings.json)이 모델의 `git add`에 섞이지 않게 한다.
+// 커밋에 섞이면 신고 경로와 실제 diff가 어긋나 V3가 FAIL을 낸다. info/exclude는 레포 공통이라 모든 worktree에 걸린다.
+export const NOMOS_LOCAL_FILES = ['/.nomos-mcp.json', '/.nomos-run.log', '/.nomos-briefing.json', '/.claude/.nomos-policy.json', '/.claude/settings.json'];
+export function excludeNomosFiles(repoPath) {
+    try {
+        const commonDir = path.resolve(repoPath, git(repoPath, ['rev-parse', '--git-common-dir']));
+        const file = path.join(commonDir, 'info', 'exclude');
+        mkdirSync(path.dirname(file), { recursive: true });
+        const current = existsSync(file) ? readFileSync(file, 'utf-8') : '';
+        const lines = new Set(current.split(/\r?\n/));
+        const missing = NOMOS_LOCAL_FILES.filter((p) => !lines.has(p));
+        if (missing.length === 0)
+            return;
+        const prefix = current.length === 0 || current.endsWith('\n') ? '' : '\n';
+        writeFileSync(file, `${current}${prefix}# NOMOS Executor가 작업공간에 쓰는 파일\n${missing.join('\n')}\n`);
+    }
+    catch {
+        // 못 써도 작업은 진행한다 — 섞이면 V3가 잡는다.
+    }
+}
 // executor clean — worktree를 정리한다. 남겨두는 게 기본이라 정리는 명시적 명령으로만 한다.
 export function cleanWorkspaces() {
     const pruned = [];

package/package.json

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