@asc-agent/runtime 0.3.0 → 0.3.1

package/README.md

@@ -7,7 +7,7 @@ proceed-by-default, escalation, audit, the external-write guard, host integratio
 here.
 
 ```bash
-npm install -g @asc-agent/runtime@0.3.0
+npm install -g @asc-agent/runtime@0.3.1
 ```
 
 npm owns the executable link (on Windows, npm's own `asc.cmd`). This package never edits

package/dist/adapters/claude-code/skill.js

@@ -32,6 +32,10 @@ description: >-
   Safely start, resume or continue a Logical Session in a project that has ASC attached.
   Triggers — "proceed with ASC", "continue the ASC session", "asc proceed", "start work
   with ASC", "ASC로 진행해", "ASC 세션 이어서", "ASC로 작업 시작", or the explicit /asc.
+  Also triggers on work-status questions in an ASC-attached project — "is this
+  implemented?", "what's left to do?", "what should I do now?", "현황 파악",
+  "이거 구현됐나", "남은 작업", "지금 뭐 해야 하나" — because answering those by
+  exploring the host directly skips ASC's freshness and evidence gates.
   Do not use it in a project where ASC is not attached.
 ---
 
@@ -40,6 +44,16 @@ description: >-
 This skill is a consumer of the ASC Generic Operator. The judgement belongs to the asc
 CLI — here you call it, act on the typed outcome, and keep the contract.
 
+## Work-status questions go through ASC first
+
+"Is X implemented?", "what's the status of this work?", "what remains?" — in an
+ASC-attached project, do NOT settle these by direct host exploration (git log, tracker
+reads). Run \`asc proceed --work <KEY>\` first and read its WORK_STATE: it fetches the
+canonical remote, grades the evidence, and refuses to conclude on a stale or key-only
+observation — none of which ad-hoc exploration does. Direct exploration may supplement
+the answer, never replace the judgement. This is mitigation at the model layer; the
+freshness and evidence gates in the CLI remain the final safeguard.
+
 ## Entry — "proceed with ASC"
 
 That phrase means: **check the current state, secure readiness, find the runnable work I

package/dist/adapters/local/repo.js

@@ -56,10 +56,19 @@ export class LocalRepoAdapter {
         if (query.refHint) {
             observation.refs = filterRefs(await this.#git(['for-each-ref', '--format=%(refname:short)', 'refs/heads', 'refs/remotes']), query.refHint);
         }
-        const canonicalRef = query.canonicalRef ?? (await this.#defaultCanonicalRef());
+        // 신선도가 먼저다. 로컬 브랜치를 정본처럼 읽으면 원격이 전진한 사실을 모른 채
+        // "구현 증거가 없다"가 나온다 — 그것이 이 어댑터가 실전에서 낸 사고였다.
+        const canonical = await this.#freshCanonical(query);
+        const canonicalRef = canonical.ref;
+        observation.freshness = canonical.freshness;
         if (canonicalRef) {
             observation.canonicalRef = canonicalRef;
             observation.mergedIntoCanonical = await this.#anyMerged(observation.refs, canonicalRef);
+            if (observation.mergedIntoCanonical !== true && observation.refs.length > 0) {
+                const equivalent = await this.#contentEquivalent(observation.refs, canonicalRef);
+                if (equivalent !== undefined)
+                    observation.contentEquivalent = equivalent;
+            }
             if (query.refHint) {
                 // 가지가 지워졌어도 이력은 남는다 — 커밋 메시지가 이 작업을 언급하는지 본다.
                 const log = await this.#git(['log', '--format=%h %s', `--grep=${query.refHint}`, '-n', '5', canonicalRef]);
@@ -98,6 +107,56 @@ export class LocalRepoAdapter {
         }
         return observation;
     }
+    /**
+     * 정본 대조 기준과 그 신선도. Profile 이 remote 를 선언했으면 당겨 온 뒤 원격 추적
+     * ref 를 기준으로 삼는다 — fetch 는 읽기다(원격 write 가 아니다). 실패는 흡수하되
+     * FETCH_FAILED 로 남긴다: "당기지 못했다"와 "저장소가 없다"는 다른 사실이다.
+     */
+    async #freshCanonical(query) {
+        const declared = query.canonicalRef;
+        if (query.remote && declared) {
+            const branch = declared.startsWith(`${query.remote}/`)
+                ? declared.slice(query.remote.length + 1)
+                : declared;
+            const fetched = await this.#git(['fetch', query.remote, branch]);
+            const tracking = `${query.remote}/${branch}`;
+            if (fetched !== null)
+                return { ref: tracking, freshness: { state: 'FRESH' } };
+            // 당기지 못했어도 원격 추적 ref 가 있으면 그쪽이 로컬 브랜치보다 정본에 가깝다.
+            const trackingExists = (await this.#git(['rev-parse', '--verify', '--quiet', tracking])) !== null;
+            return {
+                ref: trackingExists ? tracking : declared,
+                freshness: { state: 'FETCH_FAILED', detail: `git fetch ${query.remote} ${branch} 실패` },
+            };
+        }
+        const ref = declared ?? (await this.#defaultCanonicalRef());
+        return { ref, freshness: { state: 'UNKNOWN', detail: '당겨 올 원격이 선언되지 않았다' } };
+    }
+    /**
+     * 조상은 아니지만 내용이 전부 정본에 있는가 (단일 커밋 squash·rebase·cherry-pick 등가).
+     * `git cherry` 는 patch-id 로 대조한다 — `-` 만 나오면 전부 반영, `+` 가 있으면 남은
+     * 커밋이 있다. 빈 출력은 가지가 정본과 같다는 뜻이라 반영으로 친다.
+     *
+     * 한계(검증자 실측): **여러 커밋을 하나로 합친 squash 는 못 잡는다** — 합쳐진 patch-id
+     * 는 개별 커밋 어느 것과도 일치하지 않는다. 그 경우 커밋 메시지의 키 언급(grep)이
+     * 남은 통로이고, 그것마저 없으면 이 관측은 반영 사실을 모른다.
+     */
+    async #contentEquivalent(refs, canonicalRef) {
+        let measured = false;
+        for (const ref of refs) {
+            const out = await this.#git(['cherry', canonicalRef, ref]);
+            if (out === null)
+                continue;
+            measured = true;
+            const lines = out
+                .split('\n')
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0);
+            if (lines.every((line) => line.startsWith('-')))
+                return true;
+        }
+        return measured ? false : undefined;
+    }
     /**
      * Profile 이 정본 ref 를 선언하지 않았을 때, 저장소 자신에게 묻는다 (origin/HEAD).
      * 추측이 아니라 관측이다 — 없으면 없는 대로 둔다.

package/dist/cli/asc.js

@@ -13,7 +13,8 @@ import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 import { homedir, userInfo } from 'node:os';
 import { basename, dirname, join, resolve } from 'node:path';
-import { MINIMUM_NODE_MAJOR, checkNodeRuntime, } from "../core/distribution/node-runtime.js";
+import { MINIMUM_NODE_MAJOR, checkNodeRuntime, reexecWithCandidate, } from "../core/distribution/node-runtime.js";
+import { RELEASE_VERSION } from "../core/distribution/release.js";
 import { GitHubClient, discoverToken } from "../adapters/github/client.js";
 import { GitHubChangeContext, GitHubInventory, GitHubResourceContext } from "../adapters/github/context.js";
 import { GitHubEventSource } from "../adapters/github/event-source.js";
@@ -521,6 +522,17 @@ export async function runAscCommand(argv, entry = 'runtime') {
     // 두면 그쪽에 정책이 생기고(C-14 불변식 ⑦), 그러면 두 진입의 답이 갈릴 수 있다.
     const runnable = await checkNodeRuntime(nodeRuntimeDeps());
     if (!runnable.ok) {
+        // 후보를 이미 찾았으면 처방 대신 실행한다 — 같은 명령, 같은 argv, 호환 Node (A6).
+        const reexec = reexecWithCandidate(runnable, argv, {
+            env: process.env,
+            entry: fileURLToPath(import.meta.url),
+            spawn: (path, args, env) => {
+                const child = spawnSync(path, args, { stdio: 'inherit', env: env });
+                return { status: child.status, signal: child.signal, ...(child.error ? { error: child.error } : {}) };
+            },
+        });
+        if (reexec !== null)
+            return reexec;
         reportNodeRuntime(runnable, Boolean(values.json) || Boolean(values.agent));
         return 1;
     }
@@ -1007,7 +1019,9 @@ function declaredPolicies(resolved) {
     }
     return declared;
 }
-const ASC_VERSION = '0.2.1';
+// RELEASE_VERSION 이 정본이다 — 여기 문자열을 따로 두면 릴리스마다 낡는다 (0.3.0 에서
+// 0.2.1 로 남아 lock 의 ascVersion 표기가 실제와 어긋났다).
+const ASC_VERSION = RELEASE_VERSION;
 const CAPABILITIES = ['scm.github', 'state.markdown', 'approval.local'];
 const ADAPTER_VERSIONS = { 'scm.github': ASC_VERSION, 'state.markdown': ASC_VERSION };
 /**
@@ -1520,9 +1534,18 @@ async function runProfile(command, values, root) {
         ...(values.preset ? { presetId: values.preset } : {}),
         overridePath: join(root, 'override.json'),
     });
-    // 무엇이 실제로 제공되는지는 붙어 있는 Adapter가 정한다
-    const capabilities = ['scm.github', 'state.markdown', 'approval.local'];
-    const result = resolveRuntime(layers, capabilities, ASC_VERSION);
+    // 무엇이 실제로 제공되는지는 붙어 있는 Adapter가 정한다 — 상수가 아니라 실측이다 (A5).
+    // discover→probe 를 실제로 돌린다: glab 로그인 같은 상태 변화가 resolve 재실행으로
+    // 반영된다 (re-probe 수단이 따로 필요 없다). 실측 실패는 그 갈래가 빠질 뿐이다.
+    const composed = await composeBindings({ context: { projectRoot: root, env: process.env } }).catch(() => ({ bindings: [] }));
+    for (const binding of composed.bindings) {
+        console.log(`Binding: ${binding.adapterId}/${binding.resource} — ${binding.state}${binding.detail ? ` (${binding.detail})` : ''}`);
+    }
+    // lock 의 capability 표기는 아직 상수다 — 실측을 digest 재료로 쓰면 glab 로그인 여부에
+    // 따라 lock 이 흔들린다. 실측을 lock 체계에 관통시키는 것은 P1 로 넘기고(재설계 영역),
+    // 여기서는 probe 실측을 사람에게 보이는 것까지 한다. 실사용 read 경로(proceed)는
+    // buildWorkIngress 가 이미 composeBindings 실측으로 조립한다.
+    const result = resolveRuntime(layers, CAPABILITIES, ASC_VERSION);
     if (!result.ok) {
         console.error('resolve failed:');
         for (const failure of result.failures) {
@@ -1535,7 +1558,7 @@ async function runProfile(command, values, root) {
     const lock = buildLock({
         runtime,
         ascVersion: ASC_VERSION,
-        adapters: { 'scm.github': ASC_VERSION, 'state.markdown': ASC_VERSION },
+        adapters: ADAPTER_VERSIONS,
         generatedAt,
     });
     console.log(`Layers: ${runtime.resolved.policy.layers.join(' → ')}`);
@@ -2068,7 +2091,10 @@ async function buildWorkIngress(store, root, runtime, resolved) {
         return undefined;
     // 저장소는 원격 provider 와 무관하게 본다. 이 한 줄이 P0-E 의 요점이다.
     const repo = new LocalRepoAdapter({ cwd: projectRoot });
-    const canonicalRef = resolved?.layers.profile.canonical.sources[0]?.ref;
+    const canonicalSource = resolved?.layers.profile.canonical.sources[0];
+    const canonicalRef = canonicalSource?.ref;
+    // remote 를 버리면 로컬 브랜치를 정본처럼 읽는다 — 실전 오판의 경로였다.
+    const canonicalRemote = canonicalSource?.remote;
     const canonicalPaths = resolved?.layers.profile.canonical.sources.flatMap((source) => source.paths) ?? [];
     const changeContext = ports.changeContext;
     return {
@@ -2114,6 +2140,7 @@ async function buildWorkIngress(store, root, runtime, resolved) {
             return repo.observe({
                 refHint: query.refHint,
                 ...(canonicalRef ? { canonicalRef } : {}),
+                ...(canonicalRemote ? { remote: canonicalRemote } : {}),
                 ...(paths.length > 0 ? { paths } : {}),
                 ...(modules.length > 0 ? { modulePaths: modules } : {}),
             });

package/dist/core/distribution/node-runtime.d.ts

@@ -42,3 +42,32 @@ export declare function majorOf(version: string): number | null;
  * 후보를 찾고, 후보에 대해서만 `-v` 를 묻는다.
  */
 export declare function checkNodeRuntime(deps: NodeRuntimeDeps): Promise<NodeRuntimeCheck>;
+/**
+ * 재실행 감시자. 이 변수가 있으면 이미 후보 Node 로 한 번 건너뛴 프로세스다 —
+ * 거기서도 하한 미달이면 후보 자체가 낡은 것이고, 또 건너뛰면 무한 루프다.
+ */
+export declare const REEXEC_SENTINEL = "ASC_NODE_REEXEC";
+export type ReexecSpawn = (path: string, args: string[], env: Record<string, string | undefined>) => {
+    status: number | null;
+    signal?: string | null;
+    error?: Error;
+};
+export type ReexecDeps = {
+    env: Record<string, string | undefined>;
+    spawn: ReexecSpawn;
+    /** 지금 이 CLI 의 entry 파일 — 같은 명령을 그대로 다시 돌린다. */
+    entry: string;
+};
+/**
+ * 호환 Node 를 이미 찾았으면 그 Node 로 **이 명령을 그대로 다시 돌린다** (A6).
+ *
+ * 진단(NODE_RUNTIME_REQUIRED)은 정상 동작이었지만, 후보를 찾아 놓고도 매 호출
+ * PATH prefix 를 처방하는 것은 persistent 사용성 결함이다 — 처방 대신 실행한다.
+ * PATH·shell profile 은 여전히 건드리지 않는다(불변식 ⑰): 프로세스 안의 재실행일 뿐이다.
+ *
+ * null 은 "재실행하지 않았다" — 후보 없음, 이미 재실행된 프로세스(sentinel), 또는
+ * spawn 실패. 그때는 기존 안내가 그대로 나간다.
+ */
+export declare function reexecWithCandidate(check: Extract<NodeRuntimeCheck, {
+    ok: false;
+}>, argv: readonly string[], deps: ReexecDeps): number | null;

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

@@ -73,3 +73,38 @@ export async function checkNodeRuntime(deps) {
         candidates,
     };
 }
+/**
+ * 재실행 감시자. 이 변수가 있으면 이미 후보 Node 로 한 번 건너뛴 프로세스다 —
+ * 거기서도 하한 미달이면 후보 자체가 낡은 것이고, 또 건너뛰면 무한 루프다.
+ */
+export const REEXEC_SENTINEL = 'ASC_NODE_REEXEC';
+/**
+ * 호환 Node 를 이미 찾았으면 그 Node 로 **이 명령을 그대로 다시 돌린다** (A6).
+ *
+ * 진단(NODE_RUNTIME_REQUIRED)은 정상 동작이었지만, 후보를 찾아 놓고도 매 호출
+ * PATH prefix 를 처방하는 것은 persistent 사용성 결함이다 — 처방 대신 실행한다.
+ * PATH·shell profile 은 여전히 건드리지 않는다(불변식 ⑰): 프로세스 안의 재실행일 뿐이다.
+ *
+ * null 은 "재실행하지 않았다" — 후보 없음, 이미 재실행된 프로세스(sentinel), 또는
+ * spawn 실패. 그때는 기존 안내가 그대로 나간다.
+ */
+export function reexecWithCandidate(check, argv, deps) {
+    if (deps.env[REEXEC_SENTINEL])
+        return null;
+    const candidate = check.candidates.find((c) => {
+        const major = majorOf(c.version);
+        return major !== null && major >= MINIMUM_NODE_MAJOR;
+    });
+    if (!candidate)
+        return null;
+    const child = deps.spawn(candidate.path, [deps.entry, ...argv], {
+        ...deps.env,
+        [REEXEC_SENTINEL]: '1',
+    });
+    if (child.error)
+        return null;
+    if (child.signal)
+        return 128 + (REEXEC_SIGNALS[child.signal] ?? 15);
+    return child.status ?? 0;
+}
+const REEXEC_SIGNALS = { SIGHUP: 1, SIGINT: 2, SIGTERM: 15 };

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.3.0";
-export declare const RUNTIME_SPEC = "@asc-agent/runtime@0.3.0";
-export declare const BOOTSTRAP_SPEC = "@asc-agent/bootstrap@0.3.0";
+export declare const RELEASE_VERSION = "0.3.1";
+export declare const RUNTIME_SPEC = "@asc-agent/runtime@0.3.1";
+export declare const BOOTSTRAP_SPEC = "@asc-agent/bootstrap@0.3.1";
 /**
  * 아직 설치되지 않은 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.3.0';
+export const RELEASE_VERSION = '0.3.1';
 export const RUNTIME_SPEC = `${RUNTIME_PACKAGE}@${RELEASE_VERSION}`;
 export const BOOTSTRAP_SPEC = `${BOOTSTRAP_PACKAGE}@${RELEASE_VERSION}`;
 /**

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

@@ -44,6 +44,12 @@ export type WorkStateInput = {
 export type WorkStateResult = {
     state: WorkState;
     leaning?: DecidedState;
+    /**
+     * 구현 존재 증거의 등급. direct 는 정본 자체가 말하는 것(조상·정본 경로·내용 등가),
+     * proxy 는 키를 경유한 추정(언급 grep·작업 트리 잔재), none 은 아무것도 없다.
+     * "이 키 기준으로 못 찾았다"와 "구현이 없다"를 가르는 것이 이 칸이다.
+     */
+    evidenceGrade: 'direct' | 'proxy' | 'none';
     /** 판정의 근거. 사람이 그대로 읽는다. */
     evidence: string[];
     /** 보려 했으나 못 본 것. 판정을 뒤집지는 않지만 숨기지도 않는다. */

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

@@ -33,6 +33,7 @@ export function judgeWorkState(input) {
             evidence,
             limitations,
             missing,
+            evidenceGrade: 'none',
         };
     }
     const repo = input.repo;
@@ -49,7 +50,8 @@ export function judgeWorkState(input) {
     // 언급은 그 자체로 증거가 아니다. 되돌리기만 있는 이력도 이 작업을 "언급"하고, 뒤이어
     // 걷혀 나간 변경도 그렇다. 살아남은 것이 있어야 정본에 있다고 말할 수 있다.
     const mentionSurvives = mentioned.length > 0 && repo.mentionedOnlyReverts !== true && repo.mentionedArtifactsPresent === true;
-    const merged = repo.mergedIntoCanonical === true || onCanonical.length > 0 || mentionSurvives;
+    const directEvidence = repo.mergedIntoCanonical === true || onCanonical.length > 0 || repo.contentEquivalent === true;
+    const merged = directEvidence || mentionSurvives;
     const hasBranch = repo.refs.length > 0;
     const artifacts = Object.entries(repo.pathsExist).filter(([, exists]) => exists);
     if (repo.canonicalRef)
@@ -58,6 +60,9 @@ export function judgeWorkState(input) {
         evidence.push(`작업 가지: ${repo.refs.join(', ')}`);
     if (repo.mergedIntoCanonical === true)
         evidence.push('작업 가지가 정본에 병합돼 있다');
+    if (repo.contentEquivalent === true) {
+        evidence.push('작업 가지의 내용이 전부 정본에 반영돼 있다 (조상은 아니다 — rebase·squash 등가)');
+    }
     if (onCanonical.length > 0)
         evidence.push(`정본에 산출물이 있다: ${onCanonical.map(([p]) => p).join(', ')}`);
     if (artifacts.length > 0)
@@ -85,6 +90,11 @@ export function judgeWorkState(input) {
         limitations.push(`선행 작업 상태를 확인하지 못했다: ${unknownDependencies.map((d) => d.reference).join(', ')}`);
     }
     const implemented = merged || artifacts.length > 0;
+    const evidenceGrade = directEvidence
+        ? 'direct'
+        : mentionSurvives || artifacts.length > 0
+            ? 'proxy'
+            : 'none';
     // ① 구현은 정본에 있는데 tracker 가 안 따라왔다. 여기서만 tracker 를 본다 — 그것도
     //    "끝났다고 말하지 않는다"는 사실로만. tracker 가 결론을 만드는 자리는 없다.
     //    확정하려면 **살아 있는 산출물**이 있어야 한다: 병합 흔적만으로는 부분 병합·스캐폴드·
@@ -94,35 +104,54 @@ export function judgeWorkState(input) {
     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 });
+        // 측정된 반증은 언급-생존보다 무겁다: 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 (merged && input.trackerDone === false) {
         // 병합 흔적은 있는데 생존을 확인하지 못했다 — 새 구현을 시키지도, 끝났다고 하지도 않는다.
         limitations.push('정본에 병합 흔적은 있으나 구현이 지금도 남아 있는지 확인하지 못했다');
-        return decided('IMPLEMENTATION_COMPLETE_BLOCKED_VERIFICATION', evidence, limitations, { demote: true });
+        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 });
+        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 });
+        return decided('BLOCKED_DEPENDENCY', evidence, limitations, { demote: false, grade: evidenceGrade });
     }
     if (!implemented && openDependencies.length > 0) {
-        return decided('BLOCKED_DEPENDENCY', evidence, limitations, { demote: false });
+        return decided('BLOCKED_DEPENDENCY', evidence, limitations, { demote: false, grade: evidenceGrade });
     }
     // ④ 검토가 답을 기다린다.
     if (typeof input.change === 'object' && requestsResponse(input.change, input.comments)) {
-        return decided('REVIEW_RESPONSE_REQUIRED', evidence, limitations, { demote: true });
+        return decided('REVIEW_RESPONSE_REQUIRED', evidence, limitations, { demote: true, grade: evidenceGrade });
     }
     // ⑤ 구현 증거도 없고 막힌 것도 없다.
+    //
+    //    "없다"는 신선한 정본에서만 성립한다. 당겨 오지 못한 관측 위의 "없음"은 원격이
+    //    이미 품고 있는 구현을 못 본 것일 수 있다 — 그때는 착수를 추천하지 않는다.
+    //    fetch 실패는 저장소 부재가 아니다: missing 은 freshness 를 따로 가리킨다.
     if (!implemented) {
-        evidence.push('정본·작업 트리 어디에도 구현 증거가 없다');
-        return decided('ACTIONABLE', evidence, limitations, { demote: true });
+        if (repo.freshness?.state !== 'FRESH') {
+            limitations.push(`정본을 원격에서 당겨 오지 못한 관측이다 (${repo.freshness?.state ?? 'UNKNOWN'}${repo.freshness?.detail ? ` — ${repo.freshness.detail}` : ''}) — 이 위에서 "구현이 없다"를 확정하지 않는다`);
+            return { state: 'UNDECIDABLE', evidence, limitations, missing: ['canonical-freshness'], evidenceGrade };
+        }
+        evidence.push('이 작업 키를 직접 가리키는 증거를 확인하지 못했다');
+        const result = decided('ACTIONABLE', evidence, limitations, { demote: true, grade: evidenceGrade });
+        // 구조적 한계 — 키 대조는 proxy 다. 다른 키의 커밋이 이 작업의 인수 조건을 이미
+        // 충족했을 가능성은 여기서 대조하지 않았다. 표기는 하되 이 한 줄로 판정을 되돌리지는
+        // 않는다 (모든 관측에 항상 붙는 한계라, demote 재료로 쓰면 ACTIONABLE 이 사라진다).
+        result.limitations.push('다른 키·경로로 이미 충족됐을 가능성은 대조하지 않았다 — 키 기준 관측의 구조적 한계');
+        return result;
     }
     // 구현 증거는 있는데 위 어디에도 안 걸린다 — 남은 것은 검증이고, 무엇이 막혔는지는 모른다.
-    return decided('IMPLEMENTATION_COMPLETE_BLOCKED_VERIFICATION', evidence, limitations, { demote: true });
+    return decided('IMPLEMENTATION_COMPLETE_BLOCKED_VERIFICATION', evidence, limitations, { demote: true, grade: evidenceGrade });
 }
 /** 검토가 응답을 요구하는가. provider 어휘를 해석하지 않고 두 가지 표시만 본다. */
 function requestsResponse(change, comments) {
@@ -139,7 +168,14 @@ function requestsResponse(change, comments) {
  */
 function decided(state, evidence, limitations, options) {
     if (options.demote && limitations.length > 0) {
-        return { state: 'DECIDABLE_WITH_LIMITATION', leaning: state, evidence, limitations, missing: [] };
+        return {
+            state: 'DECIDABLE_WITH_LIMITATION',
+            leaning: state,
+            evidence,
+            limitations,
+            missing: [],
+            evidenceGrade: options.grade,
+        };
     }
-    return { state, evidence, limitations, missing: [] };
+    return { state, evidence, limitations, missing: [], evidenceGrade: options.grade };
 }

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

@@ -44,6 +44,24 @@ export type RepoObservation = {
      * 않은 것을 확인했다고 하지 않는다.
      */
     mentionedArtifactsPresent?: boolean;
+    /**
+     * refs 중 정본의 조상은 아니지만 **내용이 전부 정본에 반영된**(rebase·cherry-pick 등가)
+     * 가지가 있는가. SHA·이슈 키가 사라져도 내용이 살아 있으면 "미구현"이 아니다.
+     * 로컬에 가지가 남아 있을 때만 잴 수 있다 — 못 쟀으면 undefined.
+     */
+    contentEquivalent?: boolean;
+    /**
+     * 정본 대조가 얼마나 신선한가. **관측했다 ≠ 신선하다** — 로컬만 읽은 관측은 원격이
+     * 전진한 사실을 모르고, 그 위에서 "구현 증거가 없다"는 결론은 성립하지 않는다.
+     *
+     *   FRESH         원격을 당겨 온 뒤의 원격 추적 ref 를 봤다
+     *   FETCH_FAILED  당기려 했으나 실패했다 — 관측은 낡았을 수 있다
+     *   UNKNOWN       당길 대상을 몰랐다 (remote 미선언 등)
+     */
+    freshness?: {
+        state: 'FRESH' | 'FETCH_FAILED' | 'UNKNOWN';
+        detail?: string;
+    };
     /** git 자체를 쓸 수 없었던 이유. 있으면 이 관측은 비어 있다. */
     unavailable?: string;
 };
@@ -51,6 +69,11 @@ export type RepoQuery = {
     /** ref 이름에서 찾을 조각. 보통 작업 항목 키. */
     refHint?: string;
     canonicalRef?: string;
+    /**
+     * canonicalRef 를 당겨 올 원격 이름 (Profile 의 canonical source 가 선언한 것).
+     * 있으면 observe 가 fetch 를 시도하고 원격 추적 ref 를 대조 기준으로 삼는다.
+     */
+    remote?: string;
     paths?: readonly string[];
     /** 범위 재료로만 확인할 자리들. 증거 칸에 섞이지 않는다. */
     modulePaths?: readonly string[];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@asc-agent/runtime",
-  "version": "0.3.0",
-  "description": "ASC (Agent Session Control) — local-first human-in-the-loop agent control plane: core, CLI, and adapters",
+  "version": "0.3.1",
+  "description": "ASC (Agent Session Control) \u2014 local-first human-in-the-loop agent control plane: core, CLI, and adapters",
   "keywords": [
     "agent",
     "control-plane",