elanous 0.2.25 → 0.2.27

package/scripts/coord-msg-bridge.ts

@@ -0,0 +1,209 @@
+#!/usr/bin/env bun
+/** One channel fetch, one recipient's durable cursor, and idempotent msg insertion. */
+import { Database } from 'bun:sqlite';
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { effectiveInstanceRoot } from '../src/instance/resolve.js';
+import { SEAT_ALIASES, canonicalSeatId, defaultMsgStorePath, openMsgStore } from '../src/msg/msg-store.js';
+import trackData from './coord-tracks.json';
+import { fetchCoordChannelComments, type CoordChannelComment } from './coord-requests-bridge.js';
+
+const seats = new Set(trackData.tracks.map((track) => track.id));
+const allSeats = [...seats];
+type Options = { seat: string; channel: string; since?: string; dryRun: boolean };
+type Cursor = { lastId: number; createdAt: string; sinceFloor?: string; parserHash?: string };
+type Routed = { sender: string; recipients: string[] };
+
+function parseOptions(args: string[]): Options {
+  let seat = '', channel = '26146', since: string | undefined;
+  let dryRun = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--seat' && args[i + 1]) seat = canonicalSeatId(args[++i]!);
+    else if (arg === '--channel' && args[i + 1]) channel = args[++i]!;
+    else if (arg === '--since' && args[i + 1]) since = args[++i]!;
+    else if (arg === '--dry-run') dryRun = true;
+    else if (arg === '--json') continue; // output formatting belongs to the CLI entry point
+    else throw new Error(`unknown option or missing value: ${arg}`);
+  }
+  if (!seats.has(seat)) throw new Error('--seat must name a channel seat');
+  if (!/^[1-9]\d*$/.test(channel)) throw new Error('--channel must be a positive integer');
+  if (since && (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(since)
+    || !Number.isFinite(Date.parse(since)))) throw new Error('--since must be an ISO timestamp');
+  return { seat, channel, ...(since ? { since } : {}), dryRun };
+}
+
+/** Only the address part of the first line and explicit body mentions route messages. */
+export function routeCoordComment(body: string): Routed | null {
+  const [header = '', ...bodyLines] = body.split(/\r?\n/);
+  const match = /^\s*(?:#+\s*)?\*\*\[([^\]]+)\]\*\*[^\n]*?→\s*(.+)$/.exec(header);
+  if (!match) return null;
+  let sender: string;
+  try { sender = canonicalSeatId(match[1]!); } catch { return null; }
+  const recipients = new Set<string>();
+  // The channel also uses `MK(⊕ UX·TC)` for a primary addressee plus copied seats.
+  const address = match[2]!.replace(/\(⊕\s*([^)]*)\)/g, ' · cc $1');
+  const fields = address.split('·').map((part) => part.trim());
+  let inAddress = true;
+  for (const field of fields) {
+    const cc = /^cc\s+(.+)$/i.exec(field);
+    if (!inAddress && !cc) continue;
+    const tokens = (cc?.[1] ?? field).split(/[\s,]+/).filter(Boolean);
+    // A title may follow the addressee without a middle dot, for example
+    // `→ OP 🎓 확인:`. Only the leading seat tokens belong to the address.
+    const firstNonSeat = tokens.findIndex((name) => !seats.has(name)
+      && name !== '전체' && name !== '전원');
+    const names = tokens.slice(0, firstNonSeat < 0 ? tokens.length : firstNonSeat);
+    if (!names.length) {
+      if (!cc) inAddress = false;
+      continue;
+    }
+    if (names.includes('전체') || names.includes('전원')) {
+      for (const seat of allSeats) recipients.add(seat);
+    } else for (const name of names) recipients.add(name);
+    if (!cc && names.length < tokens.length) inAddress = false;
+  }
+  for (const match of bodyLines.join('\n').matchAll(/🙋\s*([A-Z][A-Z0-9_-]*)/g)) {
+    if (seats.has(match[1]!)) recipients.add(match[1]!);
+  }
+  recipients.delete(sender);
+  return { sender, recipients: [...recipients] };
+}
+
+// Include the sender canonicalizer and its aliases: either can change which
+// comments route. A harmless build-only hash change causes one safe replay.
+const parserHash = createHash('sha256').update(routeCoordComment.toString())
+  .update(canonicalSeatId.toString()).update(JSON.stringify(SEAT_ALIASES))
+  .update(JSON.stringify(allSeats)).digest('hex');
+const REPLAY_WINDOW_MS = 6 * 60 * 60 * 1000;
+
+function validComment(value: CoordChannelComment): void {
+  if (!value || !Number.isSafeInteger(value.id) || value.id <= 0 || typeof value.body !== 'string'
+    || typeof value.created_at !== 'string' || !Number.isFinite(Date.parse(value.created_at))
+    || typeof value.html_url !== 'string') throw new Error('invalid channel comment');
+}
+
+function readCursor(path: string): Cursor | null {
+  if (!existsSync(path)) return null;
+  // Each run appends one small record. Concurrent runs cannot replace a newer cursor
+  // with an older snapshot; the highest comment ID remains the effective cursor.
+  let latest: Cursor | null = null;
+  // A process can stop mid-append. The next complete record begins with the
+  // stable key prefix and remains readable even when joined to a torn suffix.
+  const records = readFileSync(path, 'utf8').replaceAll('{"lastId":', '\n{"lastId":').split('\n').filter(Boolean);
+  for (const line of records) {
+    let value: Partial<Cursor>;
+    try { value = JSON.parse(line) as Partial<Cursor>; }
+    catch (error) {
+      if (error instanceof SyntaxError) continue;
+      throw error;
+    }
+    if (!Number.isSafeInteger(value.lastId) || value.lastId! < 0 || typeof value.createdAt !== 'string'
+      || !Number.isFinite(Date.parse(value.createdAt)) || (value.sinceFloor !== undefined
+        && (typeof value.sinceFloor !== 'string' || !Number.isFinite(Date.parse(value.sinceFloor))))
+      || (value.parserHash !== undefined && !/^[a-f0-9]{64}$/.test(value.parserHash))) {
+      throw new Error('invalid channel cursor');
+    }
+    // On equal IDs, keep the current parser marker even if an older overlapping
+    // process appends its stale cursor afterward. A current marker also replaces
+    // an older marker at the same ID after a replay with no newly fetched comment.
+    if (!latest || value.lastId! > latest.lastId || (value.lastId === latest.lastId
+      && (value.parserHash === parserHash || latest.parserHash !== parserHash))) latest = {
+      lastId: value.lastId!, createdAt: value.createdAt,
+      ...(value.sinceFloor ? { sinceFloor: value.sinceFloor } : {}),
+      ...(value.parserHash ? { parserHash: value.parserHash } : {}),
+    };
+  }
+  return latest;
+}
+
+function saveCursor(path: string, cursor: Cursor): void {
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  appendFileSync(path, `${JSON.stringify(cursor)}\n`, { mode: 0o600 });
+}
+
+function hasProvenance(db: Database, key: string): boolean {
+  return db.query('SELECT 1 FROM msg_provenance WHERE provenance_key = ?').get(key) !== null;
+}
+
+export function runBridge(args: string[], fetch = fetchCoordChannelComments): {
+  seat: string; read: number; picked: number; added: number; existing: number; cursor: number;
+} {
+  return runBridgeWithClock(args, fetch, Date.now);
+}
+
+export function runBridgeWithClock(args: string[], fetch: typeof fetchCoordChannelComments, now: () => number): {
+  seat: string; read: number; picked: number; added: number; existing: number; cursor: number;
+} {
+  const options = parseOptions(args);
+  const cursorPath = join(effectiveInstanceRoot(), 'msg', `coord-bridge-${options.channel}-${options.seat}.json`);
+  const cursor = readCursor(cursorPath);
+  const replayFloor = cursor && cursor.parserHash !== parserHash ? now() - REPLAY_WINDOW_MS : undefined;
+  // GitHub filters `since` by updated_at; the creation-time check below limits
+  // parser replay to comments created in the last six hours, even if older
+  // comments were edited recently. Numeric IDs decide normal progress.
+  // GitHub's `since` is exclusive. Fetch one second before the replay floor
+  // so a comment created exactly on the six-hour boundary remains visible.
+  const since = cursor ? new Date(Math.min(Date.parse(cursor.createdAt) - 1000,
+    replayFloor === undefined ? Infinity : replayFloor - 1000)).toISOString() : options.since;
+  const comments = fetch(options.channel, since);
+  for (const comment of comments) validComment(comment); // no writes if fetching/parsing fails mid-page
+  // GitHub's `since` filters updated_at, so a caller's creation-time floor persists across runs.
+  const unseen = comments.filter((comment) => comment.id > (cursor?.lastId ?? 0));
+  const sinceFloor = cursor?.sinceFloor ?? (cursor ? undefined : options.since);
+  const pending = comments.filter((comment) =>
+    (comment.id > (cursor?.lastId ?? 0) || (replayFloor !== undefined
+      && Date.parse(comment.created_at) >= replayFloor))
+    && (!sinceFloor || Date.parse(comment.created_at) >= Date.parse(sinceFloor)));
+  const candidate = unseen.reduce<CoordChannelComment | null>((last, comment) =>
+    !last || comment.id > last.id ? comment : last, null);
+  let picked = 0, added = 0, existing = 0;
+  const dbPath = defaultMsgStorePath();
+  if (options.dryRun) {
+    const db = existsSync(dbPath) ? new Database(dbPath, { readonly: true }) : null;
+    try {
+      for (const comment of pending) {
+        const route = routeCoordComment(comment.body);
+        if (!route?.recipients.includes(options.seat)) continue;
+        picked++;
+        if (db && hasProvenance(db, `coord:${comment.id}:${options.seat}`)) existing++;
+        else added++;
+      }
+    } finally { db?.close(); }
+  } else {
+    const store = openMsgStore();
+    try {
+      store.db.transaction(() => {
+        for (const comment of pending) {
+          const route = routeCoordComment(comment.body);
+          if (!route?.recipients.includes(options.seat)) continue;
+          picked++;
+          const key = `coord:${comment.id}:${options.seat}`;
+          if (hasProvenance(store.db, key)) existing++;
+          else added++;
+          store.appendWithProvenance({ from: route.sender, to: options.seat, body: comment.body, kind: 'coord' }, key);
+        }
+      }).immediate();
+    } finally { store.close(); }
+    if (candidate || (!cursor && sinceFloor) || replayFloor !== undefined) {
+      const createdAt = candidate?.created_at ?? cursor?.createdAt ?? sinceFloor!;
+      saveCursor(cursorPath, { lastId: candidate?.id ?? cursor?.lastId ?? 0,
+        createdAt: sinceFloor && Date.parse(createdAt) < Date.parse(sinceFloor) ? sinceFloor : createdAt,
+        ...(sinceFloor ? { sinceFloor } : {}), parserHash });
+    }
+  }
+  return { seat: options.seat, read: comments.length, picked, added, existing,
+    cursor: options.dryRun ? cursor?.lastId ?? 0 : readCursor(cursorPath)?.lastId ?? 0 };
+}
+
+if (import.meta.main) {
+  try {
+    const result = runBridge(process.argv.slice(2));
+    console.log(process.argv.includes('--json') ? JSON.stringify(result)
+      : `${result.seat}: read ${result.read}, picked ${result.picked}, added ${result.added}, existing ${result.existing}, cursor ${result.cursor}`);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+}

package/scripts/coord-post.sh

@@ -2,7 +2,10 @@
 # coord-post.sh — 조율 채널 발신 «한 자리». 시각과 명시적 값을 본문에 안전하게 넣는다.
 # 사용: scripts/coord-post.sh [--set KEY=VALUE]... <본문파일>
 set -u
-CANON="docs/manual/MANUAL-multi-agent-coordination-channel-2026-07-28.md"
+SCRIPT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd) || { echo '⛔ 스크립트 위치를 못 읽었다' >&2; exit 3; }
+REPO_ROOT=$(dirname -- "$SCRIPT_DIR")
+CLI="$REPO_ROOT/bin/elanous.mjs"
+CANON="$REPO_ROOT/docs/manual/MANUAL-multi-agent-coordination-channel-2026-07-28.md"
 
 resolve_pr() {
   [ -f "$CANON" ] || return 0
@@ -40,7 +43,7 @@ BODY="${1:-}"
 grep -q '{{TS}}' "$BODY" || echo "⚠️ 본문에 {{TS}} 자리표시가 «없다» — 시각을 손으로 적지 않았는지 확인하라" >&2
 
 # 트랙 신원은 «정본 한 곳»에서 읽는다 — scripts/coord-tracks.json. 못 읽으면 추측하지 않고 선다.
-TRACKS_FILE="$(dirname "$0")/coord-tracks.json"
+TRACKS_FILE="$SCRIPT_DIR/coord-tracks.json"
 # 신원 = 2글자 id(OP·MK·TC·UX…) ⊕ 옛 한 글자 alias(S·T·O·F — 전환기엔 받되 경고). 목록은 정본에서만.
 IDS=$(grep -o '"id": *"[A-Z][A-Z]*"' "$TRACKS_FILE" 2>/dev/null | sed 's/.*"\([A-Z]*\)"$/\1/' | tr '\n' ' ')
 ALIASES=$(grep -o '"alias": *"[A-Z][A-Z]*"' "$TRACKS_FILE" 2>/dev/null | sed 's/.*"\([A-Z]*\)"$/\1/' | tr '\n' ' ')
@@ -192,7 +195,7 @@ if [ "${COORD_DRY_RUN:-}" = "1" ]; then
   exit 0
 fi
 
-POST_OUTPUT=$(bun bin/elanous.mjs gh pr comment "$PR" --body-file "$TMP" 2>&1)
+POST_OUTPUT=$(bun "$CLI" gh pr comment "$PR" --body-file "$TMP" 2>&1)
 RC=$?
 printf '%s\n' "$POST_OUTPUT" | tail -2
 VIA=""
@@ -204,11 +207,11 @@ if [ "$RC" -ne 0 ] && printf '%s' "$POST_OUTPUT" | grep -qiE 'rate limit|Somethi
   FIRSTOUT=$(head -1 "$TMP")
   # issues 코멘트 목록은 오래된 순이고 정렬 인자를 안 받는다 ⇒ 최근 10분만 since 로 자른다.
   SINCE10=$(date -u -v-10M +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date -u -d '-10 min' +%Y-%m-%dT%H:%M:%SZ)
-  if bun bin/elanous.mjs gh api "repos/{owner}/{repo}/issues/$PR/comments?since=$SINCE10&per_page=100" --jq '.[].body | split("\n")[0]' 2>/dev/null | grep -qxF -- "$FIRSTOUT"; then
+  if bun "$CLI" gh api "repos/{owner}/{repo}/issues/$PR/comments?since=$SINCE10&per_page=100" --jq '.[].body | split("\n")[0]' 2>/dev/null | grep -qxF -- "$FIRSTOUT"; then
     echo "[coord-post] 같은 첫 줄이 이미 채널에 있다 — GraphQL 이 실제로는 올렸다(이중 발신 안 함)" >&2
     exit 0
   fi
-  POST_OUTPUT=$(bun bin/elanous.mjs gh api -X POST "repos/{owner}/{repo}/issues/$PR/comments" -F "body=@$TMP" -q .html_url 2>&1)
+  POST_OUTPUT=$(bun "$CLI" gh api -X POST "repos/{owner}/{repo}/issues/$PR/comments" -F "body=@$TMP" -q .html_url 2>&1)
   RC=$?
   printf '%s\n' "$POST_OUTPUT" | tail -2
   VIA=" · REST 폴백"
@@ -224,13 +227,43 @@ POST_URL=$(printf '%s\n' "$POST_OUTPUT" | grep -oE 'https://github\.com/[^[:spac
 # test universe (OP 10-04 18:00). An explicit ELANOUS_STATE_DIR is the caller's chosen universe and wins;
 # otherwise prefer the installed CLI (resolves prod from any tree), else pin the source CLI to prod.
 if [ -n "${ELANOUS_STATE_DIR:-}" ]; then
-  RECORD=(bun bin/elanous.mjs coord event record)
+  RECORD=(bun "$CLI" coord event record)
+  MESSAGE=(bun "$CLI" msg post)
 elif command -v eln >/dev/null 2>&1; then
   RECORD=(eln coord event record)
+  MESSAGE=(eln msg post)
 else
-  RECORD=(env ELANOUS_STATE_DIR="$HOME/.elanous" bun bin/elanous.mjs --config-dir "$HOME/.elanous" coord event record)
+  RECORD=(env ELANOUS_STATE_DIR="$HOME/.elanous" bun "$CLI" --config-dir "$HOME/.elanous" coord event record)
+  MESSAGE=(env ELANOUS_STATE_DIR="$HOME/.elanous" bun "$CLI" --config-dir "$HOME/.elanous" msg post)
 fi
 if ! "${RECORD[@]}" --seat "$ID" --header "$(head -1 "$TMP")" --url "$POST_URL" >/dev/null 2>&1; then
   echo '⚠️ 맥락 원장 기록 실패(발신은 됐다)' >&2
 fi
+# S1's channel reader and this sender must agree on recipients. Keep the complete sent body
+# for msg, while the provenance key makes a later S1 scan (or a partial retry) idempotent.
+COMMENT_ID=${POST_URL##*#issuecomment-}
+if [ "$COMMENT_ID" = "$POST_URL" ] || ! [[ "$COMMENT_ID" =~ ^[0-9]+$ ]]; then
+  echo '⚠️ 채널 댓글 ID를 못 읽어 msg 반영을 건너뛴다(발신은 됐다 · S1 다리가 회수)' >&2
+  exit 0
+fi
+ROUTES=$(bun -e '
+  import { readFileSync } from "node:fs";
+  import { join } from "node:path";
+  import { pathToFileURL } from "node:url";
+  const { routeCoordComment } = await import(pathToFileURL(join(process.argv[3], "coord-msg-bridge.ts")).href);
+  const { canonicalSeatId } = await import(pathToFileURL(join(process.argv[3], "../src/msg/msg-store.ts")).href);
+  const route = routeCoordComment(readFileSync(process.argv[2], "utf8"));
+  if (!route || route.sender !== canonicalSeatId(process.argv[1])) process.exit(2);
+  console.log(route.recipients.join("\n"));
+' "$ID" "$TMP" "$SCRIPT_DIR") || {
+  echo '⚠️ msg 수신자 해석 실패(발신은 됐다 · S1 다리가 회수)' >&2
+  exit 0
+}
+while IFS= read -r RECIPIENT; do
+  [ -n "$RECIPIENT" ] || continue
+  if ! "${MESSAGE[@]}" --from "$ID" --to "$RECIPIENT" --kind coord \
+      --origin-key "coord:$COMMENT_ID:$RECIPIENT" < "$TMP" >/dev/null; then
+    echo "⚠️ msg 원장 기록 실패: $RECIPIENT(발신은 됐다 · S1 다리가 회수)" >&2
+  fi
+done <<< "$ROUTES"
 exit 0

package/scripts/coord-requests-bridge.ts

@@ -7,10 +7,17 @@ import { registerStandaloneLogSink } from '../src/domains/standalone-log-sink.js
 import { effectiveInstanceRoot } from '../src/instance/resolve.js';
 import trackData from './coord-tracks.json';
 
-type Comment = { id: number; body: string; created_at: string; html_url: string };
+export type CoordChannelComment = { id: number; body: string; created_at: string; html_url: string };
 type Options = { seat: string; channel: string; since?: string; dryRun: boolean; json: boolean };
 const seatIds = new Set(trackData.tracks.map((track) => track.id));
 
+/** Shared channel retrieval. Callers validate the complete result before changing a ledger. */
+export function fetchCoordChannelComments(channel: string, since?: string): CoordChannelComment[] {
+  const endpoint = `repos/{owner}/{repo}/issues/${channel}/comments${since ? `?since=${encodeURIComponent(since)}` : ''}`;
+  const output = execFileSync('gh', ['api', endpoint, '--paginate', '--jq', '.[]'], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+  return output.split('\n').filter(Boolean).map((line) => JSON.parse(line) as CoordChannelComment);
+}
+
 function options(args: string[]): Options {
   let seat = '';
   let channel = '23032';
@@ -98,15 +105,13 @@ async function run(args: string[]): Promise<void> {
     seat = selected.seat;
     const { channel, since, dryRun, json } = selected;
     reason = 'gh';
-    const endpoint = `repos/{owner}/{repo}/issues/${channel}/comments${since ? `?since=${encodeURIComponent(since)}` : ''}`;
-    const output = execFileSync('gh', ['api', endpoint, '--paginate', '--jq', '.[]'], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
-    const comments = output.split('\n').filter(Boolean).map((line) => JSON.parse(line) as unknown);
+    const comments = fetchCoordChannelComments(channel, since);
     reason = 'ledger';
     const path = join(effectiveInstanceRoot(), 'seat-requests', 'requests.jsonl');
     const seen = existingSeatComments(path);
     let picked = 0, added = 0, existing = 0;
     for (const item of comments) {
-      const comment = item as Partial<Comment>;
+      const comment = item as Partial<CoordChannelComment>;
       if (typeof comment.id !== 'number' || !Number.isSafeInteger(comment.id) || typeof comment.body !== 'string'
         || typeof comment.created_at !== 'string' || typeof comment.html_url !== 'string') throw new Error('gh api 댓글 필드가 잘못됐다');
       if (since && Date.parse(comment.created_at) < Date.parse(since)) continue;

package/scripts/expose-rubric-suggest.ts

@@ -28,7 +28,7 @@ function measure(run: () => Criterion): Criterion {
 export function suggestExposeRubric(root: string, files?: readonly string[], help?: HelpRunner, rulesPath?: string): Suggestion[] {
   const names = files ?? readdirSync(join(root, DOCS)).filter((name) => name.endsWith('.md')).map((name) => `${DOCS}/${name}`);
   const paths = [...new Set(names.map((name) => relative(root, resolve(root, name)).split(sep).join('/')))];
-  if (paths.some((path) => !/^release\/public\/docs\/[^/]+\.md$/.test(path))) throw new Error('문서 경로는 release/public/docs/*.md 이어야 합니다');
+  if (paths.some((path) => !/^(?:release\/public\/docs\/[^/]+|docs\/marketing\/BLOG-[^/]+)\.md$/.test(path))) throw new Error('문서 경로는 release/public/docs/*.md 또는 docs/marketing/BLOG-*.md 이어야 합니다');
   type HelpResult = ReturnType<HelpRunner> & { failure?: string };
   let helpRuns = 0;
   const rootHelp: (args: string[]) => HelpResult = help ?? ((args) => {

package/scripts/measure-tsc-affected-roots.ts

@@ -1,3 +1,10 @@
+/**
+ * Measures the changed-file gate against the whole program on recently merged PRs.
+ * The narrowed run is the gate's default root check (changed .ts ∪ direct importers), so `missed` / `same` judge that mode:
+ * the run pins TSC_GATE_ROOTS to a non-`full` value and disables the rollback switch
+ * even when the caller's shell requests a full run.
+ * `missed > 0` is reverted without a code change by running the gate with env `TSC_GATE_ROOTS=full`.
+ */
 import { spawn } from 'node:child_process';
 import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
@@ -223,7 +230,9 @@ async function measurePr(repo: string, pr: Pr, run: Runner, platform: NodeJS.Pla
     const added = compareDiagnostics(current, baseline);
     if (added.kind === 'unavailable') throw new Error(added.reason);
     result.addedDiagnostics = added.added;
-    const gateRun = await timed(run, platform, 'bun', ['scripts/ci-typecheck-changed.ts', '--local'], worktree, { ...process.env, TSC_BASE_REF: base });
+    const gateRun = await timed(run, platform, 'bun', ['scripts/ci-typecheck-changed.ts', '--local'], worktree, {
+      ...process.env, TSC_BASE_REF: base, TSC_GATE_ROOTS: 'affected', ELANOUS_TSC_AFFECTED_ROOTS: '1',
+    });
     result.narrowed = elapsed(gateRun, platform);
     result.gateExitCode = gateRun.status;
     const seen = gateDiagnostics(gateRun, worktree);

package/scripts/release-loop/export-check-node.ts

@@ -48,11 +48,14 @@ export function runExportCheck(run: CommandRunner = runCommand, repoRoot = proce
             const publicDir = join(out, 'export');
             symlinkSync(join(modulesRoot, 'node_modules'), join(publicDir, 'node_modules'), 'dir');
             const pwaModules = join(modulesRoot, 'apps', 'pwa', 'node_modules');
-            if (existsSync(pwaModules) && existsSync(join(publicDir, 'apps', 'pwa'))) symlinkSync(pwaModules, join(publicDir, 'apps', 'pwa', 'node_modules'), 'dir');
-            const built = run('bun', ['bin/elanous.mjs', 'nexus', 'build'], publicDir);
-            result = built.status === 0 && existsSync(join(publicDir, 'apps', 'pwa', 'out', 'index.html'))
-              ? { outcome: 'ok', verdict: 'pass', summary: `public export and PWA build ${commit.slice(0, 12)}`, step: 'build', tail: '' }
-              : failed('build', 'PWA build or out/index.html missing', built);
+            if (!existsSync(pwaModules)) result = failed('build', 'PWA dependencies missing; run bun install --cwd apps/pwa in the release-loop repository');
+            else {
+              if (existsSync(join(publicDir, 'apps', 'pwa'))) symlinkSync(pwaModules, join(publicDir, 'apps', 'pwa', 'node_modules'), 'dir');
+              const built = run('bun', ['bin/elanous.mjs', 'nexus', 'build'], publicDir);
+              result = built.status === 0 && existsSync(join(publicDir, 'apps', 'pwa', 'out', 'index.html'))
+                ? { outcome: 'ok', verdict: 'pass', summary: `public export and PWA build ${commit.slice(0, 12)}`, step: 'build', tail: '' }
+                : failed('build', 'PWA build or out/index.html missing', built);
+            }
           }
         }
       }

package/scripts/release-loop/node-verdict.ts

@@ -48,9 +48,14 @@ export function lastResult(run: CommandResult): Record<string, unknown> | undefi
   } catch { return undefined; }
 }
 
-export function finishNode(node: string, version: string, result: Record<string, unknown> & { outcome: NodeOutcome; verdict: NodeVerdict; summary: string }): number {
+export function finishNode(node: string, version: string, result: Record<string, unknown> & { outcome: NodeOutcome; verdict: NodeVerdict; summary: string; tail?: string }): number {
   debug.log(`release-loop.${node}`, 'result', { version, outcome: result.outcome });
-  emitNodeResult(result);
+  if (result.outcome === 'fail') {
+    const summary = result.summary.replace(/[\r\n]+/g, ' ').trim();
+    const tail = result.tail?.trim() ? result.tail : summary;
+    debug.log('release.node', 'failed', { node, summary, tail });
+    emitNodeResult({ ...result, summary, tail });
+  } else emitNodeResult(result);
   return result.outcome === 'ok' ? 0 : result.outcome === 'fail' ? 1 : 2;
 }
 

package/src/agent/task-notification.ts

@@ -62,11 +62,39 @@ export class TaskNotificationQueue {
    *  listens to both runner events and a separate `onTaskDone` hook.
    *  Keyed by taskId. */
   private seen = new Set<string>();
+  /** Wake listeners — fired once per REAL enqueue (not on seen-dup).
+   *  TUI-SEAT-READY ③ first shard: one completion event = one wake
+   *  signal so an idle parent can open the next turn. Opening the turn
+   *  itself is deliberately NOT wired here (next shard). */
+  private wakeListeners = new Set<(n: PendingTaskNotification) => void>();
+
+  /** Register a wake listener; returns an unsubscribe function.
+   *  Listeners survive `clear()` — they belong to the wiring, not the
+   *  queue contents. */
+  onEnqueue(listener: (n: PendingTaskNotification) => void): () => void {
+    this.wakeListeners.add(listener);
+    return () => { this.wakeListeners.delete(listener); };
+  }
 
   enqueue(n: PendingTaskNotification): void {
     if (this.seen.has(n.taskId)) return;
     this.seen.add(n.taskId);
     this.queue.push(n);
+    debug.log('agent.task-notification', 'wake', { taskId: n.taskId, size: this.queue.length });
+    for (const listener of this.wakeListeners) {
+      try {
+        listener(n);
+      } catch (error) {
+        // fail-soft — a throwing wake listener must not lose the
+        // queued notification or break sibling listeners.
+        try {
+          debug.log('agent.task-notification', 'wake-listener-failed', {
+            taskId: n.taskId,
+            reason: error instanceof Error ? error.message : String(error),
+          });
+        } catch { /* */ }
+      }
+    }
   }
 
   /** Return all pending notifications AND clear the queue. Parents
@@ -85,7 +113,8 @@ export class TaskNotificationQueue {
     return this.queue.length;
   }
 
-  /** Forget everything — tests use this for isolation. */
+  /** Forget everything — tests use this for isolation. Listeners are
+   *  preserved: clear() empties queue + seen, not the wake wiring. */
   clear(): void {
     this.queue = [];
     this.seen.clear();

package/src/agent-substrate/review-observation.ts

@@ -60,8 +60,11 @@ interface ReviewObservationInput {
   readonly fallbackAttempted?: boolean;
   /** 폴백이 실제로 시도한 백엔드. */
   readonly fallbackBackend?: string;
+  /** Explicitly requested primary model and the ACP backend that actually completed review. */
+  readonly requestedModel?: string;
+  readonly actualBackend?: string;
   /** 폴백을 시도하지 않은 이유. */
-  readonly fallbackNotAttemptedReason?: 'explicit-acp' | 'primary-review-succeeded';
+  readonly fallbackNotAttemptedReason?: 'explicit-acp' | 'primary-review-succeeded' | 'explicit-model';
   /** 1차가 왜 못 돌았나 — 폴백의 «사인». */
   readonly fallbackTriggerReason?: string;
   /** Each failed ACP fallback attempt, retained in order for diagnosis. */
@@ -80,7 +83,9 @@ interface ReviewObservation {
   readonly reviewRoute?: 'api' | 'acp' | 'acp-fallback';
   readonly fallbackAttempted?: boolean;
   readonly fallbackBackend?: string;
-  readonly fallbackNotAttemptedReason?: 'explicit-acp' | 'primary-review-succeeded';
+  readonly requestedModel?: string;
+  readonly actualBackend?: string;
+  readonly fallbackNotAttemptedReason?: 'explicit-acp' | 'primary-review-succeeded' | 'explicit-model';
   readonly fallbackTriggerReason?: string;
   readonly fallbackFailures?: readonly { backend: string; reason: string }[];
   readonly skippedAcpFallbackBackends?: readonly { backend: string; reason: string }[];
@@ -168,6 +173,8 @@ export function buildReviewObservation(input: ReviewObservationInput): ReviewObs
     ...(input.reviewRoute ? { reviewRoute: input.reviewRoute } : {}),
     ...(input.fallbackAttempted !== undefined ? { fallbackAttempted: input.fallbackAttempted } : {}),
     ...(input.fallbackBackend ? { fallbackBackend: safeLogText(input.fallbackBackend) } : {}),
+    ...(input.requestedModel ? { requestedModel: safeLogText(input.requestedModel) } : {}),
+    ...(input.actualBackend ? { actualBackend: safeLogText(input.actualBackend) } : {}),
     ...(input.fallbackNotAttemptedReason ? { fallbackNotAttemptedReason: input.fallbackNotAttemptedReason } : {}),
     ...(input.fallbackTriggerReason ? { fallbackTriggerReason: safeLogText(input.fallbackTriggerReason) } : {}),
     ...(input.fallbackFailures?.length ? {

package/src/agent-substrate/self-review-cli.ts

@@ -24,7 +24,7 @@ import { ACP_BACKENDS, canonicalizeBackendId } from '../acp/backend-registry.js'
 import { buildManualReviewIntent, intentFromPr, prIntentSectionCoverage, reviewIntentTruncationFromPr, reviewIntentTruncationObservation } from './review-intent.js';
 import { budgetReviewerContext, reviewDiffBudgetObservation, splitDiffByFile, type ReviewImage, type ReviewInput, type ReviewerContextItem, type ReviewResult } from './pr-reviewer.js';
 import type { ReferencedFileReader } from '../self-implement/goal-file-reader.js';
-import type { SubscriptionReviewerSpec } from '../user-config.js';
+import { getUserConfig, type SubscriptionReviewerSpec } from '../user-config.js';
 import { listRunLedgers, lookupPrGoalAcceptance, lookupRunLedger, type PrGoalAcceptanceLookup, type RunLedgerEntry, type RunLedgerLookup } from '../self-implement/run-ledger.js';
 
 /** SUBSCRIPTION-EXHAUST-REROUTE — API reviewer when the configured `roleLlm.reviewer` lane is unavailable (off codex). */
@@ -37,6 +37,8 @@ export interface SelfReviewCliOpts {
   acpModel?: string | undefined;
   acpBackend?: string | undefined;
   configuredAcpBackend?: string | undefined;
+  /** ACP review backends excluded from automatic fallback by `acp.reviewDenyBackends`. */
+  reviewDenyBackends?: string[] | undefined;
   /** `roleLlm.reviewer` (same resolution as the harness). Used only when no explicit reviewer flag is given. */
   roleReviewer?: SubscriptionReviewerSpec | undefined;
   acpTimeout?: string | undefined;
@@ -1120,10 +1122,11 @@ function roleAcpErrorReason(error: unknown): 'acp-handshake-timeout' | 'acp-erro
 
 type AcpFallbackSkip = { backend: string; reason: string };
 
-function orderedAcpReviewFallbackBackends(configuredBackend: string | undefined): {
+function orderedAcpReviewFallbackBackends(configuredBackend: string | undefined, denyBackends: readonly string[] = []): {
   backends: string[];
   skipped: AcpFallbackSkip[];
 } {
+  const denied = new Set(denyBackends.map((backend) => backend.trim().toLowerCase()).filter(Boolean));
   const candidates = [configuredBackend, ...Object.keys(ACP_BACKENDS)]
     .map((backend) => backend?.trim())
     .filter((backend): backend is string => Boolean(backend));
@@ -1135,6 +1138,10 @@ function orderedAcpReviewFallbackBackends(configuredBackend: string | undefined)
     const spec = ACP_BACKENDS[backend];
     if (!spec || seen.has(backend)) continue;
     seen.add(backend);
+    if (denied.has(backend)) {
+      skipped.push({ backend, reason: 'denied-by-acp.reviewDenyBackends' });
+      continue;
+    }
     if (spec.unsupportedReason) {
       skipped.push({ backend, reason: spec.unsupportedReason });
       continue;
@@ -1277,7 +1284,12 @@ async function runSelfReviewCliCommandPinned(
       ? { backend: opts.configuredAcpBackend, source: 'config' as const }
       : { backend: DEFAULT_REVIEW_BACKEND, source: 'default' as const };
   const acpBackend = acpBackendResolution.backend;
-  const automaticFallbacks = orderedAcpReviewFallbackBackends(opts.configuredAcpBackend);
+  const requestedModel = opts.model?.trim() || undefined;
+  const rawReviewDenyBackends = (getUserConfig().raw?.acp as { reviewDenyBackends?: unknown } | undefined)?.reviewDenyBackends;
+  const configuredReviewDenyBackends = Array.isArray(rawReviewDenyBackends)
+    ? rawReviewDenyBackends.filter((backend): backend is string => typeof backend === 'string')
+    : [];
+  const automaticFallbacks = orderedAcpReviewFallbackBackends(opts.configuredAcpBackend, opts.reviewDenyBackends ?? configuredReviewDenyBackends);
   const fallbackAcpBackends = opts.acpBackend
     ? [canonicalizeBackendId(opts.acpBackend)]
     : automaticFallbacks.backends;
@@ -1300,6 +1312,14 @@ async function runSelfReviewCliCommandPinned(
   const envModel = deps.envModel();
   const roleFallbackModel = !useAcp && !opts.model && !envModel && reviewerSource === 'role-config'
     ? deps.roleFallbackModel?.()?.trim() || undefined : undefined;
+  if (requestedModel && /^glm-\d+(?:\.\d+)?$/i.test(requestedModel)) {
+    const canonical = requestedModel.toLowerCase() === 'glm-5.3' ? 'openrouter/z-ai/glm-5.3' : undefined;
+    const suggestion = canonical ? ` 정본 모델 ID 후보: ${canonical}` : ' `local:<model>` 또는 공급자 정본 ID를 지정하세요.';
+    const message = `모델 ID가 모호합니다: ${requestedModel}.${suggestion} 짧은 별칭을 공급자 정본 ID로 바꿔 다시 시도하세요.`;
+    deps.log('model-rejected', { requestedModel: safeLogText(requestedModel), reason: 'ambiguous-model-id', ...(canonical ? { canonicalModelCandidate: canonical } : {}) }, { level: 'warn' });
+    deps.error(message);
+    return { results: opts.json ? [{ error: message, requestedModel }] : [], failed: 1 };
+  }
   const model = useAcp ? `acp:${acpBackend}${acpModel ? `/${acpModel}` : ''}` : (opts.model || envModel || roleFallbackModel || tierModel('better'));
   let roleReviewer: { llm: (prompt: string, images?: readonly ReviewImage[]) => Promise<string>; model: string } | undefined;
   let roleReviewerUnavailableReason: string | undefined;
@@ -1558,9 +1578,9 @@ async function runSelfReviewCliCommandPinned(
     let fallbackAttempted = false;
     let fallbackBackend: string | undefined;
     let fallbackTriggerReason: string | undefined;
-    let fallbackNotAttemptedReason: 'explicit-acp' | 'primary-review-succeeded' | undefined;
+    let fallbackNotAttemptedReason: 'explicit-acp' | 'primary-review-succeeded' | 'explicit-model' | undefined;
     const fallbackFailures: Array<{ backend: string; reason: string }> = [];
-    if (!useAcp && !roleReview && review.reviewed !== true) {
+    if (!useAcp && !roleReview && !opts.acpModel?.trim() && (!requestedModel || Boolean(opts.acpBackend)) && review.reviewed !== true) {
       fallbackAttempted = true;
       fallbackTriggerReason = safeLogText(review.failureReason || 'reviewed=false', 400);
       for (const backend of fallbackAcpBackends) {
@@ -1569,6 +1589,7 @@ async function runSelfReviewCliCommandPinned(
           pr: safeLogText(pr),
           failureReason: fallbackTriggerReason,
           fallbackBackend: safeLogText(backend),
+          requestedModel: safeLogText(primaryModel),
         }, { level: 'warn' });
         try {
           const fallbackReview = await deps.reviewPullRequest(
@@ -1598,12 +1619,13 @@ async function runSelfReviewCliCommandPinned(
       ...(reviewCwdPinFallbackReason ? { reviewCwdPinFallbackReason } : {}),
     };
     if (!fallbackAttempted) {
-      fallbackNotAttemptedReason = useAcp ? 'explicit-acp' : 'primary-review-succeeded';
+      fallbackNotAttemptedReason = useAcp ? 'explicit-acp' : requestedModel && review.reviewed !== true ? 'explicit-model' : 'primary-review-succeeded';
     }
     const reviewProvenance = {
       reviewRoute,
       fallbackAttempted,
       ...(fallbackBackend ? { fallbackBackend } : {}),
+      ...(fallbackBackend ? { requestedModel: primaryModel, actualBackend: `acp:${fallbackBackend}` } : {}),
       ...(fallbackNotAttemptedReason ? { fallbackNotAttemptedReason } : {}),
       ...(fallbackTriggerReason ? { fallbackTriggerReason } : {}),
       ...(fallbackFailures.length ? { fallbackFailures } : {}),