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

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

@@ -231,7 +231,11 @@ try {
   process.exit(0) // 입력을 못 읽으면 판단하지 않는다 — guard 오작동으로 전부 막는 것이 더 나쁘다
 }
 
-if (input.tool_name !== 'Bash') process.exit(0)
+// 파일을 바꾸는 도구는 **일을 시작한다는 신호**다 (F6). 읽기는 여기 없다 — 상태를 보는
+// 세션까지 관리 대상으로 끌어들이면 그것은 자동화가 아니라 방해다.
+const MUTATORS = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit'])
+const isMutation = MUTATORS.has(String(input.tool_name ?? ''))
+if (input.tool_name !== 'Bash' && !isMutation) process.exit(0)
 const command = String(input.tool_input?.command ?? '')
 
 const cwd = input.cwd ?? process.cwd()
@@ -259,6 +263,24 @@ const ascRoot = registered ? registered.root : findAscRoot(cwd)
 if (!ascRoot) process.exit(0)
 
 const managed = findManaged(ascRoot, observedSessionId)
+
+// **일이 시작되는데 논리 세션이 없다** (F6). 사람이 "ASC 적용해" 라고 말해야 했던 자리다.
+// 여기서 막고 다음 한 걸음을 그대로 준다 — 그 명령을 실행하는 것은 agent 이고, 사람이
+// 아니다. 세션에 들어간 뒤에는 이 문이 다시 열린다.
+if (isMutation && !managed) {
+  const id = observedSessionId || '<this session id>'
+  console.error(
+    [
+      '[ASC] 이 workspace 는 ASC 가 관리한다. 파일을 바꾸기 전에 논리 세션 안에 들어가라.',
+      '  asc proceed --work <WORK-KEY> --json     # 작업 항목이 있으면',
+      '  asc proceed --json                       # 이어갈 세션을 고르거나 계약을 제안받는다',
+      '  asc host claude bind <S-ID> --physical ' + id,
+      '읽기·조회는 막지 않는다 — 막는 것은 관리 밖의 변경뿐이다.',
+    ].join('\\n'),
+  )
+  process.exit(2)
+}
+
 if (!managed) process.exit(0)
 
 // 관찰은 여기서 끝난다 — 아래 차단 판정은 이 호출의 성패를 보지 않는다
@@ -266,6 +288,9 @@ try {
   recordActivity(ascRoot, managed, observedSessionId, String(input.tool_name ?? ''))
 } catch {}
 
+// 변경 도구는 여기까지다 — 아래 목록은 Bash 명령에 대한 것이다.
+if (isMutation) process.exit(0)
+
 for (const { pattern, label } of FORBIDDEN) {
   if (pattern.test(command)) {
     console.error(

package/dist/adapters/claude-code/install.d.ts

@@ -10,6 +10,32 @@ export type InstallPaths = {
     entry?: string;
 };
 export declare const defaultPaths: () => InstallPaths;
+/**
+ * ASC가 등록하는 hook들. 이벤트마다 **하나**씩이며 중복 등록은 그 자체가 결함이다.
+ *
+ * `_asc` 표식이 소유권의 근거다 — 이것이 붙은 항목만 우리가 고치고 지운다.
+ */
+type HookSpec = {
+    event: string;
+    marker: string;
+    /** 이 이벤트가 matcher를 쓰는가. SessionStart는 도구 이름으로 거르지 않는다. */
+    matcher?: string;
+    script: string;
+};
+export declare function locate(paths: InstallPaths): {
+    /** Bundle 전체. 파일이 늘어도 아래 계약(manifest·digest·멱등)은 그대로다 (C-05 §5). */
+    skills: {
+        name: string;
+        path: string;
+        text: string;
+    }[];
+    /** hook은 **하나**로 둔다. guard는 안전 층이고 중복 등록은 그 자체가 위험이다. */
+    hook: string;
+    front: string;
+    settings: string;
+    manifest: string;
+    hooks: HookSpec[];
+};
 export type InstallOutcome = {
     written: string[];
     skipped: {
@@ -72,3 +98,4 @@ export type UninstallOutcome = {
 };
 /** manifest로 증명되는 것만 제거한다. 사용자가 고친 파일은 남기고 이유를 말한다. */
 export declare function uninstall(paths: InstallPaths): Promise<UninstallOutcome>;
+export {};

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

@@ -20,7 +20,7 @@ const sha = (text) => createHash('sha256').update(text).digest('hex').slice(0, 1
 export const defaultPaths = () => ({ claudeHome: join(homedir(), '.claude') });
 const HOOK_MARKER = 'asc-external-write-guard';
 const FRONT_MARKER = 'asc-front-binding';
-function locate(paths) {
+export function locate(paths) {
     const guard = join(paths.claudeHome, 'asc', 'guard-hook.mjs');
     const front = join(paths.claudeHome, 'asc', 'front-hook.mjs');
     return {
@@ -38,6 +38,8 @@ function locate(paths) {
         hooks: (() => {
             const specs = [
                 { event: 'PreToolUse', marker: HOOK_MARKER, matcher: 'Bash', script: guard },
+                // 파일을 바꾸는 도구도 같은 문을 지난다 — 일이 시작되는 신호이기 때문이다 (F6).
+                { event: 'PreToolUse', marker: HOOK_MARKER, matcher: 'Edit|Write|MultiEdit|NotebookEdit', script: guard },
             ];
             // 부를 곳을 모르면 심지 않는다 (§InstallPaths.entry)
             if (paths.entry)

package/dist/cli/asc.js

@@ -14,7 +14,7 @@ import { fileURLToPath } from 'node:url';
 import { homedir, hostname, userInfo } from 'node:os';
 import { basename, dirname, join, resolve } from 'node:path';
 import { MINIMUM_NODE_MAJOR, checkNodeRuntime, reexecWithCandidate, } from "../core/distribution/node-runtime.js";
-import { RELEASE_VERSION } from "../core/distribution/release.js";
+import { RELEASE_VERSION, RUNTIME_PACKAGE } 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";
@@ -47,6 +47,7 @@ import { evaluateHealth, healthAlertLines } from "../core/monitor/health-alerts.
 import { Operator } from "../core/operator/proceed.js";
 import { deriveSessionContractDraft } from "../core/operator/derive-draft.js";
 import { servicePath } from "../core/distribution/external-command.js";
+import { isTransientPath, resolveServiceRuntime, serviceRuntimeLine, } from "../core/distribution/service-runtime.js";
 import { LocalCanonicalReader } from "../adapters/local/canonical.js";
 import { LocalRepoAdapter } from "../adapters/local/repo.js";
 import { GitHubAdapter } from "../adapters/github/adapter.js";
@@ -56,7 +57,7 @@ import { healJam, healLine } from "../adapters/jam/setup.js";
 import { statusIndicatesDone } from "../adapters/jam/ports.js";
 import { ProgressService } from "../core/operator/progress.js";
 import { composeBindings, defaultAdapters } from "../composition/registry.js";
-import { buildObservationChannels, buildRuntimePorts, closeToolClients, rolesFor } from "../composition/runtime.js";
+import { buildObservationChannels, buildRuntimePorts, closeToolClients, rolesFor, workItemRoles, } from "../composition/runtime.js";
 import { proposeBindings } from "../composition/propose.js";
 import { buildEventObservation } from "../composition/observe.js";
 import { availableProfiles, planBootstrap, renderPlan } from "../core/attach/bootstrap.js";
@@ -1331,6 +1332,207 @@ async function runSetup(command, values, entry = 'runtime') {
  * Core의 planner는 파일도 network도 모른다 — 사실은 여기서 관측해 넘긴다. 그래야
  * "이 명령이 무엇을 바꿀 것인가"를 아무것도 바꾸지 않고 물어볼 수 있다.
  */
+/**
+ * 이 저장소가 스스로 증명하는 Profile 이름 (P0 F2).
+ *
+ * **파일을 만들지 않는다** — 이름과 "이미 있는가"만 관측한다. 다른 논리 workspace 를
+ * 찾아 합치는 것이 아니라, 이 checkout 의 remote 하나에서 읽히는 신원이다 (C-11 유지).
+ */
+async function adoptableState(projectRoot, git) {
+    if (!git)
+        return {};
+    const remotes = await gitRemotes(projectRoot);
+    if (remotes.length === 0)
+        return {};
+    try {
+        const adopted = buildAdoptedProfile({
+            dirName: basename(projectRoot),
+            remotes,
+            scmForHost: (host) => (host === 'github.com' ? 'github' : 'git'),
+        });
+        // **공유 주소가 없으면 후보가 아니다.** remote 가 프로젝트 신원을 증명하지 못하면
+        // 그것은 이 기계 안의 폴더일 뿐이고, 무엇으로 붙을지는 사람이 정한다.
+        const project = adopted.profile.project;
+        if (!project?.repository || project.repository.startsWith('local/'))
+            return {};
+        const exists = existsSync(join(externalProfileRoot(), adopted.id, 'profile.json'));
+        return { adoptable: { id: adopted.id, exists } };
+    }
+    catch {
+        // 이름을 만들 수 없는 저장소가 있다. 그때는 이 축이 없는 것이고, 사람이 고른다.
+        return {};
+    }
+}
+/**
+ * 승인 권한자가 서 있는가, 그리고 지금 이 사람을 무엇으로 부를 수 있는가 (P0 F2).
+ *
+ * **인증된 provider 가 말한 이름을 쓴다.** ASC 가 지어내지 않고, 자격 값은 읽지 않는다.
+ */
+async function identityState(ascRoot, workspaceComing) {
+    const wired = ascRoot ? Object.keys(await loadIdentityMap(ascRoot)).length > 0 : false;
+    if (wired)
+        return { identity: { wired: true } };
+    // **세울 workspace 가 없으면 누구인지 묻지 않는다.** 물으려면 provider CLI 를 불러야
+    // 하고, 그 도구는 자기 설정 파일을 만든다 — 멈출 계획이 남기는 자국이 되면 안 된다.
+    if (!workspaceComing)
+        return { identity: { wired: false } };
+    const actor = await detectActor();
+    return { identity: { wired: false, ...(actor ? { actor } : {}) } };
+}
+/**
+ * 지금 이 사람을 `<channel>:<actor>` 로. 인증된 통로가 먼저다 — 그것이 실제로 밖에서
+ * 나를 부르는 이름이고, git 의 표시 이름은 아무 계정과도 이어지지 않는다.
+ */
+async function detectActor() {
+    const gitlab = await execText('glab', ['api', 'user']);
+    const gitlabName = readJsonField(gitlab, 'username');
+    if (gitlabName)
+        return `gitlab:${gitlabName}`;
+    const github = await execText('gh', ['api', 'user']);
+    const githubName = readJsonField(github, 'login');
+    if (githubName)
+        return `github:${githubName}`;
+    const local = await detectSelf();
+    return local ? `local:${local}` : null;
+}
+function readJsonField(text, field) {
+    if (!text)
+        return null;
+    try {
+        const value = JSON.parse(text)[field];
+        return typeof value === 'string' && value.length > 0 ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 발견이 증명하는 결합 (P0 F2).
+ *
+ * **역할은 capability 로 정한다** — provider 이름으로 정하면 이 자리가 provider 목록이
+ * 된다. 변경을 아는 통로가 code, 작업 항목을 세는 통로가 work 다. 같은 역할에 후보가
+ * 둘이면 origin remote 가 가리키는 쪽을 쓰고, 그것으로도 갈리면 아무것도 제안하지 않는다.
+ */
+async function bindingProposalState(projectRoot, profileId, willCreate) {
+    if (!profileId)
+        return {};
+    // 이미 선언이 있으면 손대지 않는다 — 사람이 적은 것이 먼저다.
+    // 파일이 아직 없어도 **이번에 만들 것이면** 비어 있는 것과 같다: adopt 는 결합을
+    // 적지 않으므로, 그 사실을 여기서 미리 알아야 한 번의 apply 로 끝난다.
+    const declared = await readProfileBindings(profileId);
+    if (declared === null && !willCreate)
+        return {};
+    if (declared !== null && declared.length > 0)
+        return {};
+    const adapters = monitorAdapters();
+    const plan = await composeBindings({ context: { projectRoot, env: process.env }, adapters, roles: [] });
+    const usable = plan.bindings.filter((binding) => binding.state === 'AVAILABLE' || binding.state === 'DEGRADED');
+    const origin = (await gitRemotes(projectRoot)).find((remote) => remote.name === 'origin');
+    const originAlias = origin ? normalizeRemote(origin.url) : null;
+    const byRole = new Map();
+    for (const binding of usable) {
+        const role = binding.provides.includes('context.change')
+            ? 'code-primary'
+            : binding.provides.includes('inventory.enumerate')
+                ? 'work'
+                : null;
+        if (!role)
+            continue;
+        byRole.set(role, [...(byRole.get(role) ?? []), { role, adapter: binding.adapterId, resource: binding.resource }]);
+    }
+    const proposal = [];
+    for (const [role, candidates] of byRole) {
+        if (candidates.length === 1) {
+            proposal.push(candidates[0]);
+            continue;
+        }
+        // origin 이 가리키는 것 하나면 그것이다 — 이 저장소의 주소가 그 판정의 근거다.
+        const matching = originAlias
+            ? candidates.filter((candidate) => originAlias.endsWith(`/${candidate.resource}`))
+            : [];
+        if (matching.length === 1)
+            proposal.push(matching[0]);
+        else
+            return {};
+    }
+    return proposal.length > 0 ? { bindingProposal: proposal } : {};
+}
+/**
+ * 발견이 증명한 결합을 Profile 파일에 적는다.
+ *
+ * **이미 있는 선언은 건드리지 않는다** — 사람이 적은 것이 먼저다. 그 밖의 필드도 그대로
+ * 둔다: 이 함수가 아는 것은 `bindings` 한 칸뿐이다.
+ */
+async function writeProfileBindings(profileId, bindings) {
+    const path = join(externalProfileRoot(), profileId, 'profile.json');
+    const profile = JSON.parse(await readFile(path, 'utf8'));
+    if (Array.isArray(profile.bindings) && profile.bindings.length > 0)
+        return false;
+    profile.bindings = bindings.map((binding) => ({ ...binding }));
+    await writeFile(path, `${JSON.stringify(profile, null, 2)}\n`, 'utf8');
+    console.log(`bindings declared in ${profileId}: ${bindings.map((b) => `${b.role}=${b.adapter}`).join(', ')}`);
+    return true;
+}
+/**
+ * 이 checkout 이 증명하는 정본 갈래 (P0 F5).
+ *
+ * **remote 에게 물어본다.** 로컬 `origin/HEAD` 는 clone 시점에 고정돼 낡는다 — 이 저장소에서
+ * 그 값은 `main` 인데 remote 의 기본 branch 는 `develop` 이었다. 낡은 값을 정본으로 적으면
+ * 세션이 엉뚱한 baseline 을 딛는다. 물어보지 못하면 적지 않는다.
+ */
+async function canonicalProposalState(projectRoot, git, profileId, willCreate) {
+    if (!git || !profileId)
+        return {};
+    const declared = await readProfileCanonical(profileId);
+    if (declared === null && !willCreate)
+        return {};
+    if (declared !== null && declared > 0)
+        return {};
+    const symref = await execText('git', ['-C', projectRoot, 'ls-remote', '--symref', 'origin', 'HEAD']);
+    const match = symref ? /^ref:\s+refs\/heads\/(\S+)\s+HEAD$/m.exec(symref) : null;
+    const branch = match?.[1];
+    if (!branch)
+        return {};
+    // provider 는 `git` 이다 — 이 값은 checkout 이 이미 들고 있는 사실이고, 그것을 읽는 통로가
+    // 선언된 provider 를 따른다 (canonical baseline 읽기).
+    return { canonicalProposal: { id: branch, provider: 'git', remote: 'origin', ref: branch } };
+}
+/** Profile 이 선언한 정본 갈래 수. 파일이 없으면 `null`. */
+async function readProfileCanonical(profileId) {
+    const path = join(externalProfileRoot(), profileId, 'profile.json');
+    try {
+        const parsed = JSON.parse(await readFile(path, 'utf8'));
+        return Array.isArray(parsed.canonical?.sources) ? parsed.canonical.sources.length : 0;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * remote 가 말한 정본 갈래를 Profile 에 적는다. 이미 선언이 있으면 손대지 않는다.
+ */
+async function writeProfileCanonical(profileId, source) {
+    const path = join(externalProfileRoot(), profileId, 'profile.json');
+    const profile = JSON.parse(await readFile(path, 'utf8'));
+    const canonical = (profile.canonical ?? {});
+    if (Array.isArray(canonical.sources) && canonical.sources.length > 0)
+        return false;
+    profile.canonical = { ...canonical, sources: [source] };
+    await writeFile(path, `${JSON.stringify(profile, null, 2)}\n`, 'utf8');
+    console.log(`canonical source declared in ${profileId}: ${source.remote}/${source.ref}`);
+    return true;
+}
+/** Profile 이 이미 선언한 결합. 파일이 없으면 `null` — 없는 것과 비어 있는 것은 다르다. */
+async function readProfileBindings(profileId) {
+    const path = join(externalProfileRoot(), profileId, 'profile.json');
+    try {
+        const parsed = JSON.parse(await readFile(path, 'utf8'));
+        return Array.isArray(parsed.bindings) ? parsed.bindings : [];
+    }
+    catch {
+        return null;
+    }
+}
 async function detectSetupState(values, entry) {
     const { root: projectRoot, git } = await discoverProjectRoot(process.cwd());
     const resolution = await resolveRoot(process.cwd(), values.root);
@@ -1340,6 +1542,10 @@ async function detectSetupState(values, entry) {
     const attachmentBroken = ascRoot ? (await inspectSetup(ascRoot)).attachment === 'BROKEN' : false;
     const scope = values.scope === 'project' ? 'project' : 'local';
     const hostReport = await verifyInstall(hostPaths());
+    const adoptable = await adoptableState(projectRoot, git);
+    const attachedProfile = ascRoot ? await lockedProfileId(ascRoot) : undefined;
+    // 이번 계획이 쓸 Profile 하나 — 그것의 결합 선언이 비어 있을 때만 제안을 관측한다.
+    const targetProfile = values.profile ?? attachedProfile ?? adoptable.adoptable?.id;
     return {
         entry,
         projectRoot,
@@ -1349,6 +1555,12 @@ async function detectSetupState(values, entry) {
         ...(values.profile ? { requestedProfile: values.profile } : {}),
         profileCandidates: await availableProfiles(installRoot(), externalProfileRoot()),
         scope,
+        ...(attachedProfile ? { attachedProfile } : {}),
+        // fresh onboarding 이 사람에게 되묻지 않으려면 이 셋이 관측돼 있어야 한다 (P0 F2).
+        ...adoptable,
+        ...(await identityState(ascRoot, Boolean(ascRoot) || Boolean(targetProfile))),
+        ...(await bindingProposalState(projectRoot, targetProfile, Boolean(adoptable.adoptable && !adoptable.adoptable.exists))),
+        ...(await canonicalProposalState(projectRoot, git, targetProfile, Boolean(adoptable.adoptable && !adoptable.adoptable.exists))),
         host: [{ id: 'claude', status: hostReport.status }],
         // Profile 이 작업 도구를 선언했으면 그 준비 상태까지 본다 (설계 §9.3).
         ...(await workBindingState(ascRoot, projectRoot)),
@@ -1367,7 +1579,10 @@ async function detectSetupState(values, entry) {
  * 스스로 할 때만 의미가 있다.
  */
 function runningFromInstalledPackage() {
-    return fileURLToPath(import.meta.url).replace(/\\/g, '/').includes('/node_modules/@asc-agent/runtime/');
+    const here = fileURLToPath(import.meta.url).replace(/\\/g, '/');
+    // **npx 캐시도 node_modules 다.** 경로 모양만 보면 임시 자리가 설치본으로 통과하고,
+    // 실제로 그렇게 통과해 등록물이 npx 캐시를 가리켰다 — 캐시를 지우면 깨진다.
+    return here.includes('/node_modules/@asc-agent/runtime/') && !isTransientPath(here);
 }
 /**
  * 지금 이 실행에서 기계 등록을 다뤄도 되는가.
@@ -1394,7 +1609,13 @@ async function persistentRuntimeState(values) {
     const adapter = serviceAdapter();
     if (!adapter)
         return {};
-    const plan = await planPersistentRuntime(adapter, serviceCommand(serviceInterval(values))).catch(() => null);
+    // 등록물이 가리킬 자리가 없으면 이 축을 그리지 않는다 — 깨진 등록을 남기느니 등록하지
+    // 않고 그 사실을 말한다 (P0 F1).
+    const runtime = await serviceRuntime();
+    if (runtime.kind !== 'STABLE') {
+        return { persistentRuntime: { action: 'unsupported', adapter: adapter.id, detail: runtime.detail } };
+    }
+    const plan = await planPersistentRuntime(adapter, serviceCommand(serviceInterval(values), runtime)).catch(() => null);
     if (!plan)
         return {};
     return {
@@ -1635,6 +1856,14 @@ async function runSetupLifecycle(command, values, entry) {
     const speak = console.log;
     if (asJson)
         console.log = console.error;
+    const relock = async (profile) => {
+        const root = await discoverRoot(process.cwd(), values.root);
+        if (!root)
+            return;
+        const code = await runProfile('resolve', { ...values, profile, write: true }, root);
+        if (code !== 0)
+            throw new Error(`profile re-lock 실패 (exit ${code})`);
+    };
     let outcome;
     try {
         outcome = await applySetupPlan(plan, {
@@ -1657,8 +1886,13 @@ async function runSetupLifecycle(command, values, entry) {
                 const adapter = serviceAdapter();
                 if (!adapter)
                     return;
+                const runtime = await serviceRuntime();
+                if (runtime.kind !== 'STABLE') {
+                    console.error(`Persistent runtime not registered — ${runtime.detail}`);
+                    return;
+                }
                 try {
-                    await adapter.install(serviceCommand(serviceInterval(values)));
+                    await adapter.install(serviceCommand(serviceInterval(values), runtime));
                     console.log(`Persistent runtime registered with ${adapter.id}.`);
                 }
                 catch (error) {
@@ -1680,8 +1914,41 @@ async function runSetupLifecycle(command, values, entry) {
                 if (code !== 0)
                     throw new Error(`${change.host} 설치 실패 (exit ${code})`);
             },
+            // 이 저장소를 설명하는 Profile 을 만든다. 이름은 plan 이 이미 정했다.
+            adoptProfile: async (change) => {
+                const code = await runProfileAdopt({ ...values, id: change.profile, json: true }, entry);
+                if (code !== 0)
+                    throw new Error(`profile adopt 실패 (exit ${code})`);
+            },
+            // 승인 권한자를 세운다. 이름과 채널뿐이고 비밀은 다루지 않는다.
+            wireIdentity: async (change) => {
+                const code = await runSetupIdentity({ ...values, actor: change.actor, role: 'both' });
+                if (code !== 0)
+                    throw new Error(`identity 결선 실패 (exit ${code})`);
+            },
+            // 발견이 증명한 결합을 Profile 에 적는다. 갈리는 것은 plan 에 들어오지 않는다.
+            declareCanonical: async (change) => {
+                const written = await writeProfileCanonical(change.profile, change.source);
+                if (written)
+                    await relock(change.profile);
+            },
+            declareBindings: async (change) => {
+                const written = await writeProfileBindings(change.profile, change.bindings);
+                // Profile 을 고쳤으면 lock 이 어긋난다 — 다음 명령이 그 drift 앞에서 멈춘다.
+                // 고친 쪽이 닫는다 (setup identity 가 하는 것과 같다).
+                if (written)
+                    await relock(change.profile);
+            },
         });
     }
+    catch (error) {
+        // **적용 실패는 stack trace 가 아니라 답이어야 한다.** agent 는 이 문서를 읽고 다음
+        // 행동을 정한다 — 예외가 그대로 나가면 stdout 이 비고 아무것도 판단할 수 없다.
+        console.log = speak;
+        const detail = error instanceof Error ? error.message : String(error);
+        emit({ ...plan, status: 'apply_failed', changesApplied: false, detail });
+        return 1;
+    }
     finally {
         console.log = speak;
     }
@@ -1719,6 +1986,7 @@ async function inspectSetup(root) {
         ...(runtime
             ? { profile: { id: runtime.layers.profile.id, origin: runtime.layers.profileOrigin } }
             : {}),
+        ...(runtime ? { canonicalSources: runtime.layers.profile.canonical.sources.length } : {}),
         hasApprovers: Object.keys(await loadIdentityMap(root)).length > 0,
         hasControllerIdentities: Object.keys(runtime?.controllerIdentities ?? {}).length > 0,
         hasMonitorIdentities: (runtime?.monitor.identities?.length ?? 0) > 0,
@@ -2201,6 +2469,7 @@ async function runProceed(values, store, root, resolved) {
     const workRef = values.work ?? undefined;
     const ingress = workRef ? await buildWorkIngress(store, root, sessions, resolved) : undefined;
     if (workRef && !ingress) {
+        // **정본이 없는 것과 다른 실패다.** 정본은 code 쪽 사실이고 이것은 작업 항목 쪽이다.
         console.error(`작업 항목 '${workRef}' 을 읽을 통로가 없다 — Profile bindings 에 작업 항목 provider 를 선언하라.`);
         return 2;
     }
@@ -2416,7 +2685,11 @@ async function buildWorkIngress(store, root, runtime, resolved) {
         plan,
         // 제안은 **말하는 것**이지 정하는 것이 아니다. 역할을 박아 넣으면 선언과 구분되지 않고,
         // capability 해석은 후보가 유일할 때 이미 스스로 풀린다.
-        roles: rolesFor(plan, declared),
+        //
+        // 다만 **작업 항목을 누구에게 물을지는 여기서 정한다** — code 와 work 가 둘 다 자원
+        // 조회를 제공하면 `rolesFor` 는 아무것도 정하지 못하고, 그러면 선언해 둔 work binding 이
+        // 있는데도 "통로가 없다" 가 된다 (P0 F7).
+        roles: { ...rolesFor(plan, declared), ...workItemRoles(plan, declared) },
         perPage: 30,
         ...jamComposition(projectRoot),
         endpointFor: (binding) => endpointOf(adapters, binding),
@@ -3509,7 +3782,11 @@ async function serviceHealth(values) {
     const adapter = serviceAdapter();
     if (!adapter)
         return null;
-    const plan = await planPersistentRuntime(adapter, serviceCommand(serviceInterval(values))).catch(() => null);
+    const runtime = await serviceRuntime();
+    if (runtime.kind !== 'STABLE') {
+        return { adapter: adapter.id, action: 'unsupported', line: serviceRuntimeLine(runtime) };
+    }
+    const plan = await planPersistentRuntime(adapter, serviceCommand(serviceInterval(values), runtime)).catch(() => null);
     if (!plan)
         return null;
     return { adapter: adapter.id, action: plan.action, line: persistentRuntimeLine(adapter.id, plan) };
@@ -3564,15 +3841,42 @@ function serviceAdapter() {
  * 지금 도는 실행 파일과 진입점을 그대로 쓴다 — 어느 build 를 쓸지는 그 진입점이 다시
  * 정하므로(C-14), 등록물이 build 를 고르는 일은 없다.
  */
-function serviceCommand(intervalSeconds) {
+function serviceCommand(intervalSeconds, runtime) {
     return {
-        program: process.execPath,
-        args: [fileURLToPath(import.meta.url), 'runtime', 'tick', '--all'],
+        program: runtime.node,
+        args: [runtime.entry, 'runtime', 'tick', '--all'],
         intervalSeconds,
-        ...serviceEnvironment(),
+        ...serviceEnvironment(runtime.node),
         logPath: join(ascHome(), 'service.log'),
     };
 }
+/**
+ * 등록물이 가리킬 Node 와 진입점 (P0 — fresh onboarding).
+ *
+ * 지금 이 프로세스가 어디서 도는지와 **다른 질문이다.** bootstrap 은 npx 캐시에서 돌 수
+ * 있고, 그 자리는 지워진다. 전역 설치본이 있으면 그것이 답이고, 없으면 등록하지 않는다.
+ */
+async function serviceRuntime() {
+    const stable = await globalRuntimeEntry();
+    const check = await checkNodeRuntime(nodeRuntimeDeps());
+    return resolveServiceRuntime({
+        runningEntry: fileURLToPath(import.meta.url),
+        runningNode: process.execPath,
+        runningNodeVersion: process.version,
+        ...(stable ? { stableEntry: stable } : {}),
+        ...(check.ok ? {} : { nodeCandidates: check.candidates }),
+    });
+}
+/** 전역 설치본의 진입점. npm 이 말하는 prefix 를 쓴다 — 경로를 지어내지 않는다. */
+async function globalRuntimeEntry() {
+    const prefix = await execText('npm', ['prefix', '-g']);
+    if (!prefix)
+        return undefined;
+    const entry = process.platform === 'win32'
+        ? join(prefix, 'node_modules', RUNTIME_PACKAGE, 'dist', 'cli', 'asc.js')
+        : join(prefix, 'lib', 'node_modules', RUNTIME_PACKAGE, 'dist', 'cli', 'asc.js');
+    return existsSync(entry) ? entry : undefined;
+}
 /**
  * 서비스가 외부 통로를 열 수 있게 하는 환경 (P0-R1).
  *
@@ -3580,10 +3884,10 @@ function serviceCommand(intervalSeconds) {
  * node 의 디렉터리를 맨 앞에 둬서 같은 node 의 npx 가 먼저 잡히게 한다. Windows 의 예약
  * 작업은 사용자 환경을 그대로 물려받으므로 환경을 싣지 않는다.
  */
-function serviceEnvironment() {
+function serviceEnvironment(node) {
     if (process.platform === 'win32')
         return {};
-    const tools = [process.execPath, jamLauncher().command, 'glab', 'git'];
+    const tools = [node, jamLauncher().command, 'glab', 'git'];
     const { path } = servicePath(tools);
     return { environment: { PATH: path } };
 }
@@ -3605,7 +3909,17 @@ async function runRuntimeService(command, values) {
         // 못 하는 것을 "했다"로 적지 않는다. 다만 이것이 오류는 아니다.
         return 0;
     }
-    const wanted = serviceCommand(serviceInterval(values));
+    const runtime = await serviceRuntime();
+    if (runtime.kind !== 'STABLE') {
+        // 등록물이 가리킬 안정된 자리가 없다. 무엇이 없어서인지 말한다 — 등록하지 않는 것이
+        // 답이고, 깨진 등록을 남기는 것은 답이 아니다.
+        if (values.json)
+            console.log(JSON.stringify({ supported: true, stable: false, ...runtime }, null, 2));
+        else
+            console.error(serviceRuntimeLine(runtime));
+        return command === 'status' || command === undefined ? 0 : 1;
+    }
+    const wanted = serviceCommand(serviceInterval(values), runtime);
     if (command === undefined || command === 'status') {
         const plan = await planPersistentRuntime(adapter, wanted);
         if (values.json) {

package/dist/composition/runtime.d.ts

@@ -53,6 +53,23 @@ export declare function closeToolClients(): Promise<void>;
  * 후보가 갈리면 만들지 않는다 — `AMBIGUOUS_BINDING`은 사람이 정할 문제이고, 여기서 하나를
  * 고르면 그 선택을 아무도 보지 못한다 (C-09 §4.2).
  */
+/**
+ * 작업 항목을 읽는 통로의 역할 이름 (P0 F7).
+ *
+ * `rolesFor` 는 **선언된 binding 이 하나일 때만** 역할을 정한다. 그래서 code binding 과
+ * work binding 이 둘 다 `context.resource` 를 제공하면 아무 역할도 서지 않고, 작업 항목
+ * 조회는 "통로가 없다" 로 끝난다 — 실기계에서 감시는 되는데 `proceed --work` 만 실패한
+ * 자리가 여기다. 없는 것이 아니라 **누구에게 물을지 정하지 않은 것**이었다.
+ *
+ * 가르는 기준은 provider 이름이 아니라 capability 모양이다: 작업 항목 통로는 목록과 자원을
+ * 알고 **변경을 모른다**. 코드 통로는 변경을 안다. 그 차이가 곧 두 축의 정의다
+ * (C-09 §2.1 — Port 를 좁게 나눈 이유가 그것이다).
+ */
+export declare function workItemRoles(plan: BindingPlan, declared: readonly {
+    role: string;
+    adapter: string;
+    resource: string;
+}[]): Partial<Record<Capability, string>>;
 /**
  * Profile이 선언한 역할 배정을 capability별 역할로 옮긴다 (C-09 §3.1·§4).
  *

package/dist/composition/runtime.js

@@ -124,6 +124,32 @@ const PORT_OF = {
  * 후보가 갈리면 만들지 않는다 — `AMBIGUOUS_BINDING`은 사람이 정할 문제이고, 여기서 하나를
  * 고르면 그 선택을 아무도 보지 못한다 (C-09 §4.2).
  */
+/**
+ * 작업 항목을 읽는 통로의 역할 이름 (P0 F7).
+ *
+ * `rolesFor` 는 **선언된 binding 이 하나일 때만** 역할을 정한다. 그래서 code binding 과
+ * work binding 이 둘 다 `context.resource` 를 제공하면 아무 역할도 서지 않고, 작업 항목
+ * 조회는 "통로가 없다" 로 끝난다 — 실기계에서 감시는 되는데 `proceed --work` 만 실패한
+ * 자리가 여기다. 없는 것이 아니라 **누구에게 물을지 정하지 않은 것**이었다.
+ *
+ * 가르는 기준은 provider 이름이 아니라 capability 모양이다: 작업 항목 통로는 목록과 자원을
+ * 알고 **변경을 모른다**. 코드 통로는 변경을 안다. 그 차이가 곧 두 축의 정의다
+ * (C-09 §2.1 — Port 를 좁게 나눈 이유가 그것이다).
+ */
+export function workItemRoles(plan, declared) {
+    const candidates = plan.bindings
+        .filter((binding) => binding.role !== undefined)
+        .filter((binding) => declared.some((d) => d.adapter === binding.adapterId && d.resource === binding.resource))
+        .filter((binding) => binding.provides.includes('context.resource') &&
+        binding.provides.includes('inventory.enumerate') &&
+        !binding.provides.includes('context.change'));
+    const roles = new Set(candidates.map((binding) => binding.role));
+    // 갈리면 고르지 않는다 — 그것은 사람이 정할 문제다 (C-09 §4.2).
+    if (roles.size !== 1)
+        return {};
+    const role = [...roles][0];
+    return { 'context.resource': role, 'inventory.enumerate': role, 'context.thread': role, 'context.history': role };
+}
 /**
  * Profile이 선언한 역할 배정을 capability별 역할로 옮긴다 (C-09 §3.1·§4).
  *

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

@@ -61,6 +61,46 @@ export type SetupState = {
      * 사람에게 "그 도구를 설정할까요?"라고 되물으면, 사람은 자기가 이미 적어 둔 것을 다시
      * 답하게 된다. 고칠 수 있는 것은 고치고, 사람만 할 수 있는 것에서만 멈춘다.
      */
+    /**
+     * 이 저장소 자신의 remote 에서 읽히는 Profile id (P0 fresh onboarding).
+     *
+     * **다른 논리 workspace 를 추측해 합치는 것이 아니다** (C-11 금지사항). 이 저장소가
+     * 스스로 증명하는 신원 하나이고, 그 이름의 Profile 이 이미 있으면 그것을 쓰고 없으면
+     * 만든다. 이것이 없어서 fresh 설치가 `ASC_PROFILE_SELECTION_REQUIRED` 앞에 멈췄고,
+     * 사람이 `profile adopt` 를 따로 쳐야 했다.
+     */
+    adoptable?: {
+        id: string;
+        exists: boolean;
+    };
+    /**
+     * 이 workspace 에 승인 권한자가 서 있는가, 그리고 지금 이 사람을 무엇으로 알아볼 수
+     * 있는가. `actor` 는 인증된 provider 가 말한 값이며 ASC 가 지어내지 않는다.
+     */
+    identity?: {
+        wired: boolean;
+        actor?: string;
+    };
+    /**
+     * 발견이 **갈리지 않고** 제안하는 결합. Profile 에 결합 선언이 없을 때만 본다.
+     * 갈리면 비어 있다 — 고르는 것은 사람이다 (C-09 §4.2).
+     */
+    bindingProposal?: readonly {
+        role: string;
+        adapter: string;
+        resource: string;
+    }[];
+    /**
+     * 이 checkout 이 증명하는 정본 갈래. remote 가 스스로 말한 기본 branch 하나이며,
+     * Profile 에 정본 선언이 비어 있을 때만 관측한다. 알 수 없으면 없다 — 지어내면 세션이
+     * 읽지 못하는 정본을 딛고 서게 된다.
+     */
+    canonicalProposal?: {
+        id: string;
+        provider: string;
+        remote: string;
+        ref: string;
+    };
     workBinding?: {
         adapter: string;
         resource: string;
@@ -86,12 +126,63 @@ export type SetupChange =
     strategy: 'npm-global';
     from: string;
 }
+/**
+ * 이 저장소를 설명하는 Profile 을 만든다 (P0 fresh onboarding).
+ *
+ * 근거는 이 저장소의 remote 하나뿐이다. 다른 workspace 를 추측하지 않는다.
+ */
+ | {
+    target: 'adopt-profile';
+    profile: string;
+}
 /** 이 checkout에 runtime을 붙인다. local scope면 저장소에는 아무것도 만들지 않는다. */
  | {
     target: 'attach-workspace';
     scope: 'local' | 'project';
     profile: string;
 }
+/**
+ * 지금 이 사람을 이 workspace 의 승인 권한자로 세운다.
+ *
+ * **비밀은 다루지 않는다** — 이름과 채널뿐이다. 이것이 계획에 없으면 fresh 설치가
+ * 승인자 0 인 채로 READY 가 되고, 사람이 `setup identity` 를 따로 쳐야 했다.
+ */
+ | {
+    target: 'identity';
+    actor: string;
+}
+/**
+ * 발견이 증명한 결합을 Profile 에 적는다.
+ *
+ * 갈리는 것은 담지 않는다. 여기 없으면 사람이 Profile 을 손으로 고쳐야 했고, 그것이
+ * fresh onboarding 에서 실제로 필요했던 단계다.
+ */
+ | {
+    target: 'profile-bindings';
+    profile: string;
+    bindings: readonly {
+        role: string;
+        adapter: string;
+        resource: string;
+    }[];
+}
+/**
+ * Profile 에 정본 갈래를 적는다.
+ *
+ * 이것이 비어 있으면 판정이 전부 "확인 못 함" 으로 나온다 — relevance 도
+ * responsibility 도 정본을 딛고 서기 때문이다. 근거는 remote 가 스스로 말한 기본
+ * branch 이고, 그 값을 얻지 못하면 이 변경은 계획에 들지 않는다.
+ */
+ | {
+    target: 'profile-canonical';
+    profile: string;
+    source: {
+        id: string;
+        provider: string;
+        remote: string;
+        ref: string;
+    };
+}
 /** Host 설치물을 지금 source에 맞춘다. 왜 필요한지까지 든다. */
  | {
     target: 'host-install';
@@ -190,17 +281,27 @@ export type SetupEffects = {
     registerPersistentRuntime?(change: Extract<SetupChange, {
         target: 'persistent-runtime';
     }>): Promise<void>;
+    /** 이 저장소를 설명하는 Profile 을 만든다. */
+    adoptProfile?(change: Extract<SetupChange, {
+        target: 'adopt-profile';
+    }>): Promise<void>;
+    /** 승인 권한자를 세운다. 비밀은 다루지 않는다. */
+    wireIdentity?(change: Extract<SetupChange, {
+        target: 'identity';
+    }>): Promise<void>;
+    /** 발견이 증명한 결합을 Profile 에 적는다. */
+    declareBindings?(change: Extract<SetupChange, {
+        target: 'profile-bindings';
+    }>): Promise<void>;
+    /** remote 가 말한 정본 갈래를 Profile 에 적는다. */
+    declareCanonical?(change: Extract<SetupChange, {
+        target: 'profile-canonical';
+    }>): Promise<void>;
 };
 export type ApplyResult = {
     applied: SetupChange[];
     changesApplied: boolean;
 };
-/**
- * plan에 적힌 것만 실행한다. **다시 판단하지 않는다** (C-14 불변식 ⑩).
- *
- * 여기서 상태를 다시 보고 마음을 바꾸면, 사람이 승인한 plan과 실제로 일어난 일이
- * 달라진다. 그 순간 plan은 아무것도 보장하지 않는 문서가 된다.
- */
 export declare function applySetupPlan(plan: SetupPlan, effects: SetupEffects): Promise<ApplyResult>;
 /** 사람이 읽는 줄. 같은 plan에서 나온다 — agent가 보는 JSON과 다른 판단이 아니다. */
 export declare function renderSetupPlan(plan: SetupPlan): string[];

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

@@ -66,7 +66,7 @@ export function computeSetupPlan(state) {
                 code: 'ASC_HOST_INSTALL_MODIFIED',
                 // 사람이 고친 것을 덮는 것은 사람이 정한다 — plan에 담아 몰래 적용하지 않는다.
                 // 다만 runtime 설치처럼 이 결정과 무관한 준비는 계획에 남는다.
-                changes,
+                changes: orderChanges(changes, false),
                 requiresUserAction: true,
                 ...actions(mode, evidence, [
                     { type: 'force_host_install', ...command(['host', host.id, 'install', '--force']) },
@@ -96,7 +96,7 @@ export function computeSetupPlan(state) {
             return {
                 status: 'user_action_required',
                 code: 'ASC_WORK_BINDING_NEEDS_USER',
-                changes,
+                changes: orderChanges(changes, false),
                 requiresUserAction: true,
                 ...actions(mode, evidence, [{ type: 'proceed', ...command(['setup', 'status']) }]),
             };
@@ -112,6 +112,7 @@ export function computeSetupPlan(state) {
         }
     }
     if (state.ascRoot && !state.attachmentBroken) {
+        pushWorkspaceChanges(changes, state, evidence);
         // 붙어 있어도 **무엇을 고를 수 있었는지**는 사실이다. 사용자 소유 Profile을 새로 놓고
         // 계획을 물었을 때 그것이 어디에도 안 보이면, 놓은 사람은 경로를 의심하게 된다.
         if (state.profileCandidates.length > 0) {
@@ -121,13 +122,23 @@ export function computeSetupPlan(state) {
     }
     // 아직 안 붙었거나, 붙이다 말았다(BROKEN). 무엇으로 붙을지는 사람이 정한다 —
     // BROKEN이면 같은 선택으로 다시 붙이는 것이 repair다.
-    const profile = state.requestedProfile ?? soleCandidate(state.profileCandidates);
+    // 이 저장소가 스스로 증명하는 Profile 이 있으면 그것이 답이다 — 이름이 이미 있으면
+    // 그것을 쓰고, 없으면 만든다. 둘 다 "다른 workspace 를 추측"하는 것이 아니다.
+    const adoptable = state.adoptable;
+    const profile = state.requestedProfile ??
+        (adoptable && state.profileCandidates.includes(adoptable.id) ? adoptable.id : undefined) ??
+        (adoptable ? adoptable.id : undefined) ??
+        soleCandidate(state.profileCandidates);
+    if (adoptable && !state.requestedProfile && !adoptable.exists) {
+        evidence.push(`profile=${adoptable.id} (adopted from this repository)`);
+        changes.push({ target: 'adopt-profile', profile: adoptable.id });
+    }
     if (!profile) {
         evidence.push(`profile candidates=${state.profileCandidates.join(', ') || '(none)'}`);
         return {
             status: 'user_action_required',
             code: 'ASC_PROFILE_SELECTION_REQUIRED',
-            changes,
+            changes: orderChanges(changes, false),
             requiresUserAction: true,
             profiles: state.profileCandidates,
             // 고를 것이 **없을** 수도 있다 — 배포본이 들고 있는 것은 예시뿐이고, 이 프로젝트를
@@ -153,9 +164,36 @@ export function computeSetupPlan(state) {
         evidence.push('adoption=project (explicit)');
     }
     changes.push({ target: 'attach-workspace', scope: state.scope, profile });
-    evidence.push(`profile=${profile}${state.requestedProfile ? ' (given)' : ' (sole candidate)'}`);
+    if (!changes.some((c) => c.target === 'adopt-profile')) {
+        evidence.push(`profile=${profile}${state.requestedProfile ? ' (given)' : ' (sole candidate)'}`);
+    }
+    pushWorkspaceChanges(changes, state, evidence, profile);
     return finish(changes, evidence, state, mode, command);
 }
+/**
+ * workspace 가 서고 나서 필요한 것들 — 승인자와 결합 선언.
+ *
+ * 둘 다 **관측된 사실이 있을 때만** 계획에 든다. 승인자는 인증된 provider 가 말한 이름이고,
+ * 결합은 발견이 갈리지 않고 제안한 것이다. 없으면 담지 않는다 — 지어내면 그 값이 곧
+ * 사람이 겪는 오작동이 된다.
+ */
+function pushWorkspaceChanges(changes, state, evidence, attachingProfile) {
+    if (state.identity && !state.identity.wired && state.identity.actor) {
+        evidence.push(`identity=${state.identity.actor} (not yet recorded)`);
+        changes.push({ target: 'identity', actor: state.identity.actor });
+    }
+    const profile = attachingProfile ?? state.attachedProfile;
+    if (!profile)
+        return;
+    if (state.bindingProposal && state.bindingProposal.length > 0) {
+        evidence.push(`bindings proposed=${state.bindingProposal.map((b) => `${b.role}:${b.adapter}`).join(', ')}`);
+        changes.push({ target: 'profile-bindings', profile, bindings: state.bindingProposal });
+    }
+    if (state.canonicalProposal) {
+        evidence.push(`canonical proposed=${state.canonicalProposal.remote}/${state.canonicalProposal.ref}`);
+        changes.push({ target: 'profile-canonical', profile, source: state.canonicalProposal });
+    }
+}
 /** 후보가 하나뿐이어도 대신 고르지 않는다 — 여기서 돌려주는 것은 "고를 것이 없다"뿐이다. */
 function soleCandidate(candidates) {
     return candidates.length === 1 ? candidates[0] : undefined;
@@ -172,7 +210,9 @@ function actions(mode, evidence, list) {
         evidence,
     };
 }
-function finish(changes, evidence, state, mode, command) {
+function finish(raw, evidence, state, mode, command) {
+    const settled = (Boolean(state.ascRoot) && !state.attachmentBroken) || raw.some((c) => c.target === 'attach-workspace');
+    const changes = orderChanges(raw, settled);
     if (changes.length === 0) {
         return {
             status: 'already_configured',
@@ -194,6 +234,34 @@ function finish(changes, evidence, state, mode, command) {
  * 여기서 상태를 다시 보고 마음을 바꾸면, 사람이 승인한 plan과 실제로 일어난 일이
  * 달라진다. 그 순간 plan은 아무것도 보장하지 않는 문서가 된다.
  */
+/**
+ * 실행 순서 (설계 §9 — fresh onboarding).
+ *
+ * **등록이 맨 마지막이다.** 예전에는 등록이 붙이기보다 먼저 계획에 들어가, OS 가 아직
+ * identity·binding 이 서지 않은 workspace 를 회차로 돌렸다. 그 회차는 실패했고, 사람은
+ * 자기가 setup 을 끝내기도 전에 실패 기록을 봤다.
+ */
+const CHANGE_ORDER = {
+    'runtime-install': 0,
+    'adopt-profile': 1,
+    'attach-workspace': 2,
+    identity: 3,
+    'profile-bindings': 4,
+    'profile-canonical': 5,
+    'work-binding-setup': 6,
+    'host-install': 7,
+    'persistent-runtime': 8,
+};
+/**
+ * 순서를 고정하고, **아직 설 자리가 아닌 등록은 뺀다.**
+ *
+ * 붙는 것이 이번 계획으로 끝나지 않으면 이 기계에 등록할 이유가 없다 — 등록물은
+ * workspace 를 돌보는 것이고, 돌볼 workspace 가 아직 없기 때문이다.
+ */
+function orderChanges(changes, attachmentSettled) {
+    const kept = attachmentSettled ? [...changes] : changes.filter((change) => change.target !== 'persistent-runtime');
+    return kept.sort((a, b) => CHANGE_ORDER[a.target] - CHANGE_ORDER[b.target]);
+}
 export async function applySetupPlan(plan, effects) {
     const applied = [];
     for (const change of plan.changes) {
@@ -220,6 +288,26 @@ export async function applySetupPlan(plan, effects) {
                     continue;
                 await effects.setupWorkBinding(change);
                 break;
+            case 'adopt-profile':
+                if (!effects.adoptProfile)
+                    continue;
+                await effects.adoptProfile(change);
+                break;
+            case 'identity':
+                if (!effects.wireIdentity)
+                    continue;
+                await effects.wireIdentity(change);
+                break;
+            case 'profile-bindings':
+                if (!effects.declareBindings)
+                    continue;
+                await effects.declareBindings(change);
+                break;
+            case 'profile-canonical':
+                if (!effects.declareCanonical)
+                    continue;
+                await effects.declareCanonical(change);
+                break;
         }
         applied.push(change);
     }
@@ -254,5 +342,15 @@ function changeLine(change) {
             return `  repair ${change.adapter} for ${change.resource} through its own setup (${change.version})`;
         case 'persistent-runtime':
             return `  register this machine's ASC runtime with ${change.adapter}`;
+        case 'adopt-profile':
+            return `  create profile ${change.profile} from this repository's remote`;
+        case 'identity':
+            return `  record ${change.actor} as this workspace's approver`;
+        case 'profile-bindings':
+            return `  declare bindings in ${change.profile}: ${change.bindings
+                .map((b) => `${b.role}=${b.adapter}:${b.resource}`)
+                .join(', ')}`;
+        case 'profile-canonical':
+            return `  declare canonical source in ${change.profile}: ${change.source.remote}/${change.source.ref}`;
     }
 }

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

@@ -8,7 +8,7 @@ export type AttachmentState = 'READY' | 'UNATTACHED' | 'BROKEN' | 'LOCK_DRIFT';
  */
 export type GateState = 'OPEN' | 'BLOCKED' | 'DEGRADED';
 export type SetupGate = {
-    id: 'approval' | 'monitor' | 'external-write';
+    id: 'approval' | 'monitor' | 'external-write' | 'canonical';
     label: string;
     state: GateState;
     /** 무엇이 없어서 막혔는지. */
@@ -30,6 +30,8 @@ export type SetupStatus = {
     gates: SetupGate[];
 };
 export type SetupInput = {
+    /** Profile 이 선언한 정본 갈래 수. 붙지 않았으면 알 수 없으므로 `undefined` 다. */
+    canonicalSources?: number;
     attachment: AttachmentState;
     /** 붙어 있는 Profile의 id와 출처. **Surface가 읽어 넘긴다** — Core는 경로를 모른다. */
     profile?: {

package/dist/core/attach/setup.js

@@ -28,7 +28,7 @@ export function assessSetup(input) {
         attachment: input.attachment,
         ...(input.profile ? { profile: input.profile } : {}),
         ready: [...ALWAYS_READY],
-        gates: [approvalGate(input), monitorGate(input), externalWriteGate(input)],
+        gates: [approvalGate(input), canonicalGate(input), monitorGate(input), externalWriteGate(input)],
     };
 }
 /** 승인 결정. identities.json은 lock digest에 없어 재고정이 필요 없다. */
@@ -46,6 +46,30 @@ function approvalGate(input) {
         howTo: ['open identities.json and add an approver in the $example form (no re-lock needed)'],
     };
 }
+/**
+ * 정본 조회 (C-08 · C-11).
+ *
+ * 코드 결합은 선언돼 있는데 정본 갈래가 비어 있으면, 판정은 "확인 못 함" 으로만 나온다 —
+ * relevance 도 responsibility 도 정본을 딛고 서기 때문이다. 실기계에서 그 상태가 READY 로
+ * 보였고, 사람은 무엇이 빠졌는지 알 방법이 없었다. 없는 것을 없다고 말한다.
+ */
+function canonicalGate(input) {
+    // 붙지 않았으면 이 축을 판정하지 않는다 — 아직 Profile 이 없다.
+    if (input.attachment !== 'READY' || input.canonicalSources === undefined) {
+        return { id: 'canonical', label: 'canonical evidence', state: 'OPEN', missing: [], warnings: [], howTo: [] };
+    }
+    if (input.canonicalSources > 0) {
+        return { id: 'canonical', label: 'canonical evidence', state: 'OPEN', missing: [], warnings: [], howTo: [] };
+    }
+    return {
+        id: 'canonical',
+        label: 'canonical evidence',
+        state: 'BLOCKED',
+        missing: ['the profile declares no canonical source, so nothing can be judged against a baseline'],
+        warnings: [],
+        howTo: [`declare one in the profile's canonical.sources — ${RESOLVE_AGAIN}`],
+    };
+}
 /**
  * 외부 감시. 두 설정이 서로 다른 것을 막는다 —
  * controller.identities가 없으면 실행 자체가 안 되고(단 --as로 우회 가능),

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

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

@@ -0,0 +1,40 @@
+import { type NodeCandidate } from './node-runtime.ts';
+/**
+ * 사라질 수 있는 자리인가.
+ *
+ * npx 캐시가 이 목록의 이유다. 임시 디렉터리도 같은 성질이고, 어느 쪽이든 **등록물이
+ * 가리키면 안 되는 자리**다. 목록은 짧게 유지한다 — 길어지면 그건 판정이 아니라 추측이다.
+ */
+export declare function isTransientPath(path: string): boolean;
+export type ServiceRuntimeInput = {
+    /** 지금 이 프로세스의 진입점 절대 경로. */
+    runningEntry: string;
+    /** 지금 이 프로세스의 Node 실행 파일. */
+    runningNode: string;
+    /** 지금 이 프로세스의 Node 버전 (`v24.1.0` 형태). */
+    runningNodeVersion: string;
+    /** 전역 설치본의 진입점. 있으면 이것이 먼저다 — 지워지지 않는 자리이기 때문이다. */
+    stableEntry?: string;
+    /** 이 기계에서 찾은 Node 후보들. 지금 Node 가 못 쓸 때만 본다. */
+    nodeCandidates?: readonly NodeCandidate[];
+};
+export type ServiceRuntimeResolution = {
+    kind: 'STABLE';
+    node: string;
+    entry: string;
+} | {
+    kind: 'UNSTABLE';
+    /** 무엇이 없어서 못 하는가. 사람이 읽고 무엇을 할지 알 수 있어야 한다. */
+    reason: 'NO_STABLE_ENTRY' | 'NO_COMPATIBLE_NODE';
+    detail: string;
+};
+/**
+ * 등록물에 박을 Node 와 진입점을 정한다. **아무것도 실행하지 않는다** — 사실은 호출자가
+ * 관측해 넘긴다.
+ *
+ * 진입점: 전역 설치본이 있으면 그것. 없으면 지금 진입점이되 **임시 자리가 아닐 때만.**
+ * Node: 지금 Node 가 하한을 넘고 임시 자리가 아니면 그것. 아니면 후보 중 첫 번째.
+ */
+export declare function resolveServiceRuntime(input: ServiceRuntimeInput): ServiceRuntimeResolution;
+/** 사람이 읽는 한 줄. 왜 등록하지 않았는지가 여기 있어야 한다. */
+export declare function serviceRuntimeLine(resolution: ServiceRuntimeResolution): string;

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

@@ -0,0 +1,76 @@
+// 등록물이 무엇을 가리켜야 하는가 (C-12 · C-14 §3).
+//
+// 실기계에서 이런 일이 났다: `npx @asc-agent/bootstrap … setup apply` 로 처음 설치한
+// 사람에게, 등록물이 **npx 캐시 안의 실행물**을 정본으로 박았다.
+//
+//   ~/.npm/_npx/<hash>/node_modules/@asc-agent/runtime/dist/cli/asc.js
+//
+// npx 캐시는 지워지는 자리다. 그것을 지우면 등록물은 남고 실행물만 사라진다 — OS 는 계속
+// 부르고 매번 실패한다. 등록은 **오래 남을 설치본**이 스스로 할 때만 뜻이 있다.
+//
+// 그래서 이 파일은 두 가지를 가른다:
+//
+//   지금 이 프로세스가 어디서 도는가      bootstrap 은 임시 자리에서 돌 수 있다
+//   등록물이 무엇을 가리켜야 하는가        임시 자리는 절대 안 된다
+//
+// Node 도 같다. 등록물이 박는 Node 는 실제로 있고, 하한을 넘고, 임시 자리가 아니어야
+// 한다 — 셋 중 하나라도 아니면 **등록하지 않는다.** 깨진 등록을 남기고 나중에 실패하는
+// 것보다, 등록하지 않고 그 사실을 말하는 편이 낫다.
+import { MINIMUM_NODE_MAJOR, majorOf } from "./node-runtime.js";
+/**
+ * 사라질 수 있는 자리인가.
+ *
+ * npx 캐시가 이 목록의 이유다. 임시 디렉터리도 같은 성질이고, 어느 쪽이든 **등록물이
+ * 가리키면 안 되는 자리**다. 목록은 짧게 유지한다 — 길어지면 그건 판정이 아니라 추측이다.
+ */
+export function isTransientPath(path) {
+    const normalized = path.replace(/\\/g, '/');
+    return (normalized.includes('/_npx/') ||
+        normalized.includes('/_cacache/') ||
+        normalized.startsWith('/tmp/') ||
+        normalized.startsWith('/private/tmp/') ||
+        normalized.startsWith('/var/folders/') ||
+        /\/Temp\//i.test(normalized));
+}
+/**
+ * 등록물에 박을 Node 와 진입점을 정한다. **아무것도 실행하지 않는다** — 사실은 호출자가
+ * 관측해 넘긴다.
+ *
+ * 진입점: 전역 설치본이 있으면 그것. 없으면 지금 진입점이되 **임시 자리가 아닐 때만.**
+ * Node: 지금 Node 가 하한을 넘고 임시 자리가 아니면 그것. 아니면 후보 중 첫 번째.
+ */
+export function resolveServiceRuntime(input) {
+    const entry = input.stableEntry && !isTransientPath(input.stableEntry)
+        ? input.stableEntry
+        : !isTransientPath(input.runningEntry)
+            ? input.runningEntry
+            : null;
+    if (!entry) {
+        return {
+            kind: 'UNSTABLE',
+            reason: 'NO_STABLE_ENTRY',
+            detail: `${input.runningEntry} is a temporary location — a registration pointing there breaks when it is cleared`,
+        };
+    }
+    const usable = (path, version) => {
+        const major = majorOf(version);
+        return major !== null && major >= MINIMUM_NODE_MAJOR && !isTransientPath(path);
+    };
+    const node = usable(input.runningNode, input.runningNodeVersion)
+        ? input.runningNode
+        : (input.nodeCandidates ?? []).find((candidate) => usable(candidate.path, candidate.version))?.path;
+    if (!node) {
+        return {
+            kind: 'UNSTABLE',
+            reason: 'NO_COMPATIBLE_NODE',
+            detail: `no Node ${MINIMUM_NODE_MAJOR} or newer at a stable path (this process runs ${input.runningNodeVersion} from ${input.runningNode})`,
+        };
+    }
+    return { kind: 'STABLE', node, entry };
+}
+/** 사람이 읽는 한 줄. 왜 등록하지 않았는지가 여기 있어야 한다. */
+export function serviceRuntimeLine(resolution) {
+    return resolution.kind === 'STABLE'
+        ? `service runtime: ${resolution.node} ${resolution.entry}`
+        : `service runtime unavailable — ${resolution.detail}`;
+}

package/dist/schemas/profile.d.ts

@@ -493,6 +493,7 @@ export declare const UserOverride: z.ZodPipeline<z.ZodEffects<z.ZodUnknown, unkn
     };
     schemaVersion: 1;
     monitorIdentities: string[];
+    identity: Record<string, string>;
     approval: {
         preferredChannel?: string | undefined;
         messenger?: {
@@ -509,7 +510,6 @@ export declare const UserOverride: z.ZodPipeline<z.ZodEffects<z.ZodUnknown, unkn
         lockedSettings?: string[] | undefined;
         unionLists?: Record<string, string[]> | undefined;
     };
-    identity: Record<string, string>;
     $comment?: string | undefined;
 }, {
     schemaVersion: 1;
@@ -522,6 +522,7 @@ export declare const UserOverride: z.ZodPipeline<z.ZodEffects<z.ZodUnknown, unkn
     } | undefined;
     $comment?: string | undefined;
     monitorIdentities?: string[] | undefined;
+    identity?: Record<string, string> | undefined;
     approval?: {
         preferredChannel?: string | undefined;
         messenger?: {
@@ -538,7 +539,6 @@ export declare const UserOverride: z.ZodPipeline<z.ZodEffects<z.ZodUnknown, unkn
         lockedSettings?: string[] | undefined;
         unionLists?: Record<string, string[]> | undefined;
     } | undefined;
-    identity?: Record<string, 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.5.0",
+  "version": "0.5.1",
   "description": "ASC (Agent Session Control) \u2014 local-first human-in-the-loop agent control plane: core, CLI, and adapters",
   "keywords": [
     "agent",