@asc-agent/runtime 0.3.2 → 0.4.0

package/dist/cli/asc.js

@@ -6,12 +6,12 @@
 // 출력만 있고 판단은 한 줄도 없다.
 //
 // 읽기 전용이다. 결정 제출은 사람의 명시적 의사표현을 받는 별도 경로로 나간다 (B-06).
-import { execFile, spawnSync } from 'node:child_process';
+import { execFile, spawn, spawnSync } from 'node:child_process';
 import { parseArgs, promisify } from 'node:util';
 import { existsSync, readdirSync, realpathSync } from 'node:fs';
 import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
-import { homedir, userInfo } from 'node:os';
+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";
@@ -32,7 +32,7 @@ import { AdoptError, buildAdoptedProfile } from "../core/attach/adopt.js";
 import { locatorsOf, lookupLocator, readIndex, register, writeIndex } from "../core/workspace/index-store.js";
 import { adoptionLine, judgeAdoption, migrate } from "../core/workspace/migrate.js";
 import { newWorkspaceId, normalizeRemote, recoverCandidates, recoverLines } from "../core/workspace/identity.js";
-import { resolveWorkspace, resolutionLine } from "../core/workspace/resolve.js";
+import { gitWorktrees, resolveWorkspace, resolutionLine } from "../core/workspace/resolve.js";
 import { assessSetup, renderSetup } from "../core/attach/setup.js";
 import { withIdentity } from "../core/attach/init.js";
 import { applySetupPlan, computeSetupPlan, renderSetupPlan, } from "../core/attach/setup-plan.js";
@@ -49,11 +49,12 @@ import { deriveSessionContractDraft } from "../core/operator/derive-draft.js";
 import { LocalRepoAdapter } from "../adapters/local/repo.js";
 import { GitHubAdapter } from "../adapters/github/adapter.js";
 import { GitLabAdapter } from "../adapters/gitlab/adapter.js";
-import { JamAdapter } from "../adapters/jam/adapter.js";
+import { JamAdapter, resolveJamCommand } from "../adapters/jam/adapter.js";
+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 { buildRuntimePorts, closeToolClients, rolesFor } from "../composition/runtime.js";
+import { buildObservationChannels, buildRuntimePorts, closeToolClients, rolesFor } 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";
@@ -67,12 +68,19 @@ import { renderProgress } from "../core/operator/render.js";
 import { AuditLedger, decisionLines, delegationLine, executionLines, reclaimLine, validationLines, DecisionClass, } from "../core/runtime/audit.js";
 import { ClosureLedger } from "../core/runtime/closure.js";
 import { Orchestrator, renderTick } from "../core/runtime/orchestrator.js";
+import { LAST_RUN_KEY, RuntimeLease, fileScope, readBackground, renderBackground, staleAfter, } from "../core/runtime/background.js";
+import { dueWorkspaces, renderWorkspaces, 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 { ObservationLedger } from "../core/monitor/observation.js";
 import { DeliveryLedger, deliver, planDigest } from "../core/presentation/digest.js";
 import { LocalPresentation } from "../adapters/local/presentation.js";
 import { collectSessions, renderCollect } from "../core/runtime/controller.js";
-import { renderFront, restoreFront } from "../core/runtime/front.js";
+import { frontOpeningLines, openFront, renderFront, restoreFront } from "../core/runtime/front.js";
+import { sessionStartPayload } from "../adapters/claude-code/session-start.js";
 import { EscalationLedger, escalationLines } from "../core/runtime/escalation.js";
 import { deriveExecutionState, executionLine } from "../core/runtime/execution-state.js";
 import { buildFinalReport, renderFinalReport } from "../core/runtime/report.js";
@@ -109,13 +117,19 @@ const USAGE = `asc — Agent Session Control
   asc profile adopt   [--id <name>] [--json]  # make a profile for this repository
   asc profile resolve --profile <id> [--preset <id>] [--install <path>] [--write]
 
-  asc runtime start [--interval-min <n>] [--delta-min <n>] [--reconcile-min <n>]
-                    [--census-min <n>] [--digest-min <n>]
-  asc runtime tick
-  asc runtime status [--json]              # which build is in use (C-14 §4)
+  asc runtime start [--detach] [--interval-min <n>] [--delta-min <n>]
+                    [--reconcile-min <n>] [--census-min <n>] [--digest-min <n>]
+                        # --detach: keep observing after this terminal closes
+  asc runtime tick [--all]                 # --all: every workspace this machine knows
+  asc runtime list [--json]                # every workspace, without visiting each one
+  asc runtime service [status] [--json]    # the machine's persistent registration
+  asc runtime service install|uninstall [--interval-min <n>]
+  asc runtime stop                         # ask the background runtime to finish its pass
+  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 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>...
                            --evidence <ref>... [--blocked-scope <path>...] [--previous <ESC-ID> --why <t>]
   asc escalate list
@@ -232,15 +246,58 @@ async function discoverRoot(start, explicitRoot) {
     return resolution.kind === 'UNRESOLVED' ? null : resolution.root;
 }
 async function resolveRoot(start, explicitRoot) {
-    return resolveWorkspace({
+    const home = ascHome();
+    const index = await readIndex(home);
+    const resolution = await resolveWorkspace({
         cwd: start,
         ...(explicitRoot ? { explicitRoot } : {}),
-        index: await readIndex(ascHome()),
+        index,
         // 홈의 `~/.asc` 는 user runtime이지 프로젝트 상태가 아니다 — 그 위로 올라가지 않는다
         stopAt: homedir(),
+        // 등록이 빗나갔을 때만 Git에게 구조를 묻는다 (C-11 §1.3).
+        worktrees: gitWorktrees,
     });
+    // 같은 저장소의 다른 checkout으로 풀렸으면 **이 경로를 등록해 둔다.** 그래야 다음부터는
+    // 예전과 같은 index 조회 하나로 끝나고, guard hook도 이 checkout을 관리 대상으로 본다.
+    if (resolution.kind === 'LINKED_WORKTREE')
+        await rememberWorktree(home, index, resolution);
+    return resolution;
+}
+/**
+ * 이번에 구조로 풀린 checkout을 index에 적는다. **workspace를 새로 만들지 않는다** —
+ * 같은 논리 workspace의 execution instance가 하나 늘었을 뿐이다 (C-11 §1.3).
+ *
+ * 실패해도 이번 판정을 무르지 않는다. 다음 호출이 Git을 한 번 더 부르는 것으로 끝난다 —
+ * 쓰기 하나가 안 됐다고 붙어 있는 workspace를 못 쓰게 만드는 쪽이 나쁘다.
+ */
+async function rememberWorktree(home, index, resolution) {
+    const now = new Date().toISOString();
+    try {
+        await writeIndex(home, register(index, {
+            workspaceId: resolution.workspaceId,
+            root: resolution.root,
+            locator: {
+                path: resolution.locator,
+                kind: resolution.kindOfLocator,
+                platform: process.platform,
+                observedAt: now,
+            },
+            now,
+        }));
+    }
+    catch {
+        // 등록만 못 했을 뿐이다. 판정은 그대로 선다.
+    }
 }
 const execFileAsync = promisify(execFile);
+/**
+ * Claude Host 설치 경로 + **이 CLI의 위치**.
+ *
+ * SessionStart hook은 상태를 물어볼 곳이 필요하고, 그곳은 지금 도는 이 실행파일이다.
+ * 그 CLI가 다시 선택된 build로 넘기므로(`runtime use development` 포함) hook이 build를
+ * 고르는 일은 없다.
+ */
+const hostPaths = () => ({ ...defaultPaths(), entry: fileURLToPath(import.meta.url) });
 /**
  * 이 binding이 가리키는 주소. 자체 호스팅은 발견 단계가 이미 알아냈으므로 같은 값을 쓴다 —
  * 여기서 다시 추측하면 두 곳이 다른 주소를 말하게 된다.
@@ -294,17 +351,60 @@ const ACTIVE_SOURCE_KEY = 'active-source';
  * digest처럼 조립을 하지 않는 명령도 같은 자리를 읽어야 하는데, 그걸 알아내려고 discovery와
  * probe를 다시 돌리면 화면 하나 그리자고 외부를 친다. 그래서 monitor가 돌 때 적어 둔다.
  */
-async function rememberMonitorSource(store, sourceId) {
-    await store.scope('monitor').set(ACTIVE_SOURCE_KEY, sourceId);
+async function rememberMonitorSources(store, sourceIds) {
+    await store.scope('monitor').set(ACTIVE_SOURCE_KEY, JSON.stringify([...sourceIds]));
 }
 /**
- * 마지막으로 붙었던 통로의 scope. 기록이 없으면 예전 이름으로 본다 —
- * 이전 설치의 shadow 기록이 이름이 바뀌었다는 이유로 사라진 것처럼 보이면 안 된다.
+ * 마지막으로 붙었던 통로들.
+ *
+ * 예전에는 문자열 하나였다 — 통로가 하나뿐이라는 전제였고, 코드와 작업 항목이 다른 곳에
+ * 있는 프로젝트에서 그 전제가 깨졌다. 옛 기록(문자열 하나)도 그대로 읽는다: 형식이
+ * 바뀌었다는 이유로 이전 설치의 shadow 기록이 사라진 것처럼 보이면 안 된다.
  */
+async function activeMonitorSources(store) {
+    const raw = await store.scope('monitor').get(ACTIVE_SOURCE_KEY);
+    if (!raw)
+        return ['github-poll'];
+    try {
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed) && parsed.every((id) => typeof id === 'string')) {
+            return parsed.length > 0 ? parsed : ['github-poll'];
+        }
+    }
+    catch {
+        // 옛 형식이다 — 문자열 하나
+    }
+    return [raw];
+}
+/** 통로별 scope. 기록이 하나뿐이던 시절의 호출부는 첫 통로를 본다. */
+async function activeMonitorScopes(store) {
+    return (await activeMonitorSources(store)).map(monitorScope);
+}
 async function activeMonitorScope(store) {
-    const sourceId = await store.scope('monitor').get(ACTIVE_SOURCE_KEY);
-    return monitorScope(sourceId ?? 'github-poll');
+    return (await activeMonitorScopes(store))[0];
 }
+/**
+ * JAM 을 부르는 방법. **한 곳에서만 정한다** — 감시와 작업 조사가 서로 다른 방법으로
+ * JAM 을 부르면 한쪽만 되는 상태가 생긴다(실제로 그랬다: 감시 경로는 이 값을 아예 넘기지
+ * 않아 선언된 JAM binding 이 통로를 만들지 못했다).
+ */
+const jamLauncher = () => process.env.ASC_JAM_PATH
+    ? { command: process.env.ASC_JAM_PATH, args: [] }
+    : { command: 'npx', args: ['--yes', '@jam-mcp/launcher'] };
+/** 조립 입력에 실을 JAM 갈래. */
+const jamComposition = (projectRoot) => {
+    const launcher = jamLauncher();
+    return { jam: { command: launcher.command, args: [...launcher.args, 'serve'], cwd: projectRoot } };
+};
+/** 이 빌드가 아는 adapter 들. 감시와 작업 조사가 같은 목록을 본다. */
+const monitorAdapters = () => {
+    const launcher = jamLauncher();
+    return [
+        new GitHubAdapter(),
+        new GitLabAdapter(),
+        new JamAdapter(process.env.ASC_JAM_PATH ? {} : { command: launcher.command, args: launcher.args }),
+    ];
+};
 /** user-owned ASC home. */
 const ascHome = () => process.env.ASC_HOME ?? join(homedir(), '.asc');
 const DECISION_ERROR = {
@@ -419,12 +519,23 @@ export async function runAscCommand(argv, entry = 'runtime') {
     }
     const { values, positionals } = parsed;
     // 실행 중인 버전을 묻는 유일한 공식 통로. 설치 안내가 버전을 핀으로 고정하는데
-    // 정작 지금 도는 것이 무엇인지 물을 방법이 없었다 (SSAFESTA Windows 실측 ASC-1).
+    // 정작 지금 도는 것이 무엇인지 물을 방법이 없었다 (Windows 실전 실측 ASC-1).
     if (values.version || positionals[0] === 'version') {
         console.log(RELEASE_VERSION);
         return 0;
     }
-    return runParsedCommand(values, positionals, entry, argv);
+    try {
+        return await runParsedCommand(values, positionals, entry, argv);
+    }
+    finally {
+        // **어느 명령이든** 자기가 띄운 도구 자식을 닫는다 (JAM MCP 서버 등).
+        //
+        // 예전에는 `proceed` 한 곳에서만 닫았다. 감시 경로가 JAM 통로를 열게 되자
+        // `monitor scan` 과 `runtime tick` 이 할 일을 다 하고도 종료하지 못했고, 등록된
+        // 서비스가 회차마다 그 프로세스를 하나씩 남겼다 — 실측에서 10분 넘게 살아 있었다.
+        // 닫는 자리를 명령마다 두면 언젠가 또 빠진다. 나가는 문은 하나다.
+        await closeToolClients();
+    }
 }
 function parseArgsOrThrow(argv) {
     return parseArgs({
@@ -457,6 +568,7 @@ function parseArgsOrThrow(argv) {
             intent: { type: 'string' },
             grant: { type: 'string' },
             'interval-min': { type: 'string' },
+            detach: { type: 'boolean' },
             'delta-min': { type: 'string' },
             'reconcile-min': { type: 'string' },
             'census-min': { type: 'string' },
@@ -563,7 +675,15 @@ async function runParsedCommand(values, positionals, entry, argv) {
     // 선택된 build로 넘길 것이 있으면 여기서 넘긴다. **선택 자체를 다루는 명령은 넘기지
     // 않는다** — 잘못 가리키는 선택을 고치거나 들여다보는 명령이 그 선택 때문에 못 돌면
     // 사람이 갇힌다.
-    if (!(group === 'runtime' && (command === 'use' || command === 'status'))) {
+    // 기계 수준 명령은 **프로젝트와 무관하다.** 붙지 않은 자리에서도 답해야 하고,
+    // 등록된 서비스는 어느 프로젝트 안에서 도는 것이 아니다 (설계 §4.1).
+    const machineLevelRuntime = 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)
             return redispatched;
@@ -576,12 +696,24 @@ async function runParsedCommand(values, positionals, entry, argv) {
     if (group === 'runtime' && (command === 'use' || command === 'status')) {
         return runRuntimeSelect(command, positionals[2], positionals[3], values);
     }
+    if (group === 'runtime' && command === 'list')
+        return runRuntimeList(values);
+    if (group === 'runtime' && command === 'service')
+        return runRuntimeService(positionals[2], values);
+    // 기계 전체 회차 — 등록된 서비스가 부르는 갈래다.
+    if (group === 'runtime' && command === 'tick' && values.all)
+        return runRuntimeTickAll(values);
     if (group === 'host')
         return runHost(command, positionals[2], positionals[3], values);
     // setup은 **붙기 전에도** 답을 줘야 한다. 아래 discoverRoot 실패는 exit 2로 끊는데,
     // 그러면 "아직 안 붙었다"를 확인하려고 부른 명령이 안 붙었다는 이유로 죽는다.
     if (group === 'setup')
         return runSetup(command, values, entry);
+    // `front open` 도 같은 이유로 여기서 답한다. Host lifecycle이 부르는 갈래라
+    // **붙지 않은 자리에서 실패하면 안 된다** — 그 자리는 대부분 ASC와 무관한 프로젝트이고,
+    // 거기서 exit 2를 내는 것은 남의 세션에 오류를 얹는 일이다 (C-11 불변식 ⑪).
+    if (group === 'front' && command === 'open')
+        return runFrontOpen(values);
     // adopt는 **붙기 전의 명령이다.** 붙을 Profile을 만드는 것이 일이므로 attach를 요구하면
     // 순서가 뒤집힌다. 나머지 profile 명령은 아래 attach 경로에 그대로 남는다.
     if (group === 'profile' && command === 'adopt')
@@ -947,7 +1079,7 @@ async function runInit(values) {
             installRoot: installRoot(),
             externalProfileRoot: externalProfileRoot(),
             ...(attachedRoot ? { ascRoot: attachedRoot } : {}),
-            hosts: [{ id: 'claude', installed: await verifyInstalled(defaultPaths()) }],
+            hosts: [{ id: 'claude', installed: await verifyInstalled(hostPaths()) }],
             bindings,
             declaredPolicies: declaredPolicies(attachedRoot ? await attachedRuntime(attachedRoot) : undefined),
         });
@@ -1057,11 +1189,18 @@ async function runRuntimeSelect(command, mode, source, values) {
     if (command === 'status') {
         const selection = await readRuntimeSelection(home);
         const target = await resolveRuntimeTarget(selection);
+        // 어느 build를 쓰는지(C-14)와 지금 관측하고 있는지(C-12)는 다른 사실이다. 한 화면에
+        // 같이 두되 섞지 않는다 — 붙지 않은 곳에서는 아래 절이 통째로 없다.
+        const background = await backgroundHere(values);
+        // 서비스 등록은 workspace 와 무관한 기계의 사실이다. 같은 화면에 두되 섞지 않는다.
+        const service = await serviceHealth(values);
         if (values.json) {
             console.log(JSON.stringify({
                 selection: selection ?? null,
                 target,
                 file: selectionPath(home),
+                ...(service ? { service } : {}),
+                ...(background ? { background } : {}),
                 // 해법은 데이터로 준다 — agent가 산문에서 경로를 추론하지 않는다
                 ...('code' in target ? { action: remediationAction(target) } : {}),
             }, null, 2));
@@ -1073,6 +1212,11 @@ async function runRuntimeSelect(command, mode, source, values) {
             return 1;
         }
         console.log(runtimeSelectionLine(target));
+        if (service)
+            console.log(service.line);
+        if (background)
+            for (const line of renderBackground(background))
+                console.log(line);
         return 0;
     }
     if (mode !== 'package' && mode !== 'development') {
@@ -1178,7 +1322,7 @@ async function detectSetupState(values, entry) {
     // "붙어 있음"으로 넘기면 plan이 applied를 답하며 실패할 proceed를 준다 (실측 ASC-2).
     const attachmentBroken = ascRoot ? (await inspectSetup(ascRoot)).attachment === 'BROKEN' : false;
     const scope = values.scope === 'project' ? 'project' : 'local';
-    const hostReport = await verifyInstall(defaultPaths());
+    const hostReport = await verifyInstall(hostPaths());
     return {
         entry,
         projectRoot,
@@ -1189,11 +1333,129 @@ async function detectSetupState(values, entry) {
         profileCandidates: await availableProfiles(installRoot(), externalProfileRoot()),
         scope,
         host: [{ id: 'claude', status: hostReport.status }],
+        // Profile 이 작업 도구를 선언했으면 그 준비 상태까지 본다 (설계 §9.3).
+        ...(await workBindingState(ascRoot, projectRoot)),
+        // 이 기계의 지속 등록. **별도 onboarding 을 만들지 않는다** — 같은 계획에 함께 든다.
+        ...(await persistentRuntimeState(values)),
         // **bootstrap으로 들어왔을 때만 본다.** 설치된 runtime이 자기를 다시 설치할 이유가
         // 없고, 그 축을 안 그리면 plan은 설치된 `asc` 를 전제하지도 않는다 (C-14 §3.4).
         ...(entry === 'bootstrap' ? { stableRuntime: await detectStableInstall(nodeProcessRunner) } : {}),
     };
 }
+/**
+ * 지금 도는 것이 **설치된 패키지인가.**
+ *
+ * 등록물은 지금 도는 진입점의 절대 경로를 박는다. checkout 이나 일회용 prefix 에서
+ * 등록하면 사라질 경로를 기계에 남기는 일이 된다 — 등록은 이 기계에 오래 남을 설치본이
+ * 스스로 할 때만 의미가 있다.
+ */
+function runningFromInstalledPackage() {
+    return fileURLToPath(import.meta.url).replace(/\\/g, '/').includes('/node_modules/@asc-agent/runtime/');
+}
+/**
+ * 지금 이 실행에서 기계 등록을 다뤄도 되는가.
+ *
+ * **기계 서비스는 HOME 으로 격리되지 않는다.** ASC_HOME 을 옮겨도 launchd·Task
+ * Scheduler·systemd 는 같은 기계 하나를 본다 — 그래서 격리된 환경에서 setup 을 통째로
+ * 돌려 보는 검증에는 이 축을 끄는 길이 필요하다. 그 길이 없으면 검증이 실행한 기계에
+ * 진짜 서비스를 남긴다.
+ */
+function serviceRegistrationAllowed() {
+    if (process.env.ASC_SERVICE === 'off')
+        return false;
+    return runningFromInstalledPackage();
+}
+/**
+ * 이 기계에 ASC runtime 이 등록돼 있는가 (설계 §6, Gate 7).
+ *
+ * 물어볼 수 없으면 이 축을 그리지 않는다 — 모르는 것을 "해야 한다"로 적으면 설치되지
+ * 않은 기계에서 setup 이 영영 끝나지 않는다.
+ */
+async function persistentRuntimeState(values) {
+    if (!serviceRegistrationAllowed())
+        return {};
+    const adapter = serviceAdapter();
+    if (!adapter)
+        return {};
+    const plan = await planPersistentRuntime(adapter, serviceCommand(serviceInterval(values))).catch(() => null);
+    if (!plan)
+        return {};
+    return {
+        persistentRuntime: {
+            action: plan.action,
+            adapter: adapter.id,
+            ...(plan.state.kind !== 'CURRENT' && 'detail' in plan.state && plan.state.detail
+                ? { detail: plan.state.detail }
+                : {}),
+        },
+    };
+}
+/**
+ * Profile 이 선언한 작업 도구가 지금 쓸 수 있는가 (설계 §9.3).
+ *
+ * **선언이 없으면 아무것도 보지 않는다** — 선언되지 않은 도구를 준비시키는 것은
+ * 사람이 하지 않은 결정을 대신 내리는 일이다.
+ *
+ * 판정은 그 도구가 한다. 여기서 하는 것은 그 판정을 setup 이 읽을 수 있는 모양으로
+ * 옮기는 것뿐이고, 도구를 실행하지 못하면 이 축을 그리지 않는다(모르는 것을
+ * "준비 안 됨"으로 적지 않는다).
+ */
+async function workBindingState(ascRoot, projectRoot) {
+    if (!ascRoot)
+        return {};
+    const runtime = await attachedRuntime(ascRoot);
+    const declared = (runtime?.layers.profile.bindings ?? []).find((binding) => binding.role === 'work');
+    // 지금 준비 상태를 물어볼 수 있는 도구는 JAM 뿐이다. 다른 adapter 가 생기면 여기가 는다.
+    if (!declared || declared.adapter !== 'jam')
+        return {};
+    const launcher = jamLauncher();
+    const adapter = new JamAdapter(process.env.ASC_JAM_PATH ? {} : { command: launcher.command, args: launcher.args });
+    const status = await adapter
+        .runtime({ projectRoot, env: process.env })
+        .catch(() => ({ state: 'UNAVAILABLE', detail: 'could not ask' }));
+    if (status.state === 'AVAILABLE') {
+        return { workBinding: { adapter: 'jam', resource: declared.resource, ready: true } };
+    }
+    const remedy = adapter.lastRemedy();
+    // 도구를 아예 못 불렀으면 이 축을 그리지 않는다 — 그 상태에서 "고쳐야 한다"고 적으면
+    // 설치되지 않은 기계에서 setup 이 영영 끝나지 않는다.
+    if (!remedy)
+        return {};
+    const version = await jamVersion(projectRoot);
+    return {
+        workBinding: {
+            adapter: 'jam',
+            resource: declared.resource,
+            ready: false,
+            remedy: remedy.kind,
+            detail: remedy.detail,
+            ...(version ? { version } : {}),
+        },
+    };
+}
+/**
+ * JAM 이 말한 자기 버전. **여기서 정하지 않는다** — 두 제품의 릴리스를 묶지 않기 위해서다.
+ * 못 읽으면 undefined 이고, 그러면 계획이 그 도구를 부르지 않는다.
+ */
+async function jamVersion(projectRoot) {
+    const launcher = jamLauncher();
+    const { command, args } = resolveJamCommand(process.env, launcher.command, launcher.args);
+    try {
+        const { stdout } = await execFileAsync(command, [...args, 'doctor', '--json'], { cwd: projectRoot });
+        return JSON.parse(stdout).axes?.packageVersion;
+    }
+    catch (error) {
+        const stdout = error.stdout;
+        if (!stdout)
+            return undefined;
+        try {
+            return JSON.parse(stdout).axes?.packageVersion;
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
 /**
  * `npm` 을 shim으로 부르지 않는다.
  *
@@ -1374,6 +1636,28 @@ async function runSetupLifecycle(command, values, entry) {
                 if (code !== 0)
                     throw new Error(`attach 실패 (exit ${code})`);
             },
+            registerPersistentRuntime: async () => {
+                const adapter = serviceAdapter();
+                if (!adapter)
+                    return;
+                try {
+                    await adapter.install(serviceCommand(serviceInterval(values)));
+                    console.log(`Persistent runtime registered with ${adapter.id}.`);
+                }
+                catch (error) {
+                    // **등록 실패는 attach 실패가 아니다.** 기계 등록은 이 프로젝트가 붙는 것과
+                    // 다른 축이고, 서비스 관리자가 없거나 거절하는 환경은 흔하다. 조용히 넘기지도
+                    // 않는다 — 무엇이 안 됐는지 말하고, 상태는 `runtime status` 가 계속 답한다.
+                    console.error(`Persistent runtime could not be registered with ${adapter.id}: ${String(error)}`);
+                }
+            },
+            // 그 도구의 공식 setup 을 부른다. ASC 가 그 설정을 손으로 조립하지 않는다.
+            setupWorkBinding: async (change) => {
+                const outcome = await healJam({ cwd: process.cwd(), version: change.version });
+                console.log(healLine(outcome));
+                if (outcome.kind === 'FAILED')
+                    throw new Error(healLine(outcome));
+            },
             installHost: async (change) => {
                 const code = await runHost('claude', 'install', undefined, { ...values, json: false });
                 if (code !== 0)
@@ -1668,7 +1952,7 @@ async function runHost(provider, command, target, values) {
         console.error(`Unknown host: ${provider ?? '(none)'} — only claude is supported today`);
         return 2;
     }
-    const paths = defaultPaths();
+    const paths = hostPaths();
     switch (command) {
         case 'install': {
             const before = await verifyInstall(paths);
@@ -2084,13 +2368,7 @@ function dependencyCandidates(workItem) {
  */
 async function buildWorkIngress(store, root, runtime, resolved) {
     const { root: projectRoot } = await discoverProjectRoot(process.cwd());
-    // JAM 은 아직 `jam` 바이너리를 깔지 않는 설치가 기본이다 — 그 경우 launcher 를 통해 부른다.
-    const jamCommand = process.env.ASC_JAM_PATH ? undefined : { command: 'npx', args: ['--yes', '@jam-mcp/launcher'] };
-    const adapters = [
-        new GitHubAdapter(),
-        new GitLabAdapter(),
-        new JamAdapter(jamCommand ?? {}),
-    ];
+    const adapters = monitorAdapters();
     const declared = resolved?.layers.profile.bindings ?? [];
     const plan = await composeBindings({
         context: { projectRoot, env: process.env },
@@ -2111,7 +2389,7 @@ async function buildWorkIngress(store, root, runtime, resolved) {
         // capability 해석은 후보가 유일할 때 이미 스스로 풀린다.
         roles: rolesFor(plan, declared),
         perPage: 30,
-        jam: { command: jamCommand?.command ?? 'jam', args: [...(jamCommand?.args ?? []), 'serve'], cwd: projectRoot },
+        ...jamComposition(projectRoot),
         endpointFor: (binding) => endpointOf(adapters, binding),
     });
     const work = ports.resourceContext;
@@ -2374,7 +2652,7 @@ async function runSession(command, target, values, store, resolved) {
     switch (command) {
         case 'issue': {
             // 누락과 오값은 다른 실수다 — "필수"라고 답하면 이미 준 사람은 자기가 무엇을
-            // 틀렸는지 모른다 (SSAFESTA Windows 실측 ASC-3).
+            // 틀렸는지 모른다 (Windows 실전 실측 ASC-3).
             const roleChoices = SessionRole.options.join('|');
             if (values.role === undefined || !values.goal) {
                 console.error(`--role and --goal are required (role: ${roleChoices})`);
@@ -3046,17 +3324,7 @@ function parseEnumArg(raw, allowed, flag) {
     console.error(`Invalid value for --${flag}: ${String(raw)} (allowed: ${allowed.join('|')})`);
     return null;
 }
-/** 한 회차 감지. 읽기만 하고, 무엇을 할지는 사람이 정한다. */
-/**
- * 감시 엔진을 세운다. **조립과 출력을 나눈다** — 상시 Runtime(C-12)이 같은 엔진을
- * 주기적으로 부르려면 조립이 명령 출력 안에 갇혀 있으면 안 된다.
- */
-async function buildMonitorEngine(values, store, resolved) {
-    const token = await discoverToken();
-    if (!token) {
-        console.error('No GitHub token found. Set ASC_GITHUB_TOKEN, or run `gh auth login`.');
-        return { ok: false, code: 2 };
-    }
+async function buildMonitorEngines(values, store, resolved) {
     // 감시 대상도, 누가 나인지도, 누가 승인자인지도 전부 설정에서 온다.
     // 명령줄로 받던 값들은 각자 제자리(Profile·Override)를 찾았다.
     const repo = resolved.layers.profile.project.repository;
@@ -3072,79 +3340,307 @@ async function buildMonitorEngine(values, store, resolved) {
     // provider를 CLI가 고르지 않는다. 선언된 요구와 실제 remote에서 Binding이 풀리고,
     // 갈리면 고르지 않고 말한다 — silent substitution 0 (C-11 §7).
     const { root: projectRoot } = await discoverProjectRoot(process.cwd());
-    const adapters = defaultAdapters();
+    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({
+    const built = await buildObservationChannels({
+        plan,
+        perPage: 30,
+        ...jamComposition(projectRoot),
+        endpointFor: (binding) => endpointOf(adapters, binding),
+    });
+    // canonical.read 처럼 한 곳이어야 의미가 서는 것은 예전 경로 그대로 역할로 고른다.
+    const singular = await buildRuntimePorts({
         plan,
         roles: rolesFor(plan, declared),
         perPage: 30,
+        ...jamComposition(projectRoot),
         endpointFor: (binding) => endpointOf(adapters, binding),
     });
-    if (!ports.eventSource) {
+    if (built.channels.length === 0) {
         console.error('No monitoring channel could be built:');
-        for (const reason of ports.unavailable)
+        for (const reason of built.unavailable)
             console.error(`  - ${reason}`);
         console.error('\nDeclare which provider takes which role in the Profile bindings.');
         return { ok: false, code: 2 };
     }
     const canonicalPaths = resolved.layers.profile.canonical.sources.flatMap((source) => source.paths);
     const myRoles = resolved.layers.override?.monitor.roles ?? [];
-    const changeContext = ports.changeContext;
-    const engine = new MonitorEngine({
-        store,
-        source: ports.eventSource,
-        ...(ports.scm ? { scm: ports.scm } : {}),
-        ...(ports.inventory ? { inventory: ports.inventory } : {}),
-        // 밖에서 알아 온 사실을 실제로 공급한다 (C-07 §2~§4). 이것이 없으면 Relevance·
-        // Shadow·Material Change가 코드에만 있고 실행 경로에는 없다.
-        ...(changeContext
-            ? {
-                observe: buildEventObservation({
-                    change: changeContext,
-                    ...(resolved.ownership ? { ownership: resolved.ownership } : {}),
-                    ...(myRoles.length ? { myRoles } : {}),
-                    ...(canonicalPaths.length ? { canonicalPaths } : {}),
-                }),
-            }
-            : {}),
-        // scope는 실제로 붙은 source가 정한다 — provider 이름을 CLI가 박지 않는다.
-        observations: new ObservationLedger(store.scope(monitorScope(ports.eventSource.id))),
-        // 조사 단계가 요청하는 통로들. 없는 것은 그 단계가 판정 불성립으로 남는다 (C-07 §6.2).
-        // 없는 것을 있는 척하지 않는다.
-        investigation: {
-            ...(ports.resourceContext ? { resource: ports.resourceContext } : {}),
-            ...(changeContext ? { change: changeContext } : {}),
-        },
-        // Core는 Profile을 모른다 — 조사에 필요한 프로젝트 사실을 Surface가 꺼내 준다.
-        investigationContext: () => ({
-            ...(resolved.ownership ? { ownership: resolved.ownership } : {}),
-            canonicalPaths,
-        }),
-        config: resolved.monitor,
-        authorizedApprover: approver,
-        canonicalSources: resolved.canonicalSources,
-        // 처음 돌 때 과거를 통째로 긁으면 사람이 읽을 수 없다 (OM §18)
-        ...(values.backfill ? {} : { startFrom: new Date().toISOString() }),
+    const channels = built.channels.map((channel) => {
+        const changeContext = channel.changeContext;
+        const engine = new MonitorEngine({
+            store,
+            source: channel.eventSource,
+            // 정본 대조는 채널이 아니라 프로젝트의 사실이다 — 역할로 고른 하나를 함께 쓴다.
+            ...(singular.scm ? { scm: singular.scm } : {}),
+            ...(channel.inventory ? { inventory: channel.inventory } : {}),
+            // 밖에서 알아 온 사실을 실제로 공급한다 (C-07 §2~§4). 이것이 없으면 Relevance·
+            // Shadow·Material Change가 코드에만 있고 실행 경로에는 없다.
+            ...(changeContext
+                ? {
+                    observe: buildEventObservation({
+                        change: changeContext,
+                        ...(resolved.ownership ? { ownership: resolved.ownership } : {}),
+                        ...(myRoles.length ? { myRoles } : {}),
+                        ...(canonicalPaths.length ? { canonicalPaths } : {}),
+                    }),
+                }
+                : {}),
+            // scope는 실제로 붙은 source가 정한다 — 채널이 둘이면 기록도 둘로 갈린다.
+            observations: new ObservationLedger(store.scope(monitorScope(channel.eventSource.id))),
+            // 조사 단계가 요청하는 통로들. 없는 것은 그 단계가 판정 불성립으로 남는다 (C-07 §6.2).
+            // 없는 것을 있는 척하지 않는다.
+            investigation: {
+                ...(channel.resourceContext ? { resource: channel.resourceContext } : {}),
+                ...(changeContext ? { change: changeContext } : {}),
+            },
+            // Core는 Profile을 모른다 — 조사에 필요한 프로젝트 사실을 Surface가 꺼내 준다.
+            investigationContext: () => ({
+                ...(resolved.ownership ? { ownership: resolved.ownership } : {}),
+                canonicalPaths,
+            }),
+            config: resolved.monitor,
+            authorizedApprover: approver,
+            canonicalSources: resolved.canonicalSources,
+            // 처음 돌 때 과거를 통째로 긁으면 사람이 읽을 수 없다 (OM §18)
+            ...(values.backfill ? {} : { startFrom: new Date().toISOString() }),
+        });
+        return {
+            engine,
+            sourceId: channel.eventSource.id,
+            label: `${channel.role ?? '(undeclared)'} · ${channel.adapterId}:${channel.resource}`,
+        };
     });
-    await rememberMonitorSource(store, ports.eventSource.id);
+    await rememberMonitorSources(store, channels.map((channel) => channel.sourceId));
     // **밀려난 후보를 말한다.** 실 프로젝트 관측에서 나온 것이다: primary가 자격 없음으로
     // 빠지고 mirror에 조용히 붙으면 "감시가 도는데 아무것도 안 잡히는" 상태가 된다.
     // 고르는 것 자체는 막지 않되, 무엇이 밀렸는지 모르게 두지 않는다 (C-11 §7).
     const skipped = plan.bindings.filter((b) => b.state !== 'AVAILABLE' && b.state !== 'DEGRADED');
     if (skipped.length > 0) {
-        console.error(`Monitoring runs on ${ports.eventSource.id}. Some candidates could not be used:`);
+        console.error('Some candidates could not be used:');
         for (const binding of skipped) {
             console.error(`  - ${binding.adapterId}:${binding.resource} — ${binding.state}${binding.detail ? ` (${binding.detail})` : ''}`);
         }
     }
-    for (const reason of ports.unavailable)
+    for (const reason of built.unavailable)
         console.error(`  - ${reason}`);
-    return { ok: true, engine, sourceId: ports.eventSource.id, repo };
+    return { ok: true, channels, repo };
+}
+/**
+ * 이 자리에서 background runtime이 돌고 있는가.
+ *
+ * **붙지 않았으면 없는 것으로 답한다** (`null`). `runtime status` 는 붙기 전에도 답해야
+ * 하는 명령이라(C-14 §5) 여기서 attach를 요구하면 그 성질이 깨진다.
+ */
+async function backgroundHere(values) {
+    const root = await discoverRoot(process.cwd(), values.root).catch(() => null);
+    if (!root)
+        return null;
+    try {
+        const scope = new MarkdownStateStore(root).scope('runtime');
+        // 기본 주기 1분에서 나온 회수 기준. start가 다른 주기를 썼다면 그쪽이 더 길 뿐이고,
+        // 살아 있는 lease를 죽은 것으로 읽지는 않는다 — heartbeat가 회차마다 갱신된다.
+        return await readBackground(scope, staleAfter(60_000));
+    }
+    catch {
+        // 읽지 못한 것을 "안 돌고 있다"로 적지 않는다 (C-12 불변식 ⑫).
+        return null;
+    }
+}
+/**
+ * 이 기계의 지속 등록 상태 (설계 §13.1).
+ *
+ * PID 는 여기 없다 — 등록물이 정본이고 프로세스는 갈아 끼우는 실행 인스턴스다
+ * (설계 §4.2). 물어볼 수 없으면 `null` 이고, 그때 화면에 그 줄이 없다.
+ */
+async function serviceHealth(values) {
+    const adapter = serviceAdapter();
+    if (!adapter)
+        return null;
+    const plan = await planPersistentRuntime(adapter, serviceCommand(serviceInterval(values))).catch(() => null);
+    if (!plan)
+        return null;
+    return { adapter: adapter.id, action: plan.action, line: persistentRuntimeLine(adapter.id, plan) };
+}
+/**
+ * 이 기계가 아는 workspace 들 (설계 §6).
+ *
+ * **두 번째 등록부를 읽지 않는다** — workspace index 하나에서 계산한다.
+ */
+async function machineWorkspaces() {
+    const home = ascHome();
+    const index = await readIndex(home);
+    return viewWorkspaces(Object.values(index.workspaces).map((workspace) => ({
+        workspaceId: workspace.workspaceId,
+        root: join(home, 'workspaces', workspace.workspaceId),
+        aliases: workspace.aliases,
+        locators: locatorsOf(index, workspace.workspaceId).map((entry) => entry.locator),
+    })), (path) => existsSync(path));
+}
+/**
+ * `asc runtime list` — 기계 전체 화면 (설계 §13.2).
+ *
+ * workspace 마다 `cd` 해서 status 를 반복하게 만들지 않는다. 여기서 밖을 치지 않는다 —
+ * 이것은 읽기이고, 관측은 회차가 한다.
+ */
+async function runRuntimeList(values) {
+    const views = await machineWorkspaces();
+    if (values.json) {
+        console.log(JSON.stringify({ workspaces: views }, null, 2));
+        return 0;
+    }
+    for (const line of renderWorkspaces(views))
+        console.log(line);
+    return 0;
+}
+/** 이 OS 의 등록 통로. 모르는 OS 면 `null` — 없는 것을 있는 척하지 않는다. */
+function serviceAdapter() {
+    switch (serviceAdapterFor(process.platform)) {
+        case 'launchd':
+            return launchdAdapter();
+        case 'schtasks':
+            return schtasksAdapter();
+        case 'systemd-user':
+            return systemdUserAdapter();
+        default:
+            return null;
+    }
+}
+/**
+ * 등록물이 실행할 명령. **한 회차만 돈다.**
+ *
+ * 지금 도는 실행 파일과 진입점을 그대로 쓴다 — 어느 build 를 쓸지는 그 진입점이 다시
+ * 정하므로(C-14), 등록물이 build 를 고르는 일은 없다.
+ */
+function serviceCommand(intervalSeconds) {
+    return {
+        program: process.execPath,
+        args: [fileURLToPath(import.meta.url), 'runtime', 'tick', '--all'],
+        intervalSeconds,
+    };
+}
+const serviceInterval = (values) => values['interval-min'] === undefined ? 5 * 60 : Math.max(60, Number(values['interval-min']) * 60);
+/**
+ * `asc runtime service` — 이 기계의 지속 등록 (설계 §4).
+ *
+ * **workspace 마다 하나가 아니다.** 사용자/기계당 하나이고, 그 하나가 아는 workspace
+ * 전부를 돌본다. 등록물은 우리가 만든 것만 다룬다.
+ */
+async function runRuntimeService(command, values) {
+    const adapter = serviceAdapter();
+    if (!adapter) {
+        const detail = `no user-scope service manager for ${process.platform}`;
+        if (values.json)
+            console.log(JSON.stringify({ supported: false, detail }, null, 2));
+        else
+            console.error(`Persistent runtime: ${detail}`);
+        // 못 하는 것을 "했다"로 적지 않는다. 다만 이것이 오류는 아니다.
+        return 0;
+    }
+    const wanted = serviceCommand(serviceInterval(values));
+    if (command === undefined || command === 'status') {
+        const plan = await planPersistentRuntime(adapter, wanted);
+        if (values.json) {
+            console.log(JSON.stringify({ adapter: adapter.id, ...plan }, null, 2));
+            return 0;
+        }
+        console.log(persistentRuntimeLine(adapter.id, plan));
+        return 0;
+    }
+    if (command === 'install') {
+        const plan = await planPersistentRuntime(adapter, wanted);
+        if (plan.action === 'unsupported') {
+            console.error(persistentRuntimeLine(adapter.id, plan));
+            return 1;
+        }
+        if (plan.action === 'none') {
+            // 멱등이다 — 같은 것을 다시 등록하지 않는다
+            console.log(persistentRuntimeLine(adapter.id, plan));
+            return 0;
+        }
+        await adapter.install(wanted);
+        console.log(`Persistent runtime registered with ${adapter.id} — one pass every ${wanted.intervalSeconds / 60} min.`);
+        return 0;
+    }
+    if (command === 'uninstall') {
+        await adapter.uninstall();
+        console.log(`Persistent runtime registration removed from ${adapter.id}.`);
+        return 0;
+    }
+    console.error(`Unknown runtime service command: ${command}\n\n${USAGE}`);
+    return 2;
+}
+/**
+ * 기계 전체 한 회차 (설계 §7).
+ *
+ * 싱글턴은 **판단하지 않는다** — 어느 workspace 가 지금 돌 수 있는지만 고르고, 회차 자체는
+ * 기존 경로가 그대로 돈다. workspace 마다 별개의 짧은 프로세스로 도는 이유는 둘이다:
+ * 한 workspace 의 실패가 다른 workspace 를 세우지 않고, 기존 lease·cursor·dedupe 경로를
+ * 한 줄도 바꾸지 않고 그대로 쓴다.
+ *
+ * DORMANT 는 건너뛴다. 살아 있는 checkout 이 없는 자리를 대신해 외부에 묻지 않는다.
+ */
+async function runRuntimeTickAll(values) {
+    // 기계 수준 lease. workspace lease 와 다른 소유 영역이다 (설계 §5.1) — 저쪽은 회차
+    // 하나를, 이쪽은 이 기계의 runtime 을 직렬화한다. 등록된 서비스와 사람이 친 명령이
+    // 겹치면 늦게 온 쪽이 조용히 물러난다 (C-12 불변식 ⑥).
+    const interval = serviceInterval(values) * 1000;
+    const lease = new RuntimeLease({
+        scope: fileScope(join(ascHome(), 'runtime-lease.json')),
+        owner: `${process.pid}@${hostname()}`,
+        staleMs: staleAfter(interval),
+    });
+    if (!(await lease.acquire())) {
+        const held = await lease.read();
+        const detail = held.kind === 'HELD' ? ` (pid ${held.record.pid})` : '';
+        if (values.json)
+            console.log(JSON.stringify({ ran: [], skipped: [], busy: true }, null, 2));
+        else
+            console.log(`Another machine-wide pass is already running${detail} — leaving it to that one.`);
+        return 0;
+    }
+    try {
+        return await tickAllWorkspaces(values, lease);
+    }
+    finally {
+        await lease.release();
+    }
+}
+async function tickAllWorkspaces(values, lease) {
+    const views = await machineWorkspaces();
+    const due = dueWorkspaces(views);
+    const skipped = views.filter((view) => view.health !== 'ACTIVE');
+    const results = [];
+    for (const workspace of due) {
+        const child = spawnSync(process.execPath, [fileURLToPath(import.meta.url), 'runtime', 'tick'], {
+            cwd: workspace.cwd,
+            stdio: values.json ? 'ignore' : 'inherit',
+            env: process.env,
+        });
+        results.push({ workspaceId: workspace.workspaceId, code: child.status ?? 1 });
+        // 회차가 길어져도 이 기계의 lease 는 살아 있어야 한다 — 갱신하지 않으면 도는 중에
+        // 죽은 것으로 보이고 두 번째 프로세스가 끼어든다.
+        await lease.renew();
+    }
+    if (values.json) {
+        console.log(JSON.stringify({
+            ran: results,
+            // 건너뛴 것을 조용히 빼지 않는다 — "아무 일도 없었다"와 다른 사실이다
+            skipped: skipped.map((view) => ({ workspaceId: view.workspaceId, health: view.health })),
+        }, null, 2));
+    }
+    else {
+        for (const result of results)
+            console.log(`${result.workspaceId}: pass exited ${result.code}`);
+        for (const view of skipped)
+            console.log(`${view.workspaceId}: ${view.health} — not observed this pass`);
+    }
+    // 한 workspace 가 실패해도 회차 자체는 성공이다. 다음 회차가 다시 본다.
+    return 0;
 }
 /**
  * 상시 Runtime (C-12). 대화를 켜 두지 않고 **상태를 지속시키고 계산을 짧게 돌린다.**
@@ -3153,7 +3649,7 @@ async function buildMonitorEngine(values, store, resolved) {
  * 재기동해도 cursor·lease·observation이 저장소에 있으므로 같은 사건을 다시 만들지 않는다.
  */
 async function runRuntime(command, values, store, renderer, resolved) {
-    if (command !== 'start' && command !== 'tick') {
+    if (command !== 'start' && command !== 'tick' && command !== 'stop') {
         console.error(`Unknown runtime command: ${command ?? '(none)'}\n\n${USAGE}`);
         return 2;
     }
@@ -3161,10 +3657,17 @@ async function runRuntime(command, values, store, renderer, resolved) {
         console.error('This only runs inside an attached project. Run `asc init --profile <id>` first.');
         return 2;
     }
-    const built = await buildMonitorEngine(values, store, resolved);
+    // 멈추는 것은 감시를 조립하지 않아도 된다 — 외부 자격이 상해 있어도 끌 수 있어야 한다.
+    if (command === 'stop')
+        return stopBackground(store);
+    // 떨어져 나가는 것은 감시를 조립하기 **전에** 한다. 부모가 외부를 한 번 치고 나서
+    // 자식이 또 치면 같은 회차를 두 번 부르는 셈이다.
+    if (command === 'start' && values.detach)
+        return detachRuntime(values);
+    const built = await buildMonitorEngines(values, store, resolved);
     if (!built.ok)
         return built.code;
-    const { engine } = built;
+    const { channels } = built;
     const minutes = (value, fallback) => value === undefined ? fallback * 60_000 : Number(value) * 60_000;
     // 주기는 Core 상수가 아니다 (C-12 불변식 ③). 명령줄이 정하고, 기본값은 여기 산다.
     const schedule = {
@@ -3179,33 +3682,46 @@ async function runRuntime(command, values, store, renderer, resolved) {
         log: (line) => console.log(line),
         lastRunAt: {
             read: async () => {
-                const raw = await scope.get('last-run');
+                const raw = await scope.get(LAST_RUN_KEY);
                 return raw ? JSON.parse(raw) : {};
             },
             write: async (kind, at) => {
-                const raw = await scope.get('last-run');
+                const raw = await scope.get(LAST_RUN_KEY);
                 const current = raw ? JSON.parse(raw) : {};
-                await scope.set('last-run', JSON.stringify({ ...current, [kind]: at }));
+                await scope.set(LAST_RUN_KEY, JSON.stringify({ ...current, [kind]: at }));
             },
         },
         actions: {
+            // 채널마다 돈다. 한 채널이 터져도 나머지는 계속한다 — 자격 하나가 상했다고
+            // 다른 통로까지 조용해지면 그것이 "변경 없음"으로 읽힌다 (C-12 불변식 ⑫).
             delta: async () => {
-                const outcome = await engine.scan();
-                if (outcome.skipped)
-                    return;
-                console.log(`  detected ${outcome.detected} · logged ${outcome.logged} · packets ${outcome.packets.length}`);
+                for (const channel of channels) {
+                    const outcome = await channel.engine.scan().catch((error) => {
+                        console.error(`  [${channel.label}] scan failed — ${String(error)}`);
+                        return null;
+                    });
+                    if (!outcome || outcome.skipped)
+                        continue;
+                    console.log(`  [${channel.label}] detected ${outcome.detected} · logged ${outcome.logged} · packets ${outcome.packets.length}`);
+                }
             },
             reconcile: async () => {
-                const sweep = await engine.reconcile();
-                if (!sweep.skipped && !sweep.complete) {
-                    // 못 본 것을 "변경 없음"으로 읽지 않는다 (C-12 불변식 ⑫)
-                    console.error(`  Reconcile did not complete${sweep.detail ? ` — ${sweep.detail}` : ''}`);
+                for (const channel of channels) {
+                    const sweep = await channel.engine.reconcile().catch((error) => {
+                        console.error(`  [${channel.label}] reconcile failed — ${String(error)}`);
+                        return null;
+                    });
+                    if (sweep && !sweep.skipped && !sweep.complete) {
+                        console.error(`  [${channel.label}] reconcile did not complete${sweep.detail ? ` — ${sweep.detail}` : ''}`);
+                    }
                 }
             },
             census: async () => {
-                const sweep = await engine.census();
-                if (!sweep.skipped && sweep.missing.length > 0) {
-                    console.log(`  ${sweep.missing.length} known items absent from this listing`);
+                for (const channel of channels) {
+                    const sweep = await channel.engine.census().catch(() => null);
+                    if (sweep && !sweep.skipped && sweep.missing.length > 0) {
+                        console.log(`  [${channel.label}] ${sweep.missing.length} known items absent from this listing`);
+                    }
                 }
             },
             digest: async () => {
@@ -3215,20 +3731,128 @@ async function runRuntime(command, values, store, renderer, resolved) {
             },
         },
     });
+    const intervalMs = minutes(values['interval-min'], 1);
+    // 회수 기준은 주기가 정한다 — 주기보다 짧은 만료는 자기 lease를 죽은 것으로 읽는다.
+    const staleMs = staleAfter(intervalMs);
+    const lease = new RuntimeLease({ scope, owner: `${process.pid}@${hostname()}`, staleMs });
+    // cron이 부르는 tick과 떨어져 나간 루프가 겹쳐 돌면 같은 회차를 둘이 한다.
+    // 같은 문을 지나게 해서 하나만 돌린다 (C-12 불변식 ⑥).
+    if (!(await lease.acquire())) {
+        const held = await lease.read();
+        console.log(held.kind === 'HELD'
+            ? `Another runtime already holds this workspace (pid ${held.record.pid}) — leaving it to that one.`
+            : 'Another runtime already holds this workspace — leaving it to that one.');
+        return 0;
+    }
     if (command === 'tick') {
-        const outcome = await orchestrator.tick();
-        console.log(renderTick(outcome));
-        return outcome.failures.length > 0 ? 1 : 0;
+        try {
+            const outcome = await orchestrator.tick();
+            console.log(renderTick(outcome));
+            return outcome.failures.length > 0 ? 1 : 0;
+        }
+        finally {
+            await lease.release();
+        }
     }
-    const intervalMs = minutes(values['interval-min'], 1);
     console.log(`Always-on runtime started — one pass every ${intervalMs / 60_000} min. Ctrl+C to stop.`);
+    // 자는 동안에도 멈출 수 있어야 한다. 깨우지 않으면 `runtime stop` 이 한 주기를 통째로
+    // 기다리고, 주기가 30분이면 30분 동안 "멈추는 중"이 된다.
+    let wake = null;
     const stop = () => {
         console.log('Stopping — a pass still running is carried to the next start by its lease.');
         orchestrator.stop();
+        wake?.();
     };
     process.once('SIGINT', stop);
     process.once('SIGTERM', stop);
-    await orchestrator.run(intervalMs, (ms) => new Promise((resolve) => setTimeout(resolve, ms).unref?.()));
+    try {
+        await orchestrator.run(intervalMs, async (ms) => {
+            // 회차마다 살아 있다고 말한다. 밀려났으면 조용히 물러난다 — 두 루프가 같은
+            // workspace를 갈아 대는 것보다 하나가 도는 편이 낫다.
+            if (!(await lease.renew())) {
+                console.log('Another runtime took this workspace — stopping.');
+                orchestrator.stop();
+                return;
+            }
+            await new Promise((resolve) => {
+                // **unref 하지 않는다.** 예전에는 여기서 타이머를 unref 했는데, 그러면 이벤트
+                // 루프를 붙잡는 것이 아무것도 없어 첫 잠에서 프로세스가 끝난다 — Node 는
+                // `unsettled top-level await` 로 exit 13 을 낸다. 상시로 돌아야 하는 루프가
+                // 조용히 한 회차만 돌고 죽던 원인이다. 멈출 때는 아래 wake 가 타이머를 지운다.
+                const timer = setTimeout(resolve, ms);
+                wake = () => {
+                    clearTimeout(timer);
+                    resolve();
+                };
+            });
+            wake = null;
+        });
+    }
+    finally {
+        await lease.release();
+    }
+    return 0;
+}
+/**
+ * 이 터미널이 닫혀도 계속 보게 한다 (C-12 §0).
+ *
+ * scheduler 제품을 설치하지 않는다 (불변식 ④) — 같은 명령을 떨어져 나간 프로세스로 다시
+ * 띄울 뿐이다. cron·launchd·Task Scheduler로 `asc runtime tick` 을 부르는 길도 그대로
+ * 열려 있고, 둘은 같은 lease를 지나므로 겹쳐 돌지 않는다.
+ */
+async function detachRuntime(values) {
+    // 지금 프로세스가 받은 인자를 그대로 쓰되 --detach 만 뺀다. 옵션을 다시 조립하면
+    // 언젠가 부모와 자식이 다른 주기로 돌게 된다.
+    const args = process.argv.slice(2).filter((arg) => arg !== '--detach');
+    const child = spawn(process.execPath, [fileURLToPath(import.meta.url), ...args], {
+        detached: true,
+        stdio: 'ignore',
+        cwd: process.cwd(),
+        env: process.env,
+    });
+    child.unref();
+    if (child.pid === undefined) {
+        console.error('Could not start a background runtime.');
+        return 1;
+    }
+    console.log(`Background runtime started (pid ${child.pid}). \`asc runtime status\` says whether it is observing.`);
+    console.log('`asc runtime stop` ends it.');
+    void values;
+    return 0;
+}
+/**
+ * 도는 runtime에게 끝내라고 한다.
+ *
+ * **lease를 지우는 것으로 멈추지 않는다** — 그러면 프로세스는 살아 있는데 아무도 그것을
+ * 모르는 상태가 된다. 신호를 보내고, 그 프로세스가 자기 lease를 놓게 한다.
+ */
+async function stopBackground(store) {
+    const scope = store.scope('runtime');
+    const state = await new RuntimeLease({ scope, owner: '(reader)' }).read();
+    if (state.kind === 'FREE') {
+        console.log('No background runtime is registered here.');
+        return 0;
+    }
+    if (state.kind === 'STALE') {
+        // 죽은 프로세스가 남긴 기록이다. 신호를 보낼 곳이 없으므로 기록만 치운다.
+        await scope.delete('runtime-lease');
+        console.log(`Cleared a stale lease from pid ${state.record.pid} — nothing was running.`);
+        return 0;
+    }
+    try {
+        process.kill(state.record.pid, 'SIGTERM');
+    }
+    catch (error) {
+        // 이미 죽은 프로세스다. 기록만 남았으므로 치운다 — 못 지우면 그 사실을 말한다.
+        if (error.code !== 'ESRCH') {
+            console.error(`Could not signal pid ${state.record.pid}: ${String(error)}`);
+            return 1;
+        }
+        await scope.delete('runtime-lease');
+        console.log(`pid ${state.record.pid} was already gone — cleared its lease.`);
+        return 0;
+    }
+    console.log(`Asked pid ${state.record.pid} to finish its pass and stop.`);
     return 0;
 }
 /**
@@ -3465,6 +4089,58 @@ async function runFreeze(group, command, values, store) {
 ${USAGE}`);
     return 2;
 }
+/** 판정 결과에서 workspace 신원만 꺼낸다. 갈래마다 모양이 달라 한 곳에서 접는다. */
+function workspaceOf(resolution) {
+    return resolution.kind === 'REGISTERED' || resolution.kind === 'LINKED_WORKTREE'
+        ? { workspaceId: resolution.workspaceId, locator: resolution.locator }
+        : null;
+}
+/**
+ * Host 세션이 열렸다 (C-12 §4). **이 명령은 실패하지 않는다.**
+ *
+ * Host lifecycle이 부르는 자리라 세 가지를 지킨다:
+ *
+ *   붙지 않은 자리        아무 말도 하지 않고 exit 0 — 남의 프로젝트를 방해하지 않는다
+ *   상태를 못 읽는 자리    왜인지 말한다 — 조용한 빈 화면을 주지 않는다 (불변식 ⑰)
+ *   미등록 linked worktree 공용 resolver가 풀고 등록까지 한다 (C-11 §1.3)
+ *
+ * **workspace 신원을 여기서 다시 구현하지 않는다.** `resolveRoot` 하나만 부른다.
+ */
+async function runFrontOpen(values) {
+    const emit = async (opening) => {
+        const lines = frontOpeningLines(opening);
+        if (values.json) {
+            // payload는 Claude Code가 SessionStart에서 읽는 봉투다. 다른 host는 lines를 쓴다.
+            console.log(JSON.stringify({ kind: opening.kind, lines, payload: sessionStartPayload(lines) }, null, 2));
+            return 0;
+        }
+        for (const line of lines)
+            console.log(line);
+        return 0;
+    };
+    const resolution = await resolveRoot(process.cwd(), values.root).catch(() => null);
+    const workspace = resolution ? workspaceOf(resolution) : null;
+    // EXPLICIT·PROJECT_LOCAL 은 workspace id가 없지만 붙은 자리다 — 신원 없이도 상태는 읽는다.
+    const root = resolution && resolution.kind !== 'UNRESOLVED' ? resolution.root : null;
+    if (!root)
+        return emit({ kind: 'NOT_ASC' });
+    const store = new MarkdownStateStore(root);
+    return emit(await openFront({
+        // 신원을 모르는 자리(project-local)라도 붙은 것은 붙은 것이다
+        workspace: workspace ?? { workspaceId: '(project-local)', locator: root },
+        restore: async () => {
+            const scope = await activeMonitorScope(store);
+            return restoreFront({
+                store,
+                pending: await new LocalOperator({ store }).list({}),
+                escalations: await escalationLedger(store).pending(),
+                health: evaluateHealth(await new CoverageLedger(store.scope(scope)).health(), new Date().toISOString(), HEALTH_THRESHOLDS),
+                ...(workspace ? { workspace } : {}),
+                bindings: claudeBindings(store),
+            });
+        },
+    }));
+}
 async function runFront(command, values, store, root) {
     if (command !== undefined && command !== 'status') {
         console.error(`Unknown front command: ${command}
@@ -3473,8 +4149,9 @@ ${USAGE}`);
         return 2;
     }
     const scope = await activeMonitorScope(store);
-    const index = await readIndex(ascHome());
-    const located = lookupLocator(index, process.cwd());
+    // **index를 직접 뒤지지 않는다.** 모든 root 판정이 지나는 같은 문을 쓴다 — 그래야
+    // 미등록 linked worktree도 같은 workspace로 풀리고, 그 자리가 등록까지 된다 (C-11 §1.3).
+    const located = workspaceOf(await resolveRoot(process.cwd(), values.root));
     const state = await restoreFront({
         store,
         pending: await new LocalOperator({ store }).list({}),
@@ -3508,51 +4185,71 @@ async function runMonitor(command, values, store, renderer, resolved) {
         console.error(`Monitoring is not running — ${readJudgment.detail}`);
         return 2;
     }
-    const built = await buildMonitorEngine(values, store, resolved);
+    const built = await buildMonitorEngines(values, store, resolved);
     if (!built.ok)
         return built.code;
-    const { engine, repo } = built;
+    const { channels, repo } = built;
+    // 채널마다 자기 회차를 돈다. **한 채널의 실패가 다른 채널을 세우지 않는다** — 코드 쪽이
+    // 자격을 잃었다고 작업 항목 쪽까지 못 보게 되면, 그것이 곧 "변화 없음"으로 읽힌다.
+    let worst = 0;
     // 어디까지 확인했는지 보여주기만 한다. 판정하지도, 무엇을 고치지도 않는다.
     if (command === 'status') {
-        const health = await engine.health();
-        console.log(values.json ? JSON.stringify(health, null, 2) : renderHealth(repo, health).join('\n'));
-        return 0;
-    }
-    if (command === 'reconcile' || command === 'census') {
-        const sweep = command === 'reconcile' ? await engine.reconcile() : await engine.census();
-        if (sweep.skipped) {
-            console.log('Another run is in progress. The next pass will pick it up.');
-            return 0;
-        }
         if (values.json) {
-            console.log(JSON.stringify(sweep, null, 2));
-            return sweep.complete ? 0 : 1;
-        }
-        console.log(`${sweep.kind}: ${sweep.seen} listed · ${sweep.changed} changed · ${sweep.packets.length} packets`);
-        if (sweep.missing.length > 0) {
-            console.log(`${sweep.missing.length} known items absent from this listing: ${sweep.missing.join(', ')}`);
-            console.log('  (whether that is deletion, permissions, visibility or a query error is not judged here — a person looks)');
+            const perChannel = [];
+            for (const channel of channels) {
+                perChannel.push({ channel: channel.label, source: channel.sourceId, health: await channel.engine.health() });
+            }
+            console.log(JSON.stringify({ repo, channels: perChannel }, null, 2));
+            return 0;
         }
-        if (!sweep.complete) {
-            // 완주하지 못한 회차를 성공으로 보이면 "확인했다"는 거짓말이 된다
-            console.error(`The listing did not complete${sweep.detail ? ` — ${sweep.detail}` : ''}. This pass makes no judgement about disappearances.`);
-            return 1;
+        for (const channel of channels) {
+            console.log(`[${channel.label}]`);
+            console.log(renderHealth(repo, await channel.engine.health()).join('\n'));
         }
         return 0;
     }
-    const outcome = await engine.scan();
-    if (outcome.skipped) {
-        console.log('Another scan is in progress. The next pass will pick it up.');
-        return 0;
+    if (command === 'reconcile' || command === 'census') {
+        for (const channel of channels) {
+            const sweep = command === 'reconcile' ? await channel.engine.reconcile() : await channel.engine.census();
+            if (sweep.skipped) {
+                console.log(`[${channel.label}] another run is in progress. The next pass will pick it up.`);
+                continue;
+            }
+            if (values.json) {
+                console.log(JSON.stringify({ channel: channel.label, ...sweep }, null, 2));
+            }
+            else {
+                console.log(`[${channel.label}] ${sweep.kind}: ${sweep.seen} listed · ${sweep.changed} changed · ${sweep.packets.length} packets`);
+                if (sweep.missing.length > 0) {
+                    console.log(`  ${sweep.missing.length} known items absent from this listing: ${sweep.missing.join(', ')}`);
+                    console.log('  (whether that is deletion, permissions, visibility or a query error is not judged here — a person looks)');
+                }
+            }
+            if (!sweep.complete) {
+                // 완주하지 못한 회차를 성공으로 보이면 "확인했다"는 거짓말이 된다
+                console.error(`[${channel.label}] the listing did not complete${sweep.detail ? ` — ${sweep.detail}` : ''}. This pass makes no judgement about disappearances.`);
+                worst = 1;
+            }
+        }
+        return worst;
     }
-    console.log(`감지 ${outcome.detected} · 중복 ${outcome.duplicates} · 기록 ${outcome.logged} · ` +
-        `보고서 ${outcome.packets.length} · 재시도 ${outcome.retries.length}`);
-    if (outcome.packets.length > 0) {
+    let packets = 0;
+    for (const channel of channels) {
+        const outcome = await channel.engine.scan();
+        if (outcome.skipped) {
+            console.log(`[${channel.label}] another scan is in progress. The next pass will pick it up.`);
+            continue;
+        }
+        console.log(`[${channel.label}] 감지 ${outcome.detected} · 중복 ${outcome.duplicates} · 기록 ${outcome.logged} · ` +
+            `보고서 ${outcome.packets.length} · 재시도 ${outcome.retries.length}`);
+        packets += outcome.packets.length;
+    }
+    if (packets > 0) {
         const operator = new LocalOperator({ store });
         console.log();
         console.log(renderer.renderList(await operator.list()).text);
     }
-    return 0;
+    return worst;
 }
 /**
  * 외부로 내보내는 경로. 승인과 분리돼 있는 이유는 OM §11.8 — 승인은 내용에 동의한