@asc-agent/runtime 0.2.0 → 0.3.0

package/dist/core/operator/proceed.d.ts

@@ -1,5 +1,10 @@
 import type { Session } from '../model/entities.ts';
 import type { StateStore } from '../../ports/state-store.ts';
+import type { RepoObservation } from '../../ports/local-repo.ts';
+import type { ChangeSummary } from '../../ports/change-context.ts';
+import type { ContextComment, ResourceSnapshot } from '../../ports/resource-context.ts';
+import type { SessionContractDraft, SessionContractPlan } from './contract-draft.ts';
+import { type WorkStateResult } from './work-state.ts';
 import type { CanonicalDrift, SessionRuntime } from '../runtime/session.ts';
 import { type EscalationLedger } from '../runtime/escalation.ts';
 import { type ExecutionVerdict } from '../runtime/execution-state.ts';
@@ -15,6 +20,57 @@ export type ProceedIntent = {
     sessionId?: string;
     /** 후보가 없을 때 초안에 실어 줄 목표 힌트. 확정이 아니다. */
     goal?: string;
+    /**
+     * 사람이 지목한 작업 항목 (예: 이슈 키). 있으면 후보가 없을 때 **조사부터** 한다 —
+     * 빈 초안을 돌려주는 대신, 실제로 할 일이 있는지를 먼저 판정한다.
+     */
+    workRef?: string;
+};
+/**
+ * 작업 항목 하나를 실제로 조사해 계약까지 잇는 통로 (P0-D).
+ *
+ * 전부 주입이다. Operator 는 adapter 도 policy 도 모르고, 여기 담긴 함수들이 하는 판정을
+ * 다시 계산하지 않는다 — 범위·책임·발급 권한은 `plan` 이 돌려주는 것을 **읽기만** 한다.
+ */
+export type WorkIngress = {
+    /** 작업 항목과 그 둘레를 모은다. 못 모은 것은 'UNAVAILABLE' 로 말한다. */
+    gather: (workRef: string) => Promise<{
+        workItem?: ResourceSnapshot;
+        trackerDone?: boolean;
+        comments?: readonly ContextComment[] | 'UNAVAILABLE';
+        change?: ChangeSummary | 'UNAVAILABLE';
+        dependencies?: readonly {
+            reference: string;
+            state?: string;
+            open?: boolean;
+        }[];
+    }>;
+    /** 저장소 관측. 없으면 'MISSING' 으로 취급되고, 그 상태에서는 어떤 추천도 하지 않는다. */
+    observeRepo?: (query: {
+        refHint: string;
+        paths?: readonly string[];
+    }) => Promise<RepoObservation>;
+    derive: (input: {
+        workRef: string;
+        goal?: string;
+        workItem: ResourceSnapshot;
+        workState: WorkStateResult;
+        repo: RepoObservation | 'MISSING';
+        /** 이미 쓰인 세션 id — 새 id 가 그 위에 겹치지 않게. */
+        existingIds: readonly string[];
+    }) => SessionContractDraft;
+    /** 이미 쓴 세션 id — 회수돼 보관된 것까지. 새 id 가 그 위에 겹치지 않게 한다. */
+    usedIds: () => Promise<readonly string[]>;
+    /** planSessionContract 를 policy·ownership·기존 id 로 감싼 것. */
+    plan: (draft: SessionContractDraft) => Promise<SessionContractPlan>;
+    /** 위임 범위 안에서만 불린다. 발급 경로는 SessionRuntime 하나뿐이다. */
+    issue: (draft: SessionContractDraft) => Promise<{
+        ok: true;
+        sessionId: string;
+    } | {
+        ok: false;
+        detail: string;
+    }>;
 };
 /** 후보 나열용 요약 — 사람이 고를 근거까지 함께 준다. */
 export type SessionCandidate = {
@@ -52,6 +108,24 @@ export type ProceedOutcome = ({
         goal: string;
         doneCriteria: string[];
     };
+    /** 조사에서 도출한 초안 전문. 조사 없이 온 경우엔 없다. */
+    full?: SessionContractDraft;
+    /** planSessionContract 판정 원본. 여기 있는 것을 다시 계산하지 않는다. */
+    plan?: SessionContractPlan;
+    /** 발급이 Controller 것일 때 사람이 그대로 실행할 명령. */
+    forController?: string[];
+}
+/**
+ * 조사해 보니 **세션을 낼 일이 아니다** (P0-B). 이미 구현돼 tracker 만 뒤처졌거나,
+ * 선행 작업·외부 검증에 막혔거나, 결론 요건이 모자란 경우다.
+ *
+ * 아무것도 쓰지 않는다. 파생 뷰이며 저장되지 않는다 — 상태 enum(OM §11.2)을 건드리지 않는다.
+ */
+ | {
+    kind: 'WORK_STATE';
+    workRef: string;
+    result: WorkStateResult;
+    nextAction: string;
 }
 /**
  * 미해소 상신이 실행 가능한 node를 전부 덮었다 (C-13 §6).
@@ -84,6 +158,11 @@ export type OperatorDeps = {
      * 주지 않으면 예전처럼 상태만 보고 간다(기존 호출자 무손상).
      */
     escalations?: EscalationLedger;
+    /**
+     * 작업 항목 통로 (P0-D). 없으면 후보가 없을 때 예전처럼 빈 초안을 제안한다 —
+     * 기존 호출자 무손상.
+     */
+    ingress?: WorkIngress;
     /**
      * 필수다. 모든 진입이 bootstrap/profile.lock 검증을 지난다 — Surface가 어디든.
      * 실 조립은 factory(cli의 createOperator)가 bootstrapGuard로 고정한다.

package/dist/core/operator/proceed.js

@@ -6,6 +6,8 @@
 //
 // guard는 optional이 아니다. CLI가 아닌 Host Adapter가 직접 불러도 profile.lock 검증을
 // 건너뛸 수 없어야 하며(C-03 §1.2), 정본 조립은 Surface가 아니라 factory가 진다.
+import { judgeWorkState } from "./work-state.js";
+import { extractPathHints } from "./derive-draft.js";
 import { proceedGateFacts } from "../runtime/escalation.js";
 import { deriveExecutionState } from "../runtime/execution-state.js";
 const RUNNABLE = new Set(['READY', 'PAUSED', 'ACTIVE']);
@@ -13,11 +15,13 @@ export class Operator {
     #store;
     #sessions;
     #escalations;
+    #ingress;
     #guard;
     constructor(deps) {
         this.#store = deps.store;
         this.#sessions = deps.sessions;
         this.#escalations = deps.escalations;
+        this.#ingress = deps.ingress;
         this.#guard = deps.guard;
     }
     async proceed(intent = {}) {
@@ -33,8 +37,15 @@ export class Operator {
             return this.#advance(session);
         }
         // 자동 탐색 — 실행 가능한 것만 후보다. archive는 collect가 이미 치웠다.
-        const candidates = (await this.#store.list('session')).filter((s) => RUNNABLE.has(s.status));
+        const runnable = (await this.#store.list('session')).filter((s) => RUNNABLE.has(s.status));
+        // 사람이 작업 항목을 지목했으면 그 작업의 세션만 후보다. 지목을 무시하고 다른 세션을
+        // 이어가면, 물어본 것과 다른 일이 시작된다 (실제로 그렇게 됐다).
+        const candidates = intent.workRef
+            ? runnable.filter((session) => session.goal.includes(intent.workRef))
+            : runnable;
         if (candidates.length === 0) {
+            if (intent.workRef && this.#ingress)
+                return this.#ingest(intent.workRef, intent.goal, this.#ingress);
             // 자동 issue 금지. 초안을 제안할 수는 있으나 발급은 Controller 승인 후 별도 행위다.
             return {
                 kind: 'PROPOSE_CONTRACT',
@@ -56,6 +67,80 @@ export class Operator {
         }
         return this.#advance(candidates[0]);
     }
+    /**
+     * 돌릴 세션은 없고 사람이 작업 항목을 지목했다 (P0-D).
+     *
+     * 순서에 뜻이 있다: **조사 → 실제 상태 판정 → (필요하면) 계약**. 계약부터 만들면 이미
+     * 끝난 일에 세션을 내게 되고, 그것이 이 경로를 고치게 된 사고였다.
+     */
+    async #ingest(workRef, goal, ingress) {
+        const gathered = await ingress.gather(workRef);
+        // 작업 항목이 지목한 경로를 함께 확인한다 — 그것이 좁은 쓰기 범위의 유일한 근거다.
+        const hints = gathered.workItem ? extractPathHints(gathered.workItem) : [];
+        const repo = ingress.observeRepo
+            ? await ingress.observeRepo({ refHint: workRef, ...(hints.length > 0 ? { paths: hints } : {}) })
+            : 'MISSING';
+        const workState = judgeWorkState({ ...gathered, repo });
+        const decided = workState.state === 'DECIDABLE_WITH_LIMITATION' ? workState.leaning : workState.state;
+        if (decided !== 'ACTIONABLE' || !gathered.workItem) {
+            return { kind: 'WORK_STATE', workRef, result: workState, nextAction: nextActionFor(workState, workRef) };
+        }
+        const draft = ingress.derive({
+            workRef,
+            goal,
+            workItem: gathered.workItem,
+            workState,
+            repo,
+            // 이미 쓴 id 목록은 통로가 안다 — 보관된 것까지 세는 것이 그쪽이다.
+            existingIds: await ingress.usedIds(),
+        });
+        const plan = await ingress.plan(draft);
+        const handout = {
+            kind: 'PROPOSE_CONTRACT',
+            draft: {
+                role: (draft.role ?? 'implementer'),
+                goal: draft.goal ?? '',
+                doneCriteria: [...(draft.criteria ?? [])],
+            },
+            full: draft,
+            plan,
+        };
+        // 계약이 성립하지 않으면 발급하지 않는다. 무엇이 남았는지는 plan 이 이미 말한다.
+        if (plan.status !== 'READY_TO_ISSUE')
+            return handout;
+        // 발급 권한은 사람의 것이다. 위임이 없으면 명령만 건네고 멈춘다 (OM §450).
+        if (plan.issuance.authority !== 'delegated') {
+            return { ...handout, forController: issueCommand(draft) };
+        }
+        // 백스톱: 저장소 전체를 쓰겠다는 계약은 위임 범위 안에서 스스로 내지 않는다.
+        // 역할의 상한이 `**` 라는 사실은 **이번 작업이** 전체를 고쳐야 한다는 근거가 아니다 —
+        // 그 근거는 사람이 이 작업에 대해 직접 말했을 때만 성립한다.
+        if (isRepositoryWide(draft) && !declaredRepositoryWide(draft)) {
+            return {
+                ...handout,
+                forController: issueCommand(draft),
+                plan: {
+                    ...plan,
+                    unresolved: [
+                        ...plan.unresolved,
+                        {
+                            field: 'boundary',
+                            reason: 'explicit_rule_requires_approval',
+                            detail: '저장소 전체를 쓰는 계약이다 — 이번 작업이 그것을 요구한다는 근거가 없어 위임 범위 안에서 발급하지 않는다.',
+                        },
+                    ],
+                },
+            };
+        }
+        const issued = await ingress.issue(draft);
+        if (!issued.ok)
+            return { kind: 'FAILED', reason: 'TRANSITION', detail: issued.detail };
+        const session = await this.#store.get('session', issued.sessionId);
+        if (!session) {
+            return { kind: 'FAILED', reason: 'NOT_FOUND', detail: `발급한 세션 '${issued.sessionId}' 을 찾지 못했다` };
+        }
+        return this.#advance(session);
+    }
     /** 상태별로 한 걸음. 전이는 전부 SessionRuntime을 지난다 — 우회 경로 없음. */
     async #advance(session) {
         switch (session.status) {
@@ -165,3 +250,40 @@ function handout(session) {
         ...(session.checkpoint ? { checkpoint: session.checkpoint } : {}),
     };
 }
+/** 세션을 내지 않을 때, 대신 무엇을 하면 되는가. 실행하지 않고 말만 한다. */
+function nextActionFor(result, workRef) {
+    switch (result.state === 'DECIDABLE_WITH_LIMITATION' ? (result.leaning ?? 'UNDECIDABLE') : result.state) {
+        case 'IMPLEMENTED_STALE_TRACKER':
+            return `구현은 정본에 있다 — 할 일은 구현이 아니라 ${workRef} 상태 정리다. 추적 시스템 반영은 외부 쓰기이므로 승인 경로(Grant)를 지난다`;
+        case 'IMPLEMENTATION_COMPLETE_BLOCKED_VERIFICATION':
+            return '구현은 끝났고 검증이 막혀 있다 — 막힌 것을 먼저 풀어라. 새 구현 세션은 필요 없다';
+        case 'BLOCKED_DEPENDENCY':
+            return '선행 작업이 열려 있다 — 그것이 닫히기 전에는 이 작업만으로 끝나지 않는다';
+        case 'REVIEW_RESPONSE_REQUIRED':
+            return '검토가 답을 기다린다 — 다음 행동은 새 구현이 아니라 응답이다';
+        default:
+            return `결론 요건이 모자라다: ${result.missing.join(', ') || '확인하지 못한 것이 있다'} — 그것을 먼저 확인하라`;
+    }
+}
+/** Controller 가 그대로 실행할 발급 명령. 조립만 하고 실행하지 않는다. */
+function issueCommand(draft) {
+    const argv = ['asc', 'session', 'issue', draft.id ?? '<S-ID>', '--role', draft.role ?? 'implementer'];
+    if (draft.goal)
+        argv.push('--goal', draft.goal);
+    for (const scope of draft.boundary ?? [])
+        argv.push('--boundary', scope);
+    for (const criterion of draft.criteria ?? [])
+        argv.push('--criteria', criterion);
+    return argv;
+}
+/** 사실상 저장소 전체를 쓰는 범위인가. 문법 판정이 아니라 리터럴 확인이다. */
+function isRepositoryWide(draft) {
+    return (draft.boundary ?? []).some((scope) => scope.replace(/\*.*$/, '') === '');
+}
+/** 이번 작업에 대해 사람·정본·Profile 이 그 범위를 직접 말했는가. */
+function declaredRepositoryWide(draft) {
+    const entry = draft.provenance?.find((field) => field.field === 'boundary');
+    if (!entry || entry.status !== 'FACT')
+        return false;
+    return entry.source === 'user' || entry.source === 'profile' || entry.source === 'canonical';
+}

package/dist/core/operator/work-state.d.ts

@@ -0,0 +1,54 @@
+import type { ChangeSummary } from '../../ports/change-context.ts';
+import type { RepoObservation } from '../../ports/local-repo.ts';
+import type { ContextComment, ResourceSnapshot } from '../../ports/resource-context.ts';
+export type WorkState = 
+/** 지금 착수할 수 있다. */
+'ACTIONABLE'
+/** 구현은 정본에 있는데 tracker 가 따라오지 않았다 — 할 일은 상태 정리지 구현이 아니다. */
+ | 'IMPLEMENTED_STALE_TRACKER'
+/** 구현은 끝났고 남은 것은 검증인데, 그 검증이 외부 사정으로 막혀 있다. */
+ | 'IMPLEMENTATION_COMPLETE_BLOCKED_VERIFICATION'
+/** 선행 작업이 열려 있어 이 작업만으로 끝낼 수 없다. */
+ | 'BLOCKED_DEPENDENCY'
+/** 남의 검토에 답하는 것이 다음 행동이다. */
+ | 'REVIEW_RESPONSE_REQUIRED'
+/** 못 본 것이 있지만 판정을 뒤집을 정도는 아니다 — 무엇에 기울었는지 `leaning` 이 말한다. */
+ | 'DECIDABLE_WITH_LIMITATION'
+/** 결론 요건이 채워지지 않았다. 추천하지 않는다. */
+ | 'UNDECIDABLE';
+/** 결정을 내릴 수 있는 상태들 — DECIDABLE_WITH_LIMITATION 의 `leaning` 이 가리키는 값. */
+export type DecidedState = Exclude<WorkState, 'DECIDABLE_WITH_LIMITATION' | 'UNDECIDABLE'>;
+/**
+ * 보지 못한 것을 두 가지로 나눠 받는다. `'UNAVAILABLE'` 은 보려 했으나 막힌 것이고,
+ * 필드 자체가 없으면 이 사건에 해당하지 않는 것이다. **저장소는 예외다** —
+ * `'MISSING'`(아예 안 봤다)이면 어떤 추천도 하지 않는다.
+ */
+export type WorkStateInput = {
+    workItem?: ResourceSnapshot;
+    /**
+     * tracker 가 "끝났다"고 말하는가. provider 어휘(한국어 상태명 등) 해석은 호출측 몫이다 —
+     * Core 가 특정 tracker 의 상태 문자열을 알면 다른 tracker 를 붙일 수 없다. 모르면 undefined.
+     */
+    trackerDone?: boolean;
+    comments?: readonly ContextComment[] | 'UNAVAILABLE';
+    /** 저장소 관측. `'MISSING'` 은 "조사하지 않았다" 이며 결론 요건 미달이다. */
+    repo: RepoObservation | 'MISSING';
+    /** MR/PR 검토 상태. 원격 provider 가 막혀 있으면 `'UNAVAILABLE'`. */
+    change?: ChangeSummary | 'UNAVAILABLE';
+    dependencies?: readonly {
+        reference: string;
+        state?: string;
+        open?: boolean;
+    }[];
+};
+export type WorkStateResult = {
+    state: WorkState;
+    leaning?: DecidedState;
+    /** 판정의 근거. 사람이 그대로 읽는다. */
+    evidence: string[];
+    /** 보려 했으나 못 본 것. 판정을 뒤집지는 않지만 숨기지도 않는다. */
+    limitations: string[];
+    /** 결론 요건 중 비어 있는 칸. 비어 있지 않으면 UNDECIDABLE 이다. */
+    missing: string[];
+};
+export declare function judgeWorkState(input: WorkStateInput): WorkStateResult;

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

@@ -0,0 +1,145 @@
+// 실제 작업 상태 판정 (P0-B).
+//
+// 존재 이유는 한 문장이다. **tracker 상태는 실제 작업 상태가 아니다.** 추적 항목이 "진행 중"
+// 이라고 말할 때 구현은 이미 정본 가지에 병합돼 있을 수 있고, "해야 할 일"인 항목이
+// 자격증명 대기로 아무도 손댈 수 없는 상태일 수 있다. 그 차이를 tracker 한 곳만 보고
+// 판단하면 이미 끝난 일을 다시 시키는 추천이 나간다.
+//
+// 이 모듈은 순수 판정이다. 읽지 않고, 쓰지 않고, 어떤 Port 도 부르지 않는다. 증거는
+// 호출측이 모아서 넘긴다 — 무엇을 못 모았는지까지 함께.
+//
+// 여기서 만든 상태는 **파생 뷰**다. 어디에도 저장하지 않고 Session/Request 상태 enum
+// (OM §11.2, 동결)을 건드리지 않는다.
+/**
+ * 결론 `ACTIONABILITY_RECOMMENDATION` 의 필수 증거.
+ *
+ * 원격 API 가 막혀 있다는 사실은 저장소를 안 본 사유가 되지 않는다 — ref·병합·파일 존재는
+ * 로컬 git 으로 읽힌다. 그래서 repository 는 'UNAVAILABLE' 이라는 선택지 없이 필수다.
+ */
+const REQUIRED = ['work-item', 'repository'];
+export function judgeWorkState(input) {
+    const evidence = [];
+    const limitations = [];
+    const missing = [];
+    if (!input.workItem || input.workItem.missing)
+        missing.push(REQUIRED[0]);
+    if (input.repo === 'MISSING')
+        missing.push(REQUIRED[1]);
+    else if (input.repo.unavailable)
+        limitations.push(`저장소 관측 실패: ${input.repo.unavailable}`);
+    if (missing.length > 0) {
+        return {
+            state: 'UNDECIDABLE',
+            evidence,
+            limitations,
+            missing,
+        };
+    }
+    const repo = input.repo;
+    const item = input.workItem;
+    evidence.push(`작업 항목: ${item.reference} — ${item.title} (${item.state})`);
+    if (input.trackerDone !== undefined)
+        evidence.push(`tracker 완료 표기: ${input.trackerDone ? '예' : '아니오'}`);
+    if (input.comments === 'UNAVAILABLE')
+        limitations.push('논의를 읽지 못했다 — 합의 여부는 이 판정의 근거가 아니다');
+    if (input.change === 'UNAVAILABLE')
+        limitations.push('MR·리뷰 상태를 읽지 못했다 (원격 provider 미인증/불가)');
+    const onCanonical = Object.entries(repo.pathsOnCanonical ?? {}).filter(([, exists]) => exists);
+    const mentioned = repo.mentionedOnCanonical ?? [];
+    // 언급은 그 자체로 증거가 아니다. 되돌리기만 있는 이력도 이 작업을 "언급"하고, 뒤이어
+    // 걷혀 나간 변경도 그렇다. 살아남은 것이 있어야 정본에 있다고 말할 수 있다.
+    const mentionSurvives = mentioned.length > 0 && repo.mentionedOnlyReverts !== true && repo.mentionedArtifactsPresent === true;
+    const merged = repo.mergedIntoCanonical === true || onCanonical.length > 0 || mentionSurvives;
+    const hasBranch = repo.refs.length > 0;
+    const artifacts = Object.entries(repo.pathsExist).filter(([, exists]) => exists);
+    if (repo.canonicalRef)
+        evidence.push(`정본 대조 기준: ${repo.canonicalRef}`);
+    if (hasBranch)
+        evidence.push(`작업 가지: ${repo.refs.join(', ')}`);
+    if (repo.mergedIntoCanonical === true)
+        evidence.push('작업 가지가 정본에 병합돼 있다');
+    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) {
+        evidence.push('그 언급은 전부 되돌리기다 — 구현이 정본에 남아 있다는 증거가 아니다');
+    }
+    if (repo.mentionedArtifactsPresent === true) {
+        evidence.push('그 변경이 건드린 파일이 정본에 아직 있다 (생존 증거 — 인수 조건 충족의 증명은 아니다)');
+    }
+    if (repo.mentionedArtifactsPresent === false) {
+        evidence.push('그 변경이 건드린 파일이 정본에 하나도 남아 있지 않다');
+    }
+    if (mentioned.length > 0 && repo.mentionedArtifactsPresent === undefined) {
+        limitations.push('언급된 커밋이 무엇을 건드렸는지 읽지 못했다 — 구현이 지금도 남아 있는지 확인하지 못했다');
+    }
+    const openDependencies = (input.dependencies ?? []).filter((d) => d.open === true);
+    if (openDependencies.length > 0) {
+        evidence.push(`열린 선행 작업: ${openDependencies.map((d) => d.reference).join(', ')}`);
+    }
+    const unknownDependencies = (input.dependencies ?? []).filter((d) => d.open === undefined);
+    if (unknownDependencies.length > 0) {
+        limitations.push(`선행 작업 상태를 확인하지 못했다: ${unknownDependencies.map((d) => d.reference).join(', ')}`);
+    }
+    const implemented = merged || artifacts.length > 0;
+    // ① 구현은 정본에 있는데 tracker 가 안 따라왔다. 여기서만 tracker 를 본다 — 그것도
+    //    "끝났다고 말하지 않는다"는 사실로만. tracker 가 결론을 만드는 자리는 없다.
+    //    확정하려면 **살아 있는 산출물**이 있어야 한다: 병합 흔적만으로는 부분 병합·스캐폴드·
+    //    되돌리기를 가려낼 수 없다. 확인하지 못했으면 확정하지 않는다.
+    //    가지가 정본의 조상이라는 것은 그 커밋들이 지금 정본 이력에 그대로 있다는 뜻이라
+    //    그 자체가 생존 증거다. 언급(grep)만 있는 경우와 다르다.
+    const artifactSurvives = repo.mergedIntoCanonical === true || onCanonical.length > 0 || repo.mentionedArtifactsPresent === true;
+    if (merged && input.trackerDone === false && artifactSurvives && repo.mentionedOnlyReverts !== true) {
+        limitations.push('인수 조건 전체가 지금도 충족되는지는 확인하지 않았다 — 여기서 말하는 것은 구현의 생존까지다');
+        return decided('IMPLEMENTED_STALE_TRACKER', evidence, limitations, { demote: false });
+    }
+    if (merged && input.trackerDone === false) {
+        // 병합 흔적은 있는데 생존을 확인하지 못했다 — 새 구현을 시키지도, 끝났다고 하지도 않는다.
+        limitations.push('정본에 병합 흔적은 있으나 구현이 지금도 남아 있는지 확인하지 못했다');
+        return decided('IMPLEMENTATION_COMPLETE_BLOCKED_VERIFICATION', evidence, limitations, { demote: true });
+    }
+    // ② 구현 증거는 있는데 남은 검증 경로가 막혔다.
+    if (implemented && input.change === 'UNAVAILABLE' && !merged) {
+        return decided('IMPLEMENTATION_COMPLETE_BLOCKED_VERIFICATION', evidence, limitations, { demote: true });
+    }
+    // ③ 가지는 있는데 병합 전이고 선행 작업이 열려 있다.
+    if (hasBranch && !merged && openDependencies.length > 0) {
+        return decided('BLOCKED_DEPENDENCY', evidence, limitations, { demote: false });
+    }
+    if (!implemented && openDependencies.length > 0) {
+        return decided('BLOCKED_DEPENDENCY', evidence, limitations, { demote: false });
+    }
+    // ④ 검토가 답을 기다린다.
+    if (typeof input.change === 'object' && requestsResponse(input.change, input.comments)) {
+        return decided('REVIEW_RESPONSE_REQUIRED', evidence, limitations, { demote: true });
+    }
+    // ⑤ 구현 증거도 없고 막힌 것도 없다.
+    if (!implemented) {
+        evidence.push('정본·작업 트리 어디에도 구현 증거가 없다');
+        return decided('ACTIONABLE', evidence, limitations, { demote: true });
+    }
+    // 구현 증거는 있는데 위 어디에도 안 걸린다 — 남은 것은 검증이고, 무엇이 막혔는지는 모른다.
+    return decided('IMPLEMENTATION_COMPLETE_BLOCKED_VERIFICATION', evidence, limitations, { demote: true });
+}
+/** 검토가 응답을 요구하는가. provider 어휘를 해석하지 않고 두 가지 표시만 본다. */
+function requestsResponse(change, comments) {
+    const state = change.reviewState?.toUpperCase() ?? '';
+    if (state.includes('CHANGES_REQUESTED') || state.includes('REQUESTED_CHANGES'))
+        return true;
+    if (comments && comments !== 'UNAVAILABLE')
+        return comments.some((c) => c.unresolved === true);
+    return false;
+}
+/**
+ * 한계가 있으면 DECIDABLE_WITH_LIMITATION 으로 내리되, 판정의 근거가 로컬 사실뿐인
+ * 상태(①③)는 내리지 않는다 — 못 본 원격 정보가 그 결론을 바꾸지 못하기 때문이다.
+ */
+function decided(state, evidence, limitations, options) {
+    if (options.demote && limitations.length > 0) {
+        return { state: 'DECIDABLE_WITH_LIMITATION', leaning: state, evidence, limitations, missing: [] };
+    }
+    return { state, evidence, limitations, missing: [] };
+}

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

@@ -18,14 +18,14 @@ export declare const ClosureRecord: z.ZodObject<{
     /** 전부 확인된 시각. 닫혀도 기록은 남는다 — 지우면 무엇을 닫았는지도 사라진다. */
     closedAt: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    logicalSessionId: string;
     openedAt: string;
+    logicalSessionId: string;
     declared: string[];
     confirmed: string[];
     closedAt?: string | undefined;
 }, {
-    logicalSessionId: string;
     openedAt: string;
+    logicalSessionId: string;
     declared?: string[] | undefined;
     confirmed?: string[] | undefined;
     closedAt?: string | undefined;

package/dist/ports/local-repo.d.ts

@@ -0,0 +1,61 @@
+export type RepoObservation = {
+    /** 현재 체크아웃된 가지. 알 수 없으면 null. */
+    branch: string | null;
+    remotes: readonly {
+        name: string;
+        url: string;
+    }[];
+    /** refHint 에 걸린 지역·원격 ref 들 (예: 이슈 키가 들어간 작업 가지). */
+    refs: readonly string[];
+    /** 무엇을 정본으로 삼아 비교했는가. Profile 이 정한다 — adapter 가 추측하지 않는다. */
+    canonicalRef?: string;
+    /**
+     * refs 중 하나라도 정본 가지에 들어가 있는가. 판정이 아니라 **증거**다 —
+     * squash 병합이면 ref 는 조상이 아니지만 산출물은 정본에 있다. 그 경우
+     * `pathsOnCanonical` 이 같은 사실을 다른 각도로 말한다.
+     */
+    mergedIntoCanonical?: boolean;
+    /**
+     * 작업 트리에 그 경로가 있는가. **이 작업의 산출물 후보만** 담는다 — 저장소에 늘 있는
+     * 자리를 여기 섞으면 "구현이 있다"는 증거가 아무 작업에서나 성립해 버린다.
+     */
+    pathsExist: Record<string, boolean>;
+    /**
+     * 저장소의 자리 목록(최상위 디렉터리 등). 범위를 좁힐 재료일 뿐 **증거가 아니다** —
+     * 판정은 이 값을 보지 않는다.
+     */
+    modulesPresent?: Record<string, boolean>;
+    /** 정본 가지에 그 경로가 있는가 (squash 병합 대비). */
+    pathsOnCanonical?: Record<string, boolean>;
+    /**
+     * 정본 가지의 이력에서 이 작업을 언급하는 커밋들. **가지가 지워진 뒤에도 남는 증거다** —
+     * 병합 후 브랜치를 지우는 팀에서는 ref 대조만으로는 "구현이 정본에 있다"를 알 수 없다.
+     */
+    mentionedOnCanonical?: readonly string[];
+    /**
+     * 언급 커밋이 전부 되돌리기인가. 되돌린 이력은 "구현이 정본에 있다"의 증거가 아니다.
+     */
+    mentionedOnlyReverts?: boolean;
+    /**
+     * 언급 커밋이 건드린 파일 중 하나라도 정본에 아직 살아 있는가.
+     *
+     * **이것은 생존 증거이지 인수 조건 충족의 증명이 아니다** — "그 변경이 지금 저장소와
+     * 끊어지지 않았다"까지만 말한다. 파일 목록을 읽지 못하면 undefined 로 둔다: 확인하지
+     * 않은 것을 확인했다고 하지 않는다.
+     */
+    mentionedArtifactsPresent?: boolean;
+    /** git 자체를 쓸 수 없었던 이유. 있으면 이 관측은 비어 있다. */
+    unavailable?: string;
+};
+export type RepoQuery = {
+    /** ref 이름에서 찾을 조각. 보통 작업 항목 키. */
+    refHint?: string;
+    canonicalRef?: string;
+    paths?: readonly string[];
+    /** 범위 재료로만 확인할 자리들. 증거 칸에 섞이지 않는다. */
+    modulePaths?: readonly string[];
+};
+export interface LocalRepoPort {
+    readonly id: string;
+    observe(query: RepoQuery): Promise<RepoObservation>;
+}

package/dist/ports/local-repo.js

@@ -0,0 +1,9 @@
+// Local Repository Port — 지금 이 저장소가 실제로 어떤 상태인가.
+//
+// 이 Port가 따로 있는 이유는 하나다. **원격 provider가 막혀 있다는 사실이 저장소를 보지
+// 않을 사유가 되어서는 안 된다.** GitLab API가 401을 주든 토큰이 없든, ref·병합 여부·
+// 파일 존재는 로컬 git 으로 전부 읽힌다. 그것을 안 읽고 "확인 불가"라고 말하면
+// 조사 누락이 접근 불가로 위장된다.
+//
+// diff 도 로그도 다루지 않는다. "구현이 정본 가지에 있는가"를 판정할 최소한만 본다.
+export {};

package/dist/ports/resource-context.d.ts

@@ -19,6 +19,13 @@ export type ResourceSnapshot = {
     revisionMarker: string;
     /** 연결된 다른 리소스. 문법은 adapter 소관이고 Core는 식별자로만 다룬다. */
     related?: readonly string[];
+    /**
+     * 이 일을 **막는다고 선언된** 것들. `related` 의 부분집합이다.
+     *
+     * 따로 두는 이유: 부모·하위 작업도 연결이지만 선행이 아니다. 그것을 선행으로 세면
+     * 거의 모든 작업이 "막혔다"가 되고, 그 판정은 아무 말도 하지 않는 것과 같다.
+     */
+    blockedBy?: readonly string[];
     /** 사라졌거나 접근할 수 없다. 없는 것과 못 읽는 것을 구분해야 판정이 성립한다. */
     missing?: boolean;
 };

package/dist/schemas/profile.d.ts

@@ -492,6 +492,7 @@ export declare const UserOverride: z.ZodPipeline<z.ZodEffects<z.ZodUnknown, unkn
         roles?: string[] | undefined;
     };
     schemaVersion: 1;
+    monitorIdentities: string[];
     approval: {
         preferredChannel?: string | undefined;
         messenger?: {
@@ -509,7 +510,6 @@ export declare const UserOverride: z.ZodPipeline<z.ZodEffects<z.ZodUnknown, unkn
         unionLists?: Record<string, string[]> | undefined;
     };
     identity: Record<string, string>;
-    monitorIdentities: string[];
     $comment?: string | undefined;
 }, {
     schemaVersion: 1;
@@ -521,6 +521,7 @@ export declare const UserOverride: z.ZodPipeline<z.ZodEffects<z.ZodUnknown, unkn
         roles?: string[] | undefined;
     } | undefined;
     $comment?: string | undefined;
+    monitorIdentities?: string[] | undefined;
     approval?: {
         preferredChannel?: string | undefined;
         messenger?: {
@@ -538,7 +539,6 @@ export declare const UserOverride: z.ZodPipeline<z.ZodEffects<z.ZodUnknown, unkn
         unionLists?: Record<string, string[]> | undefined;
     } | undefined;
     identity?: Record<string, string> | undefined;
-    monitorIdentities?: string[] | undefined;
 }>>;
 export type UserOverride = z.infer<typeof UserOverride>;
 /** attach 재현성 metadata (OM §4.9). Resolver만 쓴다. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asc-agent/runtime",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "ASC (Agent Session Control) — local-first human-in-the-loop agent control plane: core, CLI, and adapters",
   "keywords": [
     "agent",
@@ -22,7 +22,7 @@
   "author": "colosair (https://github.com/colosair)",
   "type": "module",
   "bin": {
-    "asc": "./dist/cli/asc.js"
+    "asc": "dist/cli/asc.js"
   },
   "main": "./dist/cli/asc.js",
   "types": "./dist/cli/asc.d.ts",