@asc-agent/runtime 0.6.1 → 0.7.0

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

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

@@ -27,6 +27,44 @@ export declare const PERMISSION_DENY_RULES: readonly string[];
  * worker에게 주는 설정 파일에 살고, 파일은 .asc/ 안(untracked)에 있다.
  */
 export declare function workerSettings(): string;
+/**
+ * 한 줄의 명령을 **실제로 실행되는 조각들**로 가른다 (0.7.0).
+ *
+ * 이 함수가 있는 이유는 실측이다. 예전에는 명령 문자열 전체에 정규식을 걸었고,
+ * `git commit -m "docs: push 관련"` 이 `git push` 로 읽혔다. 따옴표 안은 인자이지
+ * 실행이 아니다.
+ *
+ * 가르는 기준은 **따옴표 밖의** 제어 연산자와 개행뿐이다: `;` `&&` `||` `|` `\n`.
+ * 각 조각은 두 부분으로 나온다 —
+ *
+ * ```text
+ * bare    따옴표를 걷어낸 나머지. 판정은 여기서만 한다.
+ * quoted  따옴표 안에 있던 것들. 보통은 인자이지만, `sh -c` 처럼 그 자체가 명령이
+ *         되는 자리가 있어 호출자가 다시 볼 수 있게 함께 준다.
+ * ```
+ *
+ * **범용 shell 파서가 아니다.** 치환·here-doc·중첩 따옴표의 모든 경우를 풀지 않는다.
+ * hook 이 받는 것이 문자열 하나뿐이라는 플랫폼 제약 위에서, 인용부호를 구분하는 데까지가
+ * 이 함수의 몫이다.
+ *
+ * **hook 스크립트가 이 함수의 소스를 그대로 실어 나른다** — 그래서 자기 완결적이어야 하고,
+ * 바깥 식별자를 참조하면 안 된다.
+ */
+export declare function segmentsOf(command: string): {
+    bare: string;
+    quoted: string[];
+}[];
+/**
+ * 금지된 외부 write 가 이 명령 안에 있는가.
+ *
+ * 따옴표 밖에서만 판정하고, `sh -c '…'` · `eval '…'` 처럼 따옴표 안이 곧 명령인 자리에서는
+ * 그 안을 한 번 더 본다. 그 밖의 우회(치환·파일 경유 실행 등)는 이 층이 잡지 못한다 —
+ * 그것은 알려진 한계이며 C-03 §5.3 의 3층 방어가 그 자리를 나눠 진다.
+ */
+export declare function forbiddenIn(command: string, patterns: readonly {
+    pattern: RegExp;
+    label: string;
+}[]): string | null;
 export declare function isForbiddenCommand(command: string): {
     forbidden: boolean;
     label?: string;

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

@@ -76,12 +76,116 @@ export function workerSettings() {
         permissions: { deny: [...PERMISSION_DENY_RULES] },
     }, null, 2)}\n`;
 }
-export function isForbiddenCommand(command) {
-    for (const { pattern, label } of FORBIDDEN_COMMAND_PATTERNS) {
-        if (pattern.test(command))
-            return { forbidden: true, label };
+/**
+ * 한 줄의 명령을 **실제로 실행되는 조각들**로 가른다 (0.7.0).
+ *
+ * 이 함수가 있는 이유는 실측이다. 예전에는 명령 문자열 전체에 정규식을 걸었고,
+ * `git commit -m "docs: push 관련"` 이 `git push` 로 읽혔다. 따옴표 안은 인자이지
+ * 실행이 아니다.
+ *
+ * 가르는 기준은 **따옴표 밖의** 제어 연산자와 개행뿐이다: `;` `&&` `||` `|` `\n`.
+ * 각 조각은 두 부분으로 나온다 —
+ *
+ * ```text
+ * bare    따옴표를 걷어낸 나머지. 판정은 여기서만 한다.
+ * quoted  따옴표 안에 있던 것들. 보통은 인자이지만, `sh -c` 처럼 그 자체가 명령이
+ *         되는 자리가 있어 호출자가 다시 볼 수 있게 함께 준다.
+ * ```
+ *
+ * **범용 shell 파서가 아니다.** 치환·here-doc·중첩 따옴표의 모든 경우를 풀지 않는다.
+ * hook 이 받는 것이 문자열 하나뿐이라는 플랫폼 제약 위에서, 인용부호를 구분하는 데까지가
+ * 이 함수의 몫이다.
+ *
+ * **hook 스크립트가 이 함수의 소스를 그대로 실어 나른다** — 그래서 자기 완결적이어야 하고,
+ * 바깥 식별자를 참조하면 안 된다.
+ */
+export function segmentsOf(command) {
+    const segments = [];
+    let bare = '';
+    let quoted = [];
+    let buffer = '';
+    let quote = null;
+    const flush = () => {
+        if (bare.trim().length > 0 || quoted.length > 0)
+            segments.push({ bare, quoted });
+        bare = '';
+        quoted = [];
+    };
+    for (let i = 0; i < command.length; i += 1) {
+        const char = command[i];
+        if (quote) {
+            if (char === '\\' && quote === '"' && i + 1 < command.length) {
+                buffer += command[i + 1];
+                i += 1;
+                continue;
+            }
+            if (char === quote) {
+                quoted.push(buffer);
+                buffer = '';
+                quote = null;
+                // 따옴표가 있던 자리는 공백으로 남긴다 — 앞뒤 토큰이 붙어 버리면 안 된다.
+                bare += ' ';
+                continue;
+            }
+            buffer += char;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (char === '\\' && i + 1 < command.length) {
+            // 이스케이프된 문자는 그대로 인자다. 연산자로 읽히지 않게 한다.
+            bare += command[i + 1] === '\n' ? ' ' : command[i + 1];
+            i += 1;
+            continue;
+        }
+        if (char === '\n' || char === ';' || char === '|' || char === '&') {
+            // `&&` `||` 는 두 글자다 — 한 번만 자른다.
+            if ((char === '|' || char === '&') && command[i + 1] === char)
+                i += 1;
+            flush();
+            continue;
+        }
+        bare += char;
+    }
+    if (quote) {
+        // 닫히지 않은 따옴표. 그 안의 것을 인자로 단정하지 않는다 — 판정 대상에 남긴다.
+        bare += ' ' + buffer;
     }
-    return { forbidden: false };
+    flush();
+    return segments;
+}
+/** 이 조각이 다른 명령을 문자열로 받아 실행하는 자리인가. */
+function runsGivenText(bare) {
+    return /(^|\s)(?:sh|bash|zsh|dash|ksh)\s+(?:-[a-zA-Z]*\s+)*-c(\s|$)/.test(bare) || /(^|\s)eval(\s|$)/.test(bare);
+}
+/**
+ * 금지된 외부 write 가 이 명령 안에 있는가.
+ *
+ * 따옴표 밖에서만 판정하고, `sh -c '…'` · `eval '…'` 처럼 따옴표 안이 곧 명령인 자리에서는
+ * 그 안을 한 번 더 본다. 그 밖의 우회(치환·파일 경유 실행 등)는 이 층이 잡지 못한다 —
+ * 그것은 알려진 한계이며 C-03 §5.3 의 3층 방어가 그 자리를 나눠 진다.
+ */
+export function forbiddenIn(command, patterns) {
+    for (const segment of segmentsOf(command)) {
+        for (const { pattern, label } of patterns) {
+            if (pattern.test(segment.bare))
+                return label;
+        }
+        if (runsGivenText(segment.bare)) {
+            for (const inner of segment.quoted) {
+                const nested = forbiddenIn(inner, patterns);
+                if (nested)
+                    return nested;
+            }
+        }
+    }
+    return null;
+}
+export function isForbiddenCommand(command) {
+    const label = forbiddenIn(command, FORBIDDEN_COMMAND_PATTERNS);
+    return label ? { forbidden: true, label } : { forbidden: false };
 }
 /** 1층 — worker에게 주입하는 계약문. 지침이지 enforcement가 아니라고 전제한다. */
 export function workerContract(input) {
@@ -122,6 +226,14 @@ export function hookScript() {
     const asSource = (list) => list.map((p) => `  { pattern: ${p.pattern.toString()}, label: ${JSON.stringify(p.label)} },`).join('\n');
     const patterns = asSource(FORBIDDEN_COMMAND_PATTERNS);
     const offlinePatterns = asSource(OFFLINE_COMMAND_PATTERNS);
+    // **판정 로직을 두 번 쓰지 않는다.** 위 함수들의 소스를 그대로 실어 나른다 — 손으로
+    // 옮겨 적으면 언젠가 hook 과 단위 검사가 서로 다른 것을 막는다. 그래서 저 함수들은
+    // 바깥 식별자를 참조하지 않는다.
+    const logic = [segmentsOf, runsGivenText, forbiddenIn]
+        .map((fn) => fn.toString())
+        .join('\n\n')
+        .replace(/`/g, '\\`')
+        .replace(/\$\{/g, '\\${');
     return `#!/usr/bin/env node
 // ASC external-write guard (PreToolUse) — 설치·갱신은 \`asc host claude install\` 로만.
 // 관리 대상(ASC RuntimeBinding에 등록된) Claude 세션의 외부 write를 실행 직전에 막는다.
@@ -143,6 +255,8 @@ const OFFLINE_ONLY = [
 ${offlinePatterns}
 ]
 
+${logic}
+
 /**
  * 원격이 얼어 있는가. 얼어 있으면 완전 오프라인인지까지 본다.
  * 읽지 못하면 얼지 않은 것으로 본다 — guard 오작동이 곧 작업 중단이 되면 안 된다.
@@ -246,14 +360,13 @@ const registered = lookupWorkspace(cwd)
 if (registered === 'MISSING') {
   // **조건부 fail-closed** (C-11 §4). 이 경로는 ASC가 맡은 곳인데 runtime을 읽지 못했다.
   // 그대로 통과시키면 관리 대상 세션의 외부 write가 조용히 열린다 — 그게 가장 나쁘다.
-  for (const { pattern, label } of FORBIDDEN) {
-    if (pattern.test(command)) {
-      console.error(
-        \`[ASC guard] 이 경로는 ASC workspace로 등록돼 있는데 runtime을 읽지 못했다. \` +
-        \`'\${label}' 를 막는다 — asc setup status 로 확인하라.\`,
-      )
-      process.exit(2)
-    }
+  const blocked = forbiddenIn(command, FORBIDDEN)
+  if (blocked) {
+    console.error(
+      \`[ASC guard] 이 경로는 ASC workspace로 등록돼 있는데 runtime을 읽지 못했다. \` +
+      \`'\${blocked}' 를 막는다 — asc setup status 로 확인하라.\`,
+    )
+    process.exit(2)
   }
   process.exit(0)
 }
@@ -281,7 +394,28 @@ if (isMutation && !managed) {
   process.exit(2)
 }
 
-if (!managed) process.exit(0)
+// **관리 대상 workspace 인데 이 Run 이 어느 계약에도 들어 있지 않다** (0.7.0 B-1).
+//
+// 지금까지 여기서 통과시켰다. 그래서 결합이 사라지거나 아직 생기지 않은 상태의 세션은
+// 계약 밖에서 밖으로 쓸 수 있었다 — guard 가 있는데 열려 있는 상태이고, 그것이 가장 나쁘다.
+// 읽기는 그대로 통과한다. 막는 것은 밖으로 나가는 쓰기뿐이다.
+if (!managed) {
+  const outward = forbiddenIn(command, FORBIDDEN)
+  if (outward) {
+    const id = observedSessionId || '<this session id>'
+    console.error(
+      [
+        \`[ASC guard] 이 workspace 는 ASC 가 관리한다. '\${outward}' 는 논리 세션 밖에서 나갈 수 없다.\`,
+        '  asc proceed --work <WORK-KEY> --json     # 작업 항목이 있으면',
+        '  asc proceed --json                       # 이어갈 세션을 고르거나 계약을 제안받는다',
+        '  asc host claude bind <S-ID> --physical ' + id,
+        '읽기·조회는 막지 않는다 — 막는 것은 밖으로 나가는 쓰기뿐이다.',
+      ].join('\\n'),
+    )
+    process.exit(2)
+  }
+  process.exit(0)
+}
 
 // 관찰은 여기서 끝난다 — 아래 차단 판정은 이 호출의 성패를 보지 않는다
 try {
@@ -291,27 +425,25 @@ try {
 // 변경 도구는 여기까지다 — 아래 목록은 Bash 명령에 대한 것이다.
 if (isMutation) process.exit(0)
 
-for (const { pattern, label } of FORBIDDEN) {
-  if (pattern.test(command)) {
-    console.error(
-      \`[ASC guard] '\${label}' 는 ASC-managed 세션에서 금지다. \` +
-      \`외부 반영은 승인된 Execution Grant(asc grant run)로만 나간다.\`,
-    )
-    process.exit(2) // exit 2 = 도구 실행 차단
-  }
+const forbidden = forbiddenIn(command, FORBIDDEN)
+if (forbidden) {
+  console.error(
+    \`[ASC guard] '\${forbidden}' 는 ASC-managed 세션에서 금지다. \` +
+    \`외부 반영은 승인된 Execution Grant(asc grant run)로만 나간다.\`,
+  )
+  process.exit(2) // exit 2 = 도구 실행 차단
 }
 
 // 완전 오프라인 선언이 있을 때만 읽기까지 막는다. 로컬 작업은 얼리지 않는다.
 const freeze = freezePolicy(ascRoot)
 if (freeze && freeze.frozen && freeze.denyRemoteRead) {
-  for (const { pattern, label } of OFFLINE_ONLY) {
-    if (pattern.test(command)) {
-      console.error(
-        \`[ASC guard] 완전 오프라인이다\${freeze.reason ? ' (' + freeze.reason + ')' : ''} — '\${label}' 를 막는다. \` +
-        \`로컬 작업은 그대로 된다. 녹이려면 asc thaw.\`,
-      )
-      process.exit(2)
-    }
+  const offline = forbiddenIn(command, OFFLINE_ONLY)
+  if (offline) {
+    console.error(
+      \`[ASC guard] 완전 오프라인이다\${freeze.reason ? ' (' + freeze.reason + ')' : ''} — '\${offline}' 를 막는다. \` +
+      \`로컬 작업은 그대로 된다. 녹이려면 asc thaw.\`,
+    )
+    process.exit(2)
   }
 }
 

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

@@ -164,6 +164,35 @@ report as one.
    Finishing: \`asc session done <ID> --verified "<what the self-check covered>" --next "<next>"\`.
    Updating state is the Controller's job — point the person at \`asc controller collect\`.
 
+## "Publish it" — what a session produced, going out
+
+The person says *publish it* · *open the MR* · *get it onto develop*. That sentence is the
+approval, and it is not asked for twice. It is also not wider than itself: **"open the MR"
+is not "approve the merge"**.
+
+Nothing reaches an external system except through a grant. That is one command, then the
+act:
+
+\`\`\`text
+asc grant issue --session <S-ID> --action <key> --target <ref> --body-file <path> --as <actor>
+asc grant run <G-ID>
+\`\`\`
+
+The action key is the provider's (\`gitlab.mr.create\`, \`gitlab.note.create\`, \`git.push\`,
+\`coordination.publish\`, \`github.issue_comment.create\`). If nothing bound to this
+workspace can carry out that action, issuing **fails there** rather than after the person
+approved — read the message and fix the binding, do not look for another way out.
+
+The body comes from a file because it has to be the thing the person is agreeing to. Do
+not compose it after the fact and do not widen \`--target\`.
+
+Publishing a coordination question is the same shape — \`asc coordination publish --grant
+<G-ID> --query <X-ID> …\`. Reading (\`coordination status\`, \`coordination observe\`) needs
+no grant.
+
+**Never** reach for \`git push\`, \`glab\`, or \`gh\` directly. The guard stops those, and
+being stopped is not a puzzle to solve — it means the act belongs in a grant.
+
 ## Progress reporting
 
 From outside, a person can see nothing while work runs. Leave one line at each of the

package/dist/adapters/github/scm.d.ts

@@ -46,5 +46,7 @@ export declare class GitHubScm implements ScmPort {
      * 승인된 단일 행위. 아는 action만 수행하며, 그 외에는 아무것도 하지 않는다 —
      * Grant의 allowedWrites 검사(Executor)에 더해 Adapter도 자기 몫으로 닫아 둔다.
      */
+    /** 이 통로가 아는 행위. execute 의 분기와 같은 목록이어야 한다. */
+    supports(action: string): boolean;
     execute(action: ExternalAction): Promise<ExternalActionResult>;
 }

package/dist/adapters/github/scm.js

@@ -81,8 +81,12 @@ export class GitHubScm {
      * 승인된 단일 행위. 아는 action만 수행하며, 그 외에는 아무것도 하지 않는다 —
      * Grant의 allowedWrites 검사(Executor)에 더해 Adapter도 자기 몫으로 닫아 둔다.
      */
+    /** 이 통로가 아는 행위. execute 의 분기와 같은 목록이어야 한다. */
+    supports(action) {
+        return action === 'github.issue_comment.create';
+    }
     async execute(action) {
-        if (action.action !== 'github.issue_comment.create') {
+        if (!this.supports(action.action)) {
             return { ok: false, error: `unsupported action: ${action.action}` };
         }
         const ref = parseThreadRef(this.#expand(action.target));

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

@@ -0,0 +1,43 @@
+import type { CanonicalSnapshot } from '../../core/model/entities.ts';
+import type { BaselineQuery, ExternalAction, ExternalActionResult, ScmPort, ThreadSnapshot } from '../../ports/scm.ts';
+import { type GitLabReader, type GitLabWriter } from './client.ts';
+/** 이 adapter 가 수행할 수 있는 행위. 목록에 없는 것은 하지 않는다. */
+export declare const GITLAB_ACTIONS: readonly ["coordination.publish", "gitlab.note.create", "gitlab.mr.create", "gitlab.mr.merge", "gitlab.issue.update", "git.push"];
+export type GitLabScmDeps = {
+    reader: GitLabReader;
+    writer: GitLabWriter;
+    /** 이 결합이 가리키는 프로젝트. `#7` 처럼 짧게 온 참조를 여기에 붙인다. */
+    defaultProject?: string;
+    /** canonical source id → ref. Profile 이 정한다 — adapter 가 추측하지 않는다. */
+    sourceRefs?: Readonly<Record<string, {
+        ref: string;
+    }>>;
+    /** `git.push` 를 수행할 자리. 없으면 push 는 할 수 없다고 답한다. */
+    repoRoot?: string;
+    /** 테스트가 실제 git 을 부르지 않게 하는 통로. */
+    git?: (args: readonly string[], cwd: string) => Promise<{
+        ok: boolean;
+        detail: string;
+    }>;
+};
+export declare class GitLabScm implements ScmPort {
+    #private;
+    readonly id = "gitlab";
+    constructor(deps: GitLabScmDeps);
+    /**
+     * 스레드의 지금 상태. Drift Guard 가 승인 시점과 대조하는 값이다.
+     *
+     * 마지막 사건은 note 하나로 본다 — 목록의 마지막 id 를 쓰고, 못 읽으면 `missing` 이다.
+     * 모르는 것을 "변화 없음" 으로 적으면 오래된 초안이 그대로 나간다.
+     */
+    getThread(reference: string): Promise<ThreadSnapshot>;
+    /** 정본의 지금 baseline. Profile 이 정한 ref 만 묻는다. */
+    getBaselines(queries: readonly BaselineQuery[]): Promise<CanonicalSnapshot[]>;
+    /**
+     * 승인된 단일 행위. **아는 것만 한다** — Grant 의 allowedWrites 검사(Executor)에 더해
+     * adapter 도 자기 몫으로 닫아 둔다.
+     */
+    /** 이 통로가 아는 행위. execute 의 분기와 같은 목록이어야 한다. */
+    supports(action: string): boolean;
+    execute(action: ExternalAction): Promise<ExternalActionResult>;
+}

package/dist/adapters/gitlab/scm.js

@@ -0,0 +1,201 @@
+// GitLab SCM — 승인된 단일 외부 행위의 GitLab 인스턴스 (OM §11.5, C-09).
+//
+// 이 파일이 있는 이유는 실측이다. Grant 실행 경로는 CLI 안에서 GitHub 하나로 못 박혀
+// 있었고, 그래서 코드가 GitLab 에 있는 프로젝트에서는 승인이 끝난 뒤에야 "실행할 통로가
+// 없다" 가 드러났다. 관측 경로는 진작 provider-neutral 이었는데 실행 경로만 남아 있었다.
+//
+// **쓰기는 `execute` 하나뿐이고, 그 함수는 Grant 를 쥔 Executor 만 부른다.** Port 자체는
+// 권한을 판단하지 않으므로 호출 지점이 좁게 유지되는 것이 계약이다.
+//
+// `git.push` 가 여기 있는 것이 어색해 보일 수 있다. 그러나 원격에 쓰는 일이고, 그 원격은
+// 이 결합이 가리키는 바로 그 프로젝트다 — 승인된 외부 write 하나를 수행한다는 점에서
+// MR 생성과 같은 종류의 행위다. Core 는 여전히 어느 것도 해석하지 않는다.
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { encodeProject, parseRef } from "./client.js";
+const run = promisify(execFile);
+/** 이 adapter 가 수행할 수 있는 행위. 목록에 없는 것은 하지 않는다. */
+export const GITLAB_ACTIONS = [
+    // 조율 게시. 실행은 CoordinationSurface 가 하고, 이 통로는 **그 행위가 승인될 수
+    // 있다는 것**만 안다 — 발급 시점에 "할 수 없는 일을 승인시키지 않는다" 가 성립하려면
+    // 이 목록이 그 사실을 담아야 한다.
+    'coordination.publish',
+    'gitlab.note.create',
+    'gitlab.mr.create',
+    'gitlab.mr.merge',
+    'gitlab.issue.update',
+    'git.push',
+];
+export class GitLabScm {
+    id = 'gitlab';
+    #reader;
+    #writer;
+    #project;
+    #sourceRefs;
+    #repoRoot;
+    #git;
+    constructor(deps) {
+        this.#reader = deps.reader;
+        this.#writer = deps.writer;
+        this.#project = deps.defaultProject;
+        this.#sourceRefs = deps.sourceRefs ?? {};
+        this.#repoRoot = deps.repoRoot;
+        this.#git =
+            deps.git ??
+                (async (args, cwd) => {
+                    try {
+                        const { stdout, stderr } = await run('git', [...args], { cwd });
+                        return { ok: true, detail: (stdout || stderr).trim() };
+                    }
+                    catch (error) {
+                        const failure = error;
+                        return { ok: false, detail: (failure.stderr || failure.message || String(error)).trim() };
+                    }
+                });
+    }
+    /**
+     * 스레드의 지금 상태. Drift Guard 가 승인 시점과 대조하는 값이다.
+     *
+     * 마지막 사건은 note 하나로 본다 — 목록의 마지막 id 를 쓰고, 못 읽으면 `missing` 이다.
+     * 모르는 것을 "변화 없음" 으로 적으면 오래된 초안이 그대로 나간다.
+     */
+    async getThread(reference) {
+        const ref = parseRef(this.#expand(reference));
+        if (!ref)
+            return { reference, lastEventId: '', missing: true };
+        const path = ref.kind === 'change' ? 'merge_requests' : 'issues';
+        const response = await this.#reader.get(`/projects/${encodeProject(ref.project)}/${path}/${ref.iid}/notes?per_page=1&sort=desc`);
+        if (!response.ok || !response.data)
+            return { reference, lastEventId: '', missing: true };
+        const latest = response.data[0];
+        return { reference, lastEventId: latest ? String(latest.id) : '(none)' };
+    }
+    /** 정본의 지금 baseline. Profile 이 정한 ref 만 묻는다. */
+    async getBaselines(queries) {
+        const out = [];
+        for (const query of queries) {
+            const ref = query.ref ?? this.#sourceRefs[query.sourceId]?.ref;
+            if (!ref || !this.#project) {
+                out.push({ sourceId: query.sourceId, baseline: '(unknown)' });
+                continue;
+            }
+            const response = await this.#reader.get(`/projects/${encodeProject(this.#project)}/repository/branches/${encodeURIComponent(ref)}`);
+            const baseline = response.ok ? (response.data?.commit?.id ?? '(unknown)') : '(unknown)';
+            out.push({ sourceId: query.sourceId, baseline });
+        }
+        return out;
+    }
+    /**
+     * 승인된 단일 행위. **아는 것만 한다** — Grant 의 allowedWrites 검사(Executor)에 더해
+     * adapter 도 자기 몫으로 닫아 둔다.
+     */
+    /** 이 통로가 아는 행위. execute 의 분기와 같은 목록이어야 한다. */
+    supports(action) {
+        return GITLAB_ACTIONS.includes(action);
+    }
+    async execute(action) {
+        switch (action.action) {
+            case 'gitlab.note.create':
+                return this.#note(action);
+            case 'gitlab.mr.create':
+                return this.#createChange(action);
+            case 'gitlab.mr.merge':
+                return this.#mergeChange(action);
+            case 'gitlab.issue.update':
+                return this.#updateIssue(action);
+            case 'git.push':
+                return this.#push(action);
+            case 'coordination.publish':
+                // 이 행위는 CoordinationSurface 가 수행한다. 계약은 여기서 승인될 수 있지만
+                // 실행은 그쪽 통로다 — 두 곳이 같은 글을 올리지 않게 여기서는 하지 않는다.
+                return { ok: false, error: 'coordination.publish runs through the coordination surface' };
+            default:
+                return { ok: false, error: `unsupported action: ${action.action}` };
+        }
+    }
+    async #note(action) {
+        const ref = parseRef(this.#expand(action.target));
+        if (!ref)
+            return { ok: false, error: `unrecognized target: ${action.target}` };
+        const path = ref.kind === 'change' ? 'merge_requests' : 'issues';
+        const response = await this.#writer.post(`/projects/${encodeProject(ref.project)}/${path}/${ref.iid}/notes`, { body: action.payload });
+        if (!response.ok || !response.data)
+            return { ok: false, error: response.error ?? `HTTP ${response.status}` };
+        return { ok: true, resultRef: `${ref.project}${ref.kind === 'change' ? '!' : '#'}${ref.iid}#note_${response.data.id}` };
+    }
+    /**
+     * 변경요청 생성. payload 는 승인된 내용 그대로이므로 여기서 다시 쓰지 않는다 —
+     * 필드는 JSON 으로 온다.
+     */
+    async #createChange(action) {
+        const project = action.target || this.#project;
+        if (!project)
+            return { ok: false, error: 'no project for gitlab.mr.create' };
+        let body;
+        try {
+            body = JSON.parse(action.payload);
+        }
+        catch (error) {
+            return { ok: false, error: `payload is not JSON: ${error instanceof Error ? error.message : String(error)}` };
+        }
+        for (const required of ['source_branch', 'target_branch', 'title']) {
+            if (typeof body[required] !== 'string')
+                return { ok: false, error: `payload is missing ${required}` };
+        }
+        const response = await this.#writer.post(`/projects/${encodeProject(project)}/merge_requests`, body);
+        if (!response.ok || !response.data)
+            return { ok: false, error: response.error ?? `HTTP ${response.status}` };
+        return { ok: true, resultRef: response.data.web_url ?? `${project}!${response.data.iid}` };
+    }
+    async #mergeChange(action) {
+        const ref = parseRef(this.#expand(action.target));
+        if (!ref || ref.kind !== 'change')
+            return { ok: false, error: `unrecognized change: ${action.target}` };
+        // GitLab 의 merge 는 PUT 이다. 이 adapter 의 통로는 post 하나이므로, 통로가 넓어지기
+        // 전까지는 할 수 없다고 **말한다** — 못 하는 것을 하는 척하지 않는다.
+        const response = await this.#writer.post(`/projects/${encodeProject(ref.project)}/merge_requests/${ref.iid}/merge`, action.payload ? JSON.parse(action.payload) : {});
+        if (!response.ok || !response.data)
+            return { ok: false, error: response.error ?? `HTTP ${response.status}` };
+        return { ok: true, resultRef: response.data.web_url ?? `${ref.project}!${ref.iid}` };
+    }
+    async #updateIssue(action) {
+        const ref = parseRef(this.#expand(action.target));
+        if (!ref || ref.kind !== 'issue')
+            return { ok: false, error: `unrecognized issue: ${action.target}` };
+        let body;
+        try {
+            body = JSON.parse(action.payload);
+        }
+        catch (error) {
+            return { ok: false, error: `payload is not JSON: ${error instanceof Error ? error.message : String(error)}` };
+        }
+        const response = await this.#writer.post(`/projects/${encodeProject(ref.project)}/issues/${ref.iid}`, body);
+        if (!response.ok || !response.data)
+            return { ok: false, error: response.error ?? `HTTP ${response.status}` };
+        return { ok: true, resultRef: response.data.web_url ?? `${ref.project}#${ref.iid}` };
+    }
+    /**
+     * 원격에 가지를 올린다. target 은 `<remote> <branch>` 또는 `<branch>` 다.
+     *
+     * `--force` 계열은 받지 않는다 — 되돌릴 수 없는 형태를 승인 한 번으로 열지 않는다.
+     */
+    async #push(action) {
+        if (!this.#repoRoot)
+            return { ok: false, error: 'no repository root for git.push' };
+        const parts = action.target.trim().split(/\s+/).filter(Boolean);
+        if (parts.length === 0)
+            return { ok: false, error: 'git.push needs a branch' };
+        if (parts.some((part) => part.startsWith('-')))
+            return { ok: false, error: `git.push takes no flags: ${action.target}` };
+        const [remote, branch] = parts.length === 1 ? ['origin', parts[0]] : [parts[0], parts[1]];
+        const result = await this.#git(['push', remote, branch], this.#repoRoot);
+        return result.ok
+            ? { ok: true, resultRef: `${remote}/${branch}` }
+            : { ok: false, error: result.detail };
+    }
+    #expand(reference) {
+        if (!this.#project)
+            return reference;
+        return /^[!#]\d+$/.test(reference.trim()) ? `${this.#project}${reference.trim()}` : reference;
+    }
+}

package/dist/adapters/markdown/layout.js

@@ -7,7 +7,6 @@ const ENTITY_DIR = {
     session: 'sessions/active',
     request: 'monitor/inbox',
     grant: 'monitor/grants',
-    queueItem: 'monitor/queue',
     event: 'monitor/events',
 };
 export const CONTROL_STATE_FILE = 'state.md';
@@ -32,7 +31,6 @@ const ARCHIVE_DIR = {
     session: 'sessions/archive',
     request: 'monitor/archive/inbox',
     grant: 'monitor/archive/grants',
-    queueItem: 'monitor/archive/queue',
     event: 'monitor/archive/events',
 };
 export function archiveDir(root, kind) {

package/dist/adapters/markdown/serialize.js

@@ -85,13 +85,6 @@ function renderBody(kind, entity) {
                 lines.push(`Result: ${g.resultRef}`);
             break;
         }
-        case 'queueItem': {
-            const q = entity;
-            lines.push(`# ${q.id} — ${q.title}`, '', `State: ${q.state} (v${q.version})`);
-            if (q.sessionId)
-                lines.push(`Session: ${q.sessionId}`);
-            break;
-        }
         case 'event': {
             const e = entity;
             lines.push(`# ${e.eventKey}`, '', `${e.type} · ${e.suggestedPriority} · ${e.processing} (v${e.version})`, `Detected: ${e.detectedAt}`, `Inbox 후보: ${e.inboxCandidate ? 'yes' : 'no'}`);