@asc-agent/runtime 0.7.0 → 0.8.0

package/dist/core/execution/remote-review.js

@@ -0,0 +1,176 @@
+// Remote Review — 밖으로 나가기 전에 **사실을 검수한다** (0.8.0 보정 §D·§E).
+//
+// 승인과 검수는 다른 일이다:
+//
+//   Decision Authority   이 행동을 해도 되는가          — 사람의 자리
+//   Remote Review        지금 그 행동이 말이 되는가     — 사실의 자리
+//
+// 사람이 "게시해" 라고 말한 것은 결정권을 해결한다. 그 말이 대상 프로젝트가 맞는지,
+// 승인한 SHA 가 아직 그 SHA 인지, 같은 MR 이 이미 있는지까지 확인해 주지는 않는다.
+// 그것을 확인하는 것이 이 파일이고, **그래서 이것은 두 번째 승인 벽이 아니다** — 사람에게
+// 다시 허락을 구하지 않고, 사실이 어긋났을 때만 멈춘다.
+//
+// 판정은 하나다. MANUAL 에서는 같은 판정이 조언으로 보이고, AUTO 에서는 같은 판정이
+// 실행 전 관문이 된다. 두 벌을 만들면 언젠가 사람이 보는 것과 Agent 가 따르는 것이 갈린다.
+//
+// 이 파일은 순수하다. 원격을 읽지 않는다 — 읽은 결과를 받아 판정만 한다.
+/**
+ * 사실을 판정한다. **모르는 것을 무조건 차단으로 번역하지 않는다** (§E) — 모르는 것은
+ * 사람이 볼 일이고, 성립하지 않는 것만 실행 불가다.
+ */
+export function reviewExternalAction(input) {
+    const findings = [];
+    const facts = input.facts;
+    if (input.requireVerification === true && facts.verifiable === false) {
+        findings.push({
+            code: 'NO_VERIFY_PATH',
+            severity: 'BLOCK',
+            detail: `${facts.provider} cannot read back '${input.action}' — it will not run unattended`,
+        });
+    }
+    if (facts.capability === false) {
+        findings.push({
+            code: 'NO_CAPABILITY',
+            severity: 'BLOCK',
+            detail: `${facts.provider} cannot carry out '${input.action}'`,
+        });
+    }
+    if (input.target.trim() === '') {
+        findings.push({ code: 'MISSING_TARGET', severity: 'BLOCK', detail: 'the action has no target' });
+    }
+    // 결합 밖의 대상 — Agent 가 스스로 범위를 넓히지 않는다 (§K). 사람이 정할 일이다.
+    const bound = input.basis?.resource;
+    if (bound && facts.resource && normalize(bound) !== normalize(facts.resource)) {
+        findings.push({
+            code: 'BINDING_MISMATCH',
+            severity: 'REVIEW',
+            detail: `this run is bound to ${bound}, and the target is ${facts.resource}`,
+        });
+    }
+    // 승인이 못 박은 것과 지금이 다르다 — 승인은 그 SHA 에 대한 것이었다 (§L).
+    const head = facts.observed?.['local.head'];
+    if (input.basis?.sourceSha && head && head !== input.basis.sourceSha) {
+        findings.push({
+            code: 'DRIFT',
+            severity: 'BLOCK',
+            detail: `what was approved is ${short(input.basis.sourceSha)}, and here it is now ${short(head)}`,
+        });
+    }
+    const remote = facts.observed?.['remote.sha'];
+    if (input.basis?.remoteBaseline && remote && remote !== input.basis.remoteBaseline) {
+        findings.push({
+            code: 'DRIFT',
+            severity: 'BLOCK',
+            detail: `the remote moved since this was approved (${short(input.basis.remoteBaseline)} → ${short(remote)})`,
+        });
+    }
+    for (const reason of facts.ambiguity ?? []) {
+        findings.push({ code: 'AMBIGUOUS', severity: 'REVIEW', detail: reason });
+    }
+    for (const reason of facts.unknown ?? []) {
+        findings.push({ code: 'UNKNOWN_FACT', severity: 'REVIEW', detail: `could not read: ${reason}` });
+    }
+    const verdict = findings.some((finding) => finding.severity === 'BLOCK')
+        ? 'NOT_EXECUTABLE'
+        : findings.some((finding) => finding.severity === 'REVIEW')
+            ? 'REVIEW_REQUIRED'
+            : 'READY';
+    return { verdict, findings, expected: expectationOf(input) };
+}
+/**
+ * 성공했다면 밖에서 무엇이 보여야 하는가.
+ *
+ * 실행 전에 적어 두는 이유는 하나다: 실행 뒤에 기대치를 정하면 관측한 것이 기대치가 된다.
+ */
+export function expectationOf(input) {
+    const expected = { action: input.action, target: input.target };
+    const sha = input.basis?.sourceSha ?? input.facts.observed?.['local.head'];
+    if (sha)
+        expected['sha'] = sha;
+    if (input.facts.resource)
+        expected['resource'] = input.facts.resource;
+    // provider 가 "성공했다면 이것이 보여야 한다" 고 적어 둔 것들. Core 는 그 뜻을 풀지
+    // 않고 이름만 옮긴다 — 무엇을 확인할지는 그 행위를 아는 쪽이 안다.
+    for (const [key, value] of Object.entries(input.facts.observed ?? {})) {
+        if (key.startsWith('expect.') && value !== undefined)
+            expected[key.slice('expect.'.length)] = value;
+    }
+    return expected;
+}
+/**
+ * 실행 직전의 재확인 — **바뀔 수 있는 것만 본다.**
+ *
+ * 검수(CHECK)는 계약을 만들 때 이미 끝났다. 그때 사람이 보고 넘어간 모호함·읽지 못한
+ * 사실을 실행 직전에 다시 꺼내면 그것은 두 번째 승인 벽이 된다 — 같은 질문에 두 번
+ * 답하게 만드는 구조이고, 이 릴리스가 없애려는 바로 그 형태다.
+ *
+ * 그래서 여기서 묻는 것은 **승인 이후 실제로 움직일 수 있는 것** 셋뿐이다:
+ *
+ * ```text
+ * 이 통로가 아직 이 행위를 할 수 있는가
+ * 대상이 아직 승인된 범위 안인가
+ * 못 박은 commit·기준선이 아직 그대로인가
+ * ```
+ *
+ * 답은 둘이다: 그대로면 `null`, 아니면 실행하지 않을 이유 하나.
+ */
+export function revalidate(input) {
+    const { facts, basis } = input;
+    if (facts.capability === false) {
+        return { code: 'NO_CAPABILITY', detail: `${facts.provider} cannot carry out '${input.action}'` };
+    }
+    if (basis?.resource && facts.resource && normalize(basis.resource) !== normalize(facts.resource)) {
+        return {
+            code: 'BINDING_MISMATCH',
+            detail: `this run is bound to ${basis.resource}, and the target is ${facts.resource}`,
+        };
+    }
+    const head = facts.observed?.['local.head'];
+    if (basis?.sourceSha && head && head !== basis.sourceSha) {
+        return {
+            code: 'DRIFT',
+            detail: `what was approved is ${short(basis.sourceSha)}, and here it is now ${short(head)}`,
+        };
+    }
+    const remote = facts.observed?.['remote.sha'];
+    if (basis?.remoteBaseline && remote && remote !== basis.remoteBaseline) {
+        return {
+            code: 'DRIFT',
+            detail: `the remote moved since this was approved (${short(basis.remoteBaseline)} → ${short(remote)})`,
+        };
+    }
+    return null;
+}
+/** 사람이 읽는 한 줄들. 화면 형태는 MANUAL·AUTO 가 각자 정하고 판정은 같은 것을 쓴다. */
+export function reviewLines(outcome) {
+    const lines = [`Remote review: ${outcome.verdict}`];
+    for (const finding of outcome.findings) {
+        lines.push(`  [${finding.severity}] ${finding.code} — ${finding.detail}`);
+    }
+    return lines;
+}
+/** 원격 신원 비교용 정규화. 대소문자·`.git`·앞뒤 슬래시만 걷어낸다. */
+export function normalize(resource) {
+    return resource
+        .trim()
+        .toLowerCase()
+        .replace(/\.git$/, '')
+        .replace(/^\/+|\/+$/g, '');
+}
+const short = (sha) => (sha.length > 10 ? sha.slice(0, 10) : sha);
+export function verifyAgainst(expected, observed, keys) {
+    const mismatches = [];
+    for (const key of keys) {
+        const want = expected[key];
+        const got = observed[key];
+        if (want === undefined)
+            continue;
+        if (got === undefined) {
+            mismatches.push(`${key}: expected ${short(want)}, and it could not be read back`);
+            continue;
+        }
+        if (normalize(want) !== normalize(got))
+            mismatches.push(`${key}: expected ${short(want)}, read back ${short(got)}`);
+    }
+    return { ok: mismatches.length === 0, observed: { ...observed }, mismatches };
+}

package/dist/core/model/entities.d.ts

@@ -583,6 +583,21 @@ export type ApprovalDecision = z.infer<typeof ApprovalDecision>;
 /** Grant lifecycle (OM §11.5). 성공한 Grant는 재소비 불가 — replay guard의 근간. */
 export declare const GrantStatus: z.ZodEnum<["READY", "CLAIMED", "EXECUTED", "INVALIDATED", "EXPIRED"]>;
 export type GrantStatus = z.infer<typeof GrantStatus>;
+/**
+ * terminal 로 간 이유 (0.8.0 보정).
+ *
+ * ```text
+ * DRIFT           승인 근거가 움직였다 — 나가지 않았다
+ * NOT_EXECUTABLE  지금 성립하지 않는 행위다 — 나가지 않았다
+ * REVIEW_REQUIRED 사람이 봐야 하는 사실이 있다 — 나가지 않았다
+ * FORBIDDEN       계약이 허용하지 않는 행위다 — 나가지 않았다
+ * REJECTED        밖이 거절했다 — 나가지 않은 것이 확인됐다
+ * UNCERTAIN       나갔는지 모른다 — 다시 부르지 않는다
+ * NOT_VERIFIED    나갔는데 되돌려 읽은 것이 다르다 — 성공이 아니다
+ * ```
+ */
+export declare const GrantResolution: z.ZodEnum<["DRIFT", "NOT_EXECUTABLE", "REVIEW_REQUIRED", "FORBIDDEN", "REJECTED", "UNCERTAIN", "NOT_VERIFIED"]>;
+export type GrantResolution = z.infer<typeof GrantResolution>;
 /**
  * Policy hierarchy의 하위 override가 아니라, Controller가 hierarchy 밖에서 생성하는
  * one-shot execution contract (OM §5.2). Session 권한은 그대로 두고 별도 Executor에게만
@@ -621,10 +636,40 @@ export declare const ExecutionGrant: z.ZodEffects<z.ZodObject<{
         baseline: string;
     }>, "many">>;
     threadLastEventId: z.ZodOptional<z.ZodString>;
+    /**
+     * 승인이 못 박은 사실 (0.8.0 §L).
+     *
+     * 가지 이름은 그대로인데 내용이 달라질 수 있다 — "이 브랜치를 올려" 는 승인 시점의
+     * 그 commit 에 대한 것이었다. 실행 직전 재검수가 이 값과 지금을 견주고, 다르면 나가지
+     * 않는다. 없는 경우도 있다(모든 행위가 SHA 를 갖지는 않는다) — 없으면 그 항목은 보지
+     * 않을 뿐, 없는 것을 맞다고 치지 않는다.
+     */
+    basis: z.ZodOptional<z.ZodObject<{
+        sourceSha: z.ZodOptional<z.ZodString>;
+        remoteBaseline: z.ZodOptional<z.ZodString>;
+        /** 이 결합이 가리키는 신원. 대상이 여기서 벗어나면 관리 범위 밖이다. */
+        resource: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        sourceSha?: string | undefined;
+        remoteBaseline?: string | undefined;
+        resource?: string | undefined;
+    }, {
+        sourceSha?: string | undefined;
+        remoteBaseline?: string | undefined;
+        resource?: string | undefined;
+    }>>;
     allowedWrites: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     claimedBy: z.ZodOptional<z.ZodString>;
     consumedAt: z.ZodOptional<z.ZodString>;
     resultRef: z.ZodOptional<z.ZodString>;
+    /**
+     * 어떻게 끝났는가 (0.8.0 보정 P0-5·P1-1). **새 상태가 아니라 이유다** — 상태는 그대로
+     * 다섯이고, 이 필드는 그 중 terminal 로 간 이유를 구조화해 남긴다.
+     *
+     * 소진된 것과 성공한 것을 가르는 자리이기도 하다: 밖으로 나갔지만 되돌려 읽은 것이
+     * 다르면 그 Grant 는 다시 쓸 수 없고(INVALIDATED), 동시에 성공도 아니다.
+     */
+    resolution: z.ZodOptional<z.ZodEnum<["DRIFT", "NOT_EXECUTABLE", "REVIEW_REQUIRED", "FORBIDDEN", "REJECTED", "UNCERTAIN", "NOT_VERIFIED"]>>;
 }, "strip", z.ZodTypeAny, {
     status: "READY" | "CLAIMED" | "EXECUTED" | "INVALIDATED" | "EXPIRED";
     snapshot: {
@@ -645,8 +690,14 @@ export declare const ExecutionGrant: z.ZodEffects<z.ZodObject<{
     resultRef?: string | undefined;
     requestId?: string | undefined;
     sessionId?: string | undefined;
+    basis?: {
+        sourceSha?: string | undefined;
+        remoteBaseline?: string | undefined;
+        resource?: string | undefined;
+    } | undefined;
     claimedBy?: string | undefined;
     consumedAt?: string | undefined;
+    resolution?: "DRIFT" | "NOT_EXECUTABLE" | "REVIEW_REQUIRED" | "FORBIDDEN" | "REJECTED" | "UNCERTAIN" | "NOT_VERIFIED" | undefined;
 }, {
     status: "READY" | "CLAIMED" | "EXECUTED" | "INVALIDATED" | "EXPIRED";
     id: string;
@@ -666,9 +717,15 @@ export declare const ExecutionGrant: z.ZodEffects<z.ZodObject<{
     requestId?: string | undefined;
     sessionId?: string | undefined;
     singleUse?: boolean | undefined;
+    basis?: {
+        sourceSha?: string | undefined;
+        remoteBaseline?: string | undefined;
+        resource?: string | undefined;
+    } | undefined;
     allowedWrites?: string[] | undefined;
     claimedBy?: string | undefined;
     consumedAt?: string | undefined;
+    resolution?: "DRIFT" | "NOT_EXECUTABLE" | "REVIEW_REQUIRED" | "FORBIDDEN" | "REJECTED" | "UNCERTAIN" | "NOT_VERIFIED" | undefined;
 }>, {
     status: "READY" | "CLAIMED" | "EXECUTED" | "INVALIDATED" | "EXPIRED";
     snapshot: {
@@ -689,8 +746,14 @@ export declare const ExecutionGrant: z.ZodEffects<z.ZodObject<{
     resultRef?: string | undefined;
     requestId?: string | undefined;
     sessionId?: string | undefined;
+    basis?: {
+        sourceSha?: string | undefined;
+        remoteBaseline?: string | undefined;
+        resource?: string | undefined;
+    } | undefined;
     claimedBy?: string | undefined;
     consumedAt?: string | undefined;
+    resolution?: "DRIFT" | "NOT_EXECUTABLE" | "REVIEW_REQUIRED" | "FORBIDDEN" | "REJECTED" | "UNCERTAIN" | "NOT_VERIFIED" | undefined;
 }, {
     status: "READY" | "CLAIMED" | "EXECUTED" | "INVALIDATED" | "EXPIRED";
     id: string;
@@ -710,9 +773,15 @@ export declare const ExecutionGrant: z.ZodEffects<z.ZodObject<{
     requestId?: string | undefined;
     sessionId?: string | undefined;
     singleUse?: boolean | undefined;
+    basis?: {
+        sourceSha?: string | undefined;
+        remoteBaseline?: string | undefined;
+        resource?: string | undefined;
+    } | undefined;
     allowedWrites?: string[] | undefined;
     claimedBy?: string | undefined;
     consumedAt?: string | undefined;
+    resolution?: "DRIFT" | "NOT_EXECUTABLE" | "REVIEW_REQUIRED" | "FORBIDDEN" | "REJECTED" | "UNCERTAIN" | "NOT_VERIFIED" | undefined;
 }>;
 export type ExecutionGrant = z.infer<typeof ExecutionGrant>;
 /** Phase B 처리 결과 — 부분 실패해도 cursor는 전진하고 실패분만 재시도한다 (OM §10.5). */

package/dist/core/model/entities.js

@@ -185,6 +185,28 @@ export const ApprovalDecision = z.object({
 // ── ExecutionGrant ──────────────────────────────────────────────────────────
 /** Grant lifecycle (OM §11.5). 성공한 Grant는 재소비 불가 — replay guard의 근간. */
 export const GrantStatus = z.enum(['READY', 'CLAIMED', 'EXECUTED', 'INVALIDATED', 'EXPIRED']);
+/**
+ * terminal 로 간 이유 (0.8.0 보정).
+ *
+ * ```text
+ * DRIFT           승인 근거가 움직였다 — 나가지 않았다
+ * NOT_EXECUTABLE  지금 성립하지 않는 행위다 — 나가지 않았다
+ * REVIEW_REQUIRED 사람이 봐야 하는 사실이 있다 — 나가지 않았다
+ * FORBIDDEN       계약이 허용하지 않는 행위다 — 나가지 않았다
+ * REJECTED        밖이 거절했다 — 나가지 않은 것이 확인됐다
+ * UNCERTAIN       나갔는지 모른다 — 다시 부르지 않는다
+ * NOT_VERIFIED    나갔는데 되돌려 읽은 것이 다르다 — 성공이 아니다
+ * ```
+ */
+export const GrantResolution = z.enum([
+    'DRIFT',
+    'NOT_EXECUTABLE',
+    'REVIEW_REQUIRED',
+    'FORBIDDEN',
+    'REJECTED',
+    'UNCERTAIN',
+    'NOT_VERIFIED',
+]);
 /**
  * Policy hierarchy의 하위 override가 아니라, Controller가 hierarchy 밖에서 생성하는
  * one-shot execution contract (OM §5.2). Session 권한은 그대로 두고 별도 Executor에게만
@@ -214,10 +236,34 @@ export const ExecutionGrant = z.object({
     /** 게시 직전 Drift Guard가 대조할 기준 (OM §11.9). */
     snapshot: z.array(CanonicalSnapshot).default([]),
     threadLastEventId: z.string().optional(),
+    /**
+     * 승인이 못 박은 사실 (0.8.0 §L).
+     *
+     * 가지 이름은 그대로인데 내용이 달라질 수 있다 — "이 브랜치를 올려" 는 승인 시점의
+     * 그 commit 에 대한 것이었다. 실행 직전 재검수가 이 값과 지금을 견주고, 다르면 나가지
+     * 않는다. 없는 경우도 있다(모든 행위가 SHA 를 갖지는 않는다) — 없으면 그 항목은 보지
+     * 않을 뿐, 없는 것을 맞다고 치지 않는다.
+     */
+    basis: z
+        .object({
+        sourceSha: z.string().optional(),
+        remoteBaseline: z.string().optional(),
+        /** 이 결합이 가리키는 신원. 대상이 여기서 벗어나면 관리 범위 밖이다. */
+        resource: z.string().optional(),
+    })
+        .optional(),
     allowedWrites: z.array(z.string()).default([]), // 명시된 것 외 모든 write 금지
     claimedBy: z.string().optional(),
     consumedAt: Timestamp.optional(),
     resultRef: z.string().optional(),
+    /**
+     * 어떻게 끝났는가 (0.8.0 보정 P0-5·P1-1). **새 상태가 아니라 이유다** — 상태는 그대로
+     * 다섯이고, 이 필드는 그 중 terminal 로 간 이유를 구조화해 남긴다.
+     *
+     * 소진된 것과 성공한 것을 가르는 자리이기도 하다: 밖으로 나갔지만 되돌려 읽은 것이
+     * 다르면 그 Grant 는 다시 쓸 수 없고(INVALIDATED), 동시에 성공도 아니다.
+     */
+    resolution: GrantResolution.optional(),
 })
     .refine((grant) => Boolean(grant.requestId) !== Boolean(grant.sessionId), {
     message: 'a grant stands on exactly one basis — an approved request or a session',

package/dist/core/model/transitions.d.ts

@@ -19,6 +19,6 @@ export declare function transitionSession(session: Session, to: Session['status'
 export declare const REQUEST_TRANSITIONS: readonly TransitionRule<ApprovalRequest['status']>[];
 export declare function transitionRequest(request: ApprovalRequest, to: ApprovalRequest['status'], actor: ActorRole, patch?: Partial<Pick<ApprovalRequest, 'decision' | 'resultRef'>>): ApprovalRequest;
 export declare const GRANT_TRANSITIONS: readonly TransitionRule<ExecutionGrant['status']>[];
-export declare function transitionGrant(grant: ExecutionGrant, to: ExecutionGrant['status'], actor: ActorRole, patch?: Partial<Pick<ExecutionGrant, 'claimedBy' | 'consumedAt' | 'resultRef'>>): ExecutionGrant;
+export declare function transitionGrant(grant: ExecutionGrant, to: ExecutionGrant['status'], actor: ActorRole, patch?: Partial<Pick<ExecutionGrant, 'claimedBy' | 'consumedAt' | 'resultRef' | 'resolution'>>): ExecutionGrant;
 export declare const EVENT_TRANSITIONS: readonly TransitionRule<MonitorEvent['processing']>[];
 export declare function transitionEvent(event: MonitorEvent, to: MonitorEvent['processing'], actor: ActorRole, patch?: Partial<Pick<MonitorEvent, 'requestId'>>): MonitorEvent;

package/dist/core/policy/execution-mode.d.ts

@@ -0,0 +1,136 @@
+import { z } from 'zod';
+import type { ScopedStore } from '../../ports/state-store.ts';
+/**
+ * MANUAL  ASC 가 작업·판단·기록을 관리하지만 외부 side effect 를 강제 라우팅하지 않는다.
+ *         사람과 Host 가 실행한다. Guard 는 아무것도 hard-block 하지 않는다.
+ * AUTO    ASC-managed Agent 가 자율 실행하고, 외부 write 는 승인된 실행 경로로만 나간다.
+ *         raw 외부 write 는 Guard 가 막는다.
+ *
+ * **어느 쪽도 HITL 을 바꾸지 않는다.** AUTO 가 사람의 결정을 대신 승인하지 않고,
+ * MANUAL 이 승인을 받은 것으로 만들지도 않는다 (H-03 · H-04).
+ */
+export declare const ExecutionMode: z.ZodEnum<["MANUAL", "AUTO"]>;
+export type ExecutionMode = z.infer<typeof ExecutionMode>;
+/** policy scope 안의 키. freeze 정책이 사는 그 자리다 — 새 저장소를 만들지 않는다. */
+export declare const EXECUTION_MODE_KEY = "execution-mode";
+export declare const ExecutionModeRecord: z.ZodObject<{
+    mode: z.ZodEnum<["MANUAL", "AUTO"]>;
+    /** 언제 정해졌는가. 기록이 없는 workspace 와 명시적으로 정한 workspace 를 가른다. */
+    since: z.ZodOptional<z.ZodString>;
+    /** 누가 정했는가. AUTO→MANUAL 은 Controller 권한이 필요하다 (§11). */
+    by: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    mode: "MANUAL" | "AUTO";
+    since?: string | undefined;
+    by?: string | undefined;
+}, {
+    mode: "MANUAL" | "AUTO";
+    since?: string | undefined;
+    by?: string | undefined;
+}>;
+export type ExecutionModeRecord = z.infer<typeof ExecutionModeRecord>;
+/** 기록이 있는데 읽지 못한 이유. **새 mode 값이 아니다** — 읽기의 결과일 뿐이다. */
+export type ModeStateProblem = 'MODE_STATE_UNREADABLE' | 'MODE_STATE_INVALID';
+/**
+ * 지금 이 workspace 의 실행 축.
+ *
+ * mode 는 여전히 MANUAL·AUTO 둘뿐이다. 달라진 것은 **모를 수 있다는 사실을 적는다**는 것:
+ *
+ * ```text
+ * 기록 없음            mode MANUAL · chosen false      아무도 고르지 않았다
+ * 기록 있음            mode 그대로 · chosen true       사람이 고른 값이다
+ * 기록 있는데 못 읽음   mode 없음   · degraded         AUTO 였을 수도 있다 — 모른다
+ * ```
+ *
+ * 마지막 자리를 MANUAL 로 적으면 그것이 fail-open 이다: 저장돼 있던 AUTO 가 파일 손상·
+ * 권한·I/O 하나로 조용히 풀린다. 그래서 `mode` 를 비워 두고, 호출자가 그 사실을 마주하게 한다.
+ */
+export type ExecutionModeState = {
+    mode?: ExecutionMode;
+    chosen: boolean;
+    since?: string;
+    by?: string;
+    degraded?: ModeStateProblem;
+};
+/**
+ * 이 상태에서 밖으로 나가는 raw 쓰기를 강제 경로로 돌릴 것인가.
+ *
+ * ```text
+ * ENFORCE  AUTO 이거나, 기록을 읽지 못했다 (모르는 것을 푸는 쪽으로 기울지 않는다)
+ * ADVISE   MANUAL 이거나, 아무도 고르지 않았다
+ * ```
+ *
+ * **ENFORCE 는 AUTO 라는 뜻이 아니다.** 읽지 못한 자리는 AUTO 라고 주장하지 않으면서도
+ * 열어 두지 않는다 — 그 둘은 다른 말이고, 화면은 그 차이를 그대로 보여 준다.
+ */
+export declare function enforcementOf(state: ExecutionModeState): 'ENFORCE' | 'ADVISE';
+/** 사람이 읽는 한 줄. 세 자리를 각각 다르게 말한다. */
+export declare function modeLine(state: ExecutionModeState): string;
+/**
+ * 기록이 없으면 AUTO 가 **아니다**.
+ *
+ * 처음에는 반대로 두었다: 0.7 workspace 가 말없이 보호를 잃지 않게 하려는 것이었다.
+ * 그 결정은 이 릴리스의 상위 계약과 충돌한다 — AUTO 는 사람이 고르고 readiness 를 통과한
+ * 결과로만 존재할 수 있고(E-01), 기록이 없다는 사실은 그 둘 중 어느 것도 증명하지 않는다.
+ * 기록 없이 AUTO 로 읽으면 readiness 를 한 번도 거치지 않은 enforcement 가 켜진다.
+ *
+ * 그래서 기록이 없는 workspace 는 hard enforcement 없이 돈다. ASC 가 꺼지는 것이 아니다 —
+ * 일 관리·결정권·검수·감사는 그대로 살아 있고, Guard 만 강제하지 않는다 (§F).
+ */
+export declare const DEFAULT_EXECUTION_MODE: ExecutionMode;
+/**
+ * 읽는다. **없는 것과 못 읽은 것을 가른다** (0.8.0 보정 P0-1).
+ *
+ * 없으면 아무도 고르지 않은 것이고, 못 읽으면 무엇이 저장돼 있었는지 모르는 것이다.
+ * 뒤엣것을 MANUAL 로 적는 순간 저장된 AUTO 가 파일 하나로 풀린다.
+ */
+export declare function readExecutionMode(scope: ScopedStore): Promise<ExecutionModeState>;
+export declare function writeExecutionMode(scope: ScopedStore, mode: ExecutionMode, by: string | undefined, now?: string): Promise<ExecutionModeRecord>;
+/**
+ * AUTO 를 켤 때 물어야 하는 것 — **셋이다.**
+ *
+ * 한때 아홉이었다. binding·provider·review·verify·controller 까지 activation 시점에
+ * 물었는데, 그것들은 행위마다 달라지는 사실이다: 어느 저장소로 가는지, 그 행위를 이
+ * 통로가 되돌려 읽을 수 있는지는 **그 행위를 할 때** 답할 질문이고, 실제로 CHECK 단계가
+ * 그것을 다시 묻는다. 같은 사실을 두 번 판정하면 둘이 갈릴 자리를 만드는 것이고,
+ * "AUTO 를 켜려면 미래의 모든 행위가 지금 가능해야 한다" 는 과장이 된다.
+ *
+ * 남은 셋은 activation 시점에만 답할 수 있는 것들이다:
+ *
+ * ```text
+ * executor       관리된 쓰기 경로가 조립되는가 — 없으면 AUTO 는 막기만 하는 mode 다
+ * guard          막을 것을 실제로 막을 수 있는가 — 없으면 AUTO 는 이름뿐이다
+ * control-plane  Host 안에서 ASC 명령이 도는가 — 없으면 나갈 문이 없다 (0.7.1 실측)
+ * ```
+ */
+export declare const READINESS_AXES: readonly ["executor", "guard", "control-plane"];
+export type ReadinessAxisName = (typeof READINESS_AXES)[number];
+/**
+ * READY            그대로 쓸 수 있다
+ * BLOCKED_BY_HOST  Host 정책이 막고 있다 — ASC 가 고칠 수 없는 자리다
+ * MISSING          아직 없다
+ * DEGRADED         있지만 지금 쓸 수 없다
+ * UNKNOWN          확인하지 못했다. 있다고도 없다고도 말하지 않는다
+ */
+export type AxisState = 'READY' | 'BLOCKED_BY_HOST' | 'MISSING' | 'DEGRADED' | 'UNKNOWN';
+export type ReadinessAxis = {
+    axis: ReadinessAxisName;
+    state: AxisState;
+    detail?: string;
+};
+export type AutoReadiness = {
+    ready: boolean;
+    axes: ReadinessAxis[];
+    /** AUTO 를 막는 축들. 순서는 §9 의 확인 순서 그대로다. */
+    blocking: ReadinessAxis[];
+};
+/**
+ * AUTO 를 켜도 되는가.
+ *
+ * 묻는 것은 하나다 — **AUTO 를 켠 뒤에도 일이 나갈 길과 사람이 나갈 길이 있는가.**
+ * 행위 하나하나가 지금 가능한지는 그 행위를 할 때 CHECK 가 답한다.
+ *
+ * READY 가 아닌 것은 전부 막는다. UNKNOWN 을 READY 로 뭉개면 그것이 곧 나갈 길 없는
+ * AUTO 로 들어가는 근거가 된다.
+ */
+export declare function judgeAutoReadiness(observed: readonly ReadinessAxis[]): AutoReadiness;

package/dist/core/policy/execution-mode.js

@@ -0,0 +1,127 @@
+// Execution Mode — 실행을 누가 하는가 (0.8.0 Axis C).
+//
+// 세 축은 서로를 대신하지 않는다:
+//
+//   Agent Management   누가 무엇을 맡았고 어디까지 왔는가   (Work / Session / Handoff)
+//   Decision Authority  이 판단은 사람의 것인가              (Inbox / Approval / Query)
+//   Execution Mode      결정된 행위를 누가 실행하는가        ← 이 파일
+//
+// 이 파일에는 mode 하나와 그 mode 로 갈 수 있는지를 판정하는 순수 함수만 있다.
+// state machine 도 approval entity 도 만들지 않는다 — mode 는 기존 policy 저장소의
+// 필드 하나이고, readiness 는 이미 관측되는 사실에서 파생한다.
+import { z } from 'zod';
+/**
+ * MANUAL  ASC 가 작업·판단·기록을 관리하지만 외부 side effect 를 강제 라우팅하지 않는다.
+ *         사람과 Host 가 실행한다. Guard 는 아무것도 hard-block 하지 않는다.
+ * AUTO    ASC-managed Agent 가 자율 실행하고, 외부 write 는 승인된 실행 경로로만 나간다.
+ *         raw 외부 write 는 Guard 가 막는다.
+ *
+ * **어느 쪽도 HITL 을 바꾸지 않는다.** AUTO 가 사람의 결정을 대신 승인하지 않고,
+ * MANUAL 이 승인을 받은 것으로 만들지도 않는다 (H-03 · H-04).
+ */
+export const ExecutionMode = z.enum(['MANUAL', 'AUTO']);
+/** policy scope 안의 키. freeze 정책이 사는 그 자리다 — 새 저장소를 만들지 않는다. */
+export const EXECUTION_MODE_KEY = 'execution-mode';
+export const ExecutionModeRecord = z.object({
+    mode: ExecutionMode,
+    /** 언제 정해졌는가. 기록이 없는 workspace 와 명시적으로 정한 workspace 를 가른다. */
+    since: z.string().optional(),
+    /** 누가 정했는가. AUTO→MANUAL 은 Controller 권한이 필요하다 (§11). */
+    by: z.string().optional(),
+});
+/**
+ * 이 상태에서 밖으로 나가는 raw 쓰기를 강제 경로로 돌릴 것인가.
+ *
+ * ```text
+ * ENFORCE  AUTO 이거나, 기록을 읽지 못했다 (모르는 것을 푸는 쪽으로 기울지 않는다)
+ * ADVISE   MANUAL 이거나, 아무도 고르지 않았다
+ * ```
+ *
+ * **ENFORCE 는 AUTO 라는 뜻이 아니다.** 읽지 못한 자리는 AUTO 라고 주장하지 않으면서도
+ * 열어 두지 않는다 — 그 둘은 다른 말이고, 화면은 그 차이를 그대로 보여 준다.
+ */
+export function enforcementOf(state) {
+    return state.degraded !== undefined || state.mode === 'AUTO' ? 'ENFORCE' : 'ADVISE';
+}
+/** 사람이 읽는 한 줄. 세 자리를 각각 다르게 말한다. */
+export function modeLine(state) {
+    if (state.degraded) {
+        return state.degraded === 'MODE_STATE_INVALID'
+            ? 'Execution Mode: unreadable — the stored record is not valid. Raw external writes stay blocked until it is fixed.'
+            : 'Execution Mode: unreadable — the stored record could not be read. Raw external writes stay blocked until it is fixed.';
+    }
+    return `Execution Mode: ${state.mode}${state.chosen ? '' : ' (never chosen — nothing is being enforced)'}`;
+}
+/**
+ * 기록이 없으면 AUTO 가 **아니다**.
+ *
+ * 처음에는 반대로 두었다: 0.7 workspace 가 말없이 보호를 잃지 않게 하려는 것이었다.
+ * 그 결정은 이 릴리스의 상위 계약과 충돌한다 — AUTO 는 사람이 고르고 readiness 를 통과한
+ * 결과로만 존재할 수 있고(E-01), 기록이 없다는 사실은 그 둘 중 어느 것도 증명하지 않는다.
+ * 기록 없이 AUTO 로 읽으면 readiness 를 한 번도 거치지 않은 enforcement 가 켜진다.
+ *
+ * 그래서 기록이 없는 workspace 는 hard enforcement 없이 돈다. ASC 가 꺼지는 것이 아니다 —
+ * 일 관리·결정권·검수·감사는 그대로 살아 있고, Guard 만 강제하지 않는다 (§F).
+ */
+export const DEFAULT_EXECUTION_MODE = 'MANUAL';
+/**
+ * 읽는다. **없는 것과 못 읽은 것을 가른다** (0.8.0 보정 P0-1).
+ *
+ * 없으면 아무도 고르지 않은 것이고, 못 읽으면 무엇이 저장돼 있었는지 모르는 것이다.
+ * 뒤엣것을 MANUAL 로 적는 순간 저장된 AUTO 가 파일 하나로 풀린다.
+ */
+export async function readExecutionMode(scope) {
+    let raw;
+    try {
+        raw = await scope.get(EXECUTION_MODE_KEY);
+    }
+    catch {
+        return { chosen: true, degraded: 'MODE_STATE_UNREADABLE' };
+    }
+    if (raw === null)
+        return { mode: DEFAULT_EXECUTION_MODE, chosen: false };
+    try {
+        return { ...ExecutionModeRecord.parse(JSON.parse(raw)), chosen: true };
+    }
+    catch {
+        return { chosen: true, degraded: 'MODE_STATE_INVALID' };
+    }
+}
+export async function writeExecutionMode(scope, mode, by, now = new Date().toISOString()) {
+    const record = ExecutionModeRecord.parse({ mode, since: now, ...(by ? { by } : {}) });
+    await scope.set(EXECUTION_MODE_KEY, JSON.stringify(record));
+    return record;
+}
+/**
+ * AUTO 를 켤 때 물어야 하는 것 — **셋이다.**
+ *
+ * 한때 아홉이었다. binding·provider·review·verify·controller 까지 activation 시점에
+ * 물었는데, 그것들은 행위마다 달라지는 사실이다: 어느 저장소로 가는지, 그 행위를 이
+ * 통로가 되돌려 읽을 수 있는지는 **그 행위를 할 때** 답할 질문이고, 실제로 CHECK 단계가
+ * 그것을 다시 묻는다. 같은 사실을 두 번 판정하면 둘이 갈릴 자리를 만드는 것이고,
+ * "AUTO 를 켜려면 미래의 모든 행위가 지금 가능해야 한다" 는 과장이 된다.
+ *
+ * 남은 셋은 activation 시점에만 답할 수 있는 것들이다:
+ *
+ * ```text
+ * executor       관리된 쓰기 경로가 조립되는가 — 없으면 AUTO 는 막기만 하는 mode 다
+ * guard          막을 것을 실제로 막을 수 있는가 — 없으면 AUTO 는 이름뿐이다
+ * control-plane  Host 안에서 ASC 명령이 도는가 — 없으면 나갈 문이 없다 (0.7.1 실측)
+ * ```
+ */
+export const READINESS_AXES = ['executor', 'guard', 'control-plane'];
+/**
+ * AUTO 를 켜도 되는가.
+ *
+ * 묻는 것은 하나다 — **AUTO 를 켠 뒤에도 일이 나갈 길과 사람이 나갈 길이 있는가.**
+ * 행위 하나하나가 지금 가능한지는 그 행위를 할 때 CHECK 가 답한다.
+ *
+ * READY 가 아닌 것은 전부 막는다. UNKNOWN 을 READY 로 뭉개면 그것이 곧 나갈 길 없는
+ * AUTO 로 들어가는 근거가 된다.
+ */
+export function judgeAutoReadiness(observed) {
+    const order = new Map(READINESS_AXES.map((axis, index) => [axis, index]));
+    const axes = [...observed].sort((a, b) => (order.get(a.axis) ?? 99) - (order.get(b.axis) ?? 99));
+    const blocking = axes.filter((axis) => axis.state !== 'READY');
+    return { ready: blocking.length === 0, axes, blocking };
+}

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

@@ -30,8 +30,8 @@ export declare const FreezePolicy: z.ZodObject<{
     since?: string | undefined;
 }, {
     reason?: string | undefined;
-    frozen?: boolean | undefined;
     since?: string | undefined;
+    frozen?: boolean | undefined;
     denyRemoteRead?: boolean | undefined;
 }>;
 export type FreezePolicy = z.infer<typeof FreezePolicy>;
@@ -48,8 +48,8 @@ export declare const DeferredAction: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     id: string;
     action: "remote.read" | "remote.write" | "local.inspect" | "local.implement" | "local.test";
-    intent: string;
     basis: string[];
+    intent: string;
     deferredAt: string;
     grantRef?: string | undefined;
 }, {