@asc-agent/runtime 0.5.4 → 0.6.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.5.4
+npm install -g @asc-agent/runtime@0.6.1
 ```
 
 npm owns the executable link (on Windows, npm's own `asc.cmd`). This package never edits

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

@@ -84,6 +84,27 @@ The user does not need to know this sequence. This is the one the skill follows.
 canonical source are all a person's call, and \`setup status\` already states the reason
 and the remedy.
 
+## "Update ASC" — one command per product, no questions
+
+Each product updates itself. ASC never updates JAM and JAM never updates ASC; the person
+asking for both is what puts them in one turn.
+
+\`\`\`text
+jam update      → verify it answered
+asc update      → verify it answered
+\`\`\`
+
+Order matters that way round: ASC's work channel reads JAM, so JAM lands first. Neither
+command asks anything on the normal path, and neither re-runs setup — an update replaces
+the executable and leaves the workspace, profile, bindings, canonical source, sessions and
+evidence exactly as they were. Do not reach for \`setup apply\` to update; that is the path
+that re-infers all of it.
+
+Read the state before acting when the person asked whether an update is needed:
+\`asc update check --json\` and \`jam update check --json\` change nothing. \`UNKNOWN\` means
+the registry could not be asked — it does not mean up to date, and it is not a failure to
+report as one.
+
 ## Procedure
 
 1. Run \`asc proceed --json\` (add \`--session <S-ID>\` to name a session).

package/dist/cli/asc.js

@@ -12,9 +12,11 @@ import { existsSync, readdirSync, realpathSync } from 'node:fs';
 import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 import { homedir, hostname, userInfo } from 'node:os';
-import { basename, dirname, join, resolve } from 'node:path';
+import { createHash } from 'node:crypto';
+import { basename, dirname, join, relative, resolve } from 'node:path';
 import { MINIMUM_NODE_MAJOR, checkNodeRuntime, reexecWithCandidate, } from "../core/distribution/node-runtime.js";
 import { RELEASE_VERSION, RUNTIME_PACKAGE } from "../core/distribution/release.js";
+import { planUpdate, requiredMajorFrom, updateLine } from "../core/distribution/update.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";
@@ -133,6 +135,10 @@ const USAGE = `asc — Agent Session Control
   asc runtime status [--json]              # which build is in use, and whether it observes
   asc runtime use package
   asc runtime use development <checkout>   # run a built checkout instead
+
+  asc update                               # install the newest release and verify it
+  asc update check [--json]                # what is installed, what is published
+  asc update plan  [--json]                # what would be done, changing nothing
   asc front [status] [--json]
   asc front open [--json]                  # a host session opened here — what is waiting
   asc escalate open <S-ID> --predicate <p>... --question <t> --blocked <node>...
@@ -701,12 +707,16 @@ async function runParsedCommand(values, positionals, entry, argv) {
     // 사람이 갇힌다.
     // 기계 수준 명령은 **프로젝트와 무관하다.** 붙지 않은 자리에서도 답해야 하고,
     // 등록된 서비스는 어느 프로젝트 안에서 도는 것이 아니다 (설계 §4.1).
-    const machineLevelRuntime = group === 'runtime' &&
-        (command === 'use' ||
-            command === 'status' ||
-            command === 'list' ||
-            command === 'service' ||
-            (command === 'tick' && Boolean(values.all)));
+    // 업데이트는 **갈아 끼우려는 그 build 로 넘어가면 안 된다** — 넘어가면 구본이 자기를
+    // 교체하는 셈이고, 교체 도중 그 파일들이 사라진다. 붙지 않은 자리에서도 답해야 하므로
+    // 기계 수준 명령과 같은 자리에 둔다.
+    const machineLevelRuntime = group === 'update' ||
+        (group === 'runtime' &&
+            (command === 'use' ||
+                command === 'status' ||
+                command === 'list' ||
+                command === 'service' ||
+                (command === 'tick' && Boolean(values.all))));
     if (!machineLevelRuntime) {
         const redispatched = await redispatchIfNeeded(argv);
         if (redispatched !== null)
@@ -729,6 +739,9 @@ async function runParsedCommand(values, positionals, entry, argv) {
         return runRuntimeTickAll(values);
     if (group === 'host')
         return runHost(command, positionals[2], positionals[3], values);
+    // 갈아 끼우는 일은 붙은 프로젝트와 무관하다 — 어느 자리에서 쳐도 같은 답이어야 한다.
+    if (group === 'update')
+        return runUpdate(command, values);
     // setup은 **붙기 전에도** 답을 줘야 한다. 아래 discoverRoot 실패는 exit 2로 끊는데,
     // 그러면 "아직 안 붙었다"를 확인하려고 부른 명령이 안 붙었다는 이유로 죽는다.
     if (group === 'setup')
@@ -2043,8 +2056,16 @@ async function checkBootstrap(root) {
         adapters: ADAPTER_VERSIONS,
         ascVersion: ASC_VERSION,
     });
-    if (outcome.ok)
+    if (outcome.ok) {
+        // 판번호만 낡은 lock 은 멈출 이유가 아니다. 다만 조용히 지나가지도 않는다 —
+        // 다음 재고정 때 따라온다는 것을 여기서 한 번 말한다.
+        if (outcome.staleLock) {
+            const moved = outcome.staleLock.find((drift) => drift.field === 'ascCore.version');
+            if (moved)
+                console.error(`(profile.lock was written by ASC ${moved.locked}; this is ${moved.current}. \`asc profile resolve --write\` records it.)`);
+        }
         return { code: 0, runtime: outcome.runtime };
+    }
     // 아직 붙이지 않았으면 설정 없이 도는 경로만 쓰는 것이므로 막지 않는다
     if (outcome.reason === 'NOT_ATTACHED')
         return { code: 0 };
@@ -3920,6 +3941,205 @@ function serviceEnvironment(node) {
     return { environment: { PATH: path } };
 }
 const serviceInterval = (values) => values['interval-min'] === undefined ? 5 * 60 : Math.max(60, Number(values['interval-min']) * 60);
+/**
+ * `asc update` — 돌던 것을 잃지 않고 갈아 끼운다 (C-14 §3).
+ *
+ * 이 명령이 있는 이유는 실측이다. 한 라운드에 설치본을 다섯 번 갈아 끼웠고, 매번 사람이
+ * 구본을 먼저 지우고 `setup` 을 통째로 다시 돌렸다. 뒤쪽이 특히 나쁘다 — `setup` 은
+ * profile·binding·정본을 **다시 추론**하는 경로이고, 업데이트는 이미 정해진 것 위에서
+ * 실행본만 바꾸는 일이다. 그래서 여기서는 그 함수들을 부르지 않는다.
+ *
+ * 순서는 계획이 정하고(`planUpdate`), 여기서는 그대로 실행한다.
+ */
+async function runUpdate(command, values) {
+    if (command !== undefined && command !== 'check' && command !== 'plan') {
+        console.error(`Unknown update command: ${command}\n\n${USAGE}`);
+        return 2;
+    }
+    const plan = await observeUpdate();
+    if (command === 'check' || command === 'plan') {
+        if (values.json) {
+            console.log(JSON.stringify({ package: RUNTIME_PACKAGE, ...plan }, null, 2));
+        }
+        else {
+            console.log(updateLine(plan));
+            for (const step of plan.steps)
+                console.log(`  ${step}`);
+        }
+        // 읽기는 상태를 판정하되 실패로 만들지 않는다 — 물어본 것에는 답한 것이다.
+        return 0;
+    }
+    if (plan.steps.length === 0) {
+        console.log(updateLine(plan));
+        // 못 하는 것과 할 것이 없는 것은 다르다. `CURRENT` 만 성공이다.
+        return plan.state === 'CURRENT' ? 0 : 1;
+    }
+    return applyUpdate(plan, values);
+}
+/**
+ * 세상의 사실을 모아 계획에 넘긴다. **판정은 여기서 하지 않는다** (`setup` 과 같은 태도).
+ *
+ * registry 를 못 물으면 그 사실이 그대로 계획에 간다 — 조회 실패를 "최신" 으로 뭉개면
+ * 그 답이 곧 사람이 업데이트를 건너뛰는 근거가 된다.
+ */
+async function observeUpdate() {
+    const latest = await execText('npm', ['view', RUNTIME_PACKAGE, 'version']);
+    const engines = latest ? await execText('npm', ['view', `${RUNTIME_PACKAGE}@${latest}`, 'engines.node']) : null;
+    const required = requiredMajorFrom(engines ?? undefined);
+    const installed = await detectStableInstall(nodeProcessRunner, latest ?? RELEASE_VERSION);
+    const node = await checkNodeRuntime(nodeRuntimeDeps());
+    return planUpdate({
+        ...(installed.installedVersion ? { installed: installed.installedVersion } : {}),
+        executableVisible: installed.executableVisible,
+        ...(latest ? { latest } : {}),
+        ...(required !== undefined ? { requiredNodeMajor: required } : {}),
+        nodeVersion: process.version,
+        ...(node.ok ? {} : { nodeCandidates: node.candidates }),
+    });
+}
+/**
+ * 계획대로 실행한다. **삭제하지 않는다** — npm 전역 설치는 같은 자리를 덮으므로 치울
+ * 구본이 없고, 치울 것이 있다고 적으면 그 단계는 언젠가 지우지 말아야 할 것을 지운다.
+ */
+async function applyUpdate(plan, values) {
+    const target = plan.to;
+    console.log(updateLine(plan));
+    // 무엇이 바뀌면 안 되는지를 **먼저** 적어 둔다. 업데이트가 건드려도 되는 것은 셋뿐이다 —
+    // 설치본, host 설치물, 기계 등록물. 나머지는 이미 정해진 것이고, 그것을 다시 정하는
+    // 경로(`setup`)를 부르지 않는다는 말은 여기서 증거로 확인된다.
+    const before = await protectedState();
+    const installed = await installStableRuntime(nodeProcessRunner, target);
+    if (!installed.ok) {
+        console.error(`install failed: ${installed.detail ?? '(no detail)'}`);
+        // 설치가 아예 안 됐다. 돌던 것이 그대로 서 있는지는 확인해야 안다 — npm 은 중간에서도
+        // 실패한다.
+        return rollbackUpdate(plan);
+    }
+    // npm 이 화내지 않았다는 것과 그 버전이 실제로 서 있다는 것은 다르다 (C-14 §3.3).
+    const verified = await verifyStableInstall(nodeProcessRunner, target);
+    if (!verified.ok) {
+        console.error(`verify failed: ${verified.remedy ?? verified.state.detail ?? verified.state.status}`);
+        return rollbackUpdate(plan);
+    }
+    console.log(`installed: ${RUNTIME_PACKAGE}@${target}`);
+    let worst = 0;
+    // host 설치물은 버전마다 내용이 바뀐다. 새 runtime 에 낡은 hook 을 남기지 않는다.
+    // **사람이 고친 것은 덮지 않는다** — 그것은 남의 파일이고, 덮으면 그 사람의 수정이
+    // 말없이 사라진다. 남은 것은 말하고, 업데이트 자체는 계속 간다.
+    const host = await install(hostPaths(), undefined, { force: false });
+    for (const path of host.written)
+        console.log(`host: ${path}`);
+    for (const skip of host.skipped) {
+        console.error(`host: ${skip.path} left as it is — ${skip.reason}`);
+        worst = 1;
+    }
+    // 등록물이 낡았으면 지금 형태로 수렴시킨다. 기존 STALE→수렴 경로를 그대로 쓴다.
+    worst = Math.max(worst, await convergeService(values));
+    // 마지막은 언제나 확인이다.
+    const health = await detectStableInstall(nodeProcessRunner, target);
+    if (health.status !== 'CURRENT') {
+        console.error(`health: ${health.detail ?? health.status}`);
+        return 1;
+    }
+    // 상태 불변 — 이 명령의 가장 중요한 계약이다.
+    const changed = diffState(before, await protectedState());
+    if (changed.length > 0) {
+        // 회차가 겹쳐 관측 기록이 늘어난 것일 수도 있다. 어느 쪽이든 **무엇이 달라졌는지
+        // 말한다** — "안 바뀌었다"를 확인 없이 적는 것이 이 계약을 없애는 방식이다.
+        console.error(`state changed during the update (${changed.length}):`);
+        for (const path of changed.slice(0, 10))
+            console.error(`  ${path}`);
+        worst = 1;
+    }
+    else {
+        console.log('state: unchanged');
+    }
+    console.log(`asc ${target} is current.`);
+    return worst;
+}
+/**
+ * 바뀌면 안 되는 것들. **위치를 새로 정하지 않는다** — 이 machine 의 `~/.asc` 가 그대로
+ * 그 자리이고, 업데이트가 건드려도 되는 셋(설치본·host 설치물·기계 등록물)은 여기 없다.
+ *
+ * 등록물이 회차마다 다시 쓰는 lease·log 는 상태가 아니라 실행 흔적이라 뺀다.
+ */
+async function protectedState() {
+    const home = ascHome();
+    const state = new Map();
+    const skip = new Set(['runtime-lease.json', 'service.log']);
+    const walk = async (dir) => {
+        for (const entry of await readdir(dir, { withFileTypes: true }).catch(() => [])) {
+            const full = join(dir, entry.name);
+            if (skip.has(relative(home, full)))
+                continue;
+            if (entry.isDirectory())
+                await walk(full);
+            else
+                state.set(relative(home, full), createHash('sha256').update(await readFile(full).catch(() => Buffer.alloc(0))).digest('hex'));
+        }
+    };
+    await walk(home);
+    return state;
+}
+/** 달라진 경로들. 없어진 것도 달라진 것이다. */
+function diffState(before, after) {
+    const changed = [];
+    for (const [path, digest] of before)
+        if (after.get(path) !== digest)
+            changed.push(path);
+    for (const path of after.keys())
+        if (!before.has(path))
+            changed.push(path);
+    return changed.sort();
+}
+/**
+ * 되돌린다. **되돌릴 자리가 있을 때만** — 없던 것으로 되돌릴 수는 없고, 그때는 돌던 것이
+ * 없었다는 사실을 그대로 말한다.
+ */
+async function rollbackUpdate(plan) {
+    if (!plan.rollbackTo) {
+        console.error('Nothing to roll back to — this machine had no installed runtime before.');
+        return 1;
+    }
+    console.error(`rolling back to ${plan.rollbackTo}`);
+    const back = await installStableRuntime(nodeProcessRunner, plan.rollbackTo);
+    const verified = back.ok ? await verifyStableInstall(nodeProcessRunner, plan.rollbackTo) : null;
+    if (verified?.ok) {
+        console.error(`UPDATE_FAILED_ROLLED_BACK — asc ${plan.rollbackTo} is current again.`);
+        return 1;
+    }
+    // 되돌리기까지 실패했다. 여기서부터는 사람의 자리다 — 숨기지 않는다.
+    console.error(`BROKEN — rollback failed: ${back.detail ?? verified?.remedy ?? '(no detail)'}`);
+    console.error(`Install it directly: npm install -g ${RUNTIME_PACKAGE}@${plan.rollbackTo}`);
+    return 1;
+}
+/** 등록물을 지금 실행본으로 수렴시킨다. 등록이 없던 기계에 새로 만들지는 않는다. */
+async function convergeService(values) {
+    const adapter = serviceAdapter();
+    if (!adapter)
+        return 0;
+    const runtime = await serviceRuntime();
+    if (runtime.kind !== 'STABLE') {
+        console.error(`service: ${serviceRuntimeLine(runtime)}`);
+        return 1;
+    }
+    const wanted = serviceCommand(serviceInterval(values), runtime);
+    const plan = await planPersistentRuntime(adapter, wanted).catch(() => null);
+    if (!plan)
+        return 0;
+    if (plan.action === 'none' || plan.action === 'unsupported') {
+        console.log(`service: ${persistentRuntimeLine(adapter.id, plan)}`);
+        return 0;
+    }
+    // 등록이 없던 기계라면 `install` 이 계획된다 — 업데이트가 등록을 새로 만들지는 않는다.
+    if (plan.action === 'install') {
+        console.log('service: not registered on this machine — leaving it that way (`asc runtime service install`)');
+        return 0;
+    }
+    await adapter.install(wanted);
+    console.log(`service: converged with ${adapter.id}`);
+    return 0;
+}
 /**
  * `asc runtime service` — 이 기계의 지속 등록 (설계 §4).
  *

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.5.4";
-export declare const RUNTIME_SPEC = "@asc-agent/runtime@0.5.4";
-export declare const BOOTSTRAP_SPEC = "@asc-agent/bootstrap@0.5.4";
+export declare const RELEASE_VERSION = "0.6.1";
+export declare const RUNTIME_SPEC = "@asc-agent/runtime@0.6.1";
+export declare const BOOTSTRAP_SPEC = "@asc-agent/bootstrap@0.6.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.5.4';
+export const RELEASE_VERSION = '0.6.1';
 export const RUNTIME_SPEC = `${RUNTIME_PACKAGE}@${RELEASE_VERSION}`;
 export const BOOTSTRAP_SPEC = `${BOOTSTRAP_PACKAGE}@${RELEASE_VERSION}`;
 /**

package/dist/core/distribution/update.d.ts

@@ -0,0 +1,59 @@
+import { type NodeCandidate } from './node-runtime.ts';
+export type UpdateState = 
+/** 설치본이 registry 의 최신과 같다. */
+'CURRENT' | 'UPDATE_AVAILABLE'
+/** 대상이 요구하는 Node 가 이 기계에 없다 — 설치하지 않는다. */
+ | 'INCOMPATIBLE'
+/** 설치는 돼 있는데 실행물이 보이지 않는다. 새 것을 얹기 전에 그 사실을 말한다. */
+ | 'BROKEN'
+/** registry 를 물어보지 못했다. **아무 주장도 하지 않는다.** */
+ | 'UNKNOWN';
+/**
+ * 실행 순서. **지우는 단계가 없다** — 위 주석의 이유다.
+ */
+export type UpdateStep = 'install' | 'verify-install'
+/** 버전마다 skill·hook 내용이 바뀐다. 새 runtime 에 낡은 hook 을 남기지 않는다. */
+ | 'refresh-host'
+/** 등록물이 낡았으면 지금 형태로 수렴시킨다. 기존 STALE→수렴 경로를 그대로 쓴다. */
+ | 'converge-service' | 'verify-health';
+export declare const UPDATE_ORDER: readonly UpdateStep[];
+export type UpdateInput = {
+    /** 전역에 실제로 있는 버전. 없으면 설치된 적이 없다. */
+    installed?: string;
+    /** 그 실행물이 이 프로세스에서 보이는가. */
+    executableVisible: boolean;
+    /** registry 가 말한 최신. 못 물었으면 없다 — 그때는 아무 판정도 하지 않는다. */
+    latest?: string;
+    /** 대상이 요구하는 Node 하한. 모르면 이 build 의 하한을 쓴다. */
+    requiredNodeMajor?: number;
+    /** 지금 이 프로세스의 Node 버전. */
+    nodeVersion: string;
+    /** 이 기계에서 찾은 다른 Node 들. 지금 것이 낮을 때만 본다. */
+    nodeCandidates?: readonly NodeCandidate[];
+};
+export type UpdatePlan = {
+    state: UpdateState;
+    from?: string;
+    to?: string;
+    /** 할 일. `INCOMPATIBLE`·`UNKNOWN`·`CURRENT` 에서는 비어 있다. */
+    steps: readonly UpdateStep[];
+    /**
+     * 되돌릴 대상. **설치되어 있던 버전이 있을 때만** 채운다 — 없던 것으로 되돌릴 수는 없다.
+     */
+    rollbackTo?: string;
+    detail?: string;
+};
+/**
+ * 무엇을 할 것인가. **아무것도 하지 않는다** — 사실은 호출자가 관측해 넘긴다.
+ */
+export declare function planUpdate(input: UpdateInput): UpdatePlan;
+/** 사람이 읽는 한 줄. 왜 그 판정인지가 함께 와야 한다. */
+export declare function updateLine(plan: UpdatePlan): string;
+/**
+ * `engines.node` 가 말하는 하한. `">=24"` · `">=24.0.0 <27"` 같은 형태를 읽는다.
+ *
+ * **못 읽으면 `undefined` 다** — 0 으로 뭉개면 아무 Node 나 통과하고, 큰 수로 뭉개면
+ * 멀쩡한 기계가 INCOMPATIBLE 이 된다. 모르는 것은 모른다고 하고 호출자가 이 build 의
+ * 하한을 쓴다.
+ */
+export declare function requiredMajorFrom(engines: string | undefined): number | undefined;

package/dist/core/distribution/update.js

@@ -0,0 +1,106 @@
+// Update — 갈아 끼우되, 돌던 것을 잃지 않는다 (C-14 §3 의 연장).
+//
+// 이 파일이 있는 이유는 실측이다. 한 라운드에 설치본을 다섯 번 갈아 끼웠고, 매번 사람이
+// 이런 것을 손으로 했다:
+//
+//   npm uninstall -g …          구본을 먼저 지운다 — 실패하면 아무것도 안 남는 순서다
+//   rm -rf ~/.npm/_npx/*        캐시를 지운다
+//   setup apply 를 다시 실행     profile·binding·정본을 **다시 추론**한다
+//
+// 마지막 것이 가장 나쁘다. 업데이트는 설정을 다시 정하는 행위가 아니다. 이미 정해진 것
+// 위에서 실행본만 바꾸는 일이고, 그래서 순서가 정해져 있다:
+//
+//   놓는다 → 선 것을 확인한다 → 갈아 끼운다 → 다시 확인한다
+//
+// 지우는 단계는 없다. npm 전역 설치는 같은 자리를 덮으므로 치울 구본이 없고, 치울 것이
+// 있다고 적으면 그 단계는 언젠가 지우지 말아야 할 것을 지운다.
+//
+// **모르는 것을 최신으로 읽지 않는다.** registry 를 못 물었을 때 "최신입니다" 라고 답하면
+// 그 답이 곧 사람이 업데이트를 건너뛰는 근거가 된다.
+import { majorOf, MINIMUM_NODE_MAJOR } from "./node-runtime.js";
+export const UPDATE_ORDER = [
+    'install',
+    'verify-install',
+    'refresh-host',
+    'converge-service',
+    'verify-health',
+];
+/** 이 기계가 그 Node 하한을 만족하는가. 지금 것이 낮으면 다른 후보를 본다. */
+function nodeSatisfies(input, required) {
+    const current = majorOf(input.nodeVersion);
+    if (current !== null && current >= required)
+        return true;
+    return (input.nodeCandidates ?? []).some((candidate) => {
+        const major = majorOf(candidate.version);
+        return major !== null && major >= required;
+    });
+}
+/**
+ * 무엇을 할 것인가. **아무것도 하지 않는다** — 사실은 호출자가 관측해 넘긴다.
+ */
+export function planUpdate(input) {
+    if (!input.latest) {
+        return {
+            state: 'UNKNOWN',
+            steps: [],
+            ...(input.installed ? { from: input.installed } : {}),
+            detail: 'the registry could not be asked — nothing is claimed about being up to date',
+        };
+    }
+    const required = input.requiredNodeMajor ?? MINIMUM_NODE_MAJOR;
+    if (!nodeSatisfies(input, required)) {
+        return {
+            state: 'INCOMPATIBLE',
+            ...(input.installed ? { from: input.installed } : {}),
+            to: input.latest,
+            steps: [],
+            detail: `${input.latest} needs Node ${required} or newer, and this machine has none — nothing was installed`,
+        };
+    }
+    // 설치는 됐는데 부를 수 없다. 새 것을 얹으면 그 사실이 덮이므로 먼저 말한다.
+    if (input.installed && !input.executableVisible) {
+        return {
+            state: 'BROKEN',
+            from: input.installed,
+            to: input.latest,
+            steps: [...UPDATE_ORDER],
+            rollbackTo: input.installed,
+            detail: `${input.installed} is installed but its executable is not visible — updating will reinstall it`,
+        };
+    }
+    if (input.installed === input.latest) {
+        return { state: 'CURRENT', from: input.installed, to: input.latest, steps: [] };
+    }
+    return {
+        state: 'UPDATE_AVAILABLE',
+        ...(input.installed ? { from: input.installed, rollbackTo: input.installed } : {}),
+        to: input.latest,
+        steps: [...UPDATE_ORDER],
+    };
+}
+/** 사람이 읽는 한 줄. 왜 그 판정인지가 함께 와야 한다. */
+export function updateLine(plan) {
+    switch (plan.state) {
+        case 'CURRENT':
+            return `Up to date — ${plan.to}`;
+        case 'UPDATE_AVAILABLE':
+            return plan.from ? `Update available — ${plan.from} → ${plan.to}` : `Not installed — ${plan.to} is available`;
+        case 'INCOMPATIBLE':
+        case 'UNKNOWN':
+        case 'BROKEN':
+            return `${plan.state}: ${plan.detail ?? '(no detail)'}`;
+    }
+}
+/**
+ * `engines.node` 가 말하는 하한. `">=24"` · `">=24.0.0 <27"` 같은 형태를 읽는다.
+ *
+ * **못 읽으면 `undefined` 다** — 0 으로 뭉개면 아무 Node 나 통과하고, 큰 수로 뭉개면
+ * 멀쩡한 기계가 INCOMPATIBLE 이 된다. 모르는 것은 모른다고 하고 호출자가 이 build 의
+ * 하한을 쓴다.
+ */
+export function requiredMajorFrom(engines) {
+    if (!engines)
+        return undefined;
+    const match = /(\d+)/.exec(engines.replace(/^[^\d]*/, ''));
+    return match ? Number(match[1]) : undefined;
+}

package/dist/core/resolver/load.d.ts

@@ -85,6 +85,11 @@ export type BootstrapOutcome = {
     ok: true;
     runtime: ResolvedRuntime;
     lock: ProfileLock;
+    /**
+     * lock 이 이 build 가 아닌 판번호로 적혀 있다. 멈출 일은 아니고 (사람이 고친 설정이
+     * 아니다), 기록이 낡았다는 사실은 말한다.
+     */
+    staleLock?: LockDrift[];
 }
 /** attach 전이다. `.asc/` 자체가 없다 — 설정 없이 도는 경로만 허용된다. */
  | {
@@ -130,3 +135,16 @@ export declare function bootstrapGuard(input: {
     adapters: Record<string, string>;
     ascVersion: string;
 }): Promise<BootstrapOutcome>;
+/**
+ * 사람이 정해야 하는 어긋남만 남긴다 (C-14 실측).
+ *
+ * lock 은 **사람이 바꾼 설정**을 잡으라고 있는 파일이다. runtime 을 갈아 끼우면
+ * `ascCore.version` 과 함께 딸려 오는 adapter 판번호가 바뀌고, 그 둘이 재료인
+ * `configurationDigest` 도 따라 바뀐다 — 사람이 아무것도 고치지 않았는데 셋이 어긋난다.
+ * 그 상태로 멈추면 업데이트가 그 machine 의 모든 프로젝트를 세운다.
+ *
+ * 실측이 그것이었다: 이 machine 의 workspace 세 개가 전부 `0.3.1 → 0.6.0` 한 가지 이유로
+ * 서 있었고, 그 중 둘은 그렇게 여러 릴리스 동안 회차를 돌지 못했다. Profile·Preset·
+ * Override·capability 가 어긋나면 지금처럼 멈춘다 — 그것이 사람의 결정이다.
+ */
+export declare function configurationDrifts(drifts: readonly LockDrift[]): LockDrift[];

package/dist/core/resolver/load.js

@@ -261,7 +261,28 @@ export async function bootstrapGuard(input) {
         generatedAt: locked.generatedAt,
     });
     const drifts = compareLock(locked, current);
-    if (drifts.length > 0)
+    const configuration = configurationDrifts(drifts);
+    if (configuration.length > 0) {
         return { ok: false, reason: 'LOCK_DRIFT', drifts, runtime: resolved.runtime };
-    return { ok: true, runtime: resolved.runtime, lock: locked };
+    }
+    // 남은 것이 있다면 그것은 **이 build 가 옮겨 온 것**이다. 멈출 일이 아니지만 없던 일도
+    // 아니므로 그대로 실어 보낸다 — 호출자가 한 줄 말하고, lock 은 다음 재고정 때 따라온다.
+    return { ok: true, runtime: resolved.runtime, lock: locked, ...(drifts.length > 0 ? { staleLock: drifts } : {}) };
+}
+/**
+ * 사람이 정해야 하는 어긋남만 남긴다 (C-14 실측).
+ *
+ * lock 은 **사람이 바꾼 설정**을 잡으라고 있는 파일이다. runtime 을 갈아 끼우면
+ * `ascCore.version` 과 함께 딸려 오는 adapter 판번호가 바뀌고, 그 둘이 재료인
+ * `configurationDigest` 도 따라 바뀐다 — 사람이 아무것도 고치지 않았는데 셋이 어긋난다.
+ * 그 상태로 멈추면 업데이트가 그 machine 의 모든 프로젝트를 세운다.
+ *
+ * 실측이 그것이었다: 이 machine 의 workspace 세 개가 전부 `0.3.1 → 0.6.0` 한 가지 이유로
+ * 서 있었고, 그 중 둘은 그렇게 여러 릴리스 동안 회차를 돌지 못했다. Profile·Preset·
+ * Override·capability 가 어긋나면 지금처럼 멈춘다 — 그것이 사람의 결정이다.
+ */
+export function configurationDrifts(drifts) {
+    return drifts.filter((drift) => !VERSION_SHAPED.has(drift.field) && !drift.field.startsWith('adapters.'));
 }
+/** runtime 을 갈아 끼우는 것만으로 바뀌는 자리들. */
+const VERSION_SHAPED = new Set(['ascCore.version', 'configurationDigest']);

package/package.json

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