@asc-agent/runtime 0.7.1 → 0.8.0

package/dist/core/attach/bootstrap.js

@@ -73,15 +73,15 @@ export async function planBootstrap(input) {
             ? '쓸 수 있는 Profile이 없다 — 설치 경로에 profiles/<id>/profile.json 이 있어야 한다'
             : `어떤 Profile로 붙일지 (후보: ${candidates.join(', ')})`);
         if (candidates.length > 0)
-            steps.push('asc init --profile <위 후보 중 하나>');
+            steps.push('asc setup --profile <위 후보 중 하나>');
     }
     else if (profile.kind === 'ATTACHED_UNKNOWN') {
         // 통과시키면 무엇으로 도는지 모르는 채 굴러간다 — bootstrapGuard가 막는 것과 같은 상태다
         undecided.push('.asc/ 는 있는데 profile.lock 을 읽지 못했다 — 붙이다 만 상태다');
-        steps.push('asc init --profile <id> 로 다시 붙이거나 asc profile resolve --write 로 고정한다');
+        steps.push('asc setup 으로 다시 붙이거나 asc profile resolve --write 로 고정한다');
     }
     else if (!attached) {
-        steps.push(`asc init --profile ${profile.id}`);
+        steps.push(`asc setup --profile ${profile.id}`);
     }
     for (const host of hosts) {
         if (!host.installed)
@@ -101,7 +101,7 @@ export async function planBootstrap(input) {
                 undecided.push(policy.question);
         }
     }
-    steps.push('asc setup status');
+    steps.push('asc status');
     if (attached)
         steps.push('asc proceed');
     return {

package/dist/core/attach/setup.js

@@ -15,12 +15,12 @@
  * 포함한다 — "attach가 끝나야 아무것도 할 수 있다"는 오해를 이 목록이 직접 깬다.
  */
 const ALWAYS_READY = [
-    'issue, run, pause, resume and finish sessions (asc session, asc proceed)',
-    'record and read progress (asc progress)',
-    'check output paths up front (asc preflight)',
-    'collect finished work and confirm closure (asc controller collect, asc closure)',
-    'read incoming requests (asc inbox list/show)',
-    'install and check the host (asc host)',
+    'start, pause, resume and finish work inside a contract (asc work)',
+    'see where the work is right now (asc work status)',
+    'check output paths up front (asc work inspect)',
+    'read what is waiting for a person (asc inbox)',
+    'choose who executes an approved act (asc mode)',
+    'see and converge this installation (asc status, asc refresh)',
 ];
 const RESOLVE_AGAIN = 'after editing, re-lock with `asc profile resolve --write` (otherwise the next command stops)';
 export function assessSetup(input) {
@@ -126,11 +126,11 @@ export function renderSetup(status) {
     const lines = [];
     switch (status.attachment) {
         case 'UNATTACHED':
-            lines.push('Not attached yet — run `asc init --profile <id>` first.');
+            lines.push('Not attached yet — run `asc setup` first.');
             return lines.join('\n');
         case 'BROKEN':
             lines.push('Attachment is half-finished: a runtime exists but profile.lock does not.');
-            lines.push('  Re-attach with `asc init --profile <id>`, or lock it with `asc profile resolve --write`.');
+            lines.push('  Re-attach with `asc setup`, or lock it with `asc profile resolve --write`.');
             return lines.join('\n');
         case 'LOCK_DRIFT':
             // 이 상태에서 gate를 나열하면 "설정이 덜 찼다"로 잘못 읽힌다. 원인을 먼저 말한다.

package/dist/core/distribution/release.d.ts

@@ -1,9 +1,9 @@
 export declare const RUNTIME_PACKAGE = "@asc-agent/runtime";
 export declare const BOOTSTRAP_PACKAGE = "@asc-agent/bootstrap";
 /** runtime과 bootstrap은 초기 release에서 lockstep이다. */
-export declare const RELEASE_VERSION = "0.7.1";
-export declare const RUNTIME_SPEC = "@asc-agent/runtime@0.7.1";
-export declare const BOOTSTRAP_SPEC = "@asc-agent/bootstrap@0.7.1";
+export declare const RELEASE_VERSION = "0.8.0";
+export declare const RUNTIME_SPEC = "@asc-agent/runtime@0.8.0";
+export declare const BOOTSTRAP_SPEC = "@asc-agent/bootstrap@0.8.0";
 /**
  * 아직 설치되지 않은 machine에서 그대로 실행되는 형태 (C-14 §3.4).
  *

package/dist/core/distribution/release.js

@@ -9,7 +9,7 @@
 export const RUNTIME_PACKAGE = '@asc-agent/runtime';
 export const BOOTSTRAP_PACKAGE = '@asc-agent/bootstrap';
 /** runtime과 bootstrap은 초기 release에서 lockstep이다. */
-export const RELEASE_VERSION = '0.7.1';
+export const RELEASE_VERSION = '0.8.0';
 export const RUNTIME_SPEC = `${RUNTIME_PACKAGE}@${RELEASE_VERSION}`;
 export const BOOTSTRAP_SPEC = `${BOOTSTRAP_PACKAGE}@${RELEASE_VERSION}`;
 /**

package/dist/core/distribution/runtime-install.js

@@ -83,7 +83,7 @@ export async function verifyStableInstall(run, expectedVersion = RELEASE_VERSION
         return {
             ok: false,
             state,
-            remedy: 'Runtime package was installed, but `asc` is not visible in this process. Open a new terminal and run `asc setup status`.',
+            remedy: 'Runtime package was installed, but `asc` is not visible in this process. Open a new terminal and run `asc status`.',
         };
     }
     return { ok: false, state, remedy: state.detail };

package/dist/core/execution/executor.d.ts

@@ -32,6 +32,43 @@ export type ExecuteOutcome = {
     ok: false;
     reason: 'DRIFT';
     detail: string;
+}
+/**
+ * 실행 직전 재확인이 "지금은 성립하지 않는다" 로 답했다. 밖은 그대로다.
+ *
+ * 여기서 사람에게 다시 묻지 않는다 — 무엇을 할지는 이미 결정됐고, 이 자리가 답하는
+ * 것은 그 결정이 딛고 선 사실이 아직 그대로인가 하나다.
+ */
+ | {
+    ok: false;
+    reason: 'NOT_EXECUTABLE';
+    detail: string;
+}
+/** 밖에서 거절했다. 나간 것이 없다는 것이 확인된 실패다. */
+ | {
+    ok: false;
+    reason: 'REJECTED';
+    detail: string;
+}
+/**
+ * 나갔는지 모른다 (0.8.0 §P). 다시 부르지 않는다 — 다시 부르면 같은 것이 두 번 나갈 수
+ * 있고, 그것이 이 상태에서 가장 나쁜 결과다. Grant 는 집힌 채로 남아 재사용되지 않는다.
+ */
+ | {
+    ok: false;
+    reason: 'UNCERTAIN';
+    detail: string;
+}
+/**
+ * 나갔는데 되돌려 읽은 것이 기대와 다르다. 성공이라고 적지 않는다 — Grant 는 소진되되
+ * `EXECUTED` 가 되지 않는다. 그 상태는 밖에서 "성공적으로 끝남" 으로 읽히기 때문이다.
+ */
+ | {
+    ok: false;
+    reason: 'NOT_VERIFIED';
+    detail: string;
+    resultRef: string;
+    mismatches: string[];
 } | {
     ok: false;
     reason: 'ACTION_FAILED';
@@ -42,6 +79,13 @@ export type ExecutorDeps = {
     scm: ScmPort;
     /** 이 Physical Run의 식별자. 누가 집었는지 Grant에 남는다. */
     runId: string;
+    /**
+     * 되돌려 읽을 수 없는 행위를 실행하지 않는다 (0.8.0 보정 P1-2).
+     *
+     * 강제가 서 있는 자리(AUTO·실행 축을 읽지 못한 자리)에서 참이다. 사람이 실행하는
+     * 자리에서는 그 판단이 사람의 것이므로 호출자가 정한다.
+     */
+    requireVerification?: boolean;
     now?: () => string;
 };
 export declare class Executor {

package/dist/core/execution/executor.js

@@ -2,22 +2,31 @@
 //
 // 이 파일이 시스템에서 유일하게 외부 write를 부르는 지점이다. 순서가 곧 안전장치다:
 //
-//   CLAIM (원자적)  →  계약 범위 확인  →  Drift Guard  →  외부 행위 1회  →  EXECUTED
+//   CLAIM (원자적) → 계약 범위 확인 → Drift Guard → 실행 직전 재검수(읽기)
+//   → 외부 행위 1회 → 되돌려 읽기 → EXECUTED
 //
 // CLAIM을 먼저 하는 이유는 두 Executor가 같은 Grant로 같은 댓글을 두 번 달지 않게 하기
 // 위해서고, Drift Guard를 그 다음에 두는 이유는 승인 이후 스레드가 움직였을 때 오래된
 // 초안이 나가지 않게 하기 위해서다 (OM §11.9). 둘 다 실패는 조용히 넘어가지 않는다.
+//
+// 0.8.0 에서 앞뒤로 한 마디씩 붙었다. 앞의 재검수는 승인이 딛고 선 사실이 아직 그대로인지
+// **읽기만으로** 확인하고(§D), 뒤의 되돌려 읽기는 명령이 0 으로 끝났다는 것과 밖에 그것이
+// 있다는 것이 다르다는 사실을 다룬다(§L·§M·§N). 둘 다 판정은 Core 가 하고, 사실은 Port 가
+// 읽어 온다 — 그래야 사람이 보는 검수와 Agent 가 따르는 검수가 같은 판정이다.
 import { transitionGrant, transitionRequest } from "../model/transitions.js";
+import { expectationOf, revalidate, verifyAgainst } from "./remote-review.js";
 import { applyTransition } from "../runtime/store-ops.js";
 export class Executor {
     #store;
     #scm;
     #runId;
+    #requireVerification;
     #now;
     constructor(deps) {
         this.#store = deps.store;
         this.#scm = deps.scm;
         this.#runId = deps.runId;
+        this.#requireVerification = deps.requireVerification ?? false;
         this.#now = deps.now ?? (() => new Date().toISOString());
     }
     async run(grantId) {
@@ -42,33 +51,102 @@ export class Executor {
         //    계약 자체가 모순이면 외부 상태를 조회할 이유도 없으므로 Drift Guard보다 앞에 둔다.
         if (!claimed.entity.allowedWrites.includes(claimed.entity.action)) {
             const detail = `'${claimed.entity.action}' is not in allowed writes [${claimed.entity.allowedWrites.join(', ')}]`;
-            await this.#close(grant.id, 'INVALIDATED', this.#now(), detail);
+            await this.#close(grant.id, 'INVALIDATED', this.#now(), detail, 'FORBIDDEN');
             return { ok: false, reason: 'FORBIDDEN_ACTION', detail };
         }
         // 3. Drift Guard — 승인 시점의 기준선과 지금을 대조한다
         const drift = await this.#detectDrift(claimed.entity);
         if (drift) {
-            await this.#close(grant.id, 'INVALIDATED', this.#now(), drift);
+            await this.#close(grant.id, 'INVALIDATED', this.#now(), drift, 'DRIFT');
             return { ok: false, reason: 'DRIFT', detail: drift };
         }
-        // 4. 외부 행위 1회. payload는 승인된 내용 그대로 나간다
-        const result = await this.#scm.execute({
+        const action = {
             action: claimed.entity.action,
             target: claimed.entity.target,
             payload: claimed.entity.payload,
-        });
+        };
+        // 4. 실행 직전 재확인. 승인은 그때의 사실 위에서 났다 — **바뀔 수 있는 것만**
+        //    읽기로 다시 본다. 모호함·읽지 못한 사실은 결정 시점에 이미 사람이 넘어간 것이고,
+        //    여기서 다시 꺼내면 그것이 두 번째 승인 벽이 된다.
+        let expected;
+        if (this.#scm.review) {
+            const facts = await this.#scm.review(action);
+            // 되돌려 읽을 수 없는 행위는 자율 실행에서 내보내지 않는다 — 나간 뒤에 아무도
+            // 확인할 수 없는 쓰기가 된다. 사람이 실행하는 자리에서는 그 판단이 사람의 것이다.
+            if (this.#requireVerification && facts.verifiable === false) {
+                const detail = `${facts.provider} cannot read back '${action.action}'`;
+                await this.#close(grant.id, 'INVALIDATED', this.#now(), detail, 'NOT_EXECUTABLE');
+                return { ok: false, reason: 'NOT_EXECUTABLE', detail };
+            }
+            const moved = revalidate({
+                action: action.action,
+                facts,
+                ...(claimed.entity.basis ? { basis: claimed.entity.basis } : {}),
+            });
+            if (moved) {
+                await this.#close(grant.id, 'INVALIDATED', this.#now(), `${moved.code}: ${moved.detail}`, moved.code === 'DRIFT' ? 'DRIFT' : 'NOT_EXECUTABLE');
+                return { ok: false, reason: moved.code === 'DRIFT' ? 'DRIFT' : 'NOT_EXECUTABLE', detail: moved.detail };
+            }
+            expected = expectationOf({ action: action.action, target: action.target, facts, ...(claimed.entity.basis ? { basis: claimed.entity.basis } : {}) });
+        }
+        // 5. 외부 행위 1회. payload는 승인된 내용 그대로 나간다
+        const result = await this.#scm.execute(action);
         if (!result.ok) {
-            // 재시도하지 않는다. 실패한 호출이 정말 나가지 않았는지는 여기서 알 수 없고,
-            // 모른 채 다시 부르면 같은 글이 두 번 올라간다. 사람이 확인하고 새 Grant를 낸다.
-            await this.#close(grant.id, 'INVALIDATED', this.#now(), `실행 실패: ${result.error}`);
-            return { ok: false, reason: 'ACTION_FAILED', detail: result.error };
+            // **나갔는지 모르는 실패와 거절을 가른다** (0.8.0 §P). 어느 쪽이든 다시 부르지
+            // 않는다 — 모른 채 재시도하면 같은 것이 두 번 나갈 수 있다.
+            if (uncertain(result.error)) {
+                await this.#store.appendHistory({
+                    at: this.#now(),
+                    actor: this.#runId,
+                    kind: 'external_action_uncertain',
+                    ref: grant.id,
+                    detail: `${grant.action} → ${grant.target}: ${result.error}`,
+                });
+                // **CLAIMED 로 남기지 않는다** (0.8.0 보정 P1-1). 그 상태는 이 시스템에서 "지금
+                // 누가 집고 실행 중" 을 뜻하고(READY→CLAIMED→EXECUTED/INVALIDATED), 아무도 실행
+                // 중이 아닌 Grant 를 거기 두면 화면과 감사가 영영 틀린 말을 한다. terminal 로
+                // 닫되 **이유가 UNCERTAIN** 이다 — 재실행은 막히고, 성공도 실패도 주장하지 않는다.
+                await this.#close(grant.id, 'INVALIDATED', this.#now(), `결과 불명: ${result.error}`, 'UNCERTAIN');
+                return { ok: false, reason: 'UNCERTAIN', detail: result.error };
+            }
+            await this.#close(grant.id, 'INVALIDATED', this.#now(), `실행 실패: ${result.error}`, 'REJECTED');
+            return { ok: false, reason: 'REJECTED', detail: result.error };
+        }
+        // 6. 되돌려 읽기. exit 0 은 성공이 아니다.
+        let mismatches = [];
+        if (this.#scm.verify && expected) {
+            const read = await this.#scm.verify(action, { resultRef: result.resultRef });
+            if (!read.unsupported) {
+                const comparable = Object.keys(expected).filter((key) => key !== 'action' && key !== 'target' && read.observed[key] !== undefined);
+                const verified = verifyAgainst(expected, read.observed, comparable);
+                mismatches = comparable.length === 0 ? ['nothing could be read back to compare'] : verified.mismatches;
+            }
         }
-        // 5. 소비 기록 — 성공한 Grant는 다시 쓸 수 없다
+        // 7. 소비 기록. **되돌려 읽은 것이 다르면 EXECUTED 로 적지 않는다** (P0-5) —
+        //    그 상태는 밖에서 "성공적으로 끝남" 으로 읽힌다. 나간 것은 나갔으므로 재사용은
+        //    막되(terminal), 성공은 주장하지 않는다.
         const executedAt = this.#now();
+        if (mismatches.length > 0) {
+            await this.#close(grant.id, 'INVALIDATED', executedAt, `되돌려 읽은 것이 다르다: ${mismatches.join('; ')}`, 'NOT_VERIFIED', result.resultRef);
+            await this.#store.appendHistory({
+                at: executedAt,
+                actor: this.#runId,
+                kind: 'external_action_unverified',
+                ref: grant.id,
+                detail: `${grant.action} → ${grant.target} = ${result.resultRef} (unverified: ${mismatches.join('; ')})`,
+            });
+            return {
+                ok: false,
+                reason: 'NOT_VERIFIED',
+                detail: mismatches.join('; '),
+                resultRef: result.resultRef,
+                mismatches,
+            };
+        }
         const executed = await applyTransition(this.#store, 'grant', grant.id, (g) => transitionGrant(g, 'EXECUTED', 'executor', { resultRef: result.resultRef, consumedAt: executedAt }));
         if (!executed.ok)
             return { ok: false, reason: 'CLAIMED_BY_OTHER' };
-        // 6. 요청이 근거였다면 그 요청을 닫는다 — 외부에 무엇이 남았는지 요청에서 바로
+        // 8. 요청이 근거였다면 그 요청을 닫는다 — 외부에 무엇이 남았는지 요청에서 바로
         //    따라갈 수 있어야 한다. 세션이 근거인 경우에는 닫을 요청이 없고, 그 자취는
         //    아래 History 와 세션 자신의 기록에 남는다.
         if (claimed.entity.requestId) {
@@ -103,8 +181,24 @@ export class Executor {
         }
         return null;
     }
-    async #close(grantId, to, at, detail) {
-        await applyTransition(this.#store, 'grant', grantId, (g) => transitionGrant(g, to, 'executor'));
+    /**
+     * terminal 로 닫는다. **이유를 함께 적는다** — 상태 다섯 개만으로는 "왜" 가 남지 않고,
+     * 소진된 것과 성공한 것을 가르는 것도 그 이유다 (0.8.0 보정 P0-5).
+     */
+    async #close(grantId, to, at, detail, resolution, resultRef) {
+        await applyTransition(this.#store, 'grant', grantId, (g) => transitionGrant(g, to, 'executor', {
+            ...(resolution ? { resolution } : {}),
+            ...(resultRef ? { resultRef } : {}),
+        }));
         await this.#store.appendHistory({ at, actor: this.#runId, kind: `grant_${to.toLowerCase()}`, ref: grantId, detail });
     }
 }
+/**
+ * 이 실패가 "나가지 않았다" 인가, "모른다" 인가 (0.8.0 §P).
+ *
+ * 시간이 끊기거나 연결이 죽은 자리에서는 요청이 도착했는지 알 수 없다. 그 상태를 실패로
+ * 적고 재시도하면 같은 것이 두 번 나갈 수 있으므로, 모르는 것은 모른다고 적는다.
+ */
+function uncertain(error) {
+    return /timeout|timed out|ETIMEDOUT|ECONNRESET|EAI_AGAIN|socket hang up|aborted|network/i.test(error);
+}

package/dist/core/execution/grant.d.ts

@@ -15,6 +15,8 @@ export type IssueGrantInput = {
     /** 이 계약으로 허용되는 행위 목록. 비우면 `action` 하나만 허용된다. */
     allowedWrites?: string[];
     issuedAt: string;
+    /** 승인이 딛고 선 사실 (0.8.0 §L). 실행 직전 재검수가 이 값과 지금을 견준다. */
+    basis?: ExecutionGrant['basis'];
 };
 /**
  * 세션이 만든 결과를 내보내는 경우의 입력 (0.7.0).
@@ -43,6 +45,12 @@ export type IssueForSessionInput = {
     issuedAt: string;
     /** 게시 직전 대조할 기준 (OM §11.9). 없으면 대조하지 않는다. */
     snapshot?: CanonicalSnapshot[];
+    /**
+     * 승인이 딛고 선 사실 (0.8.0 §L). 검수가 읽어 온 값을 그대로 못 박는다 — 실행 직전
+     * 재검수가 이 값과 지금을 견주므로, 승인은 "이 가지" 가 아니라 "이 commit" 에 대한
+     * 것이 된다.
+     */
+    basis?: ExecutionGrant['basis'];
 };
 export type IssueFailure = {
     kind: 'REQUEST_NOT_FOUND';

package/dist/core/execution/grant.js

@@ -58,6 +58,7 @@ export class GrantService {
             payload,
             // 이 시점의 정본이 Drift Guard의 기준선이 된다 (OM §11.9)
             snapshot: request.snapshot,
+            ...(input.basis ? { basis: input.basis } : {}),
             ...(request.source.threadLastEventId !== undefined
                 ? { threadLastEventId: request.source.threadLastEventId }
                 : {}),
@@ -121,6 +122,7 @@ export class GrantService {
             payload: input.payload,
             snapshot: input.snapshot ?? [],
             allowedWrites: input.allowedWrites ?? [input.action],
+            ...(input.basis ? { basis: input.basis } : {}),
         });
         const created = await this.#store.create('grant', grant);
         if (!created.ok)

package/dist/core/execution/remote-review.d.ts

@@ -0,0 +1,117 @@
+/** 검수가 본 것. provider adapter 가 읽어서 넘긴다 (mutation 0). */
+export type RemoteFacts = {
+    provider: string;
+    /** 정규화된 원격 신원 — 이 결합이 가리키는 프로젝트/저장소와 견줄 값이다. */
+    resource?: string;
+    target?: string;
+    /** 이 통로가 이 행위를 할 수 있는가. */
+    capability?: boolean;
+    /** 이 통로가 이 행위를 되돌려 읽을 수 있는가 (0.8.0 보정 P1-2). */
+    verifiable?: boolean;
+    /**
+     * 관측된 사실들. 키는 provider 가 정하고 Core 는 해석하지 않는다 — 화면과 감사에
+     * 그대로 남는다. 예: `local.head`, `remote.sha`, `mr.state`, `remote.url`.
+     */
+    observed?: Readonly<Record<string, string | undefined>>;
+    /** 고를 수 없는 상태. 같은 대상이 둘 이상 후보로 보일 때 그 이유를 적는다. */
+    ambiguity?: readonly string[];
+    /** 읽지 못한 것. 모르는 것을 안다고 적지 않는다. */
+    unknown?: readonly string[];
+};
+/** 승인 시점에 못 박힌 것. 실행 직전 재검수는 이 값과 지금을 견준다. */
+export type ApprovedBasis = {
+    /** 올리기로 한 그 commit. 가지 이름만으로는 같은 승인이 다른 내용을 내보낸다. */
+    sourceSha?: string;
+    /** 승인 당시의 원격 상태. 그 뒤 남이 움직였는지 보는 기준선이다. */
+    remoteBaseline?: string;
+    /** 이 결합이 가리키는 신원. target 이 여기서 벗어나면 관리 범위 밖이다. */
+    resource?: string;
+};
+export type ReviewSeverity = 'BLOCK' | 'REVIEW' | 'NOTE';
+export type ReviewFinding = {
+    code: 'NO_CAPABILITY' | 'NO_VERIFY_PATH' | 'BINDING_MISMATCH' | 'DRIFT' | 'AMBIGUOUS' | 'UNKNOWN_FACT' | 'MISSING_TARGET' | 'NOTE';
+    severity: ReviewSeverity;
+    detail: string;
+};
+/**
+ * READY           사실이 맞는다. 결정권이 이미 풀렸다면 그대로 나갈 수 있다
+ * REVIEW_REQUIRED 사람이 봐야 하는 것이 있다 — 범위 밖 대상, 모호함, 읽지 못한 사실
+ * NOT_EXECUTABLE  지금 이 행동은 성립하지 않는다 — 할 수 없거나, 근거가 이미 움직였다
+ */
+export type ReviewVerdict = 'READY' | 'REVIEW_REQUIRED' | 'NOT_EXECUTABLE';
+export type ReviewOutcome = {
+    verdict: ReviewVerdict;
+    findings: ReviewFinding[];
+    /** 실행이 성공했다면 밖에서 무엇이 보여야 하는가. verify 가 이 값과 견준다. */
+    expected: Record<string, string>;
+};
+export type ReviewInput = {
+    action: string;
+    target: string;
+    facts: RemoteFacts;
+    basis?: ApprovedBasis;
+    /**
+     * 되돌려 읽을 수 없으면 실행하지 않는가 (0.8.0 보정 P1-2).
+     *
+     * 자율 실행(AUTO)에서는 참이다: 확인할 수 없는 쓰기를 자율로 내보내면 "성공했다" 를
+     * 아무도 세지 않는다. 사람이 실행하는 자리(MANUAL)에서는 그 판단이 사람의 것이다.
+     */
+    requireVerification?: boolean;
+};
+/**
+ * 사실을 판정한다. **모르는 것을 무조건 차단으로 번역하지 않는다** (§E) — 모르는 것은
+ * 사람이 볼 일이고, 성립하지 않는 것만 실행 불가다.
+ */
+export declare function reviewExternalAction(input: ReviewInput): ReviewOutcome;
+/**
+ * 성공했다면 밖에서 무엇이 보여야 하는가.
+ *
+ * 실행 전에 적어 두는 이유는 하나다: 실행 뒤에 기대치를 정하면 관측한 것이 기대치가 된다.
+ */
+export declare function expectationOf(input: {
+    action: string;
+    target: string;
+    facts: RemoteFacts;
+    basis?: ApprovedBasis;
+}): Record<string, string>;
+/**
+ * 실행 직전의 재확인 — **바뀔 수 있는 것만 본다.**
+ *
+ * 검수(CHECK)는 계약을 만들 때 이미 끝났다. 그때 사람이 보고 넘어간 모호함·읽지 못한
+ * 사실을 실행 직전에 다시 꺼내면 그것은 두 번째 승인 벽이 된다 — 같은 질문에 두 번
+ * 답하게 만드는 구조이고, 이 릴리스가 없애려는 바로 그 형태다.
+ *
+ * 그래서 여기서 묻는 것은 **승인 이후 실제로 움직일 수 있는 것** 셋뿐이다:
+ *
+ * ```text
+ * 이 통로가 아직 이 행위를 할 수 있는가
+ * 대상이 아직 승인된 범위 안인가
+ * 못 박은 commit·기준선이 아직 그대로인가
+ * ```
+ *
+ * 답은 둘이다: 그대로면 `null`, 아니면 실행하지 않을 이유 하나.
+ */
+export declare function revalidate(input: {
+    action: string;
+    facts: RemoteFacts;
+    basis?: ApprovedBasis;
+}): {
+    code: 'NO_CAPABILITY' | 'BINDING_MISMATCH' | 'DRIFT';
+    detail: string;
+} | null;
+/** 사람이 읽는 한 줄들. 화면 형태는 MANUAL·AUTO 가 각자 정하고 판정은 같은 것을 쓴다. */
+export declare function reviewLines(outcome: ReviewOutcome): string[];
+/** 원격 신원 비교용 정규화. 대소문자·`.git`·앞뒤 슬래시만 걷어낸다. */
+export declare function normalize(resource: string): string;
+/**
+ * 실행 뒤의 대조. **명령이 0 으로 끝났다는 것은 성공이 아니다** (§L·§M·§N).
+ *
+ * 되돌려 읽은 사실이 기대치와 다르면 성공이라고 적지 않는다.
+ */
+export type VerifyOutcome = {
+    ok: boolean;
+    /** 무엇을 봤는가. 감사에 그대로 남는다. */
+    observed: Record<string, string | undefined>;
+    mismatches: string[];
+};
+export declare function verifyAgainst(expected: Readonly<Record<string, string>>, observed: Readonly<Record<string, string | undefined>>, keys: readonly string[]): VerifyOutcome;