@asc-agent/runtime 0.6.1 → 0.7.0

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

@@ -1,4 +1,4 @@
-import { ExecutionGrant } from '../model/entities.ts';
+import { ExecutionGrant, type CanonicalSnapshot } from '../model/entities.ts';
 import type { IdentityBinding } from '../../ports/approval.ts';
 import type { StateStore } from '../../ports/state-store.ts';
 export type IssueGrantInput = {
@@ -16,6 +16,34 @@ export type IssueGrantInput = {
     allowedWrites?: string[];
     issuedAt: string;
 };
+/**
+ * 세션이 만든 결과를 내보내는 경우의 입력 (0.7.0).
+ *
+ * 초기 모델에는 이 자리가 없었다. Grant 는 `Monitor → Request → Approval` 을 위해
+ * 생겼고, 정작 **계약 안에서 일한 세션이 만든 결과**가 밖으로 나갈 자리는 없었다.
+ * 그래서 실제 작업은 관계없는 판단 요청을 하나 지어내 그 위에 얹혀야 했고, 지어낸
+ * 요청은 승인 기록을 흐린다.
+ *
+ * 여기서 승인은 **사람이 지금 그렇게 하라고 말한 것**이다. 그 말과 함께 온 내용이
+ * payload 이고, 호출자가 지어내지 않는다. 범위는 넓히지 않는다 — 승인된 것은 이
+ * 행위 하나이며 `allowedWrites` 가 그 경계다.
+ */
+export type IssueForSessionInput = {
+    grantId: string;
+    sessionId: string;
+    /** 발급자. 승인 권한자로 매핑돼 있어야 한다 — 임의 문자열로는 발급되지 않는다. */
+    issuedBy: string;
+    channel: string;
+    action: string;
+    target: string;
+    /** 사람이 내보내라고 한 내용 그대로. */
+    payload: string;
+    expiresAt?: string;
+    allowedWrites?: string[];
+    issuedAt: string;
+    /** 게시 직전 대조할 기준 (OM §11.9). 없으면 대조하지 않는다. */
+    snapshot?: CanonicalSnapshot[];
+};
 export type IssueFailure = {
     kind: 'REQUEST_NOT_FOUND';
 } | {
@@ -27,6 +55,13 @@ export type IssueFailure = {
     kind: 'NO_PAYLOAD';
 } | {
     kind: 'GRANT_EXISTS';
+} | {
+    kind: 'SESSION_NOT_FOUND';
+}
+/** 아직 일하지 않은 세션의 결과는 없다. */
+ | {
+    kind: 'SESSION_NOT_RUNNABLE';
+    status: string;
 };
 export type IssueResult = {
     ok: true;
@@ -39,4 +74,12 @@ export declare class GrantService {
     #private;
     constructor(store: StateStore, identity: IdentityBinding);
     issue(input: IssueGrantInput): Promise<IssueResult>;
+    /**
+     * 세션이 만든 결과를 내보낼 계약. 근거는 그 세션이고, 승인은 사람이 지금 한 말이다.
+     *
+     * 검증은 두 가지다: 그 세션이 실제로 있고 일한 적이 있는가, 그리고 이 사람이 승인
+     * 권한자인가. 뒤엣것은 요청 경로와 같은 통로를 쓴다 — 발급이 열려 있으면 승인 이후
+     * 구간이 통째로 무방비가 되고, 그것은 근거가 요청이든 세션이든 같다.
+     */
+    issueForSession(input: IssueForSessionInput): Promise<IssueResult>;
 }

package/dist/core/execution/grant.js

@@ -75,4 +75,63 @@ export class GrantService {
         });
         return { ok: true, grant: created.entity };
     }
+    /**
+     * 세션이 만든 결과를 내보낼 계약. 근거는 그 세션이고, 승인은 사람이 지금 한 말이다.
+     *
+     * 검증은 두 가지다: 그 세션이 실제로 있고 일한 적이 있는가, 그리고 이 사람이 승인
+     * 권한자인가. 뒤엣것은 요청 경로와 같은 통로를 쓴다 — 발급이 열려 있으면 승인 이후
+     * 구간이 통째로 무방비가 되고, 그것은 근거가 요청이든 세션이든 같다.
+     */
+    async issueForSession(input) {
+        const session = await this.#store.get('session', input.sessionId);
+        if (!session)
+            return { ok: false, failure: { kind: 'SESSION_NOT_FOUND' } };
+        // 아직 시작하지 않은 계약에는 내보낼 결과가 없다.
+        if (session.status === 'READY') {
+            return { ok: false, failure: { kind: 'SESSION_NOT_RUNNABLE', status: session.status } };
+        }
+        if (input.payload.length === 0)
+            return { ok: false, failure: { kind: 'NO_PAYLOAD' } };
+        const authorized = await this.#identity.verify({
+            channel: input.channel,
+            actor: input.issuedBy,
+            authorizedApprover: input.issuedBy,
+        });
+        if (!authorized) {
+            await this.#store.appendHistory({
+                at: input.issuedAt,
+                actor: input.issuedBy,
+                kind: 'grant_rejected',
+                ref: input.sessionId,
+                detail: `unauthorized issuer via ${input.channel} (${input.action})`,
+            });
+            return { ok: false, failure: { kind: 'FORBIDDEN_ISSUER' } };
+        }
+        const grant = ExecutionGrant.parse({
+            id: input.grantId,
+            version: 0,
+            sessionId: session.id,
+            status: 'READY',
+            issuedBy: input.issuedBy,
+            issuedAt: input.issuedAt,
+            ...(input.expiresAt !== undefined ? { expiresAt: input.expiresAt } : {}),
+            singleUse: true,
+            action: input.action,
+            target: input.target,
+            payload: input.payload,
+            snapshot: input.snapshot ?? [],
+            allowedWrites: input.allowedWrites ?? [input.action],
+        });
+        const created = await this.#store.create('grant', grant);
+        if (!created.ok)
+            return { ok: false, failure: { kind: 'GRANT_EXISTS' } };
+        await this.#store.appendHistory({
+            at: input.issuedAt,
+            actor: input.issuedBy,
+            kind: 'grant_issued',
+            ref: grant.id,
+            detail: `${grant.action} → ${grant.target} (session ${session.id})`,
+        });
+        return { ok: true, grant: created.entity };
+    }
 }

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

@@ -588,10 +588,19 @@ export type GrantStatus = z.infer<typeof GrantStatus>;
  * one-shot execution contract (OM §5.2). Session 권한은 그대로 두고 별도 Executor에게만
  * 단일 Action을 허용한다.
  */
-export declare const ExecutionGrant: z.ZodObject<{
+export declare const ExecutionGrant: z.ZodEffects<z.ZodObject<{
     id: z.ZodString;
     version: z.ZodNumber;
-    requestId: z.ZodString;
+    /**
+     * 이 계약의 근거. **둘 중 하나는 반드시 있다.**
+     *
+     * `requestId` 는 밖에서 들어온 판단 요청을 사람이 승인한 경우다 (OM §11.8 의 경로).
+     * `sessionId` 는 계약 안에서 일한 세션이 만든 결과를 사람이 내보내라고 한 경우다 —
+     * 초기 모델에는 이 자리가 없었고, 그래서 실제 작업이 밖으로 나갈 때마다 관계없는
+     * 판단 요청을 하나 지어내야 했다. 지어낸 요청은 승인 기록을 흐린다.
+     */
+    requestId: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodOptional<z.ZodString>;
     status: z.ZodEnum<["READY", "CLAIMED", "EXECUTED", "INVALIDATED", "EXPIRED"]>;
     issuedBy: z.ZodString;
     issuedAt: z.ZodString;
@@ -624,7 +633,6 @@ export declare const ExecutionGrant: z.ZodObject<{
     }[];
     id: string;
     version: number;
-    requestId: string;
     issuedBy: string;
     issuedAt: string;
     singleUse: boolean;
@@ -635,13 +643,14 @@ export declare const ExecutionGrant: z.ZodObject<{
     threadLastEventId?: string | undefined;
     expiresAt?: string | undefined;
     resultRef?: string | undefined;
+    requestId?: string | undefined;
+    sessionId?: string | undefined;
     claimedBy?: string | undefined;
     consumedAt?: string | undefined;
 }, {
     status: "READY" | "CLAIMED" | "EXECUTED" | "INVALIDATED" | "EXPIRED";
     id: string;
     version: number;
-    requestId: string;
     issuedBy: string;
     issuedAt: string;
     action: string;
@@ -654,41 +663,58 @@ export declare const ExecutionGrant: z.ZodObject<{
     threadLastEventId?: string | undefined;
     expiresAt?: string | undefined;
     resultRef?: string | undefined;
+    requestId?: string | undefined;
+    sessionId?: string | undefined;
     singleUse?: boolean | undefined;
     allowedWrites?: string[] | undefined;
     claimedBy?: string | undefined;
     consumedAt?: string | undefined;
-}>;
-export type ExecutionGrant = z.infer<typeof ExecutionGrant>;
-export declare const QueueState: z.ZodEnum<["READY", "ACTIVE", "BLOCKED", "DONE"]>;
-export type QueueState = z.infer<typeof QueueState>;
-/** 승인되어 수행하기로 한 작업 (OM §4.8). inbox = 판단 대기, queue = 승인된 작업. */
-export declare const QueueItem: z.ZodObject<{
-    id: z.ZodString;
-    version: z.ZodNumber;
-    state: z.ZodEnum<["READY", "ACTIVE", "BLOCKED", "DONE"]>;
-    title: z.ZodString;
-    sourceRequestId: z.ZodOptional<z.ZodString>;
-    blockId: z.ZodOptional<z.ZodString>;
-    sessionId: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
+}>, {
+    status: "READY" | "CLAIMED" | "EXECUTED" | "INVALIDATED" | "EXPIRED";
+    snapshot: {
+        sourceId: string;
+        baseline: string;
+    }[];
     id: string;
     version: number;
-    title: string;
-    state: "READY" | "ACTIVE" | "BLOCKED" | "DONE";
-    blockId?: string | undefined;
-    sourceRequestId?: string | undefined;
+    issuedBy: string;
+    issuedAt: string;
+    singleUse: boolean;
+    action: string;
+    target: string;
+    payload: string;
+    allowedWrites: string[];
+    threadLastEventId?: string | undefined;
+    expiresAt?: string | undefined;
+    resultRef?: string | undefined;
+    requestId?: string | undefined;
     sessionId?: string | undefined;
+    claimedBy?: string | undefined;
+    consumedAt?: string | undefined;
 }, {
+    status: "READY" | "CLAIMED" | "EXECUTED" | "INVALIDATED" | "EXPIRED";
     id: string;
     version: number;
-    title: string;
-    state: "READY" | "ACTIVE" | "BLOCKED" | "DONE";
-    blockId?: string | undefined;
-    sourceRequestId?: string | undefined;
+    issuedBy: string;
+    issuedAt: string;
+    action: string;
+    target: string;
+    payload: string;
+    snapshot?: {
+        sourceId: string;
+        baseline: string;
+    }[] | undefined;
+    threadLastEventId?: string | undefined;
+    expiresAt?: string | undefined;
+    resultRef?: string | undefined;
+    requestId?: string | undefined;
     sessionId?: string | undefined;
+    singleUse?: boolean | undefined;
+    allowedWrites?: string[] | undefined;
+    claimedBy?: string | undefined;
+    consumedAt?: string | undefined;
 }>;
-export type QueueItem = z.infer<typeof QueueItem>;
+export type ExecutionGrant = z.infer<typeof ExecutionGrant>;
 /** Phase B 처리 결과 — 부분 실패해도 cursor는 전진하고 실패분만 재시도한다 (OM §10.5). */
 export declare const EventProcessing: z.ZodEnum<["LOGGED", "PROCESSED", "PENDING_RETRY"]>;
 export type EventProcessing = z.infer<typeof EventProcessing>;

package/dist/core/model/entities.js

@@ -2,7 +2,7 @@
 // Core Contract다 — State Store Adapter는 이걸 저장 방식으로 투영할 뿐이다 (OM §7.0).
 // 스키마가 곧 타입의 정본이며 (z.infer로 타입 도출) 이중 정본을 두지 않는다.
 import { z } from 'zod';
-import { BlockId, EventKey, GrantId, QueueItemId, RequestId, SessionId, Timestamp, Version } from "./ids.js";
+import { BlockId, EventKey, GrantId, RequestId, SessionId, Timestamp, Version } from "./ids.js";
 // ── 공통 ────────────────────────────────────────────────────────────────────
 /** 전이를 수행할 수 있는 주체. Writer 규칙(OM §7.2)과 상태 전이 권한의 기준. */
 export const ActorRole = z.enum(['controller', 'monitor', 'executor', 'session']);
@@ -193,7 +193,16 @@ export const GrantStatus = z.enum(['READY', 'CLAIMED', 'EXECUTED', 'INVALIDATED'
 export const ExecutionGrant = z.object({
     id: GrantId,
     version: Version,
-    requestId: RequestId,
+    /**
+     * 이 계약의 근거. **둘 중 하나는 반드시 있다.**
+     *
+     * `requestId` 는 밖에서 들어온 판단 요청을 사람이 승인한 경우다 (OM §11.8 의 경로).
+     * `sessionId` 는 계약 안에서 일한 세션이 만든 결과를 사람이 내보내라고 한 경우다 —
+     * 초기 모델에는 이 자리가 없었고, 그래서 실제 작업이 밖으로 나갈 때마다 관계없는
+     * 판단 요청을 하나 지어내야 했다. 지어낸 요청은 승인 기록을 흐린다.
+     */
+    requestId: RequestId.optional(),
+    sessionId: SessionId.optional(),
     status: GrantStatus,
     issuedBy: z.string().min(1),
     issuedAt: Timestamp,
@@ -209,19 +218,17 @@ export const ExecutionGrant = z.object({
     claimedBy: z.string().optional(),
     consumedAt: Timestamp.optional(),
     resultRef: z.string().optional(),
+})
+    .refine((grant) => Boolean(grant.requestId) !== Boolean(grant.sessionId), {
+    message: 'a grant stands on exactly one basis — an approved request or a session',
 });
-// ── QueueItem / MonitorEvent / State ────────────────────────────────────────
-export const QueueState = z.enum(['READY', 'ACTIVE', 'BLOCKED', 'DONE']);
-/** 승인되어 수행하기로 한 작업 (OM §4.8). inbox = 판단 대기, queue = 승인된 작업. */
-export const QueueItem = z.object({
-    id: QueueItemId,
-    version: Version,
-    state: QueueState,
-    title: z.string().min(1),
-    sourceRequestId: RequestId.optional(),
-    blockId: BlockId.optional(),
-    sessionId: SessionId.optional(),
-});
+// ── MonitorEvent / State ────────────────────────────────────────────────────
+//
+// 여기 있던 `QueueItem` 은 0.7.0 에서 지웠다. OM §1 원칙 10 이 나눈 "승인된 작업" 의
+// 자리는 지금 `ApprovalRequest.QUEUED` 와 `asc proceed` 가 나눠 진다 — 전자가 사람이
+// 하기로 한 사실을 들고, 후자가 그것을 세션으로 만든다. QueueItem 은 schema·layout·
+// serializer 만 있고 만드는 코드도 읽는 코드도 없는 채 남아 있었고, 같은 사실을 두 곳에
+// 두는 자리는 언젠가 갈린다.
 /** Phase B 처리 결과 — 부분 실패해도 cursor는 전진하고 실패분만 재시도한다 (OM §10.5). */
 export const EventProcessing = z.enum(['LOGGED', 'PROCESSED', 'PENDING_RETRY']);
 export const MonitorEvent = z.object({

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

@@ -1,4 +1,4 @@
-import type { ActorRole, ApprovalRequest, ExecutionGrant, MonitorEvent, QueueItem, Session } from './entities.ts';
+import type { ActorRole, ApprovalRequest, ExecutionGrant, MonitorEvent, Session } from './entities.ts';
 export type TransitionRule<S extends string> = {
     from: S;
     to: S;
@@ -20,7 +20,5 @@ export declare const REQUEST_TRANSITIONS: readonly TransitionRule<ApprovalReques
 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 const QUEUE_TRANSITIONS: readonly TransitionRule<QueueItem['state']>[];
-export declare function transitionQueueItem(item: QueueItem, to: QueueItem['state'], actor: ActorRole, patch?: Partial<Pick<QueueItem, 'sessionId' | 'blockId'>>): QueueItem;
 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/model/transitions.js

@@ -96,19 +96,6 @@ export function transitionGrant(grant, to, actor, patch = {}) {
     }
     return next;
 }
-// ── QueueItem (OM §4.8) — Controller ONLY ───────────────────────────────────
-export const QUEUE_TRANSITIONS = [
-    { from: 'READY', to: 'ACTIVE', actors: ['controller'] },
-    { from: 'READY', to: 'BLOCKED', actors: ['controller'] },
-    { from: 'ACTIVE', to: 'BLOCKED', actors: ['controller'] },
-    { from: 'ACTIVE', to: 'DONE', actors: ['controller'] },
-    { from: 'BLOCKED', to: 'READY', actors: ['controller'] },
-    { from: 'BLOCKED', to: 'ACTIVE', actors: ['controller'] },
-];
-export function transitionQueueItem(item, to, actor, patch = {}) {
-    resolve(QUEUE_TRANSITIONS, item.state, to, actor);
-    return { ...item, ...patch, state: to, version: item.version + 1 };
-}
 // ── MonitorEvent (OM §10.5) ─────────────────────────────────────────────────
 // Phase B 실패는 그 이벤트만 PENDING_RETRY로 남는다 — cursor는 전진하고 다음 Run이
 // 실패분만 재시도한다.

package/dist/core/operator/local-operator.js

@@ -7,7 +7,15 @@
 // 별도 경로(B-06)로 나간다 — Agent가 조회하다가 이어서 승인해버릴 수 있는 문을 만들지 않는다 (C-01 §5).
 import { assembleView, assess, buildOverlay, summarize } from "../view/build-view.js";
 /** 아직 사람의 판단을 기다리는 상태. 목록의 기본 필터다. */
-const PENDING = new Set(['AWAITING_APPROVAL', 'APPROVED']);
+/**
+ * 아직 사람의 손을 떠나지 않은 것들.
+ *
+ * `QUEUED` 가 여기 있는 이유 (0.7.0 / Phase L): 그것은 **승인된 작업**이다. 사람이
+ * "하자" 고 정했고 아직 실행되지 않았다. 그런데 목록에서 빠져 있어서, `queue` 로 결정한
+ * 순간 그 항목이 화면에서 사라졌다 — 사람이 방금 하기로 한 일이 어디에도 보이지 않는다.
+ * OM §1 원칙 10 이 Inbox 와 Queue 를 나눈 것은 그것을 잃지 않기 위해서였다.
+ */
+const PENDING = new Set(['AWAITING_APPROVAL', 'APPROVED', 'QUEUED']);
 export class LocalOperator {
     #store;
     #scm;

package/dist/core/operator/proceed.js

@@ -250,11 +250,21 @@ function handout(session) {
         ...(session.checkpoint ? { checkpoint: session.checkpoint } : {}),
     };
 }
-/** 세션을 내지 않을 때, 대신 무엇을 하면 되는가. 실행하지 않고 말만 한다. */
+/**
+ * 세션을 내지 않을 때, 대신 무엇을 하면 되는가. 실행하지 않고 말만 한다.
+ *
+ * **행동은 결론보다, 결론은 증거보다 강할 수 없다** (0.7.0 / C-4). 판정이 기울기만
+ * 남겼는데 행동을 확정형으로 적으면, 못 본 것이 있다고 적어 놓고 "할 일은 이것뿐" 이라고
+ * 말하는 결과가 된다 — 사람은 뒤 문장을 읽는다.
+ */
 function nextActionFor(result, workRef) {
-    switch (result.state === 'DECIDABLE_WITH_LIMITATION' ? (result.leaning ?? 'UNDECIDABLE') : result.state) {
+    const tentative = result.state === 'DECIDABLE_WITH_LIMITATION';
+    switch (tentative ? (result.leaning ?? 'UNDECIDABLE') : result.state) {
         case 'IMPLEMENTED_STALE_TRACKER':
-            return `구현은 정본에 있다 — 할 일은 구현이 아니라 ${workRef} 상태 정리다. 추적 시스템 반영은 외부 쓰기이므로 승인 경로(Grant)를 지난다`;
+            return tentative
+                ? `구현이 정본에 있는 것으로 보인다. 다만 확인하지 못한 것이 있다 — ${result.limitations.join(' / ')}. ` +
+                    `그것부터 확인하고, 그 뒤에도 남는 것이 상태뿐이면 ${workRef} 상태 정리로 간다`
+                : `구현은 정본에 있다 — 할 일은 구현이 아니라 ${workRef} 상태 정리다. 추적 시스템 반영은 외부 쓰기이므로 승인 경로(Grant)를 지난다`;
         case 'IMPLEMENTATION_COMPLETE_BLOCKED_VERIFICATION':
             return '구현은 끝났고 검증이 막혀 있다 — 막힌 것을 먼저 풀어라. 새 구현 세션은 필요 없다';
         case 'BLOCKED_DEPENDENCY':

package/dist/core/operator/work-state.js

@@ -50,7 +50,16 @@ export function judgeWorkState(input) {
     // 언급은 그 자체로 증거가 아니다. 되돌리기만 있는 이력도 이 작업을 "언급"하고, 뒤이어
     // 걷혀 나간 변경도 그렇다. 살아남은 것이 있어야 정본에 있다고 말할 수 있다.
     const mentionSurvives = mentioned.length > 0 && repo.mentionedOnlyReverts !== true && repo.mentionedArtifactsPresent === true;
-    const directEvidence = repo.mergedIntoCanonical === true || onCanonical.length > 0 || repo.contentEquivalent === true;
+    // **파일이 있다는 것은 이 요구가 구현됐다는 뜻이 아니다** (0.7.0 / D-01).
+    //
+    // 경로는 작업 항목 본문에서 뽑아 온다. 그런데 그 경로가 가리키는 파일은 대개 이미
+    // 있던 것이고, 이번 요구는 그 **안에** 무언가를 더하는 일이다. 실측에서 그 구분이
+    // 없어 "WorldHud.tsx 가 정본에 있다" 가 "요구 4항이 구현됐다" 로 읽혔고, 아직 한 줄도
+    // 쓰지 않은 작업에 "구현하지 말고 tracker 만 정리하라" 는 추천이 나갔다.
+    //
+    // 그래서 경로 존재는 **보강 증거**다 — 정본이 이 작업의 변경을 실제로 담고 있다는 것을
+    // 다른 근거가 말할 때 그 옆에 선다. 혼자서는 아무 결론도 만들지 않는다.
+    const directEvidence = repo.mergedIntoCanonical === true || repo.contentEquivalent === true;
     const merged = directEvidence || mentionSurvives;
     const hasBranch = repo.refs.length > 0;
     const artifacts = Object.entries(repo.pathsExist).filter(([, exists]) => exists);
@@ -63,10 +72,12 @@ export function judgeWorkState(input) {
     if (repo.contentEquivalent === true) {
         evidence.push('작업 가지의 내용이 전부 정본에 반영돼 있다 (조상은 아니다 — rebase·squash 등가)');
     }
-    if (onCanonical.length > 0)
-        evidence.push(`정본에 산출물이 있다: ${onCanonical.map(([p]) => p).join(', ')}`);
-    if (artifacts.length > 0)
-        evidence.push(`작업 트리 산출물: ${artifacts.map(([p]) => p).join(', ')}`);
+    if (onCanonical.length > 0) {
+        evidence.push(`정본에 관련 파일이 있다: ${onCanonical.map(([p]) => p).join(', ')} (그 파일이 있다는 사실이지, 이 요구가 반영됐다는 증거는 아니다)`);
+    }
+    if (artifacts.length > 0) {
+        evidence.push(`작업 트리에 관련 파일이 있다: ${artifacts.map(([p]) => p).join(', ')}`);
+    }
     if (mentioned.length > 0)
         evidence.push(`정본 이력이 이 작업을 언급한다: ${mentioned.join(' / ')}`);
     if (repo.mentionedOnlyReverts === true) {
@@ -89,10 +100,14 @@ export function judgeWorkState(input) {
     if (unknownDependencies.length > 0) {
         limitations.push(`선행 작업 상태를 확인하지 못했다: ${unknownDependencies.map((d) => d.reference).join(', ')}`);
     }
-    const implemented = merged || artifacts.length > 0;
+    // 구현이 있다고 말할 수 있는 근거는 정본이 이 작업의 변경을 담고 있다는 것뿐이다.
+    // 파일의 존재(정본이든 작업 트리든)는 여기 들어오지 않는다 — 위 주석의 이유다.
+    const implemented = merged;
+    // 파일이 있다는 사실은 등급에도 들어가지 않는다 — 구현 증거가 아닌 것을 약한 구현
+    // 증거로 세면 결국 같은 오판이 한 칸 낮은 자리에서 다시 난다.
     const evidenceGrade = directEvidence
         ? 'direct'
-        : mentionSurvives || artifacts.length > 0
+        : mentionSurvives
             ? 'proxy'
             : 'none';
     // ① 구현은 정본에 있는데 tracker 가 안 따라왔다. 여기서만 tracker 를 본다 — 그것도
@@ -101,26 +116,34 @@ export function judgeWorkState(input) {
     //    되돌리기를 가려낼 수 없다. 확인하지 못했으면 확정하지 않는다.
     //    가지가 정본의 조상이라는 것은 그 커밋들이 지금 정본 이력에 그대로 있다는 뜻이라
     //    그 자체가 생존 증거다. 언급(grep)만 있는 경우와 다르다.
-    const artifactSurvives = repo.mergedIntoCanonical === true || onCanonical.length > 0 || repo.mentionedArtifactsPresent === true;
+    const artifactSurvives = repo.mergedIntoCanonical === true || repo.mentionedArtifactsPresent === true;
     if (merged && input.trackerDone === false && artifactSurvives && repo.mentionedOnlyReverts !== true) {
-        limitations.push('인수 조건 전체가 지금도 충족되는지는 확인하지 않았다 — 여기서 말하는 것은 구현의 생존까지다');
+        // **이 결론이 시키는 일은 "구현하지 말고 상태만 정리하라" 다.** 그러니 근거도 그만큼
+        // 무거워야 한다 (0.7.0 / C-4). 구현이 정본에 살아 있다는 것까지는 위에서 봤고,
+        // 남은 질문은 하나다 — 그 구현이 **받아들여졌는가**.
+        //
+        // 팀에 따라 코드가 정본에 있어도 tracker 를 일부러 열어 둔다(실 acceptance 가 남아서).
+        // 그런 자리에 "상태 정리만 하면 된다" 고 말하면 규약을 어기게 만든다. 그래서 검토가
+        // 끝났다고 말해 주는 근거가 없으면 확정하지 않고 기울기만 남긴다.
+        const accepted = acceptedByReview(input.change);
+        if (!accepted) {
+            limitations.push('구현이 받아들여졌는지 확인하지 못했다 — 인수가 남아 있다면 지금 할 일은 상태 정리가 아니다');
+        }
         // 측정된 반증은 언급-생존보다 무겁다: cherry 가 "가지에 정본 미반영 커밋이 남아
         // 있다"고 말했으면, 언급 grep 만으로 "할 일은 상태 정리"를 확정하지 않는다.
         if (repo.contentEquivalent === false) {
             limitations.push('작업 가지에 정본에 반영되지 않은 커밋이 남아 있다 (patch 대조) — 상태 정리만 남았다고 확정하지 않는다');
             return decided('IMPLEMENTED_STALE_TRACKER', evidence, limitations, { demote: true, grade: evidenceGrade });
         }
-        return decided('IMPLEMENTED_STALE_TRACKER', evidence, limitations, { demote: false, grade: evidenceGrade });
+        if (accepted)
+            evidence.push(`검토가 끝났다고 표시돼 있다: ${accepted}`);
+        return decided('IMPLEMENTED_STALE_TRACKER', evidence, limitations, { demote: !accepted, grade: evidenceGrade });
     }
     if (merged && input.trackerDone === false) {
         // 병합 흔적은 있는데 생존을 확인하지 못했다 — 새 구현을 시키지도, 끝났다고 하지도 않는다.
         limitations.push('정본에 병합 흔적은 있으나 구현이 지금도 남아 있는지 확인하지 못했다');
         return decided('IMPLEMENTATION_COMPLETE_BLOCKED_VERIFICATION', evidence, limitations, { demote: true, grade: evidenceGrade });
     }
-    // ② 구현 증거는 있는데 남은 검증 경로가 막혔다.
-    if (implemented && input.change === 'UNAVAILABLE' && !merged) {
-        return decided('IMPLEMENTATION_COMPLETE_BLOCKED_VERIFICATION', evidence, limitations, { demote: true, grade: evidenceGrade });
-    }
     // ③ 가지는 있는데 병합 전이고 선행 작업이 열려 있다.
     if (hasBranch && !merged && openDependencies.length > 0) {
         return decided('BLOCKED_DEPENDENCY', evidence, limitations, { demote: false, grade: evidenceGrade });
@@ -153,6 +176,21 @@ export function judgeWorkState(input) {
     // 구현 증거는 있는데 위 어디에도 안 걸린다 — 남은 것은 검증이고, 무엇이 막혔는지는 모른다.
     return decided('IMPLEMENTATION_COMPLETE_BLOCKED_VERIFICATION', evidence, limitations, { demote: true, grade: evidenceGrade });
 }
+/**
+ * 검토가 끝났다고 말해 주는 표시가 있는가. 있으면 그 표시를 그대로 돌려준다.
+ *
+ * provider 어휘를 Core 가 읽는 자리는 최소로 둔다 — `requestsResponse` 가 이미 같은
+ * 방식으로 두 낱말을 보고 있고, 여기서 보는 것도 두 낱말뿐이다. 모르면 `null` 이며,
+ * 모른다는 것이 "받아들여졌다" 로 읽히지 않는 것이 이 함수의 요점이다.
+ */
+function acceptedByReview(change) {
+    if (!change || change === 'UNAVAILABLE' || change.missing)
+        return null;
+    const state = change.reviewState?.toUpperCase() ?? '';
+    if (state.includes('APPROVED') || state.includes('MERGED'))
+        return change.reviewState;
+    return null;
+}
 /** 검토가 응답을 요구하는가. provider 어휘를 해석하지 않고 두 가지 표시만 본다. */
 function requestsResponse(change, comments) {
     const state = change.reviewState?.toUpperCase() ?? '';

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

@@ -4,6 +4,18 @@ import type { TickKind } from './orchestrator.ts';
 export declare const RUNTIME_LEASE_KEY = "runtime-lease";
 /** 마지막 회차 시각이 사는 열쇠. Orchestrator가 쓰고 status가 읽는다. */
 export declare const LAST_RUN_KEY = "last-run";
+/**
+ * 마지막 기계 회차가 이 workspace 에서 **어떻게 끝났는가** (0.7.0 / Phase J).
+ *
+ * 실측 하나가 이 열쇠의 출처다. 이 기계의 workspace 세 개 중 둘이 여러 릴리스 동안
+ * 회차를 한 번도 통과하지 못했는데, 화면 어디에도 그 말이 없었다 — 붙어 있고, 등록물도
+ * 서 있고, 그래서 건강해 보였다. 실패는 `service.log` 에만 흘러갔고 아무도 그것을 읽지
+ * 않는다.
+ *
+ * 새 상태 저장소가 아니다. 이미 회차가 쓰고 status 가 읽는 같은 scope 의 기록 하나이며,
+ * 판정도 하지 않는다 — 무슨 일이 있었는지만 적는다.
+ */
+export declare const LAST_PASS_KEY = "last-pass";
 /**
  * lease가 죽은 것으로 보이기까지의 최소 시간.
  *
@@ -75,13 +87,34 @@ export declare class RuntimeLease {
     /** 내 것일 때만 놓는다. 남이 이미 잡았으면 건드리지 않는다. */
     release(): Promise<void>;
 }
+/** 마지막 기계 회차가 이 workspace 에서 어떻게 끝났는가. */
+export type PassRecord = {
+    at: string;
+    /** 회차 프로세스의 종료 코드. 0 이 아니면 그 회차는 이 workspace 를 돌지 못했다. */
+    code: number;
+    /** 연속 실패 횟수. 한 번 삐끗한 것과 계속 안 되는 것은 다른 사실이다. */
+    consecutiveFailures: number;
+    /** 마지막으로 통과한 시각. 한 번도 없으면 비어 있다. */
+    lastOkAt?: string;
+};
 export type BackgroundStatus = {
     lease: LeaseState;
     /** 갈래별 마지막 실행 시각. 없는 갈래는 한 번도 돌지 않았다. */
     lastRun: Partial<Record<TickKind, string>>;
+    /** 마지막 기계 회차의 결말. 한 번도 돌지 않았으면 없다. */
+    lastPass?: PassRecord;
     /** 회수 기준. 사람이 "얼마나 조용하면 죽은 것인가"를 알아야 판단할 수 있다. */
     staleMs: number;
 };
+/**
+ * 회차 결말을 적는다. **판정하지 않는다** — 코드와 연속 실패 수를 세어 둘 뿐이다.
+ *
+ * 이전 기록을 읽어 이어 세므로, 성공 한 번이 실패의 역사를 지운다. 그것이 맞다:
+ * 지금 돌고 있다면 사람이 볼 것은 지금이다.
+ */
+export declare function recordPass(scope: ScopedStore, code: number, at?: string): Promise<PassRecord>;
+/** 붙어 있다는 것과 돌고 있다는 것은 다른 사실이다. 무엇이 어긋났는지 한 줄로 말한다. */
+export declare function passLine(record: PassRecord | undefined): string | null;
 /** 상태를 모은다. **읽기만 한다** — 보는 것이 상태를 바꾸면 아무도 못 본다. */
 export declare function readBackground(scope: ScopedStore, staleMs: number, now?: () => string): Promise<BackgroundStatus>;
 /**