@asc-agent/runtime 0.1.0

package/dist/core/policy/remote-freeze.d.ts

@@ -0,0 +1,101 @@
+import { z } from 'zod';
+import type { ScopedStore } from '../../ports/state-store.ts';
+/**
+ * 이 행위를 지금 해도 되는가.
+ *
+ *   ALLOW  그대로 한다
+ *   DENY   하지 않는다. 다시 시도할 대상도 아니다 (읽기는 얼려도 다시 밀리지 않는다)
+ *   DEFER  지금은 못 하지만 **해야 할 일이다** — 큐에 남겨 녹은 뒤 사람이 다시 본다
+ */
+export declare const FreezeDecision: z.ZodEnum<["ALLOW", "DENY", "DEFER"]>;
+export type FreezeDecision = z.infer<typeof FreezeDecision>;
+/** 행위의 갈래. provider 이름이 아니라 **무엇을 하는가**로 가른다. */
+export declare const RemoteAction: z.ZodEnum<["remote.read", "remote.write", "local.inspect", "local.implement", "local.test"]>;
+export type RemoteAction = z.infer<typeof RemoteAction>;
+export declare const FreezePolicy: z.ZodObject<{
+    frozen: z.ZodDefault<z.ZodBoolean>;
+    /** 언제부터. 얼린 시점을 모르면 무엇이 그 뒤에 쌓였는지도 모른다. */
+    since: z.ZodOptional<z.ZodString>;
+    /** 왜 얼렸는가. 이유 없는 freeze는 다음 사람이 언제 녹여도 되는지 모른다. */
+    reason: z.ZodOptional<z.ZodString>;
+    /**
+     * 원격 **읽기**까지 막을 것인가. 기본은 허용이다 — 읽기까지 막으면 조사 자체가 서지 않고,
+     * 대개 문제가 되는 것은 쓰기다. 완전 오프라인이면 명시적으로 켠다.
+     */
+    denyRemoteRead: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    frozen: boolean;
+    denyRemoteRead: boolean;
+    reason?: string | undefined;
+    since?: string | undefined;
+}, {
+    reason?: string | undefined;
+    frozen?: boolean | undefined;
+    since?: string | undefined;
+    denyRemoteRead?: boolean | undefined;
+}>;
+export type FreezePolicy = z.infer<typeof FreezePolicy>;
+export declare const DeferredAction: z.ZodObject<{
+    id: z.ZodString;
+    action: z.ZodEnum<["remote.read", "remote.write", "local.inspect", "local.implement", "local.test"]>;
+    /** 무엇을 하려 했는가. 사람이 읽고 다시 판단할 만큼은 남는다. */
+    intent: z.ZodString;
+    /** 그때 무엇을 근거로 했는가 — 녹은 뒤 그 근거가 아직 유효한지 대조할 대상이다. */
+    basis: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    deferredAt: z.ZodString;
+    /** 승인·Grant가 걸려 있던 것이면 그 참조. 자동 재사용하지 않는다. */
+    grantRef: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    action: "remote.read" | "remote.write" | "local.inspect" | "local.implement" | "local.test";
+    intent: string;
+    basis: string[];
+    deferredAt: string;
+    grantRef?: string | undefined;
+}, {
+    id: string;
+    action: "remote.read" | "remote.write" | "local.inspect" | "local.implement" | "local.test";
+    intent: string;
+    deferredAt: string;
+    basis?: string[] | undefined;
+    grantRef?: string | undefined;
+}>;
+export type DeferredAction = z.infer<typeof DeferredAction>;
+/**
+ * 이 행위를 지금 해도 되는가 (지시 §27).
+ *
+ * **로컬은 얼리지 않는다.** 구현·테스트·조사가 멈추면 freeze가 곧 작업 중단이 되고,
+ * 그러면 사람이 freeze를 안 쓴다 — 안 쓰이는 안전장치는 안전장치가 아니다.
+ */
+export declare function judgeAction(policy: FreezePolicy, action: RemoteAction): {
+    decision: FreezeDecision;
+    detail: string;
+};
+export declare class FreezeLedger {
+    #private;
+    constructor(scope: ScopedStore, now?: () => string);
+    policy(): Promise<FreezePolicy>;
+    /** 얼린다. 이유를 요구한다 — 이유 없는 freeze는 언제 녹여도 되는지 아무도 모른다. */
+    freeze(reason: string, options?: {
+        denyRemoteRead?: boolean;
+    }): Promise<FreezePolicy>;
+    /**
+     * 녹인다. **쌓인 것을 자동으로 실행하지 않는다** (지시 §27).
+     *
+     * 미뤄 둔 것을 그대로 돌려주기만 한다. 그 사이 대상이 바뀌었을 수 있고 승인 근거가
+     * 낡았을 수 있으므로, 다시 확인하고 다시 승인하는 것은 사람의 일이다.
+     */
+    thaw(): Promise<{
+        policy: FreezePolicy;
+        deferred: DeferredAction[];
+    }>;
+    /** 미뤄 둔 것을 남긴다. 같은 id를 덮어쓰지 않는다 — 미룬 사실도 기록이다. */
+    defer(input: Omit<DeferredAction, 'deferredAt'> & {
+        deferredAt?: string;
+    }): Promise<boolean>;
+    deferred(): Promise<DeferredAction[]>;
+    /** 사람이 다시 판단해 처리했다. **여기서 실행하지 않는다** — 실행은 기존 Grant 경로다. */
+    release(id: string): Promise<boolean>;
+}
+/** 사람이 읽는 줄. 녹인 뒤 무엇을 다시 봐야 하는지가 이 목록이다. */
+export declare function freezeLines(policy: FreezePolicy, deferred: readonly DeferredAction[]): string[];

package/dist/core/policy/remote-freeze.js

@@ -0,0 +1,151 @@
+// Remote Freeze — 원격을 얼려도 로컬 일은 계속 돈다 (C-10 §7 계열 · 지시 §27).
+//
+// 실전 근거: 프로젝트 운영 중 "지금은 원격에 아무것도 보내지 마라"는 상태가 실제로 있다.
+// 그때 필요한 것은 두 가지다.
+//
+//   ① 원격 쓰기가 **정말로** 안 나가야 한다 — "조심하겠다"는 약속이 아니라 차단이어야 한다
+//   ② 로컬 작업은 계속 돌아야 한다 — 얼렸다고 구현·테스트까지 멈추면 아무도 안 쓴다
+//
+// 그리고 녹일 때가 더 위험하다. 얼어 있는 동안 쌓인 것을 **자동으로 재생하지 않는다**:
+// 그 사이 대상이 바뀌었을 수 있고, 승인 근거가 낡았을 수 있다. 다시 확인하고 다시 승인한다.
+import { z } from 'zod';
+/**
+ * 이 행위를 지금 해도 되는가.
+ *
+ *   ALLOW  그대로 한다
+ *   DENY   하지 않는다. 다시 시도할 대상도 아니다 (읽기는 얼려도 다시 밀리지 않는다)
+ *   DEFER  지금은 못 하지만 **해야 할 일이다** — 큐에 남겨 녹은 뒤 사람이 다시 본다
+ */
+export const FreezeDecision = z.enum(['ALLOW', 'DENY', 'DEFER']);
+/** 행위의 갈래. provider 이름이 아니라 **무엇을 하는가**로 가른다. */
+export const RemoteAction = z.enum([
+    'remote.read',
+    'remote.write',
+    'local.inspect',
+    'local.implement',
+    'local.test',
+]);
+export const FreezePolicy = z.object({
+    frozen: z.boolean().default(false),
+    /** 언제부터. 얼린 시점을 모르면 무엇이 그 뒤에 쌓였는지도 모른다. */
+    since: z.string().optional(),
+    /** 왜 얼렸는가. 이유 없는 freeze는 다음 사람이 언제 녹여도 되는지 모른다. */
+    reason: z.string().optional(),
+    /**
+     * 원격 **읽기**까지 막을 것인가. 기본은 허용이다 — 읽기까지 막으면 조사 자체가 서지 않고,
+     * 대개 문제가 되는 것은 쓰기다. 완전 오프라인이면 명시적으로 켠다.
+     */
+    denyRemoteRead: z.boolean().default(false),
+});
+export const DeferredAction = z.object({
+    id: z.string().min(1),
+    action: RemoteAction,
+    /** 무엇을 하려 했는가. 사람이 읽고 다시 판단할 만큼은 남는다. */
+    intent: z.string().min(1),
+    /** 그때 무엇을 근거로 했는가 — 녹은 뒤 그 근거가 아직 유효한지 대조할 대상이다. */
+    basis: z.array(z.string()).default([]),
+    deferredAt: z.string().min(1),
+    /** 승인·Grant가 걸려 있던 것이면 그 참조. 자동 재사용하지 않는다. */
+    grantRef: z.string().optional(),
+});
+/**
+ * 이 행위를 지금 해도 되는가 (지시 §27).
+ *
+ * **로컬은 얼리지 않는다.** 구현·테스트·조사가 멈추면 freeze가 곧 작업 중단이 되고,
+ * 그러면 사람이 freeze를 안 쓴다 — 안 쓰이는 안전장치는 안전장치가 아니다.
+ */
+export function judgeAction(policy, action) {
+    if (!policy.frozen)
+        return { decision: 'ALLOW', detail: '얼지 않았다' };
+    switch (action) {
+        case 'remote.write':
+            // 해야 할 일이지만 지금은 아니다 — 버리지 않고 미룬다
+            return { decision: 'DEFER', detail: `원격 쓰기는 얼어 있다${policy.reason ? ` (${policy.reason})` : ''}` };
+        case 'remote.read':
+            return policy.denyRemoteRead
+                ? { decision: 'DENY', detail: '완전 오프라인 — 원격 읽기도 막혀 있다' }
+                : { decision: 'ALLOW', detail: '읽기는 허용된다 — 막히는 것은 쓰기다' };
+        default:
+            return { decision: 'ALLOW', detail: '로컬 작업은 얼리지 않는다' };
+    }
+}
+const POLICY_KEY = 'freeze-policy';
+const deferredKey = (id) => `freeze-deferred:${id}`;
+const DEFERRED_PREFIX = 'freeze-deferred:';
+export class FreezeLedger {
+    #scope;
+    #now;
+    constructor(scope, now = () => new Date().toISOString()) {
+        this.#scope = scope;
+        this.#now = now;
+    }
+    async policy() {
+        const raw = await this.#scope.get(POLICY_KEY);
+        return raw ? FreezePolicy.parse(JSON.parse(raw)) : FreezePolicy.parse({});
+    }
+    /** 얼린다. 이유를 요구한다 — 이유 없는 freeze는 언제 녹여도 되는지 아무도 모른다. */
+    async freeze(reason, options = {}) {
+        const policy = FreezePolicy.parse({
+            frozen: true,
+            since: this.#now(),
+            reason,
+            denyRemoteRead: options.denyRemoteRead ?? false,
+        });
+        await this.#scope.set(POLICY_KEY, JSON.stringify(policy));
+        return policy;
+    }
+    /**
+     * 녹인다. **쌓인 것을 자동으로 실행하지 않는다** (지시 §27).
+     *
+     * 미뤄 둔 것을 그대로 돌려주기만 한다. 그 사이 대상이 바뀌었을 수 있고 승인 근거가
+     * 낡았을 수 있으므로, 다시 확인하고 다시 승인하는 것은 사람의 일이다.
+     */
+    async thaw() {
+        const policy = FreezePolicy.parse({ frozen: false });
+        await this.#scope.set(POLICY_KEY, JSON.stringify(policy));
+        return { policy, deferred: await this.deferred() };
+    }
+    /** 미뤄 둔 것을 남긴다. 같은 id를 덮어쓰지 않는다 — 미룬 사실도 기록이다. */
+    async defer(input) {
+        const record = DeferredAction.parse({ ...input, deferredAt: input.deferredAt ?? this.#now() });
+        return this.#scope.setIfAbsent(deferredKey(record.id), JSON.stringify(record));
+    }
+    async deferred() {
+        const keys = (await this.#scope.keys(DEFERRED_PREFIX)).sort();
+        const out = [];
+        for (const key of keys) {
+            const raw = await this.#scope.get(key);
+            if (!raw)
+                continue;
+            const parsed = DeferredAction.safeParse(JSON.parse(raw));
+            if (parsed.success)
+                out.push(parsed.data);
+        }
+        return out;
+    }
+    /** 사람이 다시 판단해 처리했다. **여기서 실행하지 않는다** — 실행은 기존 Grant 경로다. */
+    async release(id) {
+        if (!(await this.#scope.get(deferredKey(id))))
+            return false;
+        await this.#scope.delete(deferredKey(id));
+        return true;
+    }
+}
+/** 사람이 읽는 줄. 녹인 뒤 무엇을 다시 봐야 하는지가 이 목록이다. */
+export function freezeLines(policy, deferred) {
+    const lines = [];
+    lines.push(policy.frozen
+        ? `원격 얼림 (${policy.since ?? '시점 미상'})${policy.reason ? ` — ${policy.reason}` : ''}`
+        : '원격 얼림 없음');
+    if (policy.frozen && policy.denyRemoteRead)
+        lines.push('  읽기도 막혀 있다 (완전 오프라인)');
+    if (deferred.length > 0) {
+        lines.push(`미뤄 둔 것 ${deferred.length}건 — 녹은 뒤 자동으로 나가지 않는다. 다시 확인하고 승인하라:`);
+        for (const item of deferred) {
+            lines.push(`  ${item.id} [${item.action}] ${item.intent} (${item.deferredAt})`);
+            if (item.basis.length > 0)
+                lines.push(`    당시 근거: ${item.basis.join(', ')} — 아직 유효한지 보라`);
+        }
+    }
+    return lines;
+}

package/dist/core/policy/scope.d.ts

@@ -0,0 +1,23 @@
+export type ParsedScope = {
+    kind: 'all';
+} | {
+    kind: 'recursive';
+    segments: string[];
+} | {
+    kind: 'children';
+    segments: string[];
+} | {
+    kind: 'exact';
+    segments: string[];
+};
+/** 문법 밖 패턴은 null이다 — 호출자는 이를 위반으로 다뤄야 하며, 통과시켜서는 안 된다. */
+export declare function parseScope(scope: string): ParsedScope | null;
+/** 실제 경로가 이 범위들 중 하나에 드는가. */
+export declare function pathInScope(path: string, scopes: readonly string[]): boolean;
+/**
+ * sub가 가리키는 경로 집합이 sup 안에 전부 들어가는가.
+ * 판정 불가(문법 밖)면 false — 모르면 거부한다.
+ */
+export declare function isScopeSubset(sub: string, sup: string): boolean;
+/** 여러 상위 범위 중 하나라도 sub를 품으면 통과다. */
+export declare function isWithinScopes(sub: string, supers: readonly string[]): boolean;

package/dist/core/policy/scope.js

@@ -0,0 +1,93 @@
+// ASC scope grammar와 두 가지 판정.
+//
+// 이 둘은 다른 질문이고 다른 답을 준다. 섞으면 권한이 새어 나간다:
+//   pathInScope   — "이 파일을 써도 되는가"           (경로 대 패턴)
+//   isScopeSubset — "이 범위가 저 범위 안에 드는가"   (패턴 대 패턴, 집합 포함)
+//
+// glob 매처로 패턴 대 패턴을 판정하면 안 된다. `node:path`의 matchesGlob으로
+// `frontend/**`가 `frontend/*`의 부분집합인지 물으면 true가 나온다 — `**`가 리터럴처럼
+// 매칭되기 때문이다. 재귀 범위가 1단계 범위 안에 든다는 답은 곧 권한 확장 통과다.
+// 그래서 문법을 좁히고 집합 포함을 직접 계산한다.
+//
+// 허용 문법 (이외는 전부 거부):
+//   **              모든 경로
+//   <prefix>/**     prefix 이하 전부 (재귀)
+//   <prefix>/*      prefix의 직속 자식만 (1단계)
+//   <path>          정확히 그 경로 하나
+/** 문법 밖 패턴은 null이다 — 호출자는 이를 위반으로 다뤄야 하며, 통과시켜서는 안 된다. */
+export function parseScope(scope) {
+    if (scope.length === 0)
+        return null;
+    if (scope === '**')
+        return { kind: 'all' };
+    const segments = scope.split('/');
+    const last = segments.at(-1);
+    const head = segments.slice(0, -1);
+    // 와일드카드는 마지막 세그먼트에만, 그리고 그 세그먼트 전체여야 한다.
+    // 'frontend/*/studio'나 'src/*.ts'는 집합 포함을 단순 계산할 수 없어 거부한다.
+    if (head.some((s) => s.includes('*') || s.length === 0))
+        return null;
+    if (last === '**')
+        return head.length > 0 ? { kind: 'recursive', segments: head } : null;
+    if (last === '*')
+        return head.length > 0 ? { kind: 'children', segments: head } : null;
+    if (last.includes('*') || last.length === 0)
+        return null;
+    return { kind: 'exact', segments };
+}
+const startsWith = (path, prefix) => prefix.length <= path.length && prefix.every((segment, i) => path[i] === segment);
+const sameSegments = (a, b) => a.length === b.length && a.every((segment, i) => segment === b[i]);
+/** 실제 경로가 이 범위들 중 하나에 드는가. */
+export function pathInScope(path, scopes) {
+    const segments = path.split('/');
+    return scopes.some((scope) => {
+        const parsed = parseScope(scope);
+        if (!parsed)
+            return false; // 잘못 쓴 범위는 아무것도 허용하지 않는다
+        switch (parsed.kind) {
+            case 'all':
+                return true;
+            case 'recursive':
+                return startsWith(segments, parsed.segments) && segments.length > parsed.segments.length;
+            case 'children':
+                return startsWith(segments, parsed.segments) && segments.length === parsed.segments.length + 1;
+            case 'exact':
+                return sameSegments(segments, parsed.segments);
+        }
+    });
+}
+/**
+ * sub가 가리키는 경로 집합이 sup 안에 전부 들어가는가.
+ * 판정 불가(문법 밖)면 false — 모르면 거부한다.
+ */
+export function isScopeSubset(sub, sup) {
+    const a = parseScope(sub);
+    const b = parseScope(sup);
+    if (!a || !b)
+        return false;
+    if (b.kind === 'all')
+        return true;
+    if (a.kind === 'all')
+        return false; // 전체는 어떤 부분범위에도 들어가지 않는다
+    switch (b.kind) {
+        case 'recursive':
+            if (!startsWith(a.segments, b.segments))
+                return false;
+            // `p/**`는 p 아래를 뜻하지 p 자신이 아니다 — pathInScope도 같은 규칙이므로,
+            // exact 'frontend'가 'frontend/**'의 부분집합이 되면 두 판정이 어긋난다.
+            return a.kind === 'exact' ? a.segments.length > b.segments.length : true;
+        case 'children':
+            // 1단계만 허용하는 범위에 재귀 범위는 들어갈 수 없다 — 이것이 matchesGlob이 놓친 지점이다.
+            if (a.kind === 'recursive')
+                return false;
+            if (a.kind === 'children')
+                return sameSegments(a.segments, b.segments);
+            return a.segments.length === b.segments.length + 1 && startsWith(a.segments, b.segments);
+        case 'exact':
+            return a.kind === 'exact' && sameSegments(a.segments, b.segments);
+    }
+}
+/** 여러 상위 범위 중 하나라도 sub를 품으면 통과다. */
+export function isWithinScopes(sub, supers) {
+    return supers.some((sup) => isScopeSubset(sub, sup));
+}

package/dist/core/presentation/digest.d.ts

@@ -0,0 +1,98 @@
+import { z } from 'zod';
+import { type HealthAlert } from '../monitor/health-alerts.ts';
+import type { DecisionSummary } from '../view/decision-view.ts';
+import type { DigestBatch, DeliveryOutcome, PresentationPort } from '../../ports/presentation.ts';
+import type { ScopedStore } from '../../ports/state-store.ts';
+export type DigestInput = {
+    at: string;
+    /** 판단 대기 중인 것들. LocalOperator가 이미 우선순위·freshness를 붙여 준다. */
+    pending: readonly DecisionSummary[];
+    /** 숨겨 두고 보는 것의 수 (C-07 §5). 숫자만 알려도 무엇을 못 보고 있는지 안다. */
+    shadowCount?: number;
+    /** 회수 경로에서 발견된 수. coverage 정보이며 우선순위와 무관하다 (C-07 §1.6). */
+    recoveredCount?: number;
+    /** 이미 보낸 것 — requestId → 그때 version. 같은 것을 두 번 묶어 보내지 않는다. */
+    delivered?: ReadonlyMap<string, number>;
+    /**
+     * 감시 자체의 경고 (C-12 §3). Core가 판정하지 않는다 — 판정은 evaluateHealth가 하고
+     * 여기는 그 결과를 함께 실어 나른다.
+     */
+    health?: readonly HealthAlert[];
+};
+export type DigestPlan = {
+    /** 지금 끊어야 하는 것. P0만이다. */
+    urgent: DecisionSummary[];
+    /** 묶어서 건넬 것. */
+    batch: DigestBatch;
+    /** 보내지 않은 것과 그 이유. 조용히 빠지면 사람이 왜 안 보였는지 알 수 없다. */
+    skipped: {
+        alreadyDecided: number;
+        alreadyDelivered: number;
+        shadow: number;
+    };
+    /**
+     * 감시 자체의 상태 (C-12 §3). 판단 요청이 아니라 **"지금 이 목록을 믿어도 되는가"** 다.
+     * 비어 있지 않으면 목록이 조용한 이유가 조용해서가 아닐 수 있다.
+     */
+    health: HealthAlert[];
+};
+/**
+ * 무엇을 지금 건네고 무엇을 묶을지 정한다.
+ *
+ * 간격·주기는 여기 없다. 그건 설정이고 실행 계기는 밖에 있다 (C-08 §2.3) — 프로젝트마다
+ * 다르고 같은 프로젝트에서도 시기마다 다르다.
+ */
+export declare function planDigest(input: DigestInput): DigestPlan;
+/**
+ * 사람이 먼저 봐야 할 것은 **몇 건이 있고 그중 지금 정해야 할 것이 무엇인가**다 (C-08 §2.4).
+ * 걸러진 것도 숫자로 남긴다 — 0으로 감추면 걸러졌다는 사실 자체가 사라진다.
+ */
+export declare function renderDigest(plan: DigestPlan): string[];
+export declare const Delivery: z.ZodObject<{
+    requestId: z.ZodString;
+    version: z.ZodNumber;
+    channel: z.ZodString;
+    externalRef: z.ZodOptional<z.ZodString>;
+    at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    version: number;
+    channel: string;
+    requestId: string;
+    externalRef?: string | undefined;
+}, {
+    at: string;
+    version: number;
+    channel: string;
+    requestId: string;
+    externalRef?: string | undefined;
+}>;
+export type Delivery = z.infer<typeof Delivery>;
+/**
+ * 어느 request를 어느 채널에 언제 보냈는가.
+ *
+ * **Core Entity가 아니다** (C-01 §9, C-02 §3) — 정본이 아니고, 전달은 best-effort이며,
+ * 실패가 canonical state에 영향을 주면 안 된다. 그래서 adapter-scope에 둔다.
+ */
+export declare class DeliveryLedger {
+    #private;
+    constructor(scope: ScopedStore, now?: () => string);
+    record(requestId: string, version: number, channel: string, externalRef?: string): Promise<void>;
+    /** 이 채널에 무엇을 어느 판으로 보냈는가. */
+    delivered(channel: string): Promise<Map<string, number>>;
+}
+export type DeliveryReport = {
+    channel: string;
+    digest?: DeliveryOutcome;
+    urgent: {
+        requestId: string;
+        outcome: DeliveryOutcome;
+    }[];
+    /** 능력이 없어 아래로 내린 것. 조용히 무시하지 않는다 (C-08 §1.3). */
+    degraded: string[];
+};
+/**
+ * 건넨다. 채널이 능력을 다 갖추지 못하면 **그 기능만 내려간다** — 급한 것을 따로 보낼 수
+ * 없으면 묶음에 실어 보내고, 그 사실을 적는다.
+ */
+export declare function deliver(plan: DigestPlan, channel: PresentationPort, ledger?: DeliveryLedger): Promise<DeliveryReport>;

package/dist/core/presentation/digest.js

@@ -0,0 +1,160 @@
+// Digest Coordinator — 감지와 방해를 분리한다 (C-08).
+//
+// 빨리 감지하는 것과 사람을 지금 끊는 것은 다른 결정이다. 지금까지 둘이 붙어 있었고, 그래서
+// 실시간 감지를 켜면 새 사건마다 작업 흐름이 끊겼다. 문제는 감지 속도가 아니라 전달 방식이다.
+//
+// **Monitor 밖이다.** Monitor의 write 경계는 자기 계약 파일·inbox entity·log뿐이고(OM §10.7),
+// 전달은 그 밖이다. 여기서 패킷을 만들지 않는다 — 이미 만들어진 것을 언제 어디로 건넬지만 정한다.
+//
+// 패킷 생성은 미루지 않는다. 미루면 그 사건은 재시도 대기로 남아 다음 회차가 같은 조사를
+// 다시 하게 되고, 미완료와 보류가 구분되지 않는다 (C-08 §2.2).
+import { z } from 'zod';
+import { healthAlertLines } from "../monitor/health-alerts.js";
+/**
+ * 무엇을 지금 건네고 무엇을 묶을지 정한다.
+ *
+ * 간격·주기는 여기 없다. 그건 설정이고 실행 계기는 밖에 있다 (C-08 §2.3) — 프로젝트마다
+ * 다르고 같은 프로젝트에서도 시기마다 다르다.
+ */
+export function planDigest(input) {
+    const urgent = [];
+    const p1 = [];
+    const p2 = [];
+    const health = input.health ?? [];
+    const skipped = { alreadyDecided: 0, alreadyDelivered: 0, shadow: input.shadowCount ?? 0 };
+    for (const item of input.pending) {
+        // 이미 결정된 것은 판단 요청이 아니다. freshness가 그 사실을 들고 있다 (C-01 §7).
+        if (item.freshness === 'ALREADY_DECIDED') {
+            skipped.alreadyDecided++;
+            continue;
+        }
+        // 같은 판(version)을 다시 보내지 않는다. 바뀌었으면 다시 보낸다 — 그건 새 사실이다.
+        if (input.delivered?.get(item.requestId) === item.version) {
+            skipped.alreadyDelivered++;
+            continue;
+        }
+        if (item.priority === 'P0')
+            urgent.push(item);
+        else if (item.priority === 'P1')
+            p1.push(item);
+        else
+            p2.push(item);
+    }
+    const groups = [
+        ...(urgent.length > 0 ? [{ priority: 'P0', items: urgent }] : []),
+        ...(p1.length > 0 ? [{ priority: 'P1', items: p1 }] : []),
+        ...(p2.length > 0 ? [{ priority: 'P2', items: p2 }] : []),
+    ];
+    return {
+        health: [...health],
+        urgent,
+        batch: {
+            at: input.at,
+            groups,
+            suppressed: { shadow: skipped.shadow, alreadyDecided: skipped.alreadyDecided },
+            ...(input.recoveredCount ? { recovered: input.recoveredCount } : {}),
+        },
+        skipped,
+    };
+}
+const LABEL = { P0: '🔴 지금 확인 필요', P1: '🟡 판단 필요', P2: '🔵 참고' };
+/**
+ * 사람이 먼저 봐야 할 것은 **몇 건이 있고 그중 지금 정해야 할 것이 무엇인가**다 (C-08 §2.4).
+ * 걸러진 것도 숫자로 남긴다 — 0으로 감추면 걸러졌다는 사실 자체가 사라진다.
+ */
+export function renderDigest(plan) {
+    const lines = [`ASC · ${plan.batch.at}`];
+    for (const group of plan.batch.groups) {
+        lines.push(`${LABEL[group.priority] ?? group.priority} ${group.items.length}`);
+        for (const item of group.items) {
+            lines.push(`  ${item.requestId}  ${item.reference}  ${item.title}`);
+            // 묶은 뒤 변한 것은 새 값을 만들지 않고 freshness 4종으로 말한다 (C-08 §3.3).
+            if (item.freshness !== 'CURRENT')
+                lines.push(`    (${item.freshness})`);
+        }
+    }
+    // 목록보다 먼저 온다. 감시가 고장 났으면 "건넬 것이 없다"는 사실이 아니다.
+    for (const line of healthAlertLines(plan.health))
+        lines.push(line);
+    if (plan.skipped.shadow > 0)
+        lines.push(`⚪ 숨김 ${plan.skipped.shadow} (관련 근거 없음 — 계속 본다)`);
+    if (plan.skipped.alreadyDecided > 0)
+        lines.push(`⚪ 이미 결정됨 ${plan.skipped.alreadyDecided}`);
+    if (plan.skipped.alreadyDelivered > 0)
+        lines.push(`⚪ 이미 보냄 ${plan.skipped.alreadyDelivered}`);
+    if (plan.batch.recovered)
+        lines.push(`↺ 회수 경로에서 발견 ${plan.batch.recovered}`);
+    if (plan.batch.groups.length === 0) {
+        // "변경 없음"과 "못 봄"을 합치지 않는다 (C-12 불변식 ⑫)
+        lines.push(plan.health.length > 0 ? '건넬 것이 없다 — 다만 위 경고를 먼저 보라.' : '건넬 것이 없다.');
+    }
+    return lines;
+}
+// ── 전달 기록 ────────────────────────────────────────────────────────────────
+export const Delivery = z.object({
+    requestId: z.string().min(1),
+    version: z.number().int().nonnegative(),
+    channel: z.string().min(1),
+    externalRef: z.string().optional(),
+    at: z.string().min(1),
+});
+/**
+ * 어느 request를 어느 채널에 언제 보냈는가.
+ *
+ * **Core Entity가 아니다** (C-01 §9, C-02 §3) — 정본이 아니고, 전달은 best-effort이며,
+ * 실패가 canonical state에 영향을 주면 안 된다. 그래서 adapter-scope에 둔다.
+ */
+export class DeliveryLedger {
+    #scope;
+    #now;
+    constructor(scope, now = () => new Date().toISOString()) {
+        this.#scope = scope;
+        this.#now = now;
+    }
+    async record(requestId, version, channel, externalRef) {
+        await this.#scope.set(`sent:${channel}:${requestId}`, JSON.stringify(Delivery.parse({ requestId, version, channel, ...(externalRef ? { externalRef } : {}), at: this.#now() })));
+    }
+    /** 이 채널에 무엇을 어느 판으로 보냈는가. */
+    async delivered(channel) {
+        const out = new Map();
+        for (const key of await this.#scope.keys(`sent:${channel}:`)) {
+            const raw = await this.#scope.get(key);
+            if (raw) {
+                const record = Delivery.parse(JSON.parse(raw));
+                out.set(record.requestId, record.version);
+            }
+        }
+        return out;
+    }
+}
+/**
+ * 건넨다. 채널이 능력을 다 갖추지 못하면 **그 기능만 내려간다** — 급한 것을 따로 보낼 수
+ * 없으면 묶음에 실어 보내고, 그 사실을 적는다.
+ */
+export async function deliver(plan, channel, ledger) {
+    const report = { channel: channel.id, urgent: [], degraded: [] };
+    if (channel.capabilities.has('presentation.priority') && channel.presentUrgent) {
+        for (const item of plan.urgent) {
+            const outcome = await channel.presentUrgent(item);
+            report.urgent.push({ requestId: item.requestId, outcome });
+            if (outcome.ok)
+                await ledger?.record(item.requestId, item.version, channel.id, outcome.externalRef);
+        }
+    }
+    else if (plan.urgent.length > 0) {
+        report.degraded.push(`${channel.id} 는 급한 건을 따로 전달하지 못한다 — ${plan.urgent.length}건을 묶음에 실었다`);
+    }
+    if (!channel.capabilities.has('presentation.digest')) {
+        report.degraded.push(`${channel.id} 는 묶음을 전달하지 못한다`);
+        return report;
+    }
+    report.digest = await channel.presentDigest(plan.batch);
+    if (report.digest.ok && ledger) {
+        for (const group of plan.batch.groups) {
+            for (const item of group.items) {
+                await ledger.record(item.requestId, item.version, channel.id, report.digest.externalRef);
+            }
+        }
+    }
+    return report;
+}