@asc-agent/runtime 0.4.0 → 0.5.1

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";
@@ -46,6 +46,9 @@ import { CoverageLedger, renderHealth } from "../core/monitor/coverage.js";
 import { evaluateHealth, healthAlertLines } from "../core/monitor/health-alerts.js";
 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";
 import { GitLabAdapter } from "../adapters/gitlab/adapter.js";
@@ -54,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";
@@ -69,12 +72,14 @@ import { AuditLedger, decisionLines, delegationLine, executionLines, reclaimLine
 import { ClosureLedger } from "../core/runtime/closure.js";
 import { Orchestrator, renderTick } from "../core/runtime/orchestrator.js";
 import { LAST_RUN_KEY, RuntimeLease, fileScope, readBackground, renderBackground, staleAfter, } from "../core/runtime/background.js";
-import { dueWorkspaces, renderWorkspaces, viewWorkspaces, } from "../core/runtime/workspaces.js";
+import { dueWorkspaces, renderWorkspaces, summarizePass, viewWorkspaces } from "../core/runtime/workspaces.js";
 import { persistentRuntimeLine, planPersistentRuntime, } from "../core/distribution/persistent-runtime.js";
 import { launchdAdapter } from "../adapters/service/launchd.js";
 import { schtasksAdapter } from "../adapters/service/schtasks.js";
 import { serviceAdapterFor, systemdUserAdapter } from "../adapters/service/systemd-user.js";
 import { QueryLedger } from "../core/runtime/query.js";
+import { CoordinationLedger, coordinationLines, responsesFrom, viewCoordination, } from "../core/runtime/coordination.js";
+import { publishLine, publishOnce, recordPublication } from "../core/runtime/publish.js";
 import { ObservationLedger } from "../core/monitor/observation.js";
 import { DeliveryLedger, deliver, planDigest } from "../core/presentation/digest.js";
 import { LocalPresentation } from "../adapters/local/presentation.js";
@@ -191,6 +196,11 @@ const USAGE = `asc — Agent Session Control
                         [--to <authority>]
   asc query list   [--json]
 
+  asc coordination [status] [--json]   # what was asked outside, and whether it reached anyone
+  asc coordination publish --query <ID> --title <text> --body-file <path>
+                   [--audience <who>] [--known <objectId>] [--work <ref>] [--json]
+  asc coordination observe [--json]    # did anything come back on what we published
+
   asc progress show   [<S-ID>]
   asc progress report <S-ID> --physical <id> --phase <text>
                       [--milestone <text>...] [--next <text>] [--unresolved <text>...]
@@ -577,6 +587,11 @@ function parseArgsOrThrow(argv) {
             validator: { type: 'string' },
             result: { type: 'string' },
             finding: { type: 'string', multiple: true },
+            query: { type: 'string' },
+            title: { type: 'string' },
+            'body-file': { type: 'string' },
+            audience: { type: 'string', multiple: true },
+            known: { type: 'string', multiple: true },
             blocker: { type: 'string', multiple: true },
             risk: { type: 'string', multiple: true },
             evidence: { type: 'string', multiple: true },
@@ -718,7 +733,7 @@ async function runParsedCommand(values, positionals, entry, argv) {
     // 순서가 뒤집힌다. 나머지 profile 명령은 아래 attach 경로에 그대로 남는다.
     if (group === 'profile' && command === 'adopt')
         return runProfileAdopt(values, entry);
-    if (!['inbox', 'grant', 'monitor', 'runtime', 'front', 'freeze', 'thaw', 'escalate', 'profile', 'session', 'controller', 'proceed', 'progress', 'preflight', 'closure', 'query'].includes(group)) {
+    if (!['inbox', 'grant', 'monitor', 'runtime', 'front', 'coordination', 'freeze', 'thaw', 'escalate', 'profile', 'session', 'controller', 'proceed', 'progress', 'preflight', 'closure', 'query'].includes(group)) {
         console.error(`Unknown command: ${group}\n\n${USAGE}`);
         return 2;
     }
@@ -760,6 +775,9 @@ async function runParsedCommand(values, positionals, entry, argv) {
     // 새 대화가 붙었을 때 지금 상태를 되찾는다 (C-12 §4). 읽기만 한다.
     if (group === 'front')
         return runFront(command, values, store, root);
+    // 밖에 물은 것이 실제로 전달됐는가. 읽기만 한다.
+    if (group === 'coordination')
+        return runCoordination(command, values, store, root, guard.runtime);
     // 사람에게 올릴 자격이 있는가 (C-13). 자격 없으면 request가 만들어지지 않는다.
     if (group === 'escalate')
         return runEscalate(command, target, values, store, guard.runtime);
@@ -1314,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);
@@ -1323,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,
@@ -1332,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)),
@@ -1350,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);
 }
 /**
  * 지금 이 실행에서 기계 등록을 다뤄도 되는가.
@@ -1377,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 {
@@ -1618,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, {
@@ -1640,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) {
@@ -1663,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;
     }
@@ -1702,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,
@@ -1929,11 +2214,23 @@ async function runProfile(command, values, root) {
 async function scmFor(resolved) {
     if (!resolved)
         return undefined;
+    const sources = resolved.layers.profile.canonical.sources;
+    // Profile 은 갈래마다 provider 를 적는다. `git` 이라고 적힌 것은 이 checkout 이 이미
+    // 들고 있는 사실이므로 원격 API 로 가지 않는다 — 갈 수 있다는 보장도 없다.
+    if (sources.length > 0 && sources.every((source) => source.provider === 'git')) {
+        const { root } = await discoverProjectRoot(process.cwd());
+        const refs = {};
+        for (const source of sources) {
+            if (source.ref)
+                refs[source.id] = { ref: source.ref, ...(source.remote ? { remote: source.remote } : {}) };
+        }
+        return new LocalCanonicalReader({ cwd: root, sourceRefs: refs });
+    }
     const token = await discoverToken();
     if (!token)
         return undefined;
     const sourceRefs = {};
-    for (const source of resolved.layers.profile.canonical.sources) {
+    for (const source of sources) {
         if (source.ref)
             sourceRefs[source.id] = { ref: source.ref };
     }
@@ -2172,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;
     }
@@ -2387,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),
@@ -3095,6 +3397,25 @@ const CLOSURE_CHECKLIST = 'closureChecklist';
 /** Orchestration Audit (C-10). 회수 후에도 남는 기록이라 Progress와 다른 자리에 산다. */
 const auditLedger = (store) => new AuditLedger(store.scope('audit'));
 const closureLedger = (store) => new ClosureLedger(store.scope('closure'));
+/**
+ * 조율 증거 원장. Bounded Query 와 **다른 scope** 에 산다 — 기대와 증거는 다른 사실이고,
+ * 한 자리에 두면 "물어봤다"와 "전달됐다"가 다시 한 레코드가 된다.
+ */
+const coordinationLedger = (store) => new CoordinationLedger(store.scope('coordination'));
+/**
+ * 지금 이 workspace 의 조율 상태.
+ *
+ * 기대는 Bounded Query 에서 오고 증거는 원장에서 온다. **여기서 상태를 만들지 않는다** —
+ * 둘을 맞춰 파생할 뿐이다.
+ */
+async function coordinationNow(store, resolved) {
+    const queries = await queryLedger(store, resolved).list();
+    return viewCoordination(coordinationLedger(store), 
+    // 답이 이미 안에서 쓰인 질의는 조율 대상이 아니다 — 밖에 물을 이유가 끝났다.
+    queries
+        .filter((entry) => entry.answer === null)
+        .map((entry) => ({ id: entry.query.id, expectsResponse: entry.query.expectedResponse !== undefined })));
+}
 /** Bounded Query (B-25). 결정권 판정에 Profile 책임 지도가 필요하다. */
 const queryLedger = (store, resolved) => new QueryLedger(store.scope('query'), resolved?.ownership);
 /**
@@ -3461,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) };
@@ -3516,13 +3841,56 @@ 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(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).
+ *
+ * 여기가 어떤 실행 파일이 필요한지 아는 자리다 — 조립 계층은 provider 를 안다. 지금 도는
+ * node 의 디렉터리를 맨 앞에 둬서 같은 node 의 npx 가 먼저 잡히게 한다. Windows 의 예약
+ * 작업은 사용자 환경을 그대로 물려받으므로 환경을 싣지 않는다.
+ */
+function serviceEnvironment(node) {
+    if (process.platform === 'win32')
+        return {};
+    const tools = [node, jamLauncher().command, 'glab', 'git'];
+    const { path } = servicePath(tools);
+    return { environment: { PATH: path } };
+}
 const serviceInterval = (values) => values['interval-min'] === undefined ? 5 * 60 : Math.max(60, Number(values['interval-min']) * 60);
 /**
  * `asc runtime service` — 이 기계의 지속 등록 (설계 §4).
@@ -3541,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) {
@@ -3626,11 +4004,15 @@ async function tickAllWorkspaces(values, lease) {
         // 죽은 것으로 보이고 두 번째 프로세스가 끼어든다.
         await lease.renew();
     }
+    const skippedViews = skipped.map((view) => ({ workspaceId: view.workspaceId, health: view.health }));
+    const summary = summarizePass(results, skippedViews);
     if (values.json) {
         console.log(JSON.stringify({
             ran: results,
             // 건너뛴 것을 조용히 빼지 않는다 — "아무 일도 없었다"와 다른 사실이다
-            skipped: skipped.map((view) => ({ workspaceId: view.workspaceId, health: view.health })),
+            skipped: skippedViews,
+            outcome: summary.outcome,
+            failed: summary.failed,
         }, null, 2));
     }
     else {
@@ -3638,9 +4020,11 @@ async function tickAllWorkspaces(values, lease) {
             console.log(`${result.workspaceId}: pass exited ${result.code}`);
         for (const view of skipped)
             console.log(`${view.workspaceId}: ${view.health} — not observed this pass`);
+        console.log(summary.line);
     }
-    // 한 workspace 가 실패해도 회차 자체는 성공이다. 다음 회차가 다시 본다.
-    return 0;
+    // 한 workspace 가 실패해도 다른 workspace 는 전부 돌았다. 그러나 실패했다는 사실은 회차의
+    // 종료 코드에 남는다 — OS 가 보는 것은 그것 하나뿐이다 (P0-R2).
+    return summary.code;
 }
 /**
  * 상시 Runtime (C-12). 대화를 켜 두지 않고 **상태를 지속시키고 계산을 짧게 돌린다.**
@@ -4136,11 +4520,178 @@ async function runFrontOpen(values) {
                 escalations: await escalationLedger(store).pending(),
                 health: evaluateHealth(await new CoverageLedger(store.scope(scope)).health(), new Date().toISOString(), HEALTH_THRESHOLDS),
                 ...(workspace ? { workspace } : {}),
+                // 안에서 할 일이 없는 것과 밖에서 답이 안 온 것은 다른 사실이다
+                coordination: await coordinationNow(store),
                 bindings: claudeBindings(store),
             });
         },
     }));
 }
+/**
+ * 이 workspace 의 조율 표면. 없으면 없다고 말한다 — 아무 데나 대신 게시하지 않는다.
+ */
+async function coordinationSurfaceFor(resolved) {
+    const { root: projectRoot } = await discoverProjectRoot(process.cwd());
+    const adapters = monitorAdapters();
+    const declared = resolved?.layers.profile.bindings ?? [];
+    const plan = await composeBindings({
+        context: { projectRoot, env: process.env },
+        adapters,
+        roles: declared.map((b) => ({ adapterId: b.adapter, resource: b.resource, role: b.role })),
+    });
+    const ports = await buildRuntimePorts({
+        plan,
+        roles: rolesFor(plan, declared),
+        ...jamComposition(projectRoot),
+        endpointFor: (binding) => endpointOf(adapters, binding),
+    });
+    return { surface: ports.coordinationSurface, unavailable: ports.unavailable };
+}
+/**
+ * `asc coordination publish` — 기대 하나를 밖에 실제로 내보낸다.
+ *
+ * 본문을 파일로 받는 이유는 하나다: 사람이 읽을 글이 셸을 지나며 조용히 달라지는 것을
+ * 막는다. 그리고 **내부 메모가 섞일 자리를 주지 않는다** — 나가는 것은 제목·본문·라벨뿐이다.
+ */
+async function runCoordinationPublish(values, store, resolved) {
+    const queryId = typeof values.query === 'string' ? values.query : undefined;
+    const title = typeof values.title === 'string' ? values.title : undefined;
+    const bodyFile = typeof values['body-file'] === 'string' ? values['body-file'] : undefined;
+    if (!queryId || !title || !bodyFile) {
+        console.error('coordination publish needs --query, --title and --body-file\n\n' + USAGE);
+        return 2;
+    }
+    const { surface, unavailable } = await coordinationSurfaceFor(resolved);
+    if (!surface) {
+        console.error('No coordination surface is bound to this workspace — nothing was published.');
+        for (const line of unavailable)
+            console.error(`  ${line}`);
+        return 1;
+    }
+    const body = await readFile(bodyFile, 'utf8');
+    const audience = values.audience ?? [];
+    const known = (values.known ?? []).map((objectId) => ({
+        objectType: 'issue',
+        objectId,
+    }));
+    const workReference = typeof values.work === 'string' ? values.work : undefined;
+    const outcome = await publishOnce({
+        queryId,
+        publicPayload: { title, body },
+        ...(audience.length > 0 ? { audience } : {}),
+        ...(known.length > 0 ? { known } : {}),
+        ...(workReference ? { workReference } : {}),
+    }, { surface, bindingRole: 'coordination-surface' });
+    if (outcome.ok) {
+        const recorded = await recordPublication(coordinationLedger(store), outcome);
+        if (values.json) {
+            console.log(JSON.stringify({ publish: outcome, recorded: recorded.ok }, null, 2));
+            return 0;
+        }
+        console.log(publishLine(outcome));
+        // 이미 적힌 사실을 다시 적지 않는다. 그것은 실패가 아니라 같은 것을 두 번 안 세는 것이다.
+        console.log(recorded.ok ? 'recorded as communication evidence' : 'already recorded');
+        return 0;
+    }
+    if (values.json)
+        console.log(JSON.stringify({ publish: outcome }, null, 2));
+    else
+        console.error(publishLine(outcome));
+    return 1;
+}
+/**
+ * `asc coordination observe` — 게시한 것에 답이 왔는가.
+ *
+ * **답의 의미를 정하지 않는다.** 여기서 남는 것은 "밖에서 사람이 글을 남겼다"까지이고,
+ * 그것이 결정인지 승인인지는 다른 계약의 몫이다. 그 시스템이 스스로 남긴 자국과 우리가
+ * 쓴 글은 세지 않는다 — 그 둘을 세면 아무도 답하지 않은 스레드가 답이 온 것으로 보인다.
+ */
+async function runCoordinationObserve(values, store, root, resolved) {
+    const ledger = coordinationLedger(store);
+    const communications = await ledger.communications();
+    if (communications.length === 0) {
+        console.log('Nothing has been published from here yet.');
+        return 0;
+    }
+    const { root: projectRoot } = await discoverProjectRoot(process.cwd());
+    const adapters = monitorAdapters();
+    const declared = resolved?.layers.profile.bindings ?? [];
+    const plan = await composeBindings({
+        context: { projectRoot, env: process.env },
+        adapters,
+        roles: declared.map((b) => ({ adapterId: b.adapter, resource: b.resource, role: b.role })),
+    });
+    // **그 게시물을 만든 통로에게 묻는다.** 프로젝트 전체의 자원 조회를 하나 고르면
+    // 어느 것을 고를지 갈리고(실제로 갈렸다), 갈리지 않더라도 다른 시스템에게 남의 게시물을
+    // 묻게 된다. 증거에 적힌 adapter 가 곧 그 통로다.
+    const built = await buildObservationChannels({
+        plan,
+        roles: rolesFor(plan, declared),
+        ...jamComposition(projectRoot),
+        endpointFor: (binding) => endpointOf(adapters, binding),
+    });
+    const contextOf = (adapterId) => built.channels.find((channel) => channel.adapterId === adapterId && channel.resourceContext)?.resourceContext;
+    // 나를 나로 알아보는 곳은 identities.json 하나다. 채널 접두사를 떼면 계정 이름이 남는다.
+    const identity = await loadIdentityMap(root);
+    const mine = new Set();
+    for (const [name, accounts] of Object.entries(identity)) {
+        mine.add(name);
+        for (const account of accounts)
+            mine.add(account.includes(':') ? account.slice(account.indexOf(':') + 1) : account);
+    }
+    let added = 0;
+    let looked = 0;
+    for (const communication of communications) {
+        const context = contextOf(communication.identity.adapter);
+        if (!context) {
+            // 못 본 것을 "답이 없다"로 넘기지 않는다.
+            console.error(`  ${communication.identity.objectId}: ${communication.identity.adapter} 통로가 열리지 않아 보지 못했다`);
+            continue;
+        }
+        looked += 1;
+        const remarks = await context
+            .getComments(communication.identity.objectId, { limit: 100 })
+            .catch(() => []);
+        for (const response of responsesFrom(communication, remarks, mine)) {
+            const outcome = await ledger.responseRecorded(response);
+            if (outcome.ok)
+                added += 1;
+        }
+    }
+    const views = await coordinationNow(store, resolved);
+    if (values.json) {
+        console.log(JSON.stringify({ published: communications.length, observed: looked, recorded: added, coordination: views }, null, 2));
+        return 0;
+    }
+    console.log(`Looked at ${looked} of ${communications.length} published artefact(s) — ${added} new response(s).`);
+    for (const line of coordinationLines(views))
+        console.log(line);
+    return 0;
+}
+/**
+ * `asc coordination` — 밖에 물은 것이 실제로 나갔는가, 답이 왔는가.
+ *
+ * **읽기만 한다.** 이 화면이 상태를 만들지 않는다는 것이 요점이다 — 보이는 것은 전부
+ * 기대와 증거에서 파생한 값이다.
+ */
+async function runCoordination(command, values, store, root, resolved) {
+    if (command === 'publish')
+        return runCoordinationPublish(values, store, resolved);
+    if (command === 'observe')
+        return runCoordinationObserve(values, store, root, resolved);
+    if (command !== undefined && command !== 'status') {
+        console.error(`Unknown coordination command: ${command}\n\n${USAGE}`);
+        return 2;
+    }
+    const views = await coordinationNow(store, resolved);
+    if (values.json) {
+        console.log(JSON.stringify({ coordination: views }, null, 2));
+        return 0;
+    }
+    for (const line of coordinationLines(views))
+        console.log(line);
+    return 0;
+}
 async function runFront(command, values, store, root) {
     if (command !== undefined && command !== 'status') {
         console.error(`Unknown front command: ${command}
@@ -4158,6 +4709,7 @@ ${USAGE}`);
         escalations: await escalationLedger(store).pending(),
         health: evaluateHealth(await new CoverageLedger(store.scope(scope)).health(), new Date().toISOString(), HEALTH_THRESHOLDS),
         ...(located ? { workspace: { workspaceId: located.workspaceId, locator: located.locator } } : {}),
+        coordination: await coordinationNow(store),
         // 도는 세션을 누가 집고 있는지. --physical 을 다시 물어보게 하지 않는다 (L-4).
         bindings: claudeBindings(store),
     });