@asc-agent/runtime 0.4.0 → 0.5.1

package/README.md

@@ -7,7 +7,7 @@ proceed-by-default, escalation, audit, the external-write guard, host integratio
 here.
 
 ```bash
-npm install -g @asc-agent/runtime@0.4.0
+npm install -g @asc-agent/runtime@0.5.1
 ```
 
 npm owns the executable link (on Windows, npm's own `asc.cmd`). This package never edits

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

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

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

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

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

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

package/dist/adapters/fixture-surface/index.d.ts

@@ -0,0 +1,33 @@
+import type { CoordinationSurfacePort, PublicPayload, SurfaceCandidate, SurfaceQuery, SurfaceSnapshot } from '../../ports/coordination-surface.ts';
+import type { RemoteIdentity } from '../../core/runtime/coordination.ts';
+type Stored = {
+    objectId: string;
+    payload: PublicPayload;
+    correlation: string;
+    workReference?: string;
+    closed?: boolean;
+};
+export type FixtureSurfaceDeps = {
+    /** 이 횟수만큼은 만들고 나서 응답을 잃는다. 객체는 남는다 — 그것이 이 사고의 요점이다. */
+    loseNextResponses?: number;
+    /** 주소를 어떻게 짓는가. 판정이 주소에 기대고 있으면 이 값을 바꿔 보면 드러난다. */
+    locatorShape?: (objectId: string) => string;
+    /** 찾기가 실패하는가. 못 찾은 것과 없는 것은 다른 사실이다. */
+    findFails?: boolean;
+};
+export declare class FixtureSurfaceAdapter implements CoordinationSurfacePort {
+    #private;
+    readonly id = "fixture-surface";
+    readonly objects: Stored[];
+    /** 실제로 만들기가 몇 번 일어났는가. 중복 생성 0 을 세는 자리다. */
+    createCalls: number;
+    constructor(deps?: FixtureSurfaceDeps);
+    find(query: SurfaceQuery): Promise<SurfaceCandidate[]>;
+    create(payload: PublicPayload, query: SurfaceQuery): Promise<RemoteIdentity>;
+    read(identity: Pick<RemoteIdentity, 'objectType' | 'objectId'>): Promise<SurfaceSnapshot | null>;
+    /** 밖에서 일어난 일을 흉내 낸다 — 시험이 게시물을 닫거나 남의 것을 심을 때 쓴다. */
+    seed(stored: Omit<Stored, 'objectId'> & {
+        objectId?: string;
+    }): RemoteIdentity;
+}
+export {};

package/dist/adapters/fixture-surface/index.js

@@ -0,0 +1,97 @@
+// Fixture Coordination Surface — 조율 표면 계약을 provider 없이 돌린다 (R7).
+//
+// 왜 있는가: 조율이 특정 회사 도구의 성질이 아니라는 것은, 그 도구가 아닌 것으로도
+// 같은 계약이 성립할 때만 증명된다. 여기 있는 것은 메모리 위의 게시판 하나이며,
+// Core 는 이것과 실제 adapter 를 구분하지 못한다 — 구분하면 그것이 결함이다.
+//
+// 실 사고를 흉내 낼 수 있어야 쓸모가 있다. 그래서 두 개의 손잡이가 있다:
+//   `loseNextResponses` — 만들어지긴 하는데 응답을 잃는다 (중복 생성의 실제 원인)
+//   `locatorShape`      — 주소 모양이 바뀐다 (주소로 판정하면 여기서 깨진다)
+export class FixtureSurfaceAdapter {
+    id = 'fixture-surface';
+    objects = [];
+    /** 실제로 만들기가 몇 번 일어났는가. 중복 생성 0 을 세는 자리다. */
+    createCalls = 0;
+    #lose;
+    #locator;
+    #findFails;
+    constructor(deps = {}) {
+        this.#lose = deps.loseNextResponses ?? 0;
+        this.#locator = deps.locatorShape ?? ((objectId) => `fixture://board/${objectId}`);
+        this.#findFails = deps.findFails ?? false;
+    }
+    #identity(stored) {
+        return {
+            adapter: this.id,
+            objectType: 'thread',
+            objectId: stored.objectId,
+            resource: 'board',
+            locator: this.#locator(stored.objectId),
+        };
+    }
+    async find(query) {
+        if (this.#findFails)
+            throw new Error('surface unreachable');
+        const out = [];
+        const seen = new Set();
+        const push = (stored, matchedBy) => {
+            if (seen.has(stored.objectId))
+                return;
+            seen.add(stored.objectId);
+            out.push({
+                identity: this.#identity(stored),
+                title: stored.payload.title,
+                matchedBy,
+                ...(stored.closed ? { closed: true } : {}),
+            });
+        };
+        for (const known of query.known ?? []) {
+            const hit = this.objects.find((stored) => stored.objectId === known.objectId);
+            if (hit)
+                push(hit, 'known-identity');
+        }
+        for (const stored of this.objects) {
+            if (stored.correlation === query.correlation)
+                push(stored, 'correlation');
+        }
+        if (query.workReference) {
+            for (const stored of this.objects) {
+                if (stored.workReference === query.workReference)
+                    push(stored, 'work-reference');
+            }
+        }
+        return out;
+    }
+    async create(payload, query) {
+        this.createCalls += 1;
+        const stored = {
+            objectId: `OBJ-${this.objects.length + 1}`,
+            payload,
+            correlation: query.correlation,
+            ...(query.workReference ? { workReference: query.workReference } : {}),
+        };
+        // 먼저 남기고 나서 응답을 잃는다 — 반대로 하면 이 fixture 가 흉내 내는 사고가 아니다.
+        this.objects.push(stored);
+        if (this.#lose > 0) {
+            this.#lose -= 1;
+            throw new Error('response lost after the object was created');
+        }
+        return this.#identity(stored);
+    }
+    async read(identity) {
+        const hit = this.objects.find((stored) => stored.objectId === identity.objectId);
+        if (!hit)
+            return null;
+        return {
+            identity: this.#identity(hit),
+            title: hit.payload.title,
+            ...(hit.closed ? { closed: true } : {}),
+        };
+    }
+    /** 밖에서 일어난 일을 흉내 낸다 — 시험이 게시물을 닫거나 남의 것을 심을 때 쓴다. */
+    seed(stored) {
+        const full = { objectId: stored.objectId ?? `OBJ-${this.objects.length + 1}`, ...stored };
+        this.objects.push(full);
+        return this.#identity(full);
+    }
+}

package/dist/adapters/gitlab/adapter.js

@@ -12,6 +12,7 @@ const PROVIDES = [
     'context.resource',
     'context.thread',
     'context.change',
+    'coordination.surface',
 ];
 /**
  * 이 host는 다른 adapter가 맡는다. 여기서 후보로 잡으면 같은 remote를 둘이 주장한다.

package/dist/adapters/gitlab/client.d.ts

@@ -28,23 +28,37 @@ export declare function glabAvailable(run: ProcessRunner): Promise<boolean>;
  * `glab api` 를 읽기 통로로 감싼 클라이언트. GET 만 다룬다 — 쓰기는 Grant 를 지나야 하고,
  * 그 경로를 우회하는 통로를 여기에 만들지 않는다.
  */
-export declare class GlabApiClient implements GitLabReader {
+export declare class GlabApiClient implements GitLabReader, GitLabWriter {
     #private;
     constructor(run: ProcessRunner);
     get<T>(path: string): Promise<GitLabResponse<T>>;
+    post<T>(path: string, body: Record<string, unknown>): Promise<GitLabResponse<T>>;
 }
 /**
  * 읽기 통로. GitLabClient(토큰)와 GlabApiClient(로그인된 도구) 둘 다 이것이다 —
  * Port 들은 어느 쪽인지 몰라야 한다. 통로가 바뀌었다고 조회 코드가 바뀌면, 통로를 늘릴
  * 때마다 같은 코드가 갈라진다.
  */
+/**
+ * 쓰기 통로. **읽기와 일부러 갈라 둔다** — 조회 코드가 쓰기를 할 수 있으면 어디서 무엇이
+ * 나가는지 아무도 세지 못한다. 이것을 쥔 곳은 조율 표면 하나뿐이고, 거기서 나가는 것은
+ * 공개 payload 로 제한돼 있다.
+ *
+ * 승인(Grant)을 지나는 외부 Action 과는 다른 경로다. 그쪽은 사람이 승인한 단일 행동을
+ * 그대로 내보내는 통로이고, 이쪽은 물어본 것이 밖에 실제로 있게 하는 조율 행위다.
+ * 둘을 한 통로로 합치면 승인의 의미가 흐려진다.
+ */
+export interface GitLabWriter {
+    post<T>(path: string, body: Record<string, unknown>): Promise<GitLabResponse<T>>;
+}
 export interface GitLabReader {
     get<T>(path: string): Promise<GitLabResponse<T>>;
 }
-export declare class GitLabClient implements GitLabReader {
+export declare class GitLabClient implements GitLabReader, GitLabWriter {
     #private;
     constructor(deps: GitLabClientDeps);
     get<T>(path: string): Promise<GitLabResponse<T>>;
+    post<T>(path: string, body: Record<string, unknown>): Promise<GitLabResponse<T>>;
 }
 /** `group/sub/project!19` 또는 `group/project#7` 을 쪼갠다. */
 export declare function parseRef(reference: string): {

package/dist/adapters/gitlab/client.js

@@ -39,6 +39,18 @@ export class GlabApiClient {
             return { ok: false, status: 0, data: null, error: String(error.message ?? error).slice(0, 200) };
         }
     }
+    async post(path, body) {
+        // 값 하나가 한 필드다. 문자열을 만들어 붙이지 않는다 — 그렇게 하면 본문에 개행이나
+        // 따옴표가 있을 때 조용히 다른 것이 나간다.
+        const fields = Object.entries(body).flatMap(([key, value]) => value === undefined ? [] : ['-f', `${key}=${String(value)}`]);
+        try {
+            const stdout = await this.#run('glab', ['api', '--method', 'POST', path.replace(/^\//, ''), ...fields]);
+            return { ok: true, status: 201, data: JSON.parse(stdout) };
+        }
+        catch (error) {
+            return { ok: false, status: 0, data: null, error: String(error.message ?? error).slice(0, 200) };
+        }
+    }
 }
 export class GitLabClient {
     #token;
@@ -65,6 +77,21 @@ export class GitLabClient {
             ...(nextPage ? { nextPage } : {}),
         };
     }
+    async post(path, body) {
+        const response = await this.#fetch(`${this.#baseUrl}${path}`, {
+            method: 'POST',
+            headers: {
+                accept: 'application/json',
+                'content-type': 'application/json',
+                'private-token': this.#token,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            return { ok: false, status: response.status, data: null, error: `HTTP ${response.status}` };
+        }
+        return { ok: true, status: response.status, data: (await response.json()) };
+    }
 }
 /** `group/sub/project!19` 또는 `group/project#7` 을 쪼갠다. */
 export function parseRef(reference) {

package/dist/adapters/gitlab/coordination.d.ts

@@ -0,0 +1,19 @@
+import type { CoordinationSurfacePort, PublicPayload, SurfaceCandidate, SurfaceQuery, SurfaceSnapshot } from '../../ports/coordination-surface.ts';
+import type { RemoteIdentity } from '../../core/runtime/coordination.ts';
+import { type GitLabReader, type GitLabWriter } from './client.ts';
+/** 상관 관계를 심는 방법. 라벨 하나이고, 그 안에 들어가는 것은 기대 id 뿐이다. */
+export declare const CORRELATION_LABEL = "asc-coordination";
+export type GitLabCoordinationDeps = {
+    reader: GitLabReader;
+    /** 없으면 만들 수 없다. **없는 것을 있는 척하지 않는다** — create 가 그렇게 답한다. */
+    writer?: GitLabWriter;
+    project: string;
+};
+export declare class GitLabCoordinationSurface implements CoordinationSurfacePort {
+    #private;
+    readonly id = "gitlab";
+    constructor(deps: GitLabCoordinationDeps);
+    find(query: SurfaceQuery): Promise<SurfaceCandidate[]>;
+    create(payload: PublicPayload, query: SurfaceQuery): Promise<RemoteIdentity>;
+    read(identity: Pick<RemoteIdentity, 'objectType' | 'objectId'>): Promise<SurfaceSnapshot | null>;
+}

package/dist/adapters/gitlab/coordination.js

@@ -0,0 +1,111 @@
+// GitLab 조율 표면 — 밖에 있는 durable 한 조율 게시물 하나를 찾고, 만들고, 되읽는다.
+//
+// 이 파일은 provider 를 아는 자리다. Core 는 `CoordinationSurfacePort` 만 알고 여기 이름을
+// 모른다 (C-09 §6). 그래서 여기서 GitLab 어휘를 쓰는 것은 계약대로이고, Core 쪽에 같은
+// 어휘가 새는 것은 결함이다.
+//
+// 신원을 무엇으로 삼는가가 이 adapter 의 핵심 결정이다. 주소(web_url)는 쓰지 않는다 —
+// 호스트가 바뀌고, 프로젝트가 옮겨 다니고, 같은 게시물이 다른 주소로 보인다. 대신
+// `group/project#iid` 를 쓴다. 이 값은 그 시스템 안에서 안정적이고, 스스로 어느 프로젝트인지
+// 말하므로 되읽기가 다른 정보를 필요로 하지 않는다.
+import { encodeProject, parseRef } from "./client.js";
+/** 상관 관계를 심는 방법. 라벨 하나이고, 그 안에 들어가는 것은 기대 id 뿐이다. */
+export const CORRELATION_LABEL = 'asc-coordination';
+const correlationLabel = (correlation) => `${CORRELATION_LABEL}:${correlation}`;
+export class GitLabCoordinationSurface {
+    id = 'gitlab';
+    #reader;
+    #writer;
+    #project;
+    constructor(deps) {
+        this.#reader = deps.reader;
+        this.#writer = deps.writer;
+        this.#project = deps.project;
+    }
+    #identity(issue, project = this.#project) {
+        return {
+            adapter: this.id,
+            objectType: 'issue',
+            // 주소가 아니라 이 값이 정본이다.
+            objectId: `${project}#${issue.iid}`,
+            resource: project,
+            ...(issue.web_url ? { locator: issue.web_url } : {}),
+            ...(issue.updated_at ? { revisionMarker: issue.updated_at } : {}),
+        };
+    }
+    #candidate(issue, matchedBy) {
+        return {
+            identity: this.#identity(issue),
+            title: issue.title,
+            matchedBy,
+            ...(issue.state === 'closed' ? { closed: true } : {}),
+        };
+    }
+    async find(query) {
+        const out = [];
+        const seen = new Set();
+        const add = (candidate) => {
+            if (seen.has(candidate.identity.objectId))
+                return;
+            seen.add(candidate.identity.objectId);
+            out.push(candidate);
+        };
+        // 1) 이미 아는 게시물. 가장 강한 근거이고, 여기서 걸리면 나머지를 볼 이유가 없다.
+        for (const known of query.known ?? []) {
+            const snapshot = await this.read(known);
+            if (snapshot) {
+                add({
+                    identity: snapshot.identity,
+                    title: snapshot.title,
+                    matchedBy: 'known-identity',
+                    ...(snapshot.closed ? { closed: true } : {}),
+                });
+            }
+        }
+        // 2) 우리가 심어 둔 상관 관계. 라벨은 그 시스템이 색인하는 값이라 제목처럼 흔들리지 않는다.
+        const labelled = await this.#reader.get(`/projects/${encodeProject(this.#project)}/issues?labels=${encodeURIComponent(correlationLabel(query.correlation))}&state=all&per_page=20`);
+        if (!labelled.ok) {
+            // 못 찾은 것을 없는 것으로 넘기지 않는다. 호출자가 이 차이로 판단한다.
+            throw new Error(labelled.error ?? `issue search failed (${labelled.status})`);
+        }
+        for (const issue of labelled.data ?? [])
+            add(this.#candidate(issue, 'correlation'));
+        // 3) 작업 항목으로 훑는다. **약한 근거다** — 같은 작업에 여러 조율이 붙을 수 있다.
+        if (query.workReference) {
+            const searched = await this.#reader.get(`/projects/${encodeProject(this.#project)}/issues?search=${encodeURIComponent(query.workReference)}&in=title,description&state=all&per_page=20`);
+            if (searched.ok)
+                for (const issue of searched.data ?? [])
+                    add(this.#candidate(issue, 'work-reference'));
+        }
+        return out;
+    }
+    async create(payload, query) {
+        if (!this.#writer)
+            throw new Error('this binding has no write channel — nothing was created');
+        // **여기를 지나는 것이 밖으로 나가는 전부다.** payload 밖의 값은 이 함수에 오지 않고,
+        // 라벨 하나만 우리가 덧붙인다 — 다음 회차가 이 게시물을 다시 찾는 근거다.
+        const labels = [...(payload.labels ?? []), correlationLabel(query.correlation)].join(',');
+        const created = await this.#writer.post(`/projects/${encodeProject(this.#project)}/issues`, {
+            title: payload.title,
+            description: payload.body,
+            labels,
+        });
+        if (!created.ok || !created.data) {
+            throw new Error(created.error ?? `issue create failed (${created.status})`);
+        }
+        return this.#identity(created.data);
+    }
+    async read(identity) {
+        const parsed = parseRef(identity.objectId);
+        if (!parsed || parsed.kind !== 'issue')
+            return null;
+        const response = await this.#reader.get(`/projects/${encodeProject(parsed.project)}/issues/${parsed.iid}`);
+        if (!response.ok || !response.data)
+            return null;
+        return {
+            identity: this.#identity(response.data, parsed.project),
+            title: response.data.title,
+            ...(response.data.state === 'closed' ? { closed: true } : {}),
+        };
+    }
+}

package/dist/adapters/gitlab/ports.d.ts

@@ -21,6 +21,12 @@ declare abstract class GitLabBase {
  * 할 일 목록(todo)으로 증분을 받는다. GitHub의 알림과 같은 자리이고, 같은 한계를 갖는다 —
  * 지정이 빠지면 오지 않는다. 그래서 Inventory가 따로 있다.
  */
+/**
+ * 두 시각 중 늦은 것. ISO 문자열이지만 **문자열 비교를 하지 않는다** — 이 API 는 계정 설정에
+ * 따라 `+09:00` 과 `Z` 를 섞어 돌려주고, 그 둘은 사전순과 시간순이 다르다. 해석이 안 되는
+ * 값은 비교하지 않고 있는 쪽을 택한다.
+ */
+export declare function laterOf(a: string | undefined, b: string | undefined): string | undefined;
 export declare class GitLabEventSource extends GitLabBase implements EventSource {
     readonly id = "gitlab-todo";
     cursorFrom(since: string): Cursor;

package/dist/adapters/gitlab/ports.js

@@ -33,6 +33,22 @@ class GitLabBase {
  * 할 일 목록(todo)으로 증분을 받는다. GitHub의 알림과 같은 자리이고, 같은 한계를 갖는다 —
  * 지정이 빠지면 오지 않는다. 그래서 Inventory가 따로 있다.
  */
+/**
+ * 두 시각 중 늦은 것. ISO 문자열이지만 **문자열 비교를 하지 않는다** — 이 API 는 계정 설정에
+ * 따라 `+09:00` 과 `Z` 를 섞어 돌려주고, 그 둘은 사전순과 시간순이 다르다. 해석이 안 되는
+ * 값은 비교하지 않고 있는 쪽을 택한다.
+ */
+export function laterOf(a, b) {
+    if (!a)
+        return b;
+    if (!b)
+        return a;
+    const ta = Date.parse(a);
+    const tb = Date.parse(b);
+    if (Number.isNaN(ta) || Number.isNaN(tb))
+        return a >= b ? a : b;
+    return tb > ta ? b : a;
+}
 export class GitLabEventSource extends GitLabBase {
     id = 'gitlab-todo';
     cursorFrom(since) {
@@ -46,8 +62,13 @@ export class GitLabEventSource extends GitLabBase {
         const response = await this.client.get(`/todos?${params}`);
         if (!response.ok || !response.data)
             return { events: [], cursor };
+        // 이번 회차(페이지 전체)에서 본 가장 늦은 시각. **반환 순서를 믿지 않는다** — 이 목록은
+        // 최신순으로 오므로 마지막 항목이 가장 오래된 것이었고, 그것을 다음 기준선으로 삼자
+        // 커서가 옛 시각에 고정돼 같은 것을 매 회차 다시 읽었다. 기준선은 뒤로 가지 않는다.
+        let highWater = parsed.highWater ?? parsed.since;
         const events = [];
         for (const todo of response.data) {
+            highWater = laterOf(highWater, todo.updated_at);
             // 기준선 이전 것은 버린다. provider가 since를 지원하지 않아 여기서 거른다 —
             // 겹쳐 읽고 key로 중복을 거르는 편이 놓치는 것보다 싸다 (OM §10.5).
             if (parsed.since && todo.updated_at < parsed.since)
@@ -69,8 +90,13 @@ export class GitLabEventSource extends GitLabBase {
             });
         }
         const next = response.nextPage
-            ? JSON.stringify({ ...(parsed.since ? { since: parsed.since } : {}), page: response.nextPage })
-            : JSON.stringify({ since: events.at(-1)?.detectedAt ?? parsed.since });
+            ? JSON.stringify({
+                ...(parsed.since ? { since: parsed.since } : {}),
+                page: response.nextPage,
+                ...(highWater ? { highWater } : {}),
+            })
+            : // 페이지를 다 돌았으면 기준선은 지금까지 본 최대값이다 — 이전 기준선보다 앞서지 않는다.
+                JSON.stringify(highWater ? { since: highWater } : {});
         return { events, cursor: next, ...(response.nextPage ? { hasMore: true } : {}) };
     }
 }
@@ -149,6 +175,7 @@ export class GitLabResourceContext extends GitLabBase {
             body: note.body ?? '',
             // 여기는 resolvable 여부를 알려준다 — 아는 것만 적는다.
             ...(note.resolvable ? { unresolved: note.resolved !== true } : {}),
+            ...(note.system ? { system: true } : {}),
         }));
     }
 }

package/dist/adapters/local/canonical.d.ts

@@ -0,0 +1,20 @@
+import type { CanonicalSnapshot } from '../../core/model/entities.ts';
+import type { BaselineQuery, ExternalAction, ExternalActionResult, ScmPort, ThreadSnapshot } from '../../ports/scm.ts';
+export type LocalCanonicalDeps = {
+    cwd: string;
+    /** sourceId → 어느 ref 를 읽는가. Profile 이 준다. */
+    sourceRefs: Readonly<Record<string, {
+        ref: string;
+        remote?: string;
+    }>>;
+    exec?: (args: readonly string[], cwd: string) => Promise<string>;
+};
+export declare class LocalCanonicalReader implements ScmPort {
+    #private;
+    readonly id = "git";
+    constructor(deps: LocalCanonicalDeps);
+    getBaselines(queries: readonly BaselineQuery[]): Promise<CanonicalSnapshot[]>;
+    /** 스레드는 이 통로의 것이 아니다. 모르는 것을 아는 척하지 않는다. */
+    getThread(reference: string): Promise<ThreadSnapshot>;
+    execute(action: ExternalAction): Promise<ExternalActionResult>;
+}

package/dist/adapters/local/canonical.js

@@ -0,0 +1,58 @@
+// 정본 baseline 을 **선언된 대로** 읽는다.
+//
+// Profile 은 정본 갈래마다 provider 를 적는다. `git` 이라고 적힌 갈래는 이 checkout 이
+// 이미 들고 있는 사실이다 — 원격 API 로 갈 이유가 없고, 갈 수 있다는 보장도 없다.
+// 실제로 그 자리에서 한 provider 의 API 로만 읽으려다, 다른 host 를 쓰는 프로젝트에서
+// 세션 발급이 통째로 막혔다. 정본을 못 읽으면 무엇을 딛고 시작하는지 적을 수 없기 때문이다.
+//
+// 여기는 **읽기만** 한다. 쓰기 통로가 아니고, 그 사실을 execute 가 그대로 말한다.
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const run = promisify(execFile);
+export class LocalCanonicalReader {
+    id = 'git';
+    #cwd;
+    #refs;
+    #exec;
+    constructor(deps) {
+        this.#cwd = deps.cwd;
+        this.#refs = deps.sourceRefs;
+        this.#exec =
+            deps.exec ??
+                (async (args, cwd) => {
+                    const { stdout } = await run('git', [...args], { cwd });
+                    return stdout.trim();
+                });
+    }
+    async getBaselines(queries) {
+        const out = [];
+        for (const query of queries) {
+            const configured = this.#refs[query.sourceId];
+            const ref = query.ref ?? configured?.ref;
+            if (!ref) {
+                out.push({ sourceId: query.sourceId, baseline: 'unknown' });
+                continue;
+            }
+            // 원격 추적 ref 를 먼저 본다. 로컬 브랜치를 정본처럼 읽으면 내 작업이 정본이 된다.
+            const remote = configured?.remote;
+            const candidates = remote ? [`${remote}/${ref}`, ref] : [ref];
+            let baseline = 'unknown';
+            for (const candidate of candidates) {
+                const sha = await this.#exec(['rev-parse', '--verify', `${candidate}^{commit}`], this.#cwd).catch(() => '');
+                if (sha) {
+                    baseline = sha;
+                    break;
+                }
+            }
+            out.push({ sourceId: query.sourceId, baseline });
+        }
+        return out;
+    }
+    /** 스레드는 이 통로의 것이 아니다. 모르는 것을 아는 척하지 않는다. */
+    async getThread(reference) {
+        return { reference, lastEventId: 'unknown', missing: true };
+    }
+    async execute(action) {
+        return { ok: false, error: `this canonical reader performs no external action: ${action.action}` };
+    }
+}

package/dist/adapters/markdown/state-store.js

@@ -314,7 +314,8 @@ function renderControlState(state) {
         '# Execution',
         `활성 Block: ${state.activeBlock ?? '없음'}`,
         `활성 세션: ${state.activeSessions.join(', ') || '없음'}`,
-        `Write Boundary 점유: ${state.writeBoundaryOccupancy.join(', ') || '없음'}`,
+        // 객체를 그대로 문자열에 넣으면 "[object Object]" 가 남는다 — 실제 state.md 에서 그렇게 보였다.
+        `Write Boundary 점유: ${state.writeBoundaryOccupancy.map((o) => `${o.sessionId} → ${o.paths.join(' ')}`).join(', ') || '없음'}`,
         `승인 대기: ${state.awaitingController.join(', ') || '없음'}`,
         '',
         '# Monitoring',