@asc-agent/runtime 0.1.0

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

@@ -0,0 +1,95 @@
+import type { StateStore } from '../../ports/state-store.ts';
+import type { HealthAlert } from '../monitor/health-alerts.ts';
+import type { EscalationRecord } from './escalation.ts';
+import type { DecisionSummary } from '../view/decision-view.ts';
+export type FrontState = {
+    /** 지금 돌고 있는 것. */
+    active: {
+        id: string;
+        role: string;
+        status: string;
+        goal: string;
+        position?: string;
+        /**
+         * 지금 이 세션을 집고 있는 physical 실행 id (기존 한계 L-4).
+         *
+         * `--physical` 을 요구하는 명령(progress report·pause·done·release)이 여럿인데
+         * 그 값을 되찾을 곳은 `asc session audit <S-ID>` 뿐이었다 — 세션 id를 이미 알아야
+         * 부를 수 있는 명령이다. 지금 무엇이 도는지 보는 화면이 그것을 같이 말한다.
+         */
+        physical?: string;
+    }[];
+    /**
+     * 발급됐는데 아무도 집지 않은 것 (C-10 §1.1). 회수 대기와 다른 상태다 —
+     * 이건 시작조차 안 됐다는 뜻이고, 그 사실이 안 보이면 위임이 조용히 증발한다.
+     */
+    unclaimed: {
+        id: string;
+        role: string;
+        goal: string;
+    }[];
+    /** 회수를 기다리는 handoff. 끝났는데 아무도 안 거둔 것들이다. */
+    awaitingCollect: {
+        id: string;
+        next: string;
+    }[];
+    /** 사람이 결정해야 하는 것. */
+    pendingDecisions: DecisionSummary[];
+    /** Controller 상태가 든 미결. closure·query가 여기 합류한다. */
+    awaitingController: readonly string[];
+    /** 감시 자체의 상태. 비어 있지 않으면 위 목록을 그대로 믿으면 안 된다. */
+    health: readonly HealthAlert[];
+    /**
+     * 사람이 결정해야 풀리는 것 (C-13). **무엇이 계속 가는지 함께 든다** —
+     * 외부 대기 하나가 전체를 세운 것처럼 보이면 사람이 그 세션을 포기한다.
+     */
+    escalations: readonly {
+        id: string;
+        predicates: string[];
+        question: string;
+        blocked: string[];
+        /** 막힌 경계(쓰기 범위). 막힌 항목과 다른 사실이라 따로 든다. */
+        blockedScope: string[];
+        runnable: string[];
+    }[];
+    /** 이 workspace가 무엇인지. 붙은 자리를 사람이 확인할 수 있어야 한다. */
+    workspace?: {
+        workspaceId: string;
+        locator: string;
+    };
+};
+export type RestoreInput = {
+    store: StateStore;
+    pending: readonly DecisionSummary[];
+    health?: readonly HealthAlert[];
+    /** 미해소 상신. 없으면 이 축은 그리지 않는다 — 없는 것을 0으로 보이게 하지 않는다. */
+    escalations?: readonly EscalationRecord[];
+    workspace?: {
+        workspaceId: string;
+        locator: string;
+    };
+    /**
+     * 세션별 소유권 조회. **구조로만 받는다** — Core가 Host adapter를 알면 안 된다.
+     * 없으면 이 축은 그리지 않는다(모르는 것을 "없음"으로 그리지 않는다).
+     */
+    bindings?: {
+        get(sessionId: string): Promise<{
+            physicalSessionId: string;
+        } | null>;
+    };
+};
+/**
+ * 지금 상태를 모은다. **쓰지 않는다.**
+ *
+ * 세션 목록은 entity에서, 미결은 Control State에서 온다 — 둘 다 이미 있는 것이고
+ * 새로 계산하지 않는다. 여기서 파생을 만들면 그 파생이 곧 두 번째 정본이 된다.
+ */
+export declare function restoreFront(input: RestoreInput): Promise<FrontState>;
+/**
+ * 사람이 읽는 복원 화면.
+ *
+ * 순서가 곧 우선순위다: **내가 지금 결정해야 하는 것**이 먼저고, 돌고 있는 것이 그다음,
+ * 감시 상태가 마지막이다. 다만 감시가 고장 났으면 그 사실을 목록보다 먼저 말한다 —
+ * 믿을 수 없는 목록을 조용히 보여주는 것이 가장 나쁘다.
+ */
+export declare function renderFront(state: FrontState): string[];

package/dist/core/runtime/front.js

@@ -0,0 +1,144 @@
+// Front Session Restore — 새 대화를 열었을 때 지금 상태를 되찾는다 (C-12 §4).
+//
+// 사람이 매번 `asc status`·`asc resume`·`asc inbox list` 를 차례로 쳐서 자기 상황을
+// 재구성하는 것은 최종형이 아니다. **상태는 지속되고 대화는 갈아입는다** — 새 Front
+// Session이 붙으면 그 자리에서 지금 무엇이 걸려 있는지 보여야 한다.
+//
+// 여기는 **읽기만 한다** (C-12 불변식 ⑮):
+//
+//   전이하지 않는다 · 승인 대기를 소비하지 않는다 · 소유권을 뺏지 않는다
+//
+// 복원이 상태를 건드리면 "확인했더니 바뀌었다"가 되고, 그러면 사람이 화면을 여는 것조차
+// 조심스러워진다.
+/**
+ * 지금 상태를 모은다. **쓰지 않는다.**
+ *
+ * 세션 목록은 entity에서, 미결은 Control State에서 온다 — 둘 다 이미 있는 것이고
+ * 새로 계산하지 않는다. 여기서 파생을 만들면 그 파생이 곧 두 번째 정본이 된다.
+ */
+export async function restoreFront(input) {
+    const sessions = await input.store.list('session');
+    const control = await input.store.getControlState();
+    const running = sessions.filter((s) => s.status === 'ACTIVE' || s.status === 'PAUSED');
+    // 도는 세션만 소유권을 묻는다 — 전수 조회가 아니라 화면에 나오는 것만.
+    const owners = new Map();
+    if (input.bindings) {
+        for (const session of running) {
+            const owner = await input.bindings.get(session.id).catch(() => null);
+            if (owner)
+                owners.set(session.id, owner.physicalSessionId);
+        }
+    }
+    const active = running
+        .map((s) => ({
+        id: s.id,
+        role: s.role,
+        status: s.status,
+        goal: s.goal,
+        ...(owners.has(s.id) ? { physical: owners.get(s.id) } : {}),
+        // 이어받을 지점이 있으면 그것까지. 없으면 없는 대로 둔다.
+        ...(s.checkpoint ? { position: s.checkpoint.position } : {}),
+    }));
+    const unclaimed = sessions
+        .filter((s) => s.status === 'READY')
+        .map((s) => ({ id: s.id, role: s.role, goal: s.goal }));
+    const awaitingCollect = sessions
+        .filter((s) => s.status === 'DONE' && s.handoff)
+        .map((s) => ({ id: s.id, next: s.handoff.next }));
+    return {
+        active,
+        unclaimed,
+        awaitingCollect,
+        pendingDecisions: [...input.pending],
+        awaitingController: control.awaitingController ?? [],
+        health: input.health ?? [],
+        escalations: (input.escalations ?? []).map((record) => ({
+            id: record.escalationId,
+            predicates: [...record.predicates],
+            question: record.question,
+            blocked: [...record.blockedNodes],
+            blockedScope: [...record.blockedScope],
+            runnable: [...record.stillRunnableNodes],
+        })),
+        ...(input.workspace ? { workspace: input.workspace } : {}),
+    };
+}
+/**
+ * 사람이 읽는 복원 화면.
+ *
+ * 순서가 곧 우선순위다: **내가 지금 결정해야 하는 것**이 먼저고, 돌고 있는 것이 그다음,
+ * 감시 상태가 마지막이다. 다만 감시가 고장 났으면 그 사실을 목록보다 먼저 말한다 —
+ * 믿을 수 없는 목록을 조용히 보여주는 것이 가장 나쁘다.
+ */
+export function renderFront(state) {
+    const lines = [];
+    if (state.workspace)
+        lines.push(`workspace ${state.workspace.workspaceId} · ${state.workspace.locator}`);
+    if (state.health.length > 0) {
+        lines.push('Read this first — monitoring state:');
+        for (const alert of state.health)
+            lines.push(`  [${alert.kind}] ${alert.detail}`);
+    }
+    lines.push(state.pendingDecisions.length > 0
+        ? `Awaiting your decision (${state.pendingDecisions.length}):`
+        : 'Nothing awaiting your decision');
+    for (const item of state.pendingDecisions.slice(0, 5)) {
+        lines.push(`  ${item.priority} ${item.requestId}  ${item.reference}  ${item.title}`);
+    }
+    if (state.pendingDecisions.length > 5)
+        lines.push(`  … and ${state.pendingDecisions.length - 5} more`);
+    if (state.active.length > 0) {
+        lines.push(`Running (${state.active.length}):`);
+        for (const session of state.active) {
+            lines.push(`  ${session.id} [${session.role}] ${session.status} — ${session.goal}`);
+            // --physical 을 요구하는 명령이 여럿이다. 그 값을 여기서 집어 갈 수 있어야 한다 (L-4).
+            if (session.physical)
+                lines.push(`    held by: ${session.physical}`);
+            if (session.position)
+                lines.push(`    resume at: ${session.position}`);
+        }
+    }
+    if (state.escalations.length > 0) {
+        lines.push(`Awaiting an outside decision (${state.escalations.length}):`);
+        for (const item of state.escalations) {
+            lines.push(`  ${item.id} [${item.predicates.join(', ')}] ${item.question}`);
+            lines.push(`    blocked: ${item.blocked.join(', ')}`);
+            // 막힌 항목과 막힌 경계는 다른 사실이다 — 경계가 안 보이면 "어디까지 남의 것인가"를 다시 물어야 한다
+            if (item.blockedScope.length > 0)
+                lines.push(`    boundary: ${item.blockedScope.join(', ')}`);
+            // 계속 가는 것을 같이 보여야 "전부 멈췄다"로 읽히지 않는다 (C-13 §6)
+            if (item.runnable.length > 0)
+                lines.push(`    still running: ${item.runnable.join(', ')}`);
+        }
+    }
+    if (state.unclaimed.length > 0) {
+        lines.push(`Issued but nobody has picked them up (${state.unclaimed.length}):`);
+        for (const session of state.unclaimed)
+            lines.push(`  ${session.id} [${session.role}] ${session.goal}`);
+    }
+    if (state.awaitingCollect.length > 0) {
+        lines.push(`Awaiting collection (${state.awaitingCollect.length}) — \`asc controller collect --as <actor>\``);
+        for (const done of state.awaitingCollect)
+            lines.push(`  ${done.id} → ${done.next}`);
+    }
+    if (state.awaitingController.length > 0) {
+        lines.push('Still open:');
+        for (const line of state.awaitingController.slice(0, 5))
+            lines.push(`  - ${line}`);
+        if (state.awaitingController.length > 5) {
+            lines.push(`  … and ${state.awaitingController.length - 5} more`);
+        }
+    }
+    if (state.pendingDecisions.length === 0 &&
+        state.active.length === 0 &&
+        state.escalations.length === 0 &&
+        state.unclaimed.length === 0 &&
+        state.awaitingCollect.length === 0 &&
+        state.awaitingController.length === 0) {
+        // 비어 있는 것과 못 보는 것을 구분한다 (C-12 불변식 ⑫과 같은 태도)
+        lines.push(state.health.length > 0
+            ? 'Nothing is pending — but read the monitoring state above first.'
+            : 'Nothing is pending.');
+    }
+    return lines;
+}

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

@@ -0,0 +1,54 @@
+export type TickKind = 'delta' | 'reconcile' | 'census' | 'digest';
+/** 한 회차에 무엇을 할지. 실패는 다음 회차로 넘어간다 — 한 번 실패가 루프를 죽이지 않는다. */
+export type TickOutcome = {
+    at: string;
+    ran: TickKind[];
+    skipped: TickKind[];
+    failures: {
+        kind: TickKind;
+        detail: string;
+    }[];
+};
+export type Schedule = {
+    /** 각 작업의 최소 간격(ms). 0이면 매 회차마다. */
+    deltaMs: number;
+    reconcileMs: number;
+    censusMs: number;
+    digestMs: number;
+};
+export type OrchestratorDeps = {
+    schedule: Schedule;
+    /** 실제 일. 없는 갈래는 아예 돌리지 않는다 — 없는 것을 있는 척하지 않는다. */
+    actions: Partial<Record<TickKind, () => Promise<void>>>;
+    /**
+     * 마지막 실행 시각을 어디에 남길지. 재기동 후 복원의 근거가 이것뿐이다 (C-12 §1.1).
+     * 저장에 실패하면 다음 회차가 더 자주 도는 것으로 끝난다 — 감지가 멈추는 것보다 낫다.
+     */
+    lastRunAt: {
+        read: () => Promise<Partial<Record<TickKind, string>>>;
+        write: (kind: TickKind, at: string) => Promise<void>;
+    };
+    now?: () => string;
+    /** 진행 상황을 사람이 볼 수 있게. 조용히 도는 것은 상시성이 아니라 불투명이다. */
+    log?: (line: string) => void;
+};
+export declare class Orchestrator {
+    #private;
+    constructor(deps: OrchestratorDeps);
+    /**
+     * 한 회차. **호출 자체가 계기다** — 이 함수를 cron이 불러도, 아래 run()이 불러도 같다.
+     *
+     * 간격이 안 됐으면 건너뛴다. 건너뛴 것도 결과에 남긴다 — "돌았는데 아무 일도 없었다"와
+     * "아예 안 돌았다"는 다른 사실이다.
+     */
+    tick(): Promise<TickOutcome>;
+    /**
+     * 멈출 때까지 돈다.
+     *
+     * 회차 하나가 터져도 루프는 계속한다 — 외부가 잠깐 죽었다고 감시가 영영 서면
+     * 그 사이의 변화는 아무도 보지 못한다. 대신 실패를 조용히 삼키지 않고 남긴다.
+     */
+    run(intervalMs: number, sleep: (ms: number) => Promise<void>): Promise<void>;
+    stop(): void;
+}
+export declare function renderTick(outcome: TickOutcome): string;

package/dist/core/runtime/orchestrator.js

@@ -0,0 +1,98 @@
+// Background Orchestrator — 실행 계기를 갖는 자리 (C-12 §1).
+//
+// 지금까지 감시는 사람이 `asc monitor scan` 을 칠 때만 돌았다. lease·retry·cursor 같은
+// 재진입 안전장치는 완비인데 **재진입시키는 주체가 없었다.**
+//
+// 이 모듈이 하는 일은 계기뿐이다:
+//
+//   하는 일    언제 무엇을 부를지 정한다
+//   안 하는 일 판정한다 / 상태를 만든다 / 승인한다
+//
+// 같은 함수를 사람이 부르든 여기가 부르든 결과가 같아야 한다 (C-12 불변식 ②).
+// 그래서 이 파일에는 Monitor·Approval의 로직이 한 줄도 없다 — 호출만 있다.
+//
+// 주기는 Core 상수가 아니다 (C-12 불변식 ③). 호출자가 정해 넣는다.
+// scheduler 제품도 모른다 (불변식 ④) — cron이 이걸 부르든, 이게 스스로 돌든 같다.
+const ORDER = ['delta', 'reconcile', 'census', 'digest'];
+export class Orchestrator {
+    #deps;
+    #now;
+    #stopped = false;
+    constructor(deps) {
+        this.#deps = deps;
+        this.#now = deps.now ?? (() => new Date().toISOString());
+    }
+    /**
+     * 한 회차. **호출 자체가 계기다** — 이 함수를 cron이 불러도, 아래 run()이 불러도 같다.
+     *
+     * 간격이 안 됐으면 건너뛴다. 건너뛴 것도 결과에 남긴다 — "돌았는데 아무 일도 없었다"와
+     * "아예 안 돌았다"는 다른 사실이다.
+     */
+    async tick() {
+        const at = this.#now();
+        const last = await this.#deps.lastRunAt.read();
+        const outcome = { at, ran: [], skipped: [], failures: [] };
+        for (const kind of ORDER) {
+            const action = this.#deps.actions[kind];
+            if (!action)
+                continue;
+            if (!due(last[kind], at, intervalOf(this.#deps.schedule, kind))) {
+                outcome.skipped.push(kind);
+                continue;
+            }
+            try {
+                await action();
+                outcome.ran.push(kind);
+                // 성공한 것만 시각을 옮긴다. 실패한 회차를 "했다"로 적으면 다음 회차가 건너뛴다.
+                await this.#deps.lastRunAt.write(kind, at);
+            }
+            catch (error) {
+                outcome.failures.push({ kind, detail: error instanceof Error ? error.message : String(error) });
+            }
+        }
+        return outcome;
+    }
+    /**
+     * 멈출 때까지 돈다.
+     *
+     * 회차 하나가 터져도 루프는 계속한다 — 외부가 잠깐 죽었다고 감시가 영영 서면
+     * 그 사이의 변화는 아무도 보지 못한다. 대신 실패를 조용히 삼키지 않고 남긴다.
+     */
+    async run(intervalMs, sleep) {
+        this.#stopped = false;
+        while (!this.#stopped) {
+            const outcome = await this.tick();
+            this.#deps.log?.(renderTick(outcome));
+            if (this.#stopped)
+                break;
+            await sleep(intervalMs);
+        }
+    }
+    stop() {
+        this.#stopped = true;
+    }
+}
+const intervalOf = (schedule, kind) => kind === 'delta'
+    ? schedule.deltaMs
+    : kind === 'reconcile'
+        ? schedule.reconcileMs
+        : kind === 'census'
+            ? schedule.censusMs
+            : schedule.digestMs;
+/** 간격이 찼는가. 기록이 없으면 처음이므로 돈다. */
+function due(lastAt, at, intervalMs) {
+    if (!lastAt)
+        return true;
+    const elapsed = new Date(at).getTime() - new Date(lastAt).getTime();
+    // 시계가 뒤로 갔거나 기록이 깨졌으면 도는 쪽을 고른다 — 멈춰 있는 것이 더 나쁘다
+    return Number.isNaN(elapsed) || elapsed >= intervalMs;
+}
+export function renderTick(outcome) {
+    const parts = [`${outcome.at}`];
+    parts.push(outcome.ran.length > 0 ? `실행 ${outcome.ran.join(', ')}` : '실행 없음');
+    if (outcome.skipped.length > 0)
+        parts.push(`간격 대기 ${outcome.skipped.join(', ')}`);
+    for (const failure of outcome.failures)
+        parts.push(`실패 ${failure.kind}: ${failure.detail}`);
+    return parts.join(' · ');
+}

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

@@ -0,0 +1,184 @@
+import { z } from 'zod';
+import { type OwnershipMap } from '../policy/ownership.ts';
+import type { ScopedStore } from '../../ports/state-store.ts';
+export declare const BoundedQuery: z.ZodObject<{
+    id: z.ZodString;
+    /** 물은 쪽. 답을 받은 뒤 흐름이 돌아갈 자리다. */
+    ownerSessionId: z.ZodString;
+    /** 물은 쪽의 파트. 되던지기 판정의 기준이라 발행 시점 스냅샷으로 박아 둔다. */
+    ownerRole: z.ZodOptional<z.ZodString>;
+    /** 어느 결정을 묻는가 (decision domain). 누구에게가 아니라 무엇에 대해서다. */
+    requestedAuthority: z.ZodString;
+    question: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    /**
+     * 답이 없을 때 물은 쪽이 취할 기본값. 이것이 있으면 질문은 차단이 아니라 확인이 되고,
+     * 없으면 blockingScope가 실제로 막힌다.
+     */
+    proposedDefault: z.ZodOptional<z.ZodString>;
+    /** 이 답이 없으면 막히는 범위. 비어 있으면 "막히지 않는다"는 뜻이다. */
+    blockingScope: z.ZodOptional<z.ZodString>;
+    expectedResponse: z.ZodDefault<z.ZodEnum<["DECIDE", "ANSWER"]>>;
+    /** 이 질의가 어느 질의에서 파생했는가. 되던지기는 여기로 드러난다. */
+    inReplyTo: z.ZodOptional<z.ZodString>;
+    openedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    question: string;
+    openedAt: string;
+    ownerSessionId: string;
+    requestedAuthority: string;
+    expectedResponse: "DECIDE" | "ANSWER";
+    context?: string | undefined;
+    ownerRole?: string | undefined;
+    proposedDefault?: string | undefined;
+    blockingScope?: string | undefined;
+    inReplyTo?: string | undefined;
+}, {
+    id: string;
+    question: string;
+    openedAt: string;
+    ownerSessionId: string;
+    requestedAuthority: string;
+    context?: string | undefined;
+    ownerRole?: string | undefined;
+    proposedDefault?: string | undefined;
+    blockingScope?: string | undefined;
+    expectedResponse?: "DECIDE" | "ANSWER" | undefined;
+    inReplyTo?: string | undefined;
+}>;
+export type BoundedQuery = z.infer<typeof BoundedQuery>;
+export declare const QueryAnswer: z.ZodObject<{
+    kind: z.ZodEnum<["DECIDE", "ANSWER", "ESCALATE"]>;
+    /** 답한 파트. DECIDE는 이 값이 그 결정의 주인일 때만 성립한다. */
+    byRole: z.ZodString;
+    body: z.ZodString;
+    /** ESCALATE 대상. Agent가 아니라 사람·권한자여야 한다 (C-04 §4.1). */
+    escalateTo: z.ZodOptional<z.ZodString>;
+    at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    kind: "DECIDE" | "ANSWER" | "ESCALATE";
+    byRole: string;
+    body: string;
+    escalateTo?: string | undefined;
+}, {
+    at: string;
+    kind: "DECIDE" | "ANSWER" | "ESCALATE";
+    byRole: string;
+    body: string;
+    escalateTo?: string | undefined;
+}>;
+export type QueryAnswer = z.infer<typeof QueryAnswer>;
+export type OpenOutcome = {
+    ok: true;
+    query: BoundedQuery;
+} | {
+    ok: false;
+    reason: 'INVALID_ID';
+    detail: string;
+} | {
+    ok: false;
+    reason: 'ALREADY_EXISTS';
+    detail: string;
+} | {
+    ok: false;
+    reason: 'ORIGIN_NOT_FOUND';
+    detail: string;
+}
+/** 받은 질의를 제3자에게 다시 넘겼다. 종결 수단은 DECIDE/ANSWER/ESCALATE뿐이다. */
+ | {
+    ok: false;
+    reason: 'ONE_HOP_VIOLATION';
+    detail: string;
+    origin: BoundedQuery;
+}
+/** 같은 결정이 물은 쪽으로 되돌아왔다. */
+ | {
+    ok: false;
+    reason: 'CIRCULAR_DELEGATION';
+    detail: string;
+    origin: BoundedQuery;
+};
+export type AnswerOutcome = {
+    ok: true;
+    query: BoundedQuery;
+    answer: QueryAnswer;
+} | {
+    ok: false;
+    reason: 'NOT_FOUND';
+    detail: string;
+} | {
+    ok: false;
+    reason: 'ALREADY_ANSWERED';
+    detail: string;
+    answer: QueryAnswer;
+}
+/** 그 결정의 주인이 아니다. 할 수 있는 것은 ANSWER 또는 ESCALATE다. */
+ | {
+    ok: false;
+    reason: 'FORBIDDEN_AUTHORITY';
+    detail: string;
+};
+export type OpenSpec = {
+    id: string;
+    ownerSessionId: string;
+    ownerRole?: string;
+    requestedAuthority: string;
+    question: string;
+    context?: string;
+    proposedDefault?: string;
+    blockingScope?: string;
+    expectedResponse?: 'DECIDE' | 'ANSWER';
+    inReplyTo?: string;
+};
+export type Violation = {
+    attemptedId: string;
+    kind: 'ONE_HOP_VIOLATION' | 'CIRCULAR_DELEGATION';
+    originId: string;
+    detail: string;
+    at: string;
+};
+export declare class QueryLedger {
+    #private;
+    constructor(scope: ScopedStore, ownership?: OwnershipMap, now?: () => string);
+    /**
+     * 질의를 연다. 되던지기는 **여기서** 막는다 — 실행 중인 세션을 끊는 대신 발행을 막는
+     * 것이 OM §16(Interrupt 부재)을 지키면서 순환을 끊는 유일한 자리다.
+     */
+    open(spec: OpenSpec): Promise<OpenOutcome>;
+    /**
+     * 답은 한 번만 쓰인다. 두 사람이 동시에 답해도 먼저 쓴 것이 남고 나중 것은 거절된다 —
+     * 조용히 덮으면 누구 말을 따랐는지 알 수 없게 된다.
+     *
+     * **이 호출은 어떤 Core 전이도 일으키지 않는다.** DECIDE도 마찬가지다 (C-04 §3.4).
+     */
+    answer(id: string, input: Omit<QueryAnswer, 'at'>): Promise<AnswerOutcome>;
+    get(id: string): Promise<BoundedQuery | null>;
+    getAnswer(id: string): Promise<QueryAnswer | null>;
+    list(): Promise<{
+        query: BoundedQuery;
+        answer: QueryAnswer | null;
+    }[]>;
+    /**
+     * 사람에게 넘겨진 질의. 답은 쓰였지만 **끝난 것이 아니다** — 그 답이 "사람이 정하라"였다.
+     * 이것이 없으면 ESCALATE는 어느 화면에도 뜨지 않는 write-only 로그가 된다.
+     */
+    escalated(): Promise<{
+        query: BoundedQuery;
+        answer: QueryAnswer;
+    }[]>;
+    /** 아직 답이 없는 질의. 누군가 기다리고 있다는 뜻이다. */
+    pending(): Promise<BoundedQuery[]>;
+    /** 막힌 발행 시도. 막았다고 사라지지 않는다 — 같은 결정이 돌고 있었다는 사실이다. */
+    violations(): Promise<Violation[]>;
+}
+/**
+ * 사람에게 넘겨진 질의를 줄로. 상신했는데 어느 화면에도 안 뜨는 상태를 막는 것이 목적이다.
+ */
+export declare function escalatedLines(answered: readonly {
+    query: BoundedQuery;
+    answer: QueryAnswer;
+}[]): string[];
+/** 사람이 읽을 줄로. collect의 "판단이 필요한 것"에 그대로 들어간다. */
+export declare function queryLines(open: readonly BoundedQuery[], violations: readonly Violation[]): string[];