@asc-agent/runtime 0.3.0 → 0.3.2

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.2
 ```
 
 npm owns the executable link (on Windows, npm's own `asc.cmd`). This package never edits

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

@@ -7,6 +7,7 @@
 // 호스트 세션이 자기 도구 목록을 보고 채우는 것은 별도 경로(host-report)다.
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import { resolveExternalCommand } from "../../core/distribution/external-command.js";
 const run = promisify(execFile);
 export const CAPABILITIES = [
     'cross_session_message',
@@ -26,8 +27,12 @@ export const CAPABILITIES = [
 /** 안전에 필수인 capability — 없으면 degrade가 아니라 STOP이다 (C-03 §5.2). */
 export const SAFETY_CRITICAL = ['external_write_guard'];
 const tryRun = async (command, args) => {
+    // Windows에서 `claude` 는 npm이 만든 `.cmd` shim이라 bare 이름 execFile은
+    // 실패한다 — PATH에 실재하는데 "못 찾았다"가 되는 오판이 실측에서 나왔다.
+    // 실행 형태를 먼저 해석해 세 OS에서 같은 의미로 부른다.
+    const resolved = resolveExternalCommand(command, args);
     try {
-        const { stdout } = await run(command, args, { timeout: 15_000 });
+        const { stdout } = await run(resolved.command, resolved.args, { timeout: 15_000 });
         return { ok: true, stdout };
     }
     catch {

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/jam/mcp-client.js

@@ -10,6 +10,7 @@
 //   stderr를 프로토콜로 읽지 않는다 — 진단용으로만 쓰고, 그것도 길이를 제한한다
 //   자격 값을 절대 기록하지 않는다 — 이 파일은 토큰을 받지도, 보지도, 남기지도 않는다
 import { spawn } from 'node:child_process';
+import { resolveExternalCommand } from "../../core/distribution/external-command.js";
 const PROTOCOL_VERSION = '2024-11-05';
 /** 진단으로 남길 stderr 최대 길이. 무한히 모으면 그 자체가 새는 곳이 된다. */
 const STDERR_KEEP = 2000;
@@ -30,9 +31,12 @@ export class JamMcpClient {
         if (this.#ready && this.#child)
             return { ok: true, value: { name: '', version: '' } };
         try {
+            // Windows에서 `jam` 은 npm `.cmd` shim이다 — bare 이름 spawn은 ENOENT가 나고
+            // (asc init 실측: "spawn jam ENOENT"), 실행 형태를 해석해야 세 OS에서 같다.
+            const resolved = resolveExternalCommand(this.#deps.command, this.#deps.args ?? []);
             this.#child = this.#deps.spawnProcess
                 ? this.#deps.spawnProcess()
-                : spawn(this.#deps.command, [...(this.#deps.args ?? [])], {
+                : spawn(resolved.command, resolved.args, {
                     stdio: ['pipe', 'pipe', 'pipe'],
                     ...(this.#deps.cwd ? { cwd: this.#deps.cwd } : {}),
                 });

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";
@@ -63,7 +64,7 @@ import { preflight } from "../core/operator/preflight.js";
 import { DraftProvenance, issueArgs, planSessionContract, } from "../core/operator/contract-draft.js";
 import { lookupAuthority } from "../core/policy/ownership.js";
 import { renderProgress } from "../core/operator/render.js";
-import { AuditLedger, decisionLines, delegationLine, executionLines, reclaimLine, validationLines, } from "../core/runtime/audit.js";
+import { AuditLedger, decisionLines, delegationLine, executionLines, reclaimLine, validationLines, DecisionClass, } from "../core/runtime/audit.js";
 import { ClosureLedger } from "../core/runtime/closure.js";
 import { Orchestrator, renderTick } from "../core/runtime/orchestrator.js";
 import { QueryLedger } from "../core/runtime/query.js";
@@ -158,7 +159,7 @@ const USAGE = `asc — Agent Session Control
   asc session pause  <ID> --position <text> --next <text> [--done <task>...]
   asc session resume <ID>
   asc session done   <ID> --verified <text> --next <text> [--done <task>...]
-                        [--changed <path>...] [--unresolved <text>...]
+                        [--changed <path>...] [--unresolved <text>...] [--physical <id>]
   asc session list
 
   asc controller collect
@@ -405,10 +406,32 @@ function reportNodeRuntime(check, asJson) {
         console.error(`  ${action.node.version} at ${action.node.path}\n    ${action.display}`);
 }
 export async function runAscCommand(argv, entry = 'runtime') {
-    const { values, positionals } = parseArgs({
+    let parsed;
+    try {
+        parsed = parseArgsOrThrow(argv);
+    }
+    catch (error) {
+        // 모르는 옵션은 사용자 입력 오류다 — Node 스택을 던지면 그때부터 도구를 의심하게 된다.
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Could not read the arguments: ${message.split('\n')[0]}`);
+        console.error('Run `asc --help` for the commands and flags this build understands.');
+        return 2;
+    }
+    const { values, positionals } = parsed;
+    // 실행 중인 버전을 묻는 유일한 공식 통로. 설치 안내가 버전을 핀으로 고정하는데
+    // 정작 지금 도는 것이 무엇인지 물을 방법이 없었다 (SSAFESTA Windows 실측 ASC-1).
+    if (values.version || positionals[0] === 'version') {
+        console.log(RELEASE_VERSION);
+        return 0;
+    }
+    return runParsedCommand(values, positionals, entry, argv);
+}
+function parseArgsOrThrow(argv) {
+    return parseArgs({
         args: argv,
         allowPositionals: true,
         options: {
+            version: { type: 'boolean', default: false },
             root: { type: 'string' },
             parent: { type: 'string' },
             'issued-by': { type: 'string' },
@@ -508,6 +531,8 @@ export async function runAscCommand(argv, entry = 'runtime') {
             help: { type: 'boolean', short: 'h', default: false },
         },
     });
+}
+async function runParsedCommand(values, positionals, entry, argv) {
     const [group, command, target, extra] = positionals;
     if (values.help || group === undefined) {
         console.log(USAGE);
@@ -521,6 +546,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;
     }
@@ -600,7 +636,7 @@ export async function runAscCommand(argv, entry = 'runtime') {
         return runFreeze(group, command, values, store);
     switch (command) {
         case 'list': {
-            const items = await operator.list({ all: values.all, ...(priority ? { priority } : {}) });
+            const items = await operator.list({ all: Boolean(values.all), ...(priority ? { priority } : {}) });
             console.log(values.json ? JSON.stringify(items, null, 2) : renderer.renderList(items).text);
             return 0;
         }
@@ -1007,7 +1043,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 };
 /**
@@ -1136,6 +1174,9 @@ async function detectSetupState(values, entry) {
     const { root: projectRoot, git } = await discoverProjectRoot(process.cwd());
     const resolution = await resolveRoot(process.cwd(), values.root);
     const ascRoot = resolution.kind === 'UNRESOLVED' ? undefined : resolution.root;
+    // 디렉터리가 있다고 붙은 것이 아니다 — profile.lock까지 서야 붙은 것이다. 빈 skeleton을
+    // "붙어 있음"으로 넘기면 plan이 applied를 답하며 실패할 proceed를 준다 (실측 ASC-2).
+    const attachmentBroken = ascRoot ? (await inspectSetup(ascRoot)).attachment === 'BROKEN' : false;
     const scope = values.scope === 'project' ? 'project' : 'local';
     const hostReport = await verifyInstall(defaultPaths());
     return {
@@ -1143,6 +1184,7 @@ async function detectSetupState(values, entry) {
         projectRoot,
         git,
         ...(ascRoot ? { ascRoot } : {}),
+        ...(attachmentBroken ? { attachmentBroken } : {}),
         ...(values.profile ? { requestedProfile: values.profile } : {}),
         profileCandidates: await availableProfiles(installRoot(), externalProfileRoot()),
         scope,
@@ -1520,9 +1562,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 +1586,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 +2119,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 +2168,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 } : {}),
             });
@@ -2318,9 +2373,16 @@ async function runSession(command, target, values, store, resolved) {
     const at = new Date().toISOString();
     switch (command) {
         case 'issue': {
+            // 누락과 오값은 다른 실수다 — "필수"라고 답하면 이미 준 사람은 자기가 무엇을
+            // 틀렸는지 모른다 (SSAFESTA Windows 실측 ASC-3).
+            const roleChoices = SessionRole.options.join('|');
+            if (values.role === undefined || !values.goal) {
+                console.error(`--role and --goal are required (role: ${roleChoices})`);
+                return 2;
+            }
             const role = SessionRole.safeParse(values.role);
-            if (!role.success || !values.goal) {
-                console.error('--role and --goal are required (role: planner|researcher|implementer|verifier)');
+            if (!role.success) {
+                console.error(`'${String(values.role)}' is not a role this build knows — choose one of: ${roleChoices}`);
                 return 2;
             }
             const authority = parseAuthority(values.authority);
@@ -2380,12 +2442,19 @@ async function runSession(command, target, values, store, resolved) {
                 console.error('At least one --evidence and one --why are required (C-13 §4).');
                 return 2;
             }
+            // 오값을 Core까지 흘리면 ZodError 원문이 사람에게 떨어진다 (실측 ASC-5).
+            // 사용자 입력 검증은 Surface의 몫이다 — 여기서 고를 수 있는 값을 그대로 준다.
+            const parsedClass = DecisionClass.safeParse(decisionClass);
+            if (!parsedClass.success) {
+                console.error(`'${decisionClass}' is not a decision class — choose one of: ${DecisionClass.options.join(', ')}`);
+                return 2;
+            }
             const audit = auditLedger(store);
             const recorded = await audit.decide({
                 sessionId: target,
                 actor: values.as ?? values.principal ?? '(미상)',
                 ownership: values.ownership ?? [],
-                class: decisionClass,
+                class: parsedClass.data,
                 evidenceRefs: [evidence[0], ...evidence.slice(1)],
                 selectedOption: selected,
                 alternatives: values.alternative ?? [],

package/dist/core/attach/setup-plan.d.ts

@@ -14,6 +14,14 @@ export type SetupState = {
     git: boolean;
     /** 이미 붙어 있으면 그 runtime 뿌리. 없으면 안 붙은 것이다. */
     ascRoot?: string;
+    /**
+     * runtime 디렉터리는 있는데 profile.lock을 읽지 못하는 상태 — 붙이다 만 것이다.
+     *
+     * 이것을 "붙어 있음"으로 읽으면 plan은 `applied`를 답하면서 실패할 `asc proceed`를
+     * 다음 행동으로 준다 (SSAFESTA Windows 실측 ASC-2: 파일 잠금이 빈 skeleton만 남긴
+     * 경우). 붙이다 만 상태는 붙일 것이 남은 상태다 — repair가 plan에 드러나야 한다.
+     */
+    attachmentBroken?: boolean;
     /** 붙어 있다면 무엇으로 붙었는가. */
     attachedProfile?: string;
     /** 사람이 `--profile` 로 지정한 것. */

package/dist/core/attach/setup-plan.js

@@ -17,7 +17,9 @@ export function computeSetupPlan(state) {
     const evidence = [
         `project=${state.projectRoot}`,
         state.git ? 'git=yes' : 'git=no',
-        state.ascRoot ? `attached=${state.ascRoot}` : 'attached=no',
+        state.ascRoot
+            ? `attached=${state.ascRoot}${state.attachmentBroken ? ' (BROKEN — profile.lock unreadable)' : ''}`
+            : 'attached=no',
         `scope=${state.scope}`,
     ];
     // 지금 명령이 어디서 도는가. 설치된 `asc` 가 없으면 bootstrap이고, 그때 agent에게
@@ -76,7 +78,7 @@ export function computeSetupPlan(state) {
             changes.push({ target: 'host-install', host: host.id, from: host.status });
         }
     }
-    if (state.ascRoot) {
+    if (state.ascRoot && !state.attachmentBroken) {
         // 붙어 있어도 **무엇을 고를 수 있었는지**는 사실이다. 사용자 소유 Profile을 새로 놓고
         // 계획을 물었을 때 그것이 어디에도 안 보이면, 놓은 사람은 경로를 의심하게 된다.
         if (state.profileCandidates.length > 0) {
@@ -84,7 +86,8 @@ export function computeSetupPlan(state) {
         }
         return finish(changes, evidence, state, mode, command);
     }
-    // 아직 안 붙었다. 무엇으로 붙을지는 사람이 정한다.
+    // 아직 안 붙었거나, 붙이다 말았다(BROKEN). 무엇으로 붙을지는 사람이 정한다 —
+    // BROKEN이면 같은 선택으로 다시 붙이는 것이 repair다.
     const profile = state.requestedProfile ?? soleCandidate(state.profileCandidates);
     if (!profile) {
         evidence.push(`profile candidates=${state.profileCandidates.join(', ') || '(none)'}`);

package/dist/core/distribution/external-command.d.ts

@@ -0,0 +1,22 @@
+export type ResolvedInvocation = {
+    command: string;
+    args: string[];
+};
+export type ResolveDeps = {
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+    /** 테스트 주입용 — 실제 파일시스템을 보지 않게 한다. */
+    exists?: (path: string) => boolean;
+    readText?: (path: string) => string | null;
+    nodePath?: string;
+};
+/**
+ * npm `.cmd` shim이 가리키는 JS 진입점.
+ *
+ * npm이 쓰는 shim은 두 세대가 있고 둘 다 `"%dp0%\<상대경로>" %*` 형태로 JS를 부른다:
+ *   "%_prog%"  "%dp0%\node_modules\<pkg>\<bin>.js" %*
+ *   "%dp0%\node.exe"  "%dp0%\node_modules\<pkg>\<bin>.js" %*
+ * 형태가 다르면 null — 아는 척하지 않고 cmd.exe 경로로 넘어간다.
+ */
+export declare function shimTarget(shimText: string): string | null;
+export declare function resolveExternalCommand(command: string, args: readonly string[], deps?: ResolveDeps): ResolvedInvocation;

package/dist/core/distribution/external-command.js

@@ -0,0 +1,79 @@
+// 바깥 CLI를 Windows에서도 실제로 찾아 부른다 (C-14 §11의 연장).
+//
+// Node는 보안 수정 이후 shell 없이 `.cmd` 를 실행하지 않는다. 그런데 npm이 전역 설치로
+// 만들어 주는 명령은 Windows에서 전부 `.cmd` shim이다 — bare 이름을 Unix 방식으로만
+// spawn하면 ENOENT/EINVAL이 나고, 호출자는 "설치돼 있지 않다"고 오판한다
+// (SSAFESTA Windows 실측: shim이 PATH에 실재하는데 host probe가 not found →
+// external_write_guard STOP까지 이어졌다).
+//
+// shell을 켜는 것은 답이 아니다 — 인자가 escape 없이 이어붙는다(DEP0190). 대신:
+//   ① PATH에서 `.exe` 를 찾으면 그대로 부른다 (shell 불필요).
+//   ② `.cmd` shim이면 그 안이 가리키는 JS 진입점을 읽어 지금 도는 node로 직접 부른다 —
+//      cli/asc.ts의 npm 해석(resolveCommand)과 같은 태도다.
+//   ③ shim을 못 읽으면 cmd.exe /d /c 로 그 .cmd 를 부른다 — cmd.exe는 진짜 실행 파일이라
+//      shell 옵션이 필요 없다.
+// 셋 다 실패하면 이름 그대로 돌려준다 — PATH에 진짜 실행 파일이 있는 환경이 그 경우다.
+import { existsSync, readFileSync } from 'node:fs';
+import { delimiter as winDelimiter, dirname, extname, isAbsolute, join } from 'node:path/win32';
+const defaultRead = (path) => {
+    try {
+        return readFileSync(path, 'utf8');
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * npm `.cmd` shim이 가리키는 JS 진입점.
+ *
+ * npm이 쓰는 shim은 두 세대가 있고 둘 다 `"%dp0%\<상대경로>" %*` 형태로 JS를 부른다:
+ *   "%_prog%"  "%dp0%\node_modules\<pkg>\<bin>.js" %*
+ *   "%dp0%\node.exe"  "%dp0%\node_modules\<pkg>\<bin>.js" %*
+ * 형태가 다르면 null — 아는 척하지 않고 cmd.exe 경로로 넘어간다.
+ */
+export function shimTarget(shimText) {
+    const match = /"%dp0%\\([^"%]+\.(?:js|mjs|cjs))"/i.exec(shimText);
+    return match ? match[1] : null;
+}
+export function resolveExternalCommand(command, args, deps = {}) {
+    const platform = deps.platform ?? process.platform;
+    if (platform !== 'win32')
+        return { command, args: [...args] };
+    // 경로나 확장자를 이미 갖췄으면 호출자가 알고 부르는 것이다 — 손대지 않는다.
+    if (isAbsolute(command) || command.includes('/') || command.includes('\\') || extname(command) !== '') {
+        return { command, args: [...args] };
+    }
+    const env = deps.env ?? process.env;
+    const exists = deps.exists ?? existsSync;
+    const readText = deps.readText ?? defaultRead;
+    const nodePath = deps.nodePath ?? process.execPath;
+    const pathValue = env.PATH ?? env.Path ?? '';
+    let firstShim = null;
+    for (const dir of pathValue.split(winDelimiter)) {
+        if (!dir)
+            continue;
+        const exe = join(dir, `${command}.exe`);
+        if (exists(exe))
+            return { command: exe, args: [...args] };
+        if (!firstShim) {
+            for (const ext of ['.cmd', '.bat']) {
+                const shim = join(dir, `${command}${ext}`);
+                if (exists(shim)) {
+                    firstShim = shim;
+                    break;
+                }
+            }
+        }
+    }
+    if (firstShim) {
+        const text = readText(firstShim);
+        const target = text ? shimTarget(text) : null;
+        if (target) {
+            const script = join(dirname(firstShim), target);
+            if (exists(script))
+                return { command: nodePath, args: [script, ...args] };
+        }
+        return { command: 'cmd.exe', args: ['/d', '/c', firstShim, ...args] };
+    }
+    return { command, args: [...args] };
+}

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

package/dist/core/operator/progress.js

@@ -76,7 +76,9 @@ export class ProgressService {
             return {
                 ok: false,
                 reason: 'NOT_OWNER',
-                detail: `${logicalSessionId} 에 Runtime이 붙어 있지 않다 — 먼저 소유권을 주장하라`,
+                // "주장하라"만으로는 다음 명령을 모른다 — 복구 명령까지가 오류 메시지다 (실측 ASC-4).
+                // Core는 host 이름을 모른다(B-17) — 자리만 비워 두면 Surface가 채운다.
+                detail: `${logicalSessionId} 에 Runtime이 붙어 있지 않다 — 먼저 소유권을 주장하라: asc host <host> bind ${logicalSessionId} --physical <id>`,
             };
         }
         if (binding.physicalSessionId !== physicalSessionId) {

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/core/runtime/session.js

@@ -70,7 +70,12 @@ export class SessionRuntime {
             return {
                 ok: false,
                 reason: 'NOT_OWNER',
-                detail: `${id} 에는 Runtime이 붙어 있다 — owner(${binding.physicalSessionId})만 기록할 수 있다`,
+                // owner가 누구인지만 말하면 owner 본인도 다음 명령을 모른다 — pause/done은
+                // `--physical <owner>` 로 자격을 대고, 아니면 소유권을 먼저 놓는다 (실측 ASC-6).
+                // Core는 host 이름을 모른다(B-17) — `<host>` 자리는 Surface의 어휘다.
+                detail: `${id} 에는 Runtime이 붙어 있다 — owner(${binding.physicalSessionId})만 기록할 수 있다. ` +
+                    `owner라면 --physical ${binding.physicalSessionId} 을 붙여 다시 실행하고, ` +
+                    `그 세션이 끝났다면 asc host <host> release ${id} --physical ${binding.physicalSessionId} 로 소유권을 놓아라`,
             };
         }
         if (binding.physicalSessionId !== physicalSessionId) {

package/dist/core/workspace/resolve.js

@@ -66,7 +66,13 @@ async function findProjectLocal(start, stopAt, exists) {
         // 정지선 자체는 보지 않는다 — 홈의 `.asc` 는 user runtime이지 프로젝트 상태가 아니다
         if (boundary && normalized === boundary)
             return null;
-        if (await exists(join(dir, ASC_DIR)))
+        const candidate = join(dir, ASC_DIR);
+        // 정지선이 홈이어도 **다른 홈**의 `.asc` 는 걸러지지 않는다. Windows는 temp
+        // 디렉터리가 사용자 프로필 아래라, temp의 프로젝트에서 위로 걷다 실사용자
+        // `~/.asc` 를 프로젝트 상태로 오인했다 (SSAFESTA 실측 — setup status가
+        // UNATTACHED 대신 BROKEN을 답한 원인). user runtime은 내용으로 알아본다:
+        // workspaces/·profiles/·runtime.json 은 홈에만 생긴다.
+        if ((await exists(candidate)) && !(await looksLikeUserRuntime(candidate, exists)))
             return dir;
         const parent = dirname(dir);
         if (parent === dir)
@@ -74,6 +80,14 @@ async function findProjectLocal(start, stopAt, exists) {
         dir = parent;
     }
 }
+/** `~/.asc` 꼴인가 — 프로젝트 부착이 아니라 이 기계의 user runtime 홈인가. */
+async function looksLikeUserRuntime(ascDir, exists) {
+    for (const marker of ['workspaces', 'profiles', 'runtime.json']) {
+        if (await exists(join(ascDir, marker)))
+            return true;
+    }
+    return false;
+}
 /** 사람이 읽는 한 줄. 왜 그 뿌리인지가 함께 와야 사람이 틀린 결합을 알아챈다. */
 export function resolutionLine(resolution) {
     switch (resolution.kind) {

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.2",
+  "description": "ASC (Agent Session Control) \u2014 local-first human-in-the-loop agent control plane: core, CLI, and adapters",
   "keywords": [
     "agent",
     "control-plane",