@asc-agent/runtime 0.1.0

package/dist/core/runtime/claims.js

@@ -0,0 +1,153 @@
+// Claim Provenance — 사실과 추론을 갈라 적고, 뒤집혀도 지우지 않는다 (C-10 §6).
+//
+// 실전에서 반복된 사고가 이것이다: 어느 시점에 "A가 B를 막고 있다"고 판단했고, 나중에
+// 그게 아니었음이 드러났는데, 그 사이의 기록이 통째로 다시 쓰여 **언제 무엇을 근거로
+// 그렇게 봤는지가 사라졌다.** 그러면 같은 오판을 또 한다.
+//
+// 그래서 둘을 나눈다:
+//
+//   History        당시 판단을 그대로 보존한다. append-only
+//   Current View   STALE을 뺀 최신 claim의 projection. 저장하지 않는다
+//
+// **추론을 정본으로 자동 승격하지 않는다** (C-10 불변식 ⑬). INFERRED는 INFERRED로 남고,
+// CONFIRMED가 되려면 실측이 따로 있어야 한다.
+import { z } from 'zod';
+/**
+ * 이 진술을 무엇으로 보는가 (C-10 §6).
+ *
+ *   CONFIRMED  실측했다
+ *   INFERRED   근거로부터 추론했다
+ *   PENDING    확인이 필요하다
+ *   STALE      나중 증거가 뒤집었다
+ */
+export const ClaimStatus = z.enum(['CONFIRMED', 'INFERRED', 'PENDING', 'STALE']);
+/** id 문법. 파일명 변환이 단사가 아니라 자유 문자열을 그대로 키에 넣지 않는다. */
+export const CLAIM_ID = /^[A-Za-z0-9._-]+$/;
+export const Claim = z.object({
+    claimId: z.string().regex(CLAIM_ID),
+    /** 무엇을 주장하는가. 한 문장이어야 뒤집을 때 무엇이 뒤집혔는지 분명하다. */
+    statement: z.string().min(1),
+    status: ClaimStatus,
+    /** 어디서 왔는가 — 명령·문서·사람. 없으면 근거 없는 주장이다. */
+    evidenceRefs: z.array(z.string()).default([]),
+    observedAt: z.string().min(1),
+    /** 이 claim이 대체한 것. */
+    supersedes: z.string().optional(),
+    /** 이 claim을 대체한 것. **기록에 남기되 원본은 지우지 않는다.** */
+    supersededBy: z.string().optional(),
+    /** 왜 뒤집혔는가. STALE인데 이유가 없으면 다음 사람이 같은 판단을 또 한다. */
+    supersededReason: z.string().optional(),
+});
+const claimKey = (id) => `claim:${id}`;
+const stalePrefix = 'claim-stale:';
+/** 뒤집힘 마커. 원본을 고치지 않고 따로 append한다 — Closure Ledger와 같은 형태다. */
+const staleKey = (id) => `${stalePrefix}${id}`;
+const CLAIM_PREFIX = 'claim:';
+export class ClaimLedger {
+    #scope;
+    #now;
+    constructor(scope, now = () => new Date().toISOString()) {
+        this.#scope = scope;
+        this.#now = now;
+    }
+    /**
+     * 새 판단을 적는다. **같은 id를 덮어쓰지 않는다** — 덮어쓰면 그게 곧 "다시 쓰기"이고,
+     * 이 모듈이 막으려는 것이 정확히 그것이다.
+     */
+    async record(input) {
+        if (!CLAIM_ID.test(input.claimId)) {
+            return { ok: false, reason: 'INVALID_ID', detail: `claim id 형식이 아니다: '${input.claimId}'` };
+        }
+        const claim = Claim.parse({
+            claimId: input.claimId,
+            statement: input.statement,
+            status: input.status,
+            evidenceRefs: input.evidenceRefs ?? [],
+            observedAt: input.observedAt ?? this.#now(),
+            ...(input.supersedes ? { supersedes: input.supersedes } : {}),
+        });
+        if (await this.#scope.setIfAbsent(claimKey(claim.claimId), JSON.stringify(claim))) {
+            return { ok: true, claim };
+        }
+        return { ok: false, reason: 'DUPLICATE_ID', detail: `${claim.claimId} 는 이미 있다 — 새 id로 적으라` };
+    }
+    /**
+     * 새 증거가 옛 판단을 뒤집었다.
+     *
+     * **옛 claim을 지우지도 고치지도 않는다.** 뒤집힘 마커를 따로 남기고, 읽을 때 합친다.
+     * 그래야 "그때는 왜 그렇게 봤는가"가 남는다.
+     */
+    async supersede(input) {
+        const previous = await this.#read(claimKey(input.staleId));
+        if (!previous)
+            return { ok: false, reason: 'NOT_FOUND', detail: `${input.staleId} 를 찾지 못했다` };
+        if (previous.status === 'STALE') {
+            return { ok: false, reason: 'ALREADY_STALE', detail: `${input.staleId} 는 이미 뒤집힌 기록이다` };
+        }
+        const at = input.at ?? this.#now();
+        const recorded = await this.record({ ...input.replacement, observedAt: at, supersedes: input.staleId });
+        if (!recorded.ok) {
+            return { ok: false, reason: 'NOT_FOUND', detail: recorded.detail };
+        }
+        const marker = { supersededBy: recorded.claim.claimId, supersededReason: input.reason, at };
+        if (!(await this.#scope.setIfAbsent(staleKey(input.staleId), JSON.stringify(marker)))) {
+            return { ok: false, reason: 'ALREADY_STALE', detail: `${input.staleId} 는 이미 뒤집힌 기록이다` };
+        }
+        return { ok: true, stale: { ...previous, status: 'STALE', ...marker, supersededReason: input.reason }, current: recorded.claim };
+    }
+    /** 당시 판단 그대로. 뒤집힌 것도 든다 — History는 지우지 않는다. */
+    async history() {
+        const keys = (await this.#scope.keys(CLAIM_PREFIX)).filter((key) => !key.startsWith(stalePrefix)).sort();
+        const out = [];
+        for (const key of keys) {
+            const claim = await this.#read(key);
+            if (claim)
+                out.push(await this.#compose(claim));
+        }
+        return out.sort((a, b) => a.observedAt.localeCompare(b.observedAt));
+    }
+    /**
+     * 지금 무엇이 사실로 서 있는가. **STALE을 뺀 최신 claim의 projection이며 저장하지 않는다**
+     * (C-10 불변식 ⑫).
+     */
+    async current() {
+        return (await this.history()).filter((claim) => claim.status !== 'STALE');
+    }
+    async get(claimId) {
+        const claim = await this.#read(claimKey(claimId));
+        return claim ? this.#compose(claim) : null;
+    }
+    async #compose(claim) {
+        const raw = await this.#scope.get(staleKey(claim.claimId));
+        if (!raw)
+            return claim;
+        const marker = JSON.parse(raw);
+        return { ...claim, status: 'STALE', supersededBy: marker.supersededBy, supersededReason: marker.supersededReason };
+    }
+    async #read(key) {
+        const raw = await this.#scope.get(key);
+        if (!raw)
+            return null;
+        const parsed = Claim.safeParse(JSON.parse(raw));
+        return parsed.success ? parsed.data : null;
+    }
+}
+const MARK = {
+    CONFIRMED: '확인',
+    INFERRED: '추론',
+    PENDING: '미확인',
+    STALE: '뒤집힘',
+};
+/**
+ * 사람이 읽는 줄. **추론을 확인처럼 보이게 하지 않는다** — 이 표시가 흐려지는 순간
+ * 사람이 추론 위에서 결정한다.
+ */
+export function claimLines(claims) {
+    if (claims.length === 0)
+        return ['적힌 판단 없음'];
+    return claims.map((claim) => {
+        const evidence = claim.evidenceRefs.length > 0 ? ` [${claim.evidenceRefs.join(', ')}]` : ' [근거 없음]';
+        const superseded = claim.supersededBy ? ` → ${claim.supersededBy} (${claim.supersededReason ?? '이유 미기록'})` : '';
+        return `${claim.claimId} (${MARK[claim.status]}) ${claim.statement}${evidence}${superseded}`;
+    });
+}

package/dist/core/runtime/closure.d.ts

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import type { ScopedStore } from '../../ports/state-store.ts';
+/**
+ * 항목 id 문법. Markdown Adapter의 파일명 변환이 단사가 아니라 `a:b`와 `a-b`가 같은
+ * 파일이 되고, 그러면 setIfAbsent가 EEXIST를 돌려줘 **조용히 잃는 게 아니라 "이미
+ * 확인됨"으로 오판**한다. Profile resolve가 선언 입구에서 먼저 막고, 여기서 한 번 더 본다.
+ */
+export declare const CLOSURE_ITEM_ID: RegExp;
+export declare const ClosureRecord: z.ZodObject<{
+    logicalSessionId: z.ZodString;
+    /**
+     * 회수 시점 선언의 스냅샷. Profile이 나중에 바뀌어도 이 세션이 무엇을 지고 있었는지는
+     * 흔들리지 않아야 한다.
+     */
+    declared: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    confirmed: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    openedAt: z.ZodString;
+    /** 전부 확인된 시각. 닫혀도 기록은 남는다 — 지우면 무엇을 닫았는지도 사라진다. */
+    closedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    logicalSessionId: string;
+    openedAt: string;
+    declared: string[];
+    confirmed: string[];
+    closedAt?: string | undefined;
+}, {
+    logicalSessionId: string;
+    openedAt: string;
+    declared?: string[] | undefined;
+    confirmed?: string[] | undefined;
+    closedAt?: string | undefined;
+}>;
+export type ClosureRecord = z.infer<typeof ClosureRecord>;
+export type ConfirmOutcome = {
+    ok: true;
+    record: ClosureRecord;
+    newlyClosed: boolean;
+} | {
+    ok: false;
+    reason: 'NOT_FOUND';
+    detail: string;
+} | {
+    ok: false;
+    reason: 'UNKNOWN_ITEM';
+    detail: string;
+    declared: readonly string[];
+} | {
+    ok: false;
+    reason: 'INVALID_ITEM_ID';
+    detail: string;
+};
+export declare class ClosureLedger {
+    #private;
+    constructor(scope: ScopedStore, now?: () => string);
+    /**
+     * 회수 시점에 의무를 연다. **이미 있으면 손대지 않는다** — collect는 여러 번 돌고,
+     * 두 번째 회수가 기록을 덮으면 이미 확인한 항목이 미확인으로 되돌아간다.
+     * @returns 이번에 새로 연 기록. 이미 있었거나 선언이 없으면 null
+     */
+    open(logicalSessionId: string, declared: readonly string[]): Promise<ClosureRecord | null>;
+    /**
+     * Controller의 명시 확인. 항목마다 자기 키에 한 번만 쓰므로 서로 다른 항목을 동시에
+     * 확인해도 덮이지 않고, 같은 항목을 두 번 확인해도 처음 것이 남는다.
+     */
+    confirm(logicalSessionId: string, items: readonly string[]): Promise<ConfirmOutcome>;
+    get(logicalSessionId: string): Promise<ClosureRecord | null>;
+    /** 전부. 닫힌 것도 남는다 — 무엇을 닫았는지가 사라지면 기록이 아니다. */
+    list(): Promise<ClosureRecord[]>;
+    /** 아직 닫히지 않은 것들. 세션이 archive에 있어도 여기 남아 있다. */
+    pending(): Promise<ClosureRecord[]>;
+}
+/** 미확인 항목을 사람이 읽을 줄로. collect의 "판단이 필요한 것"에 그대로 들어간다. */
+export declare function pendingLines(records: readonly ClosureRecord[]): string[];

package/dist/core/runtime/closure.js

@@ -0,0 +1,162 @@
+// Project Closure — 세션이 끝난 뒤에도 남는 마무리 의무 (B-20).
+//
+// 근거(B-16): Logical Session이 DONE 됐을 때 프로젝트 쪽은 하나도 닫혀 있지 않았다 —
+// tasks 0/17, backlog 미갱신, 작업일지 미기록, 수동 검증 미실행. 별도 closure 세션이
+// 그걸 다 맞추고 나서야 실제로 끝났다. `Logical Session DONE ≠ Project Closure DONE`.
+//
+// 왜 Session/Handoff가 아니라 별도 기록인가:
+//   ① closure는 회수 **이후**에 온다. Handoff에 넣으면 done 시점에 모르는 것을 적어야 한다.
+//   ② 세션은 회수되면 archive로 간다. 거기 매달아 두면 다음 collect에서 사라진다 —
+//      그게 정확히 B-20이 고치려는 문제(미완료 사실의 소실)다.
+//   ③ 이건 Controller의 기록이지 세션이 스스로 선언한 계약이 아니다.
+//
+// 확인은 **추론하지 않는다.** Handoff 텍스트에 "backlog 갱신함"이라고 쓰여 있어도 확인이
+// 아니다. Controller가 항목 id를 명시로 줄 때만 확인이다 — 문자열을 읽어 판단하는 순간
+// Gate가 휴리스틱이 되고, 사람이 확인하지 않은 것을 확인됐다고 기록하게 된다.
+//
+// 저장은 **전부 setIfAbsent 위에 선다.** ScopedStore에서 원자성이 약속된 것은 그것뿐이고
+// (`set`은 계약이 침묵한다), 잃는 것이 표시값이 아니라 사람이 한 확인이기 때문이다.
+// 읽고-고쳐-쓰기를 하면 서로 다른 항목을 동시에 확인할 때 하나가 조용히 덮인다 —
+// 미완료 사실의 소실을 막겠다는 모듈이 그 기록을 잃는 셈이라, 경쟁 자체가 생기지 않도록
+// 항목마다 다른 키에 한 번만 쓴다. 세션당 파일이 1+N개가 되지만, 그 비용이 옳다.
+import { z } from 'zod';
+/**
+ * 항목 id 문법. Markdown Adapter의 파일명 변환이 단사가 아니라 `a:b`와 `a-b`가 같은
+ * 파일이 되고, 그러면 setIfAbsent가 EEXIST를 돌려줘 **조용히 잃는 게 아니라 "이미
+ * 확인됨"으로 오판**한다. Profile resolve가 선언 입구에서 먼저 막고, 여기서 한 번 더 본다.
+ */
+export const CLOSURE_ITEM_ID = /^[A-Za-z0-9._-]+$/;
+export const ClosureRecord = z.object({
+    logicalSessionId: z.string().min(1),
+    /**
+     * 회수 시점 선언의 스냅샷. Profile이 나중에 바뀌어도 이 세션이 무엇을 지고 있었는지는
+     * 흔들리지 않아야 한다.
+     */
+    declared: z.array(z.string()).default([]),
+    confirmed: z.array(z.string()).default([]),
+    openedAt: z.string().min(1),
+    /** 전부 확인된 시각. 닫혀도 기록은 남는다 — 지우면 무엇을 닫았는지도 사라진다. */
+    closedAt: z.string().optional(),
+});
+/** 선언 스냅샷. 회수 시점에 한 번 쓰고 이후 바뀌지 않는다. */
+const recordKey = (id) => `closure:rec:${id}`;
+/** 항목별 확인 마커. 이 키가 존재하면 확인된 것이다. */
+const confirmKey = (id, item) => `closure:cnf:${id}:${item}`;
+const confirmPrefix = (id) => `closure:cnf:${id}:`;
+/** CLOSED 전이 마커. 전이를 정확히 한 번만 보고하기 위한 것이다. */
+const doneKey = (id) => `closure:done:${id}`;
+export class ClosureLedger {
+    #scope;
+    #now;
+    constructor(scope, now = () => new Date().toISOString()) {
+        this.#scope = scope;
+        this.#now = now;
+    }
+    /**
+     * 회수 시점에 의무를 연다. **이미 있으면 손대지 않는다** — collect는 여러 번 돌고,
+     * 두 번째 회수가 기록을 덮으면 이미 확인한 항목이 미확인으로 되돌아간다.
+     * @returns 이번에 새로 연 기록. 이미 있었거나 선언이 없으면 null
+     */
+    async open(logicalSessionId, declared) {
+        if (declared.length === 0)
+            return null; // 선언하지 않은 프로젝트에 의무를 지우지 않는다
+        // Profile resolve가 이미 걸렀어야 하지만, Core를 직접 부르는 경로가 우회로가 되면 안 된다
+        const invalid = declared.filter((item) => !CLOSURE_ITEM_ID.test(item));
+        if (invalid.length > 0) {
+            throw new Error(`마무리 항목 id로 쓸 수 없는 값: ${invalid.join(', ')} (허용: A-Z a-z 0-9 . _ -)`);
+        }
+        const stored = { logicalSessionId, declared: [...declared], openedAt: this.#now() };
+        const written = await this.#scope.setIfAbsent(recordKey(logicalSessionId), JSON.stringify(stored));
+        if (!written)
+            return null;
+        return ClosureRecord.parse({ ...stored, confirmed: [] });
+    }
+    /**
+     * Controller의 명시 확인. 항목마다 자기 키에 한 번만 쓰므로 서로 다른 항목을 동시에
+     * 확인해도 덮이지 않고, 같은 항목을 두 번 확인해도 처음 것이 남는다.
+     */
+    async confirm(logicalSessionId, items) {
+        const stored = await this.#storedRecord(logicalSessionId);
+        if (!stored) {
+            return { ok: false, reason: 'NOT_FOUND', detail: `${logicalSessionId} 에 열린 마무리 항목이 없다` };
+        }
+        const malformed = items.filter((item) => !CLOSURE_ITEM_ID.test(item));
+        if (malformed.length > 0) {
+            return {
+                ok: false,
+                reason: 'INVALID_ITEM_ID',
+                detail: `항목 id로 쓸 수 없는 값: ${malformed.join(', ')} (허용: A-Z a-z 0-9 . _ -)`,
+            };
+        }
+        // 선언에 없는 id는 받지 않는다 — 오타를 삼키면 확인한 줄 안다
+        const unknown = items.filter((item) => !stored.declared.includes(item));
+        if (unknown.length > 0) {
+            return {
+                ok: false,
+                reason: 'UNKNOWN_ITEM',
+                detail: `선언에 없는 항목: ${unknown.join(', ')}`,
+                declared: stored.declared,
+            };
+        }
+        const at = this.#now();
+        for (const item of items) {
+            await this.#scope.setIfAbsent(confirmKey(logicalSessionId, item), at);
+        }
+        const confirmed = await this.#confirmedItems(logicalSessionId);
+        const allDone = stored.declared.every((item) => confirmed.includes(item));
+        // 마지막 두 항목을 동시에 확인하면 양쪽 다 "이제 전부 찼다"고 본다.
+        // 전이를 계산으로 내면 두 번 보고되므로, 마커를 집은 쪽만 새로 닫은 것으로 친다.
+        let newlyClosed = false;
+        if (allDone)
+            newlyClosed = await this.#scope.setIfAbsent(doneKey(logicalSessionId), at);
+        return { ok: true, record: await this.#compose(stored), newlyClosed };
+    }
+    async get(logicalSessionId) {
+        const stored = await this.#storedRecord(logicalSessionId);
+        return stored ? this.#compose(stored) : null;
+    }
+    /** 전부. 닫힌 것도 남는다 — 무엇을 닫았는지가 사라지면 기록이 아니다. */
+    async list() {
+        const records = [];
+        for (const key of await this.#scope.keys('closure:rec:')) {
+            const raw = await this.#scope.get(key);
+            if (!raw)
+                continue;
+            records.push(await this.#compose(JSON.parse(raw)));
+        }
+        return records.sort((a, b) => a.logicalSessionId.localeCompare(b.logicalSessionId));
+    }
+    /** 아직 닫히지 않은 것들. 세션이 archive에 있어도 여기 남아 있다. */
+    async pending() {
+        return (await this.list()).filter((r) => r.closedAt === undefined);
+    }
+    async #storedRecord(logicalSessionId) {
+        const raw = await this.#scope.get(recordKey(logicalSessionId));
+        return raw ? JSON.parse(raw) : null;
+    }
+    async #confirmedItems(logicalSessionId) {
+        const prefix = confirmPrefix(logicalSessionId);
+        return (await this.#scope.keys(prefix)).map((key) => key.slice(prefix.length));
+    }
+    /** 선언 스냅샷과 확인 마커를 합쳐 하나의 기록으로 보인다. */
+    async #compose(stored) {
+        const confirmed = await this.#confirmedItems(stored.logicalSessionId);
+        const closedAt = await this.#scope.get(doneKey(stored.logicalSessionId));
+        return ClosureRecord.parse({
+            ...stored,
+            // 선언 순서대로 보인다 — 파일 나열 순서가 화면에 새지 않게
+            confirmed: stored.declared.filter((item) => confirmed.includes(item)),
+            ...(closedAt ? { closedAt } : {}),
+        });
+    }
+}
+/** 미확인 항목을 사람이 읽을 줄로. collect의 "판단이 필요한 것"에 그대로 들어간다. */
+export function pendingLines(records) {
+    const lines = [];
+    for (const record of records) {
+        const pending = record.declared.filter((item) => !record.confirmed.includes(item));
+        for (const item of pending)
+            lines.push(`${record.logicalSessionId}: 마무리 미확인 — ${item}`);
+    }
+    return lines;
+}

package/dist/core/runtime/controller.d.ts

@@ -0,0 +1,40 @@
+import type { Session } from '../model/entities.ts';
+import type { StateStore } from '../../ports/state-store.ts';
+import { ClosureLedger } from './closure.ts';
+import type { AuditLedger } from './audit.ts';
+import { type QueryLedger } from './query.ts';
+import type { EscalationLedger } from './escalation.ts';
+export type CollectOutcome = {
+    active: string[];
+    /** 이번에 거둔 세션들. Handoff를 읽었다는 뜻이다. */
+    collected: string[];
+    /** 사람이 판단할 것 — 미결과 막힌 세션. */
+    awaiting: string[];
+    occupancy: {
+        sessionId: string;
+        paths: string[];
+    }[];
+};
+export type CollectOptions = {
+    /** Profile이 선언한 마무리 항목. Core는 Profile을 모른다 — Surface가 꺼내 넘긴다. */
+    closureChecklist?: readonly string[];
+    closureLedger?: ClosureLedger;
+    /** 답을 기다리는 질의와 막힌 되던지기 (B-25). 사람이 보는 유일한 창구가 여기다. */
+    queryLedger?: QueryLedger;
+    /** 아직 결정되지 않은 상신 (C-13). 사람이 결정해야 풀리는 것들이다. */
+    escalationLedger?: EscalationLedger;
+    /**
+     * 회수 주체 (C-10 §2.4). 모르면 `'controller'` 라는 익명 문자열이 History에 남는데,
+     * 그건 감사 대상이 아니라 감사 공백이다 — 누가 거뒀는지 아는 쪽이 넘긴다.
+     */
+    reclaimedBy?: string;
+    /** 회수 사실을 증거로도 남긴다. archive 뒤에는 세션에서 복원할 수 없다. */
+    auditLedger?: AuditLedger;
+};
+/**
+ * 지금 세션들을 훑어 Controller 상태를 다시 쓴다.
+ * 요약하지 않는다 — 미결은 미결대로, 점유는 점유대로 남긴다.
+ */
+export declare function collectSessions(store: StateStore, at: string, options?: CollectOptions): Promise<CollectOutcome>;
+/** 사람이 읽는 회수 결과. 다음에 무엇을 할지가 맨 아래 오도록 짠다. */
+export declare function renderCollect(outcome: CollectOutcome, sessions: readonly Session[]): string;

package/dist/core/runtime/controller.js

@@ -0,0 +1,121 @@
+// Controller 회수 — 끝난 세션을 사람이 거둬들이는 절차 (OM §7.2·§9).
+//
+// 세션은 자기 파일에 Handoff를 쓰는 데까지 하고 멈춘다. state·block·queue를 세션이
+// 직접 고치게 두면 여러 세션이 같은 문서를 두고 다투게 되고, 무엇보다 Controller가
+// 상태를 모르는 채로 흘러간다. 그래서 회수는 별도 행위이고 사람이 시작한다.
+import { ClosureLedger, pendingLines } from "./closure.js";
+import { escalatedLines, queryLines } from "./query.js";
+/**
+ * 지금 세션들을 훑어 Controller 상태를 다시 쓴다.
+ * 요약하지 않는다 — 미결은 미결대로, 점유는 점유대로 남긴다.
+ */
+export async function collectSessions(store, at, options = {}) {
+    const sessions = await store.list('session');
+    const active = sessions.filter((s) => s.status === 'ACTIVE' || s.status === 'PAUSED').map((s) => s.id);
+    const finished = sessions.filter((s) => s.status === 'DONE');
+    const blocked = sessions.filter((s) => s.status === 'BLOCKED' || s.status === 'FAILED');
+    // 미결은 세션이 끝났다고 사라지지 않는다. 누가 판단해야 하는지 이름과 함께 남긴다.
+    const awaiting = [];
+    for (const session of finished) {
+        for (const item of session.handoff?.unresolved ?? [])
+            awaiting.push(`${session.id}: ${item}`);
+    }
+    for (const session of blocked)
+        awaiting.push(`${session.id}: ${session.status}`);
+    // 프로젝트 마무리 의무. 세션은 회수되면 archive로 가지만 이 기록은 남아, 확인될 때까지
+    // 매 회수에 계속 올라온다 — 한 번 보이고 사라지면 그게 B-20이 고치려는 문제다.
+    const ledger = options.closureLedger;
+    if (ledger) {
+        for (const session of finished)
+            await ledger.open(session.id, options.closureChecklist ?? []);
+        awaiting.push(...pendingLines(await ledger.pending()));
+    }
+    // 결정이 Agent 사이에서 멈춰 있거나 돌고 있었다는 사실. 세션 상태로는 드러나지 않는다 —
+    // 답을 기다리는 쪽은 멀쩡히 ACTIVE이고, 막힌 되던지기는 세션 어디에도 남지 않는다.
+    const queries = options.queryLedger;
+    if (queries) {
+        awaiting.push(...queryLines(await queries.pending(), await queries.violations()));
+        // 사람에게 넘긴 질의도 아직 끝난 것이 아니다 — 답이 쓰였다고 pending에서만 빼면
+        // 상신은 어느 화면에도 뜨지 않는 write-only 로그가 된다.
+        awaiting.push(...escalatedLines(await queries.escalated()));
+    }
+    // 아직 결정되지 않은 상신 (C-13). 무엇이 막혔고 무엇이 계속 가는지 함께 든다.
+    const escalations = options.escalationLedger;
+    if (escalations) {
+        for (const record of await escalations.pending()) {
+            awaiting.push(`${record.escalationId} [${record.predicates.join(', ')}] ${record.question}` +
+                ` — 막힘 ${record.blockedNodes.join(', ')}` +
+                (record.stillRunnableNodes.length > 0 ? ` · 계속 ${record.stillRunnableNodes.join(', ')}` : ''));
+        }
+    }
+    // 멈춰 있는 세션이 무엇 때문에 멈췄다고 적었는지 (C-13 불변식 ⑤ — 표면화까지다).
+    for (const session of sessions) {
+        if (session.status !== 'PAUSED')
+            continue;
+        for (const blocker of session.checkpoint?.blockers ?? []) {
+            awaiting.push(`${session.id}: 진행 중 막힌 것 — ${blocker}`);
+        }
+    }
+    // 병렬 세션이 같은 경로를 잡고 있는지 보이게 한다. 잠금은 걸지 않는다 —
+    // 겹치게 발급하지 않는 것이 Controller의 몫이고, 이 표가 그 판단의 근거다 (OM §9).
+    const occupancy = sessions
+        .filter((s) => (s.status === 'ACTIVE' || s.status === 'PAUSED') && (s.writeBoundary?.length ?? 0) > 0)
+        .map((s) => ({ sessionId: s.id, paths: s.writeBoundary ?? [] }));
+    const state = await store.getControlState();
+    await store.setControlState(state.version, {
+        ...state,
+        version: state.version + 1,
+        activeSessions: active,
+        ...(finished.at(-1) ? { recentHandoff: finished.at(-1).id } : {}),
+        writeBoundaryOccupancy: occupancy,
+        awaitingController: awaiting,
+    });
+    const reclaimedBy = options.reclaimedBy ?? 'controller';
+    for (const session of finished) {
+        await store.appendHistory({
+            at,
+            actor: reclaimedBy,
+            kind: 'session_collected',
+            ref: session.id,
+            detail: session.handoff?.next ?? '',
+        });
+        // archive 직전이 실행 증거가 아직 살아 있는 마지막 순간이다 (C-10 §2.4).
+        await options.auditLedger?.reclaim({
+            sessionId: session.id,
+            reclaimedBy,
+            reclaimedAt: at,
+            ...(session.handoff ? { handoffRef: session.handoff.recordedAt } : {}),
+        });
+        // 거둔 것은 보관소로 옮긴다. 옮기고 나면 목록에 나오지 않으므로 두 번째 회수가
+        // 같은 세션을 다시 거두지 않는다 — 멱등을 따로 구현할 필요가 없다 (OM §7.4).
+        await store.archive('session', session.id);
+    }
+    return { active, collected: finished.map((s) => s.id), awaiting, occupancy };
+}
+/** 사람이 읽는 회수 결과. 다음에 무엇을 할지가 맨 아래 오도록 짠다. */
+export function renderCollect(outcome, sessions) {
+    const lines = [];
+    lines.push(`활성 세션: ${outcome.active.join(', ') || '없음'}`);
+    if (outcome.occupancy.length > 0) {
+        lines.push('', '쓰기 범위 점유:');
+        for (const item of outcome.occupancy)
+            lines.push(`  ${item.sessionId} → ${item.paths.join(', ')}`);
+    }
+    if (outcome.collected.length > 0) {
+        lines.push('', '거둔 세션:');
+        for (const id of outcome.collected) {
+            const session = sessions.find((s) => s.id === id);
+            lines.push(`  ${id} — ${session?.handoff?.next ?? '(다음 작업 없음)'}`);
+            for (const done of session?.handoff?.done ?? [])
+                lines.push(`    완료: ${done}`);
+            if (session?.handoff?.verified)
+                lines.push(`    검증: ${session.handoff.verified}`);
+        }
+    }
+    if (outcome.awaiting.length > 0) {
+        lines.push('', '판단이 필요한 것:');
+        for (const item of outcome.awaiting)
+            lines.push(`  - ${item}`);
+    }
+    return lines.join('\n');
+}