elanous 0.2.35 → 0.2.36

package/src/loops/orchestrator/knowhow-pack.ts

@@ -0,0 +1,364 @@
+/**
+ * K3 knowledge pack — the coordinator reads OP knowhow from `내부 문서 `KNOWHOW``
+ * on every tick, so a doc landing alone (no code deploy) refreshes what is resident.
+ *
+ * A pack holds only items whose `상태:` is `active` **and** that carry a `재는 명령:`;
+ * every item is ordered by id and the pack carries a content hash so a reply can cite
+ * exactly which pack it read.
+ *
+ * The inbox may then *propose* an item's 처방 — it never writes, and it never changes a lock.
+ * A measurement command is executed only when it passes the read-only allowlist; when its
+ * output contradicts the item's `기대`, the advice is stale and the inbox answers 모름.
+ */
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { debug } from '../../debug/log.js';
+
+export const KNOWHOW_PACK_VERSION = 'K3';
+export const KNOWHOW_DOC_RELATIVE_PATH = 'docs/roles/OP/KNOWHOW.md';
+
+export interface KnowhowItem {
+  id: string;
+  title: string;
+  status: string;
+  situation: string;
+  signal: string;
+  prescription: string;
+  command: string;
+  expectation: string;
+  validWhen: string;
+  source: string;
+}
+
+export interface KnowhowPack {
+  version: string;
+  hash: string;
+  docPath: string;
+  items: KnowhowItem[];
+}
+
+export interface KnowhowCommandRun {
+  status: number;
+  output: string;
+  /** Set when the runner refused to execute (placeholder, timeout, spawn failure). */
+  skipped?: string;
+}
+
+export type KnowhowCommandRunner = (command: string) => KnowhowCommandRun;
+
+export interface KnowhowOptions {
+  /** Explicit doc path; otherwise `ELANOUS_KNOWHOW_DOC`, otherwise the repository copy. */
+  docPath?: string;
+  /** Working directory for measurement commands. */
+  cwd?: string;
+  /** Measurement seam: replaced by tests, defaults to the guarded read-only runner. */
+  runCommand?: KnowhowCommandRunner;
+}
+
+export type KnowhowFreshness = 'confirmed' | 'stale' | 'unmeasured' | 'unverifiable';
+
+export interface KnowhowMatch {
+  item: KnowhowItem;
+  score: number;
+  matchedTokens: string[];
+}
+
+export interface KnowhowAdvice extends KnowhowMatch {
+  packVersion: string;
+  packHash: string;
+  freshness: KnowhowFreshness;
+  detail: string;
+}
+
+/** Label → item field. Labels keep their parenthetical form when the doc uses one. */
+const FIELD_LABELS: Array<[RegExp, keyof KnowhowItem]> = [
+  [/^상황$/i, 'situation'],
+  [/^신호(?:\(관측\))?$/i, 'signal'],
+  [/^처방(?:\(힐링\))?$/i, 'prescription'],
+  [/^재는 명령$/i, 'command'],
+  [/^기대$/i, 'expectation'],
+  [/^유효 조건$/i, 'validWhen'],
+  [/^출처$/i, 'source'],
+];
+
+function stripTicks(value: string): string {
+  const trimmed = value.trim();
+  const match = /^`([\s\S]*)`$/.exec(trimmed);
+  return match ? match[1]!.trim() : trimmed;
+}
+
+function labeledLine(section: string, field: keyof KnowhowItem): string {
+  for (const line of section.split('\n')) {
+    const entry = /^-\s+([^:]{1,24}):\s*(.+)$/.exec(line.trim());
+    if (!entry) continue;
+    const label = entry[1]!.trim();
+    if (FIELD_LABELS.some(([pattern, name]) => name === field && pattern.test(label))) return stripTicks(entry[2]!);
+  }
+  return '';
+}
+
+/** Split the markdown inventory into K items. Unknown labels are ignored, not fatal. */
+export function parseKnowhowDoc(text: string): KnowhowItem[] {
+  const sections = text.split(/^## /m).slice(1);
+  const items: KnowhowItem[] = [];
+  for (const section of sections) {
+    const heading = /^(K-OP-(?:[A-Z]{1,4}-)?\d+)\s+(.*)$/.exec(section.split('\n', 1)[0] ?? '');
+    if (!heading) continue;
+    const item: KnowhowItem = {
+      id: heading[1]!, title: heading[2]!.trim(), status: '', situation: labeledLine(section, 'situation'),
+      signal: labeledLine(section, 'signal'), prescription: labeledLine(section, 'prescription'),
+      command: labeledLine(section, 'command'), expectation: labeledLine(section, 'expectation'),
+      validWhen: labeledLine(section, 'validWhen'), source: labeledLine(section, 'source'),
+    };
+    const status = /상태:\s*([A-Za-z][A-Za-z-]*)/.exec(item.source);
+    if (status) item.status = status[1]!;
+    if (item.status !== 'active') continue;
+    if (!item.command || /^\(없음/.test(item.command)) continue;
+    items.push(item);
+  }
+  return items.sort((a, b) => a.id.localeCompare(b.id));
+}
+
+export function buildKnowhowPack(items: KnowhowItem[], docPath: string): KnowhowPack {
+  const body = items.map(item => [item.id, item.title, item.situation, item.signal, item.prescription,
+    item.command, item.expectation].join('\n')).join('\n---\n');
+  const hash = createHash('sha256').update(`${KNOWHOW_PACK_VERSION}\n${body}`).digest('hex').slice(0, 16);
+  return { version: KNOWHOW_PACK_VERSION, hash, docPath, items };
+}
+
+/** Marker text for a command that still carries `<...>` placeholders from the doc. */
+const PLACEHOLDER_SOURCE = '<[^<>\\n]{1,60}>';
+const PLACEHOLDER = new RegExp(PLACEHOLDER_SOURCE, 'g');
+
+function repositoryRoot(): string | null {
+  let current = dirname(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < 8; depth++) {
+    if (existsSync(join(current, KNOWHOW_DOC_RELATIVE_PATH))) return current;
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+
+export function resolveKnowhowDocPath(explicit?: string): string | null {
+  if (explicit) return existsSync(explicit) ? explicit : null;
+  const fromEnv = process.env.ELANOUS_KNOWHOW_DOC;
+  if (fromEnv) return existsSync(fromEnv) ? fromEnv : null;
+  if (existsSync(join(process.cwd(), KNOWHOW_DOC_RELATIVE_PATH))) return join(process.cwd(), KNOWHOW_DOC_RELATIVE_PATH);
+  const root = repositoryRoot();
+  return root ? join(root, KNOWHOW_DOC_RELATIVE_PATH) : null;
+}
+
+const packCache = new Map<string, { stamp: string; pack: KnowhowPack }>();
+
+/** Resident pack for one tick: re-read whenever the doc's mtime/size changes. */
+export function loadKnowhowPack(docPath: string): KnowhowPack | null {
+  if (!existsSync(docPath)) return null;
+  let stamp: string;
+  try {
+    const info = statSync(docPath);
+    stamp = `${info.mtimeMs}:${info.size}`;
+  } catch { return null; }
+  const cached = packCache.get(docPath);
+  if (cached && cached.stamp === stamp) return cached.pack;
+  const pack = buildKnowhowPack(parseKnowhowDoc(readFileSync(docPath, 'utf8')), docPath);
+  packCache.set(docPath, { stamp, pack });
+  debug.log('loop.knowhow-pack', 'load', { version: pack.version, hash: pack.hash,
+    items: pack.items.length, docPath });
+  return pack;
+}
+
+const STOPWORDS = new Set(['그리고', '그러나', '하지만', '그러면', '어떻게', '무엇', '뭐가', '뭘', '이거', '그거',
+  '저거', '지금', '오늘', '내일', '확인', '요청', '질문', '경우', '때문', '때는', '먼저', '다시', '대한', '위해',
+  '에서', '으로', '하는', '하지', '한다', '있다', '없다', '같다', '되는', '되나', '됐다', '있나', '인가', '무슨',
+  '어느', '이런', '그런', '저런', '좀', '더', '또는', '그게', '이게', '저게', '합니까', '인지', '하는데',
+  '보다', '라며', '해도', '하면', '해서', '부터', '까지', '아직', '이미', '모두', '이후', '이전', '동안',
+  'the', 'and', 'for', 'you', 'can', 'this', 'that', 'what', 'which', 'how', 'why', 'when', 'with', 'from',
+  'are', 'was', 'were', 'has', 'have', 'had', 'not', 'but', 'all', 'any', 'our', 'your', 'its', 'it', 'is',
+  'of', 'to', 'in', 'on', 'do', 'does', 'did', 'please', 'anyone']);
+
+const KOREAN_SUFFIXES = ['에서부터', '으로부터', '에서는', '으로는', '이었습니다', '했습니다', '됩니다', '됐습니다',
+  '합니까', '했나요', '되나요', '인가요', '에서', '으로', '부터', '까지', '했나', '됐나', '되나', '했지', '하지',
+  '됐다', '한다', '된다', '이다', '있다', '없다', '었던', '였던', '라는', '이라', '거나', '면서', '지만',
+  '에게', '한테', '보다', '처럼', '만큼', '라고', '하고', '해도', '하면', '인데', '나요', '가요', '세요',
+  '은', '는', '을', '를', '이', '가', '의', '에', '와', '과', '로', '도', '만', '라', '며', '서', '나', '고', '면'];
+
+function normalizeToken(raw: string): string {
+  let token = raw.toLowerCase();
+  for (const suffix of KOREAN_SUFFIXES) {
+    if (token.length > suffix.length + 1 && token.endsWith(suffix)) {
+      token = token.slice(0, -suffix.length);
+      break;
+    }
+  }
+  return token;
+}
+
+function tokenize(text: string): string[] {
+  const tokens: string[] = [];
+  for (const raw of text.toLowerCase().split(/[^0-9a-z가-힣-]+/)) {
+    const token = normalizeToken(raw);
+    if (token.length < 2 || STOPWORDS.has(raw) || STOPWORDS.has(token)) continue;
+    if (/^\d+$/.test(token)) continue;
+    tokens.push(token);
+  }
+  return tokens;
+}
+
+function tokensMatch(a: string, b: string): boolean {
+  if (a === b) return true;
+  if (a.length >= 3 && b.length >= 3 && (a.startsWith(b) || b.startsWith(a))) return true;
+  return false;
+}
+
+const MIN_MATCH_SCORE = 2.2;
+const MIN_MATCH_TOKENS = 2;
+
+/**
+ * Match a question against the pack item text (title ⊕ 상황 ⊕ 신호) using inverse document
+ * frequency, so a word shared by most items ("착지", "PR") cannot carry a match alone.
+ */
+export function matchKnowhowItem(pack: KnowhowPack, question: string, minScore = MIN_MATCH_SCORE): KnowhowMatch | null {
+  const questionTokens = [...new Set(tokenize(question))];
+  if (questionTokens.length === 0 || pack.items.length === 0) return null;
+  const itemTokens = pack.items.map(item => [...new Set(tokenize(`${item.title} ${item.situation} ${item.signal}`))]);
+  const total = pack.items.length;
+  const scored = pack.items.map((item, index) => {
+    const matched: string[] = [];
+    let score = 0;
+    for (const token of questionTokens) {
+      const hits = itemTokens.filter(tokens => tokens.some(candidate => tokensMatch(token, candidate))).length;
+      if (hits === 0 || !itemTokens[index]!.some(candidate => tokensMatch(token, candidate))) continue;
+      matched.push(token);
+      score += Math.log((total + 1) / (hits + 0.5));
+    }
+    return { item, score: Number(score.toFixed(3)), matchedTokens: matched };
+  }).sort((a, b) => b.score - a.score || a.item.id.localeCompare(b.item.id));
+  const best = scored[0];
+  if (!best || best.matchedTokens.length < MIN_MATCH_TOKENS || best.score < minScore) return null;
+  return best;
+}
+
+const READ_ONLY_BINARIES = new Set(['rg', 'grep', 'cat', 'head', 'tail', 'wc', 'ls', 'jq', 'awk', 'find',
+  'sort', 'uniq', 'cut', 'echo', 'pwd', 'stat', 'file', 'date', 'printf', 'true', 'test']);
+const GIT_READ_ONLY_SUBCOMMANDS = new Set(['status', 'log', 'show', 'diff', 'rev-parse', 'rev-list',
+  'ls-files', 'ls-tree', 'worktree', 'shortlog', 'blame', 'describe', 'branch', 'tag', 'remote', 'config', 'cat-file']);
+const GIT_WRITE_ARGS = new Set(['-d', '-D', '-m', '-M', '--delete', '--move', '--force', '--set', '--unset',
+  '--add', '--edit', '--prune', 'add', 'commit', 'push', 'merge', 'reset', 'checkout', 'switch', 'clean',
+  'rm', 'mv', 'apply', 'stash', 'gc', 'update-ref', 'submodule', 'rebase', 'cherry-pick', 'revert']);
+const ELANOUSH_READ_ONLY: Record<string, string[] | null> = {
+  logs: null, 'tasks:show': null, 'tasks:list': null,
+  release: ['checklist'], decisions: ['list'], msg: ['list'], memory: ['list'],
+};
+
+export type ReadOnlyVerdict = { ok: true } | { ok: false; reason: string };
+
+/** Allowlist guard: only commands that cannot mutate the repository or the ledgers run. */
+export function isReadOnlyCommand(command: string): ReadOnlyVerdict {
+  const stripped = command.replace(PLACEHOLDER, ' ');
+  if (!stripped.trim()) return { ok: false, reason: 'empty command' };
+  if (/[<>`$]|[;\n]/.test(stripped)) return { ok: false, reason: 'shell redirect, substitution or sequence' };
+  const segments = stripped.split(/\s*(?:&&|\|\||\||&)\s*/).map(part => part.trim()).filter(Boolean);
+  if (segments.length === 0) return { ok: false, reason: 'empty command' };
+  for (const segment of segments) {
+    const words = segment.split(/\s+/);
+    const binary = words[0]!.replace(/^.*\//, '');
+    const args = words.slice(1);
+    if (binary === 'git') {
+      const sub = args.find(word => !word.startsWith('-'));
+      if (!sub) return { ok: false, reason: 'git without subcommand' };
+      if (!GIT_READ_ONLY_SUBCOMMANDS.has(sub)) return { ok: false, reason: `git ${sub} is not read-only` };
+      if (args.some(word => GIT_WRITE_ARGS.has(word))) return { ok: false, reason: `git ${sub} write flag` };
+      continue;
+    }
+    if (binary === 'eln' || binary === 'elanous') {
+      const verbs = args.filter(word => !word.startsWith('-'));
+      const [first, second, third] = verbs;
+      // `eln tasks show` and `eln release checklist status` name the verb in two words.
+      if (first && second && `${first}:${second}` in ELANOUSH_READ_ONLY) {
+        const allowed = ELANOUSH_READ_ONLY[`${first}:${second}`];
+        if (allowed && (!third || !allowed.includes(third))) {
+          return { ok: false, reason: `${binary} ${first} ${second} ${third ?? ''} is not read-only` };
+        }
+        continue;
+      }
+      if (!first || !(first in ELANOUSH_READ_ONLY)) return { ok: false, reason: `${binary} ${first ?? ''} is not read-only` };
+      const allowed = ELANOUSH_READ_ONLY[first];
+      if (allowed && (!second || !allowed.includes(second))) return { ok: false, reason: `${binary} ${first} ${second ?? ''} is not read-only` };
+      continue;
+    }
+    if (!READ_ONLY_BINARIES.has(binary)) return { ok: false, reason: `${binary} is not on the read-only allowlist` };
+  }
+  return { ok: true };
+}
+
+export type ExpectationVerdict = 'confirmed' | 'stale' | 'unverifiable';
+
+/**
+ * Compare a measurement output against the item's 기대. Only machine-checkable wordings
+ * are judged: `N 줄/건/개` (exact count) and `≥N` / `N 이상` (lower bound).
+ */
+export function evaluateExpectation(expectation: string, output: string): { verdict: ExpectationVerdict; detail: string } {
+  const lines = output.split('\n').map(line => line.trim()).filter(line => line.length > 0);
+  const counted = /(\d+)\s*(줄|행|건|개|line)/.exec(expectation);
+  if (counted) {
+    const expected = Number(counted[1]);
+    const ok = lines.length === expected;
+    return { verdict: ok ? 'confirmed' : 'stale', detail: `기대 ${expected}${counted[2]} · 실제 ${lines.length}줄` };
+  }
+  const lower = /(?:[≥>=]\s*(\d+))|(?:(\d+)\s*이상)/.exec(expectation);
+  if (lower) {
+    const expected = Number(lower[1] ?? lower[2]);
+    const numbers = (output.match(/\d+/g) ?? []).map(Number);
+    const ok = numbers.length > 0 && numbers.every(value => value >= expected);
+    return { verdict: ok ? 'confirmed' : 'stale',
+      detail: `기대 ≥${expected} · 실제 ${numbers.length > 0 ? numbers.join(',') : '(수 없음)'}` };
+  }
+  if (!lines.length) return { verdict: 'stale', detail: '기대 비교 불가 · 재는 명령 출력이 비었다' };
+  return { verdict: 'unverifiable', detail: `기대 문면: ${expectation.slice(0, 120)} — 자동 비교 규칙 없음` };
+}
+
+/** Default runner: guarded, bounded, and never shells a doc placeholder. */
+export function readOnlyRunner(cwd: string): KnowhowCommandRunner {
+  return (command: string): KnowhowCommandRun => {
+    const verdict = isReadOnlyCommand(command);
+    if (!verdict.ok) return { status: -1, output: '', skipped: verdict.reason };
+    if (new RegExp(PLACEHOLDER_SOURCE).test(command)) return { status: -1, output: '', skipped: 'placeholder 미치환' };
+    const run = spawnSync('bash', ['-c', command], { cwd, encoding: 'utf8', timeout: 15_000, maxBuffer: 1 << 20 });
+    if (run.error) return { status: -1, output: '', skipped: run.error.message.slice(0, 120) };
+    return { status: run.status ?? -1, output: `${run.stdout ?? ''}${run.stderr ?? ''}` };
+  };
+}
+
+export function measureKnowhowItem(
+  item: KnowhowItem, run: KnowhowCommandRunner,
+): { freshness: KnowhowFreshness; detail: string } {
+  const verdict = isReadOnlyCommand(item.command);
+  if (!verdict.ok) return { freshness: 'unmeasured', detail: `재지 못함 — ${verdict.reason} (읽기 전용 허용 목록 밖)` };
+  const result = run(item.command);
+  if (result.skipped) return { freshness: 'unmeasured', detail: `재지 못함 — ${result.skipped}` };
+  if (result.status !== 0) return { freshness: 'unmeasured', detail: `재지 못함 — rc=${result.status}` };
+  const judged = evaluateExpectation(item.expectation, result.output);
+  return { freshness: judged.verdict, detail: judged.detail };
+}
+
+/** The advice the inbox may propose: item ⊕ pack identity ⊕ freshness of its measurement. */
+export function knowhowAdvice(question: string, options: KnowhowOptions = {}): KnowhowAdvice | null {
+  const docPath = resolveKnowhowDocPath(options.docPath);
+  if (!docPath) return null;
+  const pack = loadKnowhowPack(docPath);
+  if (!pack) return null;
+  const match = matchKnowhowItem(pack, question);
+  if (!match) return null;
+  const run = options.runCommand ?? readOnlyRunner(options.cwd ?? process.cwd());
+  const measured = measureKnowhowItem(match.item, run);
+  const advice: KnowhowAdvice = { ...match, packVersion: pack.version, packHash: pack.hash,
+    freshness: measured.freshness, detail: measured.detail };
+  debug.log('loop.knowhow-pack', 'advice', { id: match.item.id, score: match.score,
+    freshness: advice.freshness, packHash: pack.hash });
+  return advice;
+}

package/src/loops/orchestrator/tick.ts

@@ -24,6 +24,7 @@ import { seatCapDetails } from '../budget.js';
 export { isLaunchEligible } from './traffic.js';
 import { readTaskAgentState, TASK_SEATS, type HandTaskOptions, type TaskCard as TaskAgentCard, type HandTaskResult, type TaskLauncher, type TaskSeat } from '../../task-agent/task-hand.js';
 import { runCoordinatorAgentInbox, runCoordinatorInbox, type CoordinatorInboxResult } from './inbox.js';
+import type { KnowhowOptions } from './knowhow-pack.js';
 import { loadAgentRolePack, type AgentReplyInput } from '../agent-reply.js';
 import type { LLMProvider } from '../../llm.js';
 
@@ -90,6 +91,8 @@ export interface TickDeps {
   /** Production still uses the restricted turn; tests can supply a deterministic turn. */
   coordinatorAgentRun?: AgentReplyInput['runAgent'];
   coordinatorAgentProvider?: LLMProvider;
+  /** Resident knowhow pack seam; the real intake reads 내부 문서 `KNOWHOW` every tick. */
+  coordinatorKnowhow?: KnowhowOptions | false;
 }
 
 /** ORCH-TA-HAND ledger — one row per handed `orch:<card>:<cell>` key so a cell is handed once across ticks and processes. */
@@ -498,7 +501,8 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
         ? runCoordinatorAgentInbox({ role, pack: loadAgentRolePack('coordinator'), path: inboxPath, root,
             ...(deps.coordinatorAgentRun ? { runAgent: deps.coordinatorAgentRun } : {}),
             ...(deps.coordinatorAgentProvider ? { provider: deps.coordinatorAgentProvider } : {}) })
-        : runCoordinatorInbox(undefined, 100, inboxPath);
+        : runCoordinatorInbox(undefined, 100, inboxPath,
+          deps.coordinatorKnowhow === undefined ? {} : { knowhow: deps.coordinatorKnowhow });
     }))();
     if (inbox.replied || inbox.acknowledged) {
       observe('exchange', 'coordinator-inbox-replied', inbox.replied);

package/src/maturity/feature-maturity.ts

@@ -62,7 +62,7 @@ export const FEATURE_MATURITY = {
     preview: 'beta', pty: 'beta', pr: 'beta', repo: 'beta', role: 'beta', machine: 'beta', image: 'beta', 'agent-env': 'beta',
     where: 'stable', bench: 'beta', shadow: 'beta', llm: 'beta', storage: 'beta', leader: 'beta',
     pod: 'beta', browser: 'beta', questions: 'beta', usage: 'stable', live: 'beta',
-    research: 'beta', release: 'beta', rfc: 'beta', know: 'beta', freeze: 'beta', flow: 'beta', seat: 'beta', hq: 'beta', steward: 'beta', coord: 'beta', context: 'beta', 'model-watch': 'beta', doctor: 'stable',
+    research: 'beta', release: 'beta', rfc: 'beta', know: 'beta', freeze: 'beta', herdr: 'beta', flow: 'beta', seat: 'beta', hq: 'beta', steward: 'beta', coord: 'beta', context: 'beta', 'model-watch': 'beta', doctor: 'stable',
     control: 'beta', resources: 'beta', hooks: 'beta', setup: 'stable', start: 'stable',
     grounding: 'beta', graph: 'beta', loop: 'stable', resource: 'beta', card: 'stable', 'launch-head': 'beta',
     a2a: 'beta', plugin: 'stable', make: 'beta', skills: 'beta', connect: 'beta', import: 'beta',

package/src/models/prompts.ts

@@ -189,7 +189,14 @@ export function getModelTier(
 
 /** Minimal tool-call hygiene for older GPT/o-series models. Kept
  *  short and generic so stronger providers do not get burdened with
- *  Codex-specific anti-loop rules they do not need. */
+ *  Codex-specific anti-loop rules they do not need.
+ *
+ *  TUI-OPS-TURN-GUARD gap ② (2026-10-22): rule 4 states the ops-turn
+ *  guard split — it must live here too, not only in the codex addon,
+ *  because gpt-6 ids stay in the 'gpt' family (usesCodexBehaviorGuards
+ *  widens the behavior predicate, not the family) and gpt-6 models run
+ *  those llm.ts phase guards. The tool names mirror the allow lists in
+ *  src/llm/tool-loop-steered-rejection.ts that llm.ts consumes. */
 const TOOL_DISCIPLINE_GPT = [
   '',
   '## Tool-call hygiene',
@@ -197,6 +204,7 @@ const TOOL_DISCIPLINE_GPT = [
   '1. NEVER call the same tool with identical arguments twice in a row. If you already Read a file, use its previous tool_result from history — do not re-Read.',
   '2. After each tool_result, emit AT LEAST one sentence of reasoning (what you learned, what you will do next) BEFORE issuing the next tool call. Silent tool-spam is a failure mode we actively block.',
   '3. If any tool_result contains "DUPLICATE CALL", "RUNTIME BLOCKED", "TOOL CALL REJECTED", or "SYSTEM BUDGET NOTICE" — STOP. Your next output MUST be plain text (the final answer or a clear "impossible because X"), not another tool call.',
+  '4. Ops turns (TUI-OPS-TURN-GUARD): read-only ops observation tools (`logs_query`, `PtyShellPoll`) stay runnable mid-ops-turn — keep observing the run with them. Write-capable ops tools (`schedule_manage`, `se_build`) are phase-governed: when one returns "TOOL CALL REJECTED" it is out of phase for this turn — do not retry it; rule 3 applies (finish in plain text).',
   '',
 ].join('\n');
 
@@ -204,7 +212,13 @@ const TOOL_DISCIPLINE_GPT = [
  *  Their common failure mode is read-only polling on stable state
  *  (Read / GetDashboardState / similar) instead of acting on the
  *  result they already have. Keep this focused on tool-loop hygiene,
- *  not orchestration prose. */
+ *  not orchestration prose.
+ *
+ *  TUI-OPS-TURN-GUARD gap ② (2026-10-22): rule 5 states the ops-turn
+ *  guard split so the prompt half matches the ACTION_PHASE_OPS_TOOLS /
+ *  REPAIR_PHASE_READ_ONLY_OPS_TOOLS allow lists llm.ts consumes —
+ *  read-only ops observation stays runnable mid-ops-turn, write-capable
+ *  ops tools stay phase-governed. */
 const TOOL_DISCIPLINE_CODEX = [
   '',
   '## Tool-call hygiene',
@@ -213,6 +227,7 @@ const TOOL_DISCIPLINE_CODEX = [
   '2. Treat read-only state tools as stable within the current turn. Do NOT re-call a state-inspection tool unless an intervening action could have changed the state.',
   '3. After each tool_result, emit AT LEAST one sentence of reasoning (what you learned, what you will do next) BEFORE issuing the next tool call.',
   '4. If any tool_result contains "DUPLICATE CALL", "RUNTIME BLOCKED", "TOOL CALL REJECTED", or "SYSTEM BUDGET NOTICE" — STOP. Your next output MUST be plain text, not another tool call.',
+  '5. Ops turns (TUI-OPS-TURN-GUARD): read-only ops observation tools (`logs_query`, `PtyShellPoll`) stay runnable mid-ops-turn — keep observing the run with them. Write-capable ops tools (`schedule_manage`, `se_build`) are phase-governed: when one returns "TOOL CALL REJECTED" it is out of phase for this turn — do not retry it; rule 4 applies (finish in plain text).',
   '',
 ].join('\n');
 

package/src/msg/msg-post-office.ts

@@ -0,0 +1,116 @@
+// ── 우편국(post office) 발견 ⊕ 재시작 — `msg serve --sse` 가 자기 포트를 적고, `msg post` 가 죽은 것을 다시 띄운다 ──
+//
+// 왜 «발견 파일» 인가: `eln msg serve --sse` 는 원장을 빨리 밀어 주는 별도 프로세스이고 설치본을 갈아 끼우면
+// 그 프로세스는 조용히 사라진다. `watch --sse` 는 폴링으로 돌아가므로 «동작은 하지만» 구독자는 늦어진다.
+// 서비스가 자기 포트·pid 를 `<상태 루트>/msg/sse.json` 에 적으면, 글을 저장한 «뒤» post 경로가
+// 그 줄을 읽어 «응답하지 않는 우편국» 을 같은 포트로 한 번 다시 띄울 수 있다.
+//
+// ⛔ 원장이 정본이다 — 다시 띄운 서비스는 저장된 글을 처음부터(=`since`·`Last-Event-ID`) 재생하므로
+//    서비스가 죽어 있던 동안 저장된 글도 잃지 않는다.
+// ⛔ 재시작은 글의 성패를 바꾸지 않는다 — 어떤 실패도 결과 값으로만 돌아온다(fail-open).
+// ⛔ 시험 우주에서는 실제 프로세스를 띄우지 않는다 — `ELANOUS_MSG_SSE_LIVE=1` 로만 연다(격리 실물 시험용).
+
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+import { effectiveInstanceRoot, prodInstanceRoot } from '../instance/resolve.js';
+
+export interface PostOfficeInfo {
+  /** Loopback port the SSE service answers on. */
+  port: number;
+  /** Process that wrote the line; a dead pid means the service is gone. */
+  pid: number;
+  url: string;
+}
+
+export type PostOfficeEnsure =
+  | { state: 'absent' }
+  | { state: 'skipped'; reason: string }
+  | { state: 'listening'; port: number }
+  | { state: 'restarted'; port: number };
+
+/** `<상태 루트>/msg/sse.json` — the ledger directory `msg serve` and `msg post` already share. */
+export function postOfficeFile(stateRoot: string): string {
+  return join(stateRoot, 'msg', 'sse.json');
+}
+
+/** The recorded service, or null when nothing registered one — 파일이 없으면 «모름»이지 «서비스 없음»의 측정이 아니다. */
+export function readPostOffice(stateRoot: string): PostOfficeInfo | null {
+  let raw: unknown;
+  try { raw = JSON.parse(readFileSync(postOfficeFile(stateRoot), 'utf8')); }
+  catch { return null; }
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+  const { port, pid } = raw as { port?: unknown; pid?: unknown };
+  if (typeof port !== 'number' || !Number.isSafeInteger(port) || port < 0 || port > 65535) return null;
+  if (typeof pid !== 'number' || !Number.isSafeInteger(pid) || pid <= 0) return null;
+  return { port, pid, url: `http://127.0.0.1:${port}` };
+}
+
+/** Called by `msg serve --sse` right after the service binds its port. */
+export function writePostOffice(stateRoot: string, info: { port: number; pid?: number }): PostOfficeInfo {
+  const path = postOfficeFile(stateRoot);
+  mkdirSync(dirname(path), { recursive: true });
+  const value: PostOfficeInfo = { port: info.port, pid: info.pid ?? process.pid, url: `http://127.0.0.1:${info.port}` };
+  writeFileSync(path, `${JSON.stringify(value)}\n`);
+  return value;
+}
+
+/** Called when the service stops — only the writer's own line is removed, never a newer one. */
+export function clearPostOffice(stateRoot: string, pid: number = process.pid): boolean {
+  const current = readPostOffice(stateRoot);
+  if (current !== null && current.pid !== pid) return false;
+  try { rmSync(postOfficeFile(stateRoot), { force: true }); return true; }
+  catch { return false; }
+}
+
+function pidAlive(pid: number): boolean {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+/** Any HTTP answer (401 included) means the service is listening; silence means it is gone. */
+async function probePostOffice(url: string): Promise<boolean> {
+  try {
+    const response = await fetch(`${url}/stream`, { signal: AbortSignal.timeout(500) });
+    try { await response.body?.cancel(); } catch { /* body already closed */ }
+    return true;
+  } catch { return false; }
+}
+
+function liveUniverse(): boolean {
+  return effectiveInstanceRoot() === prodInstanceRoot() || process.env.ELANOUS_MSG_SSE_LIVE === '1';
+}
+
+/** Restart the same installed CLI entry that is running this command — `eln msg serve --sse --port <p>`. */
+function spawnPostOffice({ port }: { port: number }): void {
+  const entry = process.argv[1];
+  if (!entry) throw new Error('post office restart needs the running CLI entry (process.argv[1])');
+  const child = Bun.spawn([process.execPath, entry, 'msg', 'serve', '--sse', '--port', String(port)], {
+    detached: true, stdio: ['ignore', 'ignore', 'ignore'], env: process.env,
+  });
+  (child as unknown as { unref?: () => void }).unref?.();
+}
+
+export interface EnsurePostOfficeInput {
+  /** State root that holds `msg/sse.json`. */
+  stateRoot: string;
+  /** Test seam — liveness of the recorded pid (default: signal 0). */
+  alive?: (pid: number) => boolean;
+  /** Test seam — does the recorded service answer on its port? (default: one HTTP probe). */
+  probe?: (url: string) => Promise<boolean>;
+  /** Test seam / fake-bin — start a new service on the recorded port. */
+  launch?: (input: { port: number }) => void;
+}
+
+/**
+ * Restart a registered post office that no longer answers. Absent registration and a live service are no-ops,
+ * so a plain `msg post` keeps its current behavior.
+ */
+export async function ensurePostOffice(input: EnsurePostOfficeInput): Promise<PostOfficeEnsure> {
+  const info = readPostOffice(input.stateRoot);
+  if (info === null) return { state: 'absent' };
+  const alive = (input.alive ?? pidAlive)(info.pid);
+  if (alive && await (input.probe ?? probePostOffice)(info.url)) return { state: 'listening', port: info.port };
+  if (input.launch === undefined && !liveUniverse()) return { state: 'skipped', reason: 'test-universe' };
+  (input.launch ?? spawnPostOffice)({ port: info.port });
+  return { state: 'restarted', port: info.port };
+}