@asc-agent/runtime 0.6.1 → 0.7.1

package/dist/adapters/memory/runtime-binding.d.ts

@@ -1,12 +1,19 @@
 import type { ScopedStore } from '../../ports/state-store.ts';
 import { RuntimeBinding, type ClaimOutcome, type RuntimeBindings } from '../../core/operator/runtime-binding.ts';
-/** 내려놓음·승계의 흔적. 현재 view가 아니라 이력이다. */
+/**
+ * 집음·내려놓음·승계의 흔적. 현재 view가 아니라 이력이다.
+ *
+ * `CLAIMED` 가 여기 있는 이유는 실측이다. 내려놓음만 적으니 이력이 반쪽이 되어,
+ * "log 의 마지막이 RELEASED 인데 현재 binding 이 남아 있다" 를 stale 로 읽을 수 없었다 —
+ * 다시 집은 사실이 어디에도 없어서 정상 재결합과 지워지지 않은 묘비가 같은 모양이었다.
+ */
 export type BindingLogEntry = {
     logicalSessionId: string;
     physicalSessionId: string;
     provider: string;
     workerId?: string;
-    kind: 'RELEASED' | 'SUPERSEDED';
+    kind: 'CLAIMED' | 'RELEASED' | 'SUPERSEDED';
+    /** 집은 시각. CLAIMED 에서는 `endedAt` 과 같다 — 아직 끝나지 않았다. */
     claimedAt: string;
     endedAt: string;
 };
@@ -14,9 +21,27 @@ export declare class ScopedRuntimeBindings implements RuntimeBindings {
     #private;
     constructor(scope: ScopedStore, now?: () => string);
     claim(binding: Omit<RuntimeBinding, 'updatedAt'>, at: string): Promise<ClaimOutcome>;
+    /** 지금 살아 있는 결합 전부. 이력(log)은 여기 없다. */
+    current(): Promise<RuntimeBinding[]>;
     observe(logicalSessionId: string, physicalSessionId: string, patch: Partial<Pick<RuntimeBinding, 'workerId' | 'runtimeKind' | 'lastObservedState' | 'capabilitySnapshot'>>, at: string): Promise<ClaimOutcome>;
     release(logicalSessionId: string, physicalSessionId: string): Promise<boolean>;
     rebind(binding: Omit<RuntimeBinding, 'updatedAt'>, at: string): Promise<RuntimeBinding>;
+    /**
+     * 살아 있어야 할 이유가 없는 결합 (0.7.0).
+     *
+     * 판정은 이력과 시각으로만 한다: 이 세션의 마지막 사건이 **끝남**(RELEASED·SUPERSEDED)
+     * 인데 현재 결합이 그 시각보다 나중에 갱신되지 않았다면, 지워졌어야 할 것이 남은 것이다.
+     * 나중에 갱신됐으면 그것은 다시 집은 것이고 정상이다 — 그 구분이 없으면 정상 재결합을
+     * 죽은 것으로 읽는다.
+     *
+     * **아무것도 지우지 않는다.** 무엇이 그런 상태인지만 답하고, 치우는 것은 호출자가 한다.
+     */
+    stale(): Promise<RuntimeBinding[]>;
+    /**
+     * 그 결합을 치운다. **이력은 건드리지 않는다** — 있었던 일은 남는다.
+     * 이미 없으면 아무 일도 하지 않는다(멱등).
+     */
+    forget(logicalSessionId: string): Promise<boolean>;
     /** 이 세션을 거쳐 간 소유권 이력. 현재 owner는 여기 없다 — get()이 답한다. */
     history(logicalSessionId: string): Promise<BindingLogEntry[]>;
     get(logicalSessionId: string): Promise<RuntimeBinding | null>;

package/dist/adapters/memory/runtime-binding.js

@@ -27,19 +27,33 @@ export class ScopedRuntimeBindings {
     }
     async claim(binding, at) {
         const parsed = RuntimeBinding.parse({ ...binding, updatedAt: at });
+        // **한 Physical Run 은 한 번에 한 Logical Session 만 잡는다.**
+        //
+        // 지금까지 원자성은 Logical 쪽에서만 봤다 — 같은 physical 이 다른 세션을 하나 더
+        // 집는 것은 아무도 막지 않았고, 실측에서 그 겹침이 회차마다 나타났다
+        // (S-03 이 살아 있는 동안 S-04 가 같은 physical 로 집혔고, 그 뒤로도 계속).
+        // 그 상태에서는 guard 가 "이 physical 은 관리 대상" 이라고 답할 때 어느 계약을
+        // 말하는지 정해지지 않는다. 뺏지 않는다 — 그 결정은 사람의 것이다 (C-03 §3.2).
+        const held = await this.#currentOf(parsed.physicalSessionId);
+        if (held && held.logicalSessionId !== parsed.logicalSessionId) {
+            return { ok: false, reason: 'RUNTIME_CONFLICT', current: held };
+        }
         // setIfAbsent가 원자성을 진다 — 확인과 쓰기 사이에 다른 Physical Session이 끼지 못한다.
         if (await this.#scope.setIfAbsent(keyOf(parsed.logicalSessionId), JSON.stringify(parsed))) {
+            await this.#log(parsed, 'CLAIMED');
             return { ok: true, binding: parsed };
         }
         const current = await this.get(parsed.logicalSessionId);
         if (!current) {
             // 그 사이 owner가 내려놨다 — 한 번 더 집어 본다. 또 지면 진 것이다.
             if (await this.#scope.setIfAbsent(keyOf(parsed.logicalSessionId), JSON.stringify(parsed))) {
+                await this.#log(parsed, 'CLAIMED');
                 return { ok: true, binding: parsed };
             }
             return { ok: false, reason: 'RUNTIME_CONFLICT', current: (await this.get(parsed.logicalSessionId)) };
         }
-        // 같은 Physical Session의 재-claim은 충돌이 아니라 이어 잡기다 (respawn 아님)
+        // 같은 Physical Session의 재-claim은 충돌이 아니라 이어 잡기다 (respawn 아님).
+        // 이력에 다시 적지 않는다 — 같은 결합이 이어진 것이지 새로 집은 것이 아니다.
         if (current.physicalSessionId === parsed.physicalSessionId) {
             const refreshed = { ...current, updatedAt: at };
             await this.#scope.set(keyOf(parsed.logicalSessionId), JSON.stringify(refreshed));
@@ -47,6 +61,24 @@ export class ScopedRuntimeBindings {
         }
         return { ok: false, reason: 'RUNTIME_CONFLICT', current };
     }
+    /** 이 Physical Run 이 지금 잡고 있는 결합. 없으면 `null`. */
+    async #currentOf(physicalSessionId) {
+        for (const binding of await this.current()) {
+            if (binding.physicalSessionId === physicalSessionId)
+                return binding;
+        }
+        return null;
+    }
+    /** 지금 살아 있는 결합 전부. 이력(log)은 여기 없다. */
+    async current() {
+        const out = [];
+        for (const key of await this.#scope.keys('runtime-binding:')) {
+            const raw = await this.#scope.get(key);
+            if (raw)
+                out.push(RuntimeBinding.parse(JSON.parse(raw)));
+        }
+        return out;
+    }
     async observe(logicalSessionId, physicalSessionId, patch, at) {
         const current = await this.get(logicalSessionId);
         if (!current || current.physicalSessionId !== physicalSessionId) {
@@ -78,8 +110,47 @@ export class ScopedRuntimeBindings {
         }
         const next = RuntimeBinding.parse({ ...binding, updatedAt: at });
         await this.#scope.set(keyOf(next.logicalSessionId), JSON.stringify(next));
+        if (!previous || previous.physicalSessionId !== next.physicalSessionId) {
+            await this.#log(next, 'CLAIMED');
+        }
         return next;
     }
+    /**
+     * 살아 있어야 할 이유가 없는 결합 (0.7.0).
+     *
+     * 판정은 이력과 시각으로만 한다: 이 세션의 마지막 사건이 **끝남**(RELEASED·SUPERSEDED)
+     * 인데 현재 결합이 그 시각보다 나중에 갱신되지 않았다면, 지워졌어야 할 것이 남은 것이다.
+     * 나중에 갱신됐으면 그것은 다시 집은 것이고 정상이다 — 그 구분이 없으면 정상 재결합을
+     * 죽은 것으로 읽는다.
+     *
+     * **아무것도 지우지 않는다.** 무엇이 그런 상태인지만 답하고, 치우는 것은 호출자가 한다.
+     */
+    async stale() {
+        const out = [];
+        for (const binding of await this.current()) {
+            const history = await this.history(binding.logicalSessionId);
+            const last = history.at(-1);
+            if (!last || last.kind === 'CLAIMED')
+                continue;
+            if (last.physicalSessionId !== binding.physicalSessionId)
+                continue;
+            // 끝남 이후에 갱신됐으면 다시 집은 것이다.
+            if (binding.updatedAt > last.endedAt)
+                continue;
+            out.push(binding);
+        }
+        return out;
+    }
+    /**
+     * 그 결합을 치운다. **이력은 건드리지 않는다** — 있었던 일은 남는다.
+     * 이미 없으면 아무 일도 하지 않는다(멱등).
+     */
+    async forget(logicalSessionId) {
+        if (!(await this.get(logicalSessionId)))
+            return false;
+        await this.#scope.delete(keyOf(logicalSessionId));
+        return true;
+    }
     /** 이 세션을 거쳐 간 소유권 이력. 현재 owner는 여기 없다 — get()이 답한다. */
     async history(logicalSessionId) {
         const keys = await this.#scope.keys(logPrefix(logicalSessionId));

package/dist/cli/asc.js

@@ -27,6 +27,8 @@ import { IDENTITY_FILE } from "./identity-config.js";
 import { TextRenderer } from "../adapters/text/renderer.js";
 import { ApprovalService } from "../core/approval/service.js";
 import { Executor } from "../core/execution/executor.js";
+import { transitionGrant } from "../core/model/transitions.js";
+import { applyTransition } from "../core/runtime/store-ops.js";
 import { GrantService } from "../core/execution/grant.js";
 import { DecisionKind } from "../core/model/entities.js";
 import { discoverProjectRoot, excludeFromGit, identitiesTemplate, overrideTemplate, writeIfAbsent } from "../core/attach/init.js";
@@ -73,7 +75,7 @@ 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 { LAST_RUN_KEY, RuntimeLease, fileScope, readBackground, recordPass, renderBackground, staleAfter, } from "../core/runtime/background.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";
@@ -114,6 +116,8 @@ const USAGE = `asc — Agent Session Control
 
   asc grant issue <REQUEST_ID> --action <key> --target <ref> --as <actor>
                   [--grant-id <id>] [--expires <iso>]
+  asc grant issue --session <S-ID> --action <key> --target <ref> --body-file <path> --as <actor>
+                        # what a session produced, sent out because a person said so
   asc grant run   <GRANT_ID> [--run-id <id>]
 
   asc monitor scan      [--backfill] [--as <controller>]   # fast path
@@ -126,7 +130,8 @@ const USAGE = `asc — Agent Session Control
 
   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
+                        # development and recovery only — the machine's registration is
+                        # what observes on the normal path (asc runtime service)
   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
@@ -203,8 +208,9 @@ const USAGE = `asc — Agent Session Control
   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>
+  asc coordination publish --grant <G-ID> --query <ID> --title <text> --body-file <path>
                    [--audience <who>] [--known <objectId>] [--work <ref>] [--json]
+                        # publishing is an outward write — it goes through an approved grant
   asc coordination observe [--json]    # did anything come back on what we published
 
   asc progress show   [<S-ID>]
@@ -789,7 +795,7 @@ async function runParsedCommand(values, positionals, entry, argv) {
     if (group === 'preflight')
         return runPreflight(values, store, guard.runtime);
     if (group === 'grant')
-        return runGrant(command, target, values, store, root);
+        return runGrant(command, target, values, store, root, guard.runtime);
     if (group === 'monitor')
         return runMonitor(command, values, store, renderer, guard.runtime);
     if (group === 'runtime')
@@ -2047,6 +2053,8 @@ const installRoot = () => join(dirname(fileURLToPath(import.meta.url)), '..');
  * **경로를 아는 것은 Surface의 몫이다.** Core에 홈을 알려 주지 않는다 (C-11).
  */
 const externalProfileRoot = () => join(ascHome(), 'profiles');
+/** 한 프로세스에서 한 번만 말한다. 사실은 매번 같고, 반복은 읽히지 않는다. */
+let staleLockReported = false;
 async function checkBootstrap(root) {
     const outcome = await bootstrapGuard({
         ascRoot: root,
@@ -2059,10 +2067,14 @@ async function checkBootstrap(root) {
     if (outcome.ok) {
         // 판번호만 낡은 lock 은 멈출 이유가 아니다. 다만 조용히 지나가지도 않는다 —
         // 다음 재고정 때 따라온다는 것을 여기서 한 번 말한다.
-        if (outcome.staleLock) {
+        // 한 명령 안에서 이 문이 두 번 지나간다. 같은 말을 두 번 하면 그때부터 사람은
+        // 이 줄을 읽지 않는다 — 회차 기록에도 매번 두 줄씩 쌓였다.
+        if (outcome.staleLock && !staleLockReported) {
             const moved = outcome.staleLock.find((drift) => drift.field === 'ascCore.version');
-            if (moved)
+            if (moved) {
+                staleLockReported = true;
                 console.error(`(profile.lock was written by ASC ${moved.locked}; this is ${moved.current}. \`asc profile resolve --write\` records it.)`);
+            }
         }
         return { code: 0, runtime: outcome.runtime };
     }
@@ -2436,6 +2448,14 @@ async function runHost(provider, command, target, values) {
                 }));
                 return 0;
             }
+            // 지워졌어야 할 결합이 남아 있으면 여기서 치운다 (0.7.0).
+            // 별도 migration 명령을 만들지 않는 이유는 하나다 — 이 상태를 만나는 자리가
+            // 여기이고, 사람이 따로 기억해야 하는 정리 절차는 결국 안 돌아간다.
+            for (const dead of await bindings.stale()) {
+                if (await bindings.forget(dead.logicalSessionId)) {
+                    console.error(`(stale binding cleared: ${dead.logicalSessionId} ← ${dead.physicalSessionId})`);
+                }
+            }
             if (!values.physical) {
                 console.error('--physical <Claude session id> is required.');
                 return 2;
@@ -2449,8 +2469,19 @@ async function runHost(provider, command, target, values) {
                 if (released)
                     for (const evidence of running)
                         await audit.endExecution(evidence.executionId, 'RELEASED', at);
-                console.log(released ? `${target} ownership released` : 'Release failed — you are not the owner');
-                return released ? 0 : 1;
+                if (!released) {
+                    console.error('Release failed — you are not the owner');
+                    return 1;
+                }
+                // **놓았다고 말하기 전에 확인한다.** guard 는 이 파일 하나로 관리 대상을 정하므로,
+                // 지워지지 않은 채 "released" 라고 적으면 그 세션의 외부 write 가 계속 막힌다.
+                const after = await bindings.get(target);
+                if (after) {
+                    console.error(`Release did not take — ${target} is still bound to ${after.physicalSessionId}.`);
+                    return 1;
+                }
+                console.log(`${target} ownership released`);
+                return 0;
             }
             const spec = {
                 logicalSessionId: target,
@@ -2487,8 +2518,14 @@ async function runHost(provider, command, target, values) {
             }
             const claimed = await bindings.claim(spec, at);
             if (!claimed.ok) {
-                console.error(`RUNTIME_CONFLICT: ${target} 의 owner는 ${claimed.current.physicalSessionId} 다. ` +
-                    '죽은 세션이 확실하면 --force 로 rebind하라.');
+                // 부딪힌 상대가 **어느 세션인지** 말한다. 같은 Run 이 다른 세션을 잡고 있는 경우와
+                // 이 세션을 다른 Run 이 잡고 있는 경우는 사람이 할 일이 다르다.
+                const other = claimed.current.logicalSessionId;
+                console.error(other === target
+                    ? `RUNTIME_CONFLICT: ${target} 은 이미 ${claimed.current.physicalSessionId} 가 잡고 있다. ` +
+                        '죽은 세션이 확실하면 --force 로 rebind하라.'
+                    : `RUNTIME_CONFLICT: 이 Run(${physical}) 은 지금 ${other} 을 잡고 있다. ` +
+                        `한 Run 은 한 세션만 잡는다 — 먼저 놓아라: asc host claude release ${other} --physical ${physical}`);
                 return 1;
             }
             await recordExecution('host bind');
@@ -3329,7 +3366,7 @@ async function runController(command, values, store, resolved) {
         // 누가 거뒀는지 모르면 History에 'controller' 라는 익명이 남는다 (C-10 §2.4)
         ...(reclaimedBy ? { reclaimedBy } : {}),
     });
-    console.log(renderCollect(outcome, await store.list('session')));
+    console.log(renderCollect(outcome));
     // 거둔 세션의 live 진행 표시는 여기서 정리한다 — 종결 보고(terminal)는 남는다
     const cleared = await progressService(store).collect(outcome.collected);
     if (cleared.length > 0)
@@ -4024,15 +4061,14 @@ async function applyUpdate(plan, values) {
     console.log(`installed: ${RUNTIME_PACKAGE}@${target}`);
     let worst = 0;
     // host 설치물은 버전마다 내용이 바뀐다. 새 runtime 에 낡은 hook 을 남기지 않는다.
-    // **사람이 고친 것은 덮지 않는다** — 그것은 남의 파일이고, 덮으면 그 사람의 수정이
-    // 말없이 사라진다. 남은 것은 말하고, 업데이트 자체는 계속 간다.
-    const host = await install(hostPaths(), undefined, { force: false });
-    for (const path of host.written)
-        console.log(`host: ${path}`);
-    for (const skip of host.skipped) {
-        console.error(`host: ${skip.path} left as it is — ${skip.reason}`);
-        worst = 1;
-    }
+    //
+    // **새로 설치된 build 가 자기 내용을 쓴다.** 이 프로세스는 아직 갈아 끼우기 **전의**
+    // build 이고, 그 build 의 `hookScript()` 는 옛 내용을 만든다 — 실기계에서 update 가
+    // "host: …/SKILL.md" 를 적고 끝났는데 probe 는 여전히 INSTALLED_STALE 이었다. 갱신했다고
+    // 말하면서 옛 내용을 다시 쓴 것이다.
+    //
+    // 사람이 고친 것을 덮지 않는 규칙은 그쪽(`host claude install`)이 그대로 진다.
+    worst = Math.max(worst, await refreshHost());
     // 등록물이 낡았으면 지금 형태로 수렴시킨다. 기존 STALE→수렴 경로를 그대로 쓴다.
     worst = Math.max(worst, await convergeService(values));
     // 마지막은 언제나 확인이다.
@@ -4092,6 +4128,31 @@ function diffState(before, after) {
             changed.push(path);
     return changed.sort();
 }
+/**
+ * 새 build 에게 host 설치물을 자기 내용으로 맞추게 한다.
+ *
+ * 지금 도는 프로세스로 부르지 않는 이유는 하나다 — 이 프로세스는 교체되기 전의 build 다.
+ * 전역 실행물을 못 찾으면 갱신하지 않고 그 사실을 말한다. 조용히 건너뛰면 낡은 hook 이
+ * 새 runtime 옆에 남고, 그 조합은 아무도 시험한 적이 없다.
+ */
+async function refreshHost() {
+    const entry = await globalRuntimeEntry();
+    if (!entry) {
+        console.error('host: could not find the installed runtime to refresh with — run `asc host claude install`');
+        return 1;
+    }
+    const child = spawnSync(process.execPath, [entry, 'host', 'claude', 'install'], { encoding: 'utf8' });
+    const output = `${child.stdout ?? ''}${child.stderr ?? ''}`;
+    for (const line of output.split('\n')) {
+        if (line.startsWith('installed:') || line.startsWith('skipped:'))
+            console.log(`host: ${line}`);
+    }
+    if (child.status !== 0) {
+        console.error(`host: refresh failed${output.trim() ? ` — ${output.trim().split('\n').at(-1)}` : ''}`);
+        return 1;
+    }
+    return 0;
+}
 /**
  * 되돌린다. **되돌릴 자리가 있을 때만** — 없던 것으로 되돌릴 수는 없고, 그때는 돌던 것이
  * 없었다는 사실을 그대로 말한다.
@@ -4247,7 +4308,12 @@ async function tickAllWorkspaces(values, lease) {
             stdio: values.json ? 'ignore' : 'inherit',
             env: process.env,
         });
-        results.push({ workspaceId: workspace.workspaceId, code: child.status ?? 1 });
+        const code = child.status ?? 1;
+        results.push({ workspaceId: workspace.workspaceId, code });
+        // **회차가 어떻게 끝났는지 그 자리에 적는다** (Phase J). 이것이 없으면 실패는
+        // service.log 로만 흘러가고, 붙어 있는 workspace 가 여러 릴리스 동안 한 번도 돌지
+        // 못한 채 건강해 보인다 — 실측에서 셋 중 둘이 그 상태였다.
+        await recordPass(new MarkdownStateStore(workspace.root).scope('runtime'), code).catch(() => undefined);
         // 회차가 길어져도 이 기계의 lease 는 살아 있어야 한다 — 갱신하지 않으면 도는 중에
         // 죽은 것으로 보이고 두 번째 프로세스가 끼어든다.
         await lease.renew();
@@ -4809,6 +4875,39 @@ async function runCoordinationPublish(values, store, resolved) {
         console.error('coordination publish needs --query, --title and --body-file\n\n' + USAGE);
         return 2;
     }
+    // **밖으로 나가는 쓰기는 승인된 계약을 지난다** (OM §11.5, 0.7.0 / Phase H).
+    //
+    // 조율 게시는 오래 이 규칙 밖에 있었다. 근거는 adapter 주석 하나였다 — "물어본 것이
+    // 밖에 실제로 있게 하는 행위이지 승인된 단일 행동이 아니다". 그 구분은 뜻이 있지만,
+    // 계약을 대체할 결정으로 어디에도 기록되지 않았고 실제로 하는 일은 남의 저장소에
+    // 글을 만드는 것이다. 살아 있는 불변식을 따른다.
+    //
+    // 읽기(status·observe)는 그대로다. 계약을 요구하는 것은 실제로 나가는 이 한 번뿐이다.
+    const grantId = typeof values.grant === 'string' ? values.grant : undefined;
+    if (!grantId) {
+        console.error('밖으로 나가는 게시는 승인된 계약을 지난다 — --grant <G-ID> 가 필요하다.');
+        console.error('세션이 만든 결과라면:');
+        console.error('  asc grant issue --session <S-ID> --action coordination.publish \\');
+        console.error('       --target <query-id> --body-file <path> --as <actor>');
+        return 2;
+    }
+    const grant = await store.get('grant', grantId);
+    if (!grant) {
+        console.error(`${grantId} 를 찾지 못했다.`);
+        return 1;
+    }
+    if (grant.status !== 'READY') {
+        console.error(`${grantId} 는 지금 ${grant.status} 다 — 한 번 쓴 계약은 다시 쓰지 않는다.`);
+        return 1;
+    }
+    if (grant.action !== 'coordination.publish') {
+        console.error(`${grantId} 가 승인한 것은 '${grant.action}' 이지 게시가 아니다.`);
+        return 1;
+    }
+    if (grant.target !== queryId) {
+        console.error(`${grantId} 가 승인한 대상은 ${grant.target} 인데 지금 게시하려는 것은 ${queryId} 다.`);
+        return 1;
+    }
     const { surface, unavailable } = await coordinationSurfaceFor(resolved);
     if (!surface) {
         console.error('No coordination surface is bound to this workspace — nothing was published.');
@@ -4831,6 +4930,16 @@ async function runCoordinationPublish(values, store, resolved) {
         ...(workReference ? { workReference } : {}),
     }, { surface, bindingRole: 'coordination-surface' });
     if (outcome.ok) {
+        // 한 번 쓴 계약은 다시 쓰이지 않는다 (OM §11.5 single_use). 게시가 실제로 나간
+        // 뒤에 옮긴다 — 먼저 옮기면 실패한 게시가 계약만 태운다.
+        const consumedAt = new Date().toISOString();
+        const claimed = await applyTransition(store, 'grant', grantId, (g) => transitionGrant(g, 'CLAIMED', 'executor', { claimedBy: `cli-${process.pid}` }));
+        if (claimed.ok) {
+            await applyTransition(store, 'grant', grantId, (g) => transitionGrant(g, 'EXECUTED', 'executor', {
+                resultRef: outcome.identity.objectId,
+                consumedAt,
+            }));
+        }
         const recorded = await recordPublication(coordinationLedger(store), outcome);
         if (values.json) {
             console.log(JSON.stringify({ publish: outcome, recorded: recorded.ok }, null, 2));
@@ -5055,15 +5164,70 @@ async function runMonitor(command, values, store, renderer, resolved) {
  * 외부로 내보내는 경로. 승인과 분리돼 있는 이유는 OM §11.8 — 승인은 내용에 동의한
  * 것이고, 무엇을 어디에 쓸지는 Controller가 따로 지정한다.
  */
-async function runGrant(command, target, values, store, root) {
+async function runGrant(command, target, values, store, root, runtime) {
     switch (command) {
         case 'issue': {
-            if (!target || !values.action || !values.target || !values.as) {
+            // 근거는 둘 중 하나다 — 밖에서 들어온 판단 요청, 또는 계약 안에서 일한 세션.
+            const fromSession = values.session ?? undefined;
+            if ((!target && !fromSession) || !values.action || !values.target || !values.as) {
                 console.error('Usage: asc grant issue REQ-0042 --action <key> --target <ref> --as <actor>');
+                console.error('   or: asc grant issue --session <S-ID> --action <key> --target <ref> --body-file <path> --as <actor>');
+                return 2;
+            }
+            // **할 수 없는 일을 승인시키지 않는다** (0.7.0 / F-3).
+            //
+            // 예전에는 아무 action 으로나 Grant 가 발급되고, 사람이 승인한 **뒤에** 실행에서
+            // "unsupported action" 이 나왔다. 승인의 의미가 그 자리에서 무너진다 — 사람은
+            // 나갈 것에 동의했는데 나갈 수 없는 것이었다.
+            const outward = await externalWritePort(runtime);
+            if (!outward) {
+                console.error('밖으로 내보낼 통로가 없다 — 이 행위를 수행할 결합이 Profile 에 없다.');
+                console.error('지금 무엇이 풀리는지: asc setup status');
+                return 2;
+            }
+            if (outward.supports && !outward.supports(values.action)) {
+                console.error(`'${String(values.action)}' 를 수행할 수 있는 통로가 없다 (${outward.id}).`);
+                console.error('승인 뒤에 실패하는 것보다 지금 멈추는 편이 낫다 — 발급하지 않았다.');
                 return 2;
             }
             // 발급도 승인 권한자만 할 수 있다 — 외부로 나가는 권한이 여기서 만들어지기 때문이다
             const grants = new GrantService(store, new LocalIdentityBinding(await loadIdentityMap(root)));
+            if (fromSession) {
+                // 사람이 지금 내보내라고 한 것이 승인이다. 그 말과 함께 온 내용이 payload 이고,
+                // 여기서 지어내지 않는다 — 사람이 본 적 없는 글이 사람의 이름을 달고 나가면 안 된다.
+                const bodyFile = values['body-file'];
+                if (!bodyFile) {
+                    console.error('--body-file <path> 가 필요하다 — 내보낼 내용은 사람이 준 것이어야 한다.');
+                    return 2;
+                }
+                const payload = await readFile(bodyFile, 'utf8').catch(() => null);
+                if (payload === null) {
+                    console.error(`내용을 읽지 못했다: ${bodyFile}`);
+                    return 2;
+                }
+                const forSession = await grants.issueForSession({
+                    grantId: values['grant-id'] ?? `G-${String(Date.now()).slice(-4)}`,
+                    sessionId: fromSession,
+                    issuedBy: values.as,
+                    channel: 'local',
+                    action: values.action,
+                    target: values.target,
+                    payload,
+                    ...(values.expires ? { expiresAt: values.expires } : {}),
+                    issuedAt: new Date().toISOString(),
+                });
+                if (!forSession.ok) {
+                    console.error(GRANT_ERROR[forSession.failure.kind] ?? forSession.failure.kind);
+                    return 1;
+                }
+                console.log(`${forSession.grant.id} READY — ${forSession.grant.action} → ${forSession.grant.target}`);
+                console.log('The target state is checked again before execution. If it changed in the meantime, nothing runs.');
+                return 0;
+            }
+            if (!target) {
+                console.error('요청 근거가 없다 — REQUEST_ID 를 주거나 --session <S-ID> 를 쓰라.');
+                return 2;
+            }
             const issued = await grants.issue({
                 grantId: values['grant-id'] ?? `G-${String(Date.now()).slice(-4)}`,
                 requestId: target,
@@ -5087,19 +5251,22 @@ async function runGrant(command, target, values, store, root) {
                 console.error('Usage: asc grant run G-0001');
                 return 2;
             }
-            const token = await discoverToken();
-            if (!token) {
-                console.error('No GitHub token found. Set ASC_GITHUB_TOKEN, or run `gh auth login`.');
-                return 2;
-            }
             const grant = await store.get('grant', target);
             if (!grant) {
                 console.error(`${target} was not found.`);
                 return 1;
             }
-            // 이 한 번이 실제로 밖에 나간다. 계약이 지정한 대상·내용 그대로이며,
-            // 직전에 대상 상태를 다시 확인한다.
-            const scm = new GitHubScm({ client: new GitHubClient({ token }), defaultRepo: repoOf(grant.target) });
+            // **어느 provider 로 나갈지는 여기서 고르지 않는다** (C-09 · B-49).
+            //
+            // 예전에는 이 자리에서 GitHub client 를 직접 만들었다. 관측 경로는 진작 결합으로
+            // 풀리고 있었는데 실행 경로만 한 갈래에 묶여 있어서, 코드가 다른 곳에 있는
+            // 프로젝트에서는 승인이 끝난 **뒤에야** 실행할 통로가 없다는 것이 드러났다.
+            const scm = await externalWritePort(runtime);
+            if (!scm) {
+                console.error('밖으로 내보낼 통로가 없다 — Profile bindings 에 외부 쓰기를 제공하는 결합이 필요하다.');
+                console.error('지금 무엇이 풀리는지: asc setup status');
+                return 2;
+            }
             const outcome = await new Executor({
                 store,
                 scm,
@@ -5117,6 +5284,36 @@ async function runGrant(command, target, values, store, root) {
             return 2;
     }
 }
+/**
+ * 승인된 행위가 실제로 나갈 통로 (C-09 · OM §11.5).
+ *
+ * 조립은 Composition 의 몫이다 — 이 자리에서 provider 를 알면 provider 교체가 다시 CLI
+ * 수술이 된다. 없으면 `null` 이고, 없는 것을 있는 척하지 않는다.
+ */
+async function externalWritePort(runtime) {
+    const { root: projectRoot } = await discoverProjectRoot(process.cwd());
+    const adapters = monitorAdapters();
+    const declared = runtime?.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),
+        repoRoot: projectRoot,
+        ...(runtime?.layers.profile.canonical.sources
+            ? {
+                sourceRefs: Object.fromEntries(runtime.layers.profile.canonical.sources
+                    .filter((source) => typeof source.ref === 'string')
+                    .map((source) => [source.id, { ref: source.ref }])),
+            }
+            : {}),
+        endpointFor: (binding) => endpointOf(adapters, binding),
+    });
+    return ports.scm ?? null;
+}
 /** `owner/repo#19` 에서 저장소만. 짧은 참조를 풀 때 쓴다. */
 function repoOf(target) {
     const match = /^([^/\s]+\/[^#\s]+)#\d+$/.exec(target);
@@ -5128,6 +5325,8 @@ const GRANT_ERROR = {
     FORBIDDEN_ISSUER: '계약을 발급할 권한이 없다. .asc/identities.json 에 `"이름": ["local:계정"]` 형태로 매핑을 추가하라 ' +
         '(현재 상태는 `asc setup status`).',
     NO_PAYLOAD: '내보낼 내용이 없다.',
+    SESSION_NOT_FOUND: '그 세션을 찾지 못했다.',
+    SESSION_NOT_RUNNABLE: '아직 시작하지 않은 세션이다 — 내보낼 결과가 없다.',
     GRANT_EXISTS: '같은 id의 계약이 이미 있다.',
 };
 // import 만으로 명령이 돌면 안 된다 — bootstrap이 이 모듈을 불러오는 순간 세상이 바뀐다.

package/dist/composition/runtime.d.ts

@@ -38,6 +38,8 @@ export type BuildInput = {
     sourceRefs?: Readonly<Record<string, {
         ref: string;
     }>>;
+    /** 이 결합이 가리키는 저장소가 이 기계 어디에 있는가. 원격에 올리는 행위에만 쓴다. */
+    repoRoot?: string;
     /** 이벤트 조회 페이지 크기. */
     perPage?: number;
     /** 자격 조회 통로 주입점(테스트용). adapter id를 받아 그 adapter의 자격을 돌려준다. */

package/dist/composition/runtime.js

@@ -12,6 +12,7 @@ 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";
 import { GitHubScm } from "../adapters/github/scm.js";
+import { GitLabScm } from "../adapters/gitlab/scm.js";
 import { GitLabClient, GlabApiClient, discoverToken as discoverGitLabToken, glabAvailable, } from "../adapters/gitlab/client.js";
 import { GitLabCoordinationSurface } from "../adapters/gitlab/coordination.js";
 import { GitLabChangeContext, GitLabEventSource, GitLabInventory, GitLabResourceContext, } from "../adapters/gitlab/ports.js";
@@ -34,6 +35,15 @@ const FACTORIES = {
             // 조율 표면. 토큰 통로일 때만 쓰기가 가능하다 — 도구를 통로로 쓰는 경우도 POST 를
             // 대신 보내 준다. 둘 다 아니면 create 가 그 사실을 그대로 말한다.
             coordinationSurface: new GitLabCoordinationSurface({ reader: client, writer: client, project }),
+            // 승인된 외부 write 의 통로. 관측은 진작 provider-neutral 이었는데 실행만 한 갈래에
+            // 묶여 있어, 승인이 끝난 뒤에야 "실행할 통로가 없다" 가 드러나던 자리다.
+            scm: new GitLabScm({
+                reader: client,
+                writer: client,
+                defaultProject: project,
+                sourceRefs: input.sourceRefs ?? {},
+                ...(input.repoRoot ? { repoRoot: input.repoRoot } : {}),
+            }),
             // canonical 통로는 아직 없다. 없는 것을 있는 척하지 않는다.
         };
     },

package/dist/core/attach/init.js

@@ -110,12 +110,20 @@ export function withIdentity(identities, override, input) {
     const nextIdentities = { ...identities };
     const nextOverride = { ...override };
     if (input.controller) {
-        nextIdentities[input.name] = [input.actor];
+        // **한 사람이 여러 채널 identity 를 갖는다** (OM §11.6). schema 가 배열인 것이 그
+        // 뜻이고, 읽는 쪽(LocalIdentityBinding)도 배열 전체를 Set 으로 담아 대조한다.
+        // 그런데 여기서는 배열을 통째로 덮고 있었다 — 한 채널로 잡아 둔 identity 가 다음
+        // setup 에서 다른 채널 하나로 바뀌어 사라졌다. 더하고, 중복만 지운다.
+        const merged = (existing) => [
+            ...new Set([
+                ...(Array.isArray(existing) ? existing.filter((v) => typeof v === 'string') : []),
+                input.actor,
+            ]),
+        ];
+        nextIdentities[input.name] = merged(nextIdentities[input.name]);
         const controller = { ...(nextOverride.controller ?? {}) };
-        controller.identities = {
-            ...(controller.identities ?? {}),
-            [input.name]: [input.actor],
-        };
+        const controllerIdentities = controller.identities ?? {};
+        controller.identities = { ...controllerIdentities, [input.name]: merged(controllerIdentities[input.name]) };
         nextOverride.controller = controller;
     }
     if (input.monitor) {