elanous 0.2.8 → 0.2.10

package/src/intake-plane/seat-doc-route.ts

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { readFileSync, realpathSync, statSync } from 'node:fs';
+import { isAbsolute, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import type { MissionOrigin } from '../autopilot/mission-origin.js';
 import { debug } from '../debug/log.js';
@@ -15,7 +15,7 @@ import { answerAsSeat, isNoGraphFailure } from './seat-answer.js';
 const POLL_MS = 5_000;
 const TIMEOUT_MS = 30 * 60_000;
 const DOC = /전략|한\s*장|원페이저|기획|보도자료|글|메모|초안|\b(?:one-pager|strategy|post|memo|draft)\b/i;
-const CODE = /구현|버그|고쳐|\b(?:fix|implement|PR)\b/i;
+const CODE = /구현|버그|고쳐|\b(?:fix|implement)\b|\bPR\b(?!\s*#?\d+\b)/i;
 const RESEARCH = /전략|시장|경쟁|\bstrategy\b/i;
 /** EV12a — a question or a request for status / a report is answered, never turned into a code goal. */
 const ASK = /상황|현황|진행|준비|어때|어떻게|알려|보고|정리|요약|공유|\?|？|\b(?:status|update|report|summary|summari[sz]e|how|what)\b/i;
@@ -30,6 +30,8 @@ export interface SeatDocDeps {
   submitExec?: (text: string) => Promise<{ id: string }>;
   getExec?: (id: string) => Promise<ExecSnapshot | null>;
   getFile?: (path: string) => Promise<string>;
+  /** Resolve only references explicitly supplied in the request; null means their claims cannot be verified. */
+  readSource?: (ref: string) => Promise<string | null>;
   publishFile?: (content: string, key: string) => string | null;
   sendOutbound?: typeof sendOutbound;
   sleep?: (ms: number) => Promise<void>;
@@ -97,6 +99,160 @@ async function execFile(path: string): Promise<string> {
   return (await execResponse(path.slice('/v1/exec-requests'.length))).text();
 }
 
+const SUPPLIED_REF = /https?:\/\/[^\s<>()[\]]+|\bPR\s*#?\d+\b|(?:\.?\.?\/|[\w.-]+\/)[\w./-]+\.(?:md|txt|csv|json|pdf)\b|\b[\w.-]+\.(?:md|txt|csv|json|pdf)\b/gi;
+// Keep units and grammatical particles with the figure; never backtrack from 42% to 42.
+const NUMBER = /(?<![\p{L}\p{N}_#.,])([+-]?\d+(?:[,.]\d+)*(?:(?:%|년|월|일|명|건|원|배)(?![\p{N}_%A-Za-z]|[.,]\d)|(?![\p{L}\p{N}_%]|[.,]\d)))(은|는|이|가|을|를|에|의|도|만|에서|으로|와|과)?/gu;
+
+function suppliedReferences(text: string): string[] {
+  return [...new Set([...text.matchAll(SUPPLIED_REF)].map(([ref]) => ref!.replace(/[.,;]+$/, '')))];
+}
+
+const SOURCE_TIMEOUT_MS = 5_000;
+const MAX_SOURCE_BYTES = 200_000;
+// The default resolver only reads repository-local files and these two public HTTPS hosts.
+const SOURCE_URL_HOSTS = new Set(['github.com', 'raw.githubusercontent.com']);
+
+function allowedSourceUrl(value: string): boolean {
+  try {
+    const url = new URL(value);
+    return url.protocol === 'https:' && SOURCE_URL_HOSTS.has(url.hostname)
+      && !url.username && !url.password && !url.port;
+  } catch { return false; }
+}
+
+async function readPublicSource(ref: string): Promise<string | null> {
+  let url = ref;
+  const signal = AbortSignal.timeout(SOURCE_TIMEOUT_MS);
+  for (let redirects = 0; redirects < 3; redirects++) {
+    if (!allowedSourceUrl(url)) return null;
+    const response = await fetch(url, { signal, redirect: 'manual' });
+    if (response.status >= 300 && response.status < 400) {
+      const location = response.headers.get('location');
+      if (!location) return null;
+      url = new URL(location, url).href;
+      continue;
+    }
+    if (!response.ok || !/^(?:text\/|application\/(?:json|xml))/.test(response.headers.get('content-type') ?? '')) return null;
+    if (Number(response.headers.get('content-length') ?? 0) > MAX_SOURCE_BYTES) {
+      await response.body?.cancel();
+      return null;
+    }
+    if (!response.body) return null;
+    const reader = response.body.getReader();
+    const chunks: Uint8Array[] = [];
+    let size = 0;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        size += value.byteLength;
+        if (size > MAX_SOURCE_BYTES) return null;
+        chunks.push(value);
+      }
+      const bytes = new Uint8Array(size);
+      let offset = 0;
+      for (const chunk of chunks) { bytes.set(chunk, offset); offset += chunk.byteLength; }
+      return new TextDecoder().decode(bytes);
+    } finally {
+      if (size > MAX_SOURCE_BYTES) await reader.cancel();
+      reader.releaseLock();
+    }
+  }
+  return null;
+}
+
+async function defaultReadSource(ref: string): Promise<string | null> {
+  try {
+    if (/^https?:\/\//i.test(ref)) return await readPublicSource(ref);
+    if (/^PR\s*#?\d+$/i.test(ref)) {
+      const number = ref.match(/\d+/)![0];
+      const child = Bun.spawn(['gh', 'pr', 'view', number, '--json', 'title,body'], { stdout: 'pipe', stderr: 'ignore' });
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      const timeout = new Promise<null>(finish => {
+        timer = setTimeout(() => { child.kill(9); finish(null); }, SOURCE_TIMEOUT_MS);
+      });
+      try {
+        const result = await Promise.race([
+          Promise.all([new Response(child.stdout).text(), child.exited]).then(([out, code]) => ({ out, code })),
+          timeout,
+        ]);
+        if (!result || result.code !== 0 || result.out.length > MAX_SOURCE_BYTES) return null;
+        const pr = JSON.parse(result.out) as { title?: string; body?: string };
+        return `${pr.title ?? ''}\n${pr.body ?? ''}`;
+      } finally { clearTimeout(timer); }
+    }
+    const root = realpathSync(process.cwd());
+    const actual = realpathSync(resolve(root, ref));
+    const within = relative(root, actual);
+    if (isAbsolute(within) || within === '..' || within.startsWith('../')) return null;
+    const file = statSync(actual);
+    if (!file.isFile() || file.size > MAX_SOURCE_BYTES || /\.pdf$/i.test(actual)) return null;
+    return readFileSync(actual, 'utf8');
+  } catch { return null; }
+}
+
+function citationFor(ref: string): string {
+  return /^PR\s*#?(\d+)$/i.test(ref) ? `PR #${ref.match(/\d+/)![0]}` : ref;
+}
+
+function claimLabel(line: string, offset: number, length: number): string | null {
+  const before = line.slice(0, offset).split(/[,;:，；。.!?\n]/).at(-1) ?? '';
+  const after = (line.slice(offset + length).split(/[,;:，；。.!?\n]/)[0] ?? '').replace(/^\s*(?:\[출처: [^\]]+\]|«확인 필요»)/, '');
+  // Never borrow a label from another figure in the same clause.
+  if ([...before.matchAll(NUMBER), ...after.matchAll(NUMBER)].length) return null;
+  const left = before.trim().replace(/^(?:[#*>-]+\s*)+/, '');
+  const right = after.match(/^\s*([\p{L}]{2,}(?:\s+[\p{L}]{2,})*)/u)?.[1];
+  return /[\p{L}]{2,}/u.test(left) ? left : right ?? null;
+}
+
+const CLAIM_DIRECTION = /증가|상승|성장|확대|개선|감소|하락|축소|악화/g;
+const CLAIM_FORECAST = /예상|전망|예측|추정|계획|예정|기대|목표|가능성/;
+// Range and approximation words change what a figure claims («42%» ≠ «42% 미만»); both sides must carry the same set.
+const CLAIM_QUALIFIER = /미만|이하|이상|초과|이내|약|최대|최소|가량|정도|내외|안팎|넘게|넘는|남짓|까지|부터|대략|거의|이상의|under|over|about|up to|at least|at most|less than|more than|nearly|almost/giu;
+
+function claimDirection(segment: string): string | undefined {
+  const directions = [...segment.matchAll(CLAIM_DIRECTION)];
+  if (directions.length > 1) return undefined;
+  const direction = directions[0];
+  const after = direction ? segment.slice(direction.index + direction[0].length) : '';
+  const negated = direction && /^\s*(?:하지\s*(?:않|못)|않|못|안\s*(?:했|함)|없|아니)/u.test(after);
+  // Polarity outside the recognized predicate is ambiguous; do not use it to establish provenance.
+  if (/않|못|안\s|없|아니/u.test(segment) && !negated) return undefined;
+  const qualifiers = [...new Set([...segment.matchAll(CLAIM_QUALIFIER)].map(match => match[0].toLowerCase().replace(/^이상의$/, '이상')))].sort().join(',');
+  return `${direction?.[0] ?? ''}|${negated ? 'negated' : 'affirmed'}|${CLAIM_FORECAST.test(segment) ? 'forecast' : 'observed'}|${qualifiers}`;
+}
+
+function hasClaimPair(source: string, number: string, label: string, direction: string | undefined): boolean {
+  if (direction === undefined) return false;
+  return source.split(/\n|,(?=\s)|[;:，；。!?]|\.(?!\d)/).some(segment => {
+    const figures = [...segment.matchAll(NUMBER)];
+    if (figures.length !== 1 || figures[0]![1] !== number) return false;
+    return claimLabel(segment, figures[0]!.index, figures[0]![0].length) === label
+      && claimDirection(segment) === direction;
+  });
+}
+
+function citeDocumentNumbers(content: string, sources: Map<string, string | null>): string {
+  let fenced = false;
+  return content.split('\n').map(line => {
+    if (/^\s*```/.test(line)) { fenced = !fenced; return line; }
+    if (fenced || /^\s*(?:참고 자료|출처:)/.test(line)) return line;
+    const occupied = [...line.matchAll(/https?:\/\/\S+|\[출처: [^\]]+\]|(?:\.?\.?\/|[\w.-]+\/)[\w./-]+\.(?:md|txt|csv|json|pdf)|\b[\w.-]+\.(?:md|txt|csv|json|pdf)\b/g)]
+      .map(match => [match.index, match.index + match[0].length] as const);
+    const annotated = new RegExp(`${NUMBER.source}(?:\\s*(?:\\[출처: [^\\]]+\\]|«확인 필요»))?`, 'gu');
+    return line.replace(annotated, (claim, number: string, particle: string | undefined, offset: number) => {
+      if (occupied.some(([start, end]) => offset >= start && offset < end)) return claim;
+      const figure = `${number}${particle ?? ''}`;
+      const label = claimLabel(line, offset, claim.length);
+      const before = line.slice(0, offset).split(/[,;:，；。.!?]/).at(-1) ?? '';
+      const after = line.slice(offset + claim.length).split(/[,;:，；。.!?]/)[0] ?? '';
+      const direction = claimDirection(`${before} ${after}`);
+      const matches = label ? [...sources].filter(([, source]) => source && hasClaimPair(source, number, label, direction)) : [];
+      return matches.length === 1 ? `${figure} [출처: ${citationFor(matches[0]![0])}]` : `${figure} «확인 필요»`;
+    });
+  }).join('\n');
+}
+
 function chatPwaUrl(): string | undefined {
   const endpoint = resolveDaemonEndpoint({ purpose: 'write' });
   return endpoint?.pwaUrl;
@@ -115,14 +271,15 @@ function accessiblePwaUrl(value: string | undefined): string | undefined {
   } catch { return undefined; }
 }
 
-async function fileLinks(id: string, result: ExecSnapshot, deps: SeatDocDeps): Promise<Map<string, string>> {
+async function fileLinks(id: string, result: ExecSnapshot, deps: SeatDocDeps, sources: Map<string, string | null>): Promise<Map<string, string>> {
   const links = new Map<string, string>();
   for (const entry of result.results) {
     if (entry.kind !== 'report' && entry.kind !== 'text') continue;
     if (!entry.url.startsWith(`/v1/exec-requests/${encodeURIComponent(id)}/files/`)) continue;
     try {
       // The authenticated daemon route is the only source of bytes; a raw file path is never trusted.
-      const content = await (deps.getFile ?? execFile)(entry.url);
+      const raw = await (deps.getFile ?? execFile)(entry.url);
+      const content = sources.size ? citeDocumentNumbers(raw, sources) : raw;
       const ext = entry.kind === 'report' ? 'md' : 'txt';
       const digest = createHash('sha256').update(content).digest('hex');
       const key = `seat-doc/${encodeURIComponent(id)}/${digest}.${ext}`;
@@ -158,6 +315,13 @@ export async function submitSeatDocRequest({ text, reportTo, deps = {} }: {
   const body = parseSeatAddress(text)?.body.trim() ?? text.trim();
   let withoutResearch = false;
   let requestText = text;
+  const refs = suppliedReferences(body);
+  const sources = new Map<string, string | null>();
+  for (const ref of refs) {
+    try { sources.set(ref, await (deps.readSource ?? defaultReadSource)(ref)); }
+    catch { sources.set(ref, null); }
+  }
+  if (refs.length) requestText += '\n\n문서 수치 근거 규칙: 제공된 파일·URL·PR 번호의 실제 내용을 확인하고, 근거가 확인된 각 수치 바로 뒤에 [출처: <파일|PR|명령>] 형식으로 실물 참조를 붙이세요. 근거를 확인할 수 없는 수치는 삭제하거나 바꾸지 말고 «확인 필요»로 표시하세요. 서로 다른 출처에 같은 숫자가 있다는 이유만으로 출처를 추정하지 마세요.';
   if (RESEARCH.test(body)) {
     try {
       const sources = (await (deps.research ?? research)(body)).slice(0, 5);
@@ -196,7 +360,7 @@ export async function submitSeatDocRequest({ text, reportTo, deps = {} }: {
       if (now() < deadline) await sleep(Math.min(POLL_MS, Math.max(0, deadline - now())));
     }
     log('settled', { id, status: result?.status ?? (lookupAvailable ? 'timeout' : 'lookup-unavailable'), lastConfirmedStatus });
-    const links = result?.status === 'done' ? await fileLinks(id, result, deps) : new Map<string, string>();
+    const links = result?.status === 'done' ? await fileLinks(id, result, deps, sources) : new Map<string, string>();
     let reply = message(id, result, withoutResearch, lookupAvailable, accessiblePwaUrl((deps.pwaUrl ?? chatPwaUrl)()), links);
     if (isNoGraphFailure(result)) {
       // EV12d — a question with no fitting graph gets the seat's own answer, not «문서 요청 실패».

package/src/intake-plane/telegram-seat-work.ts

@@ -1,5 +1,11 @@
 import { debug } from '../debug/log.js';
+import { telegramDecisionOwner } from '../decisions/telegram-decision-cards.js';
+import { canonicalSeatId } from '../msg/msg-store.js';
+import { dispatchCeoTask, type CeoCommandDeps } from '../seat-dispatch/ceo-commands.js';
+import { ceoTaskDeps, classifyCeoIntent } from '../seat-dispatch/ceo-intent.js';
 import { parseSeatAddress, resolveSeat } from '../seat-address/seat-address.js';
+import { getUserConfig, type UserConfig } from '../user-config.js';
+import { answerAsSeat } from './seat-answer.js';
 import {
   submitIntakeWork,
   type SubmitIntakeWorkDeps,
@@ -8,15 +14,39 @@ import type { TelegramWorkMessage } from './telegram-work.js';
 
 export interface TelegramSeatWorkDeps extends SubmitIntakeWorkDeps {
   submit?: typeof submitIntakeWork;
+  config?: UserConfig;
+  answer?: typeof answerAsSeat;
+  dispatch?: typeof dispatchCeoTask;
+  commandDeps?: CeoCommandDeps;
 }
 
-/** Addressed Telegram work goes through graph intake, not the chat turn. */
+/** Addressed work preserves graph intake except for one owner's private seat request. */
 export async function handleTelegramSeatWork(
   text: string,
   msg: TelegramWorkMessage,
   deps: TelegramSeatWorkDeps = {},
 ): Promise<string | null> {
-  if (!text.startsWith('@')) return null;
+  const owner = (): { cfg: UserConfig; id: string } | null => {
+    if (msg.userId === undefined || String(msg.chatId) !== String(msg.userId)) return null;
+    const cfg = deps.config ?? getUserConfig();
+    const id = telegramDecisionOwner(cfg);
+    return id && id === String(msg.userId) ? { cfg, id } : null;
+  };
+  const sendTask = async (seat: string, body: string, cfg: UserConfig, id: string): Promise<string> => {
+    const result = await (deps.dispatch ?? dispatchCeoTask)(seat, body, deps.commandDeps ?? ceoTaskDeps(cfg, id), { via: 'telegram' });
+    debug.log('seat.dispatch', 'intent', { seat, intent: 'task', via: 'telegram', outcome: result.channel });
+    return result.reply;
+  };
+  if (!text.startsWith('@')) {
+    if (!text.trim() || /^\s*[/@＠]/.test(text)) return null;
+    const auth = owner();
+    const configured = (auth?.cfg.raw?.seatDispatch as { defaultSeat?: unknown } | undefined)?.defaultSeat;
+    if (typeof configured !== 'string' || classifyCeoIntent(text) !== 'task') return null;
+    const seat = resolveSeat(configured);
+    if (!seat) return null;
+    const id = canonicalSeatId(seat.id);
+    return ['OP', 'TC', 'MK', 'UX'].includes(id) ? sendTask(id, text, auth!.cfg, auth!.id) : null;
+  }
   const address = parseSeatAddress(text);
   if (!address) return null;
 
@@ -34,6 +64,18 @@ export async function handleTelegramSeatWork(
     return '어떤 일을 맡길까요? 좌석 주소 뒤에 요청 내용을 적어 다시 보내 주세요.';
   }
 
+  if (seats.length === 1 && seats[0]?.seat) {
+    const auth = owner();
+    const seatId = canonicalSeatId(seats[0].seat.id);
+    if (auth && ['OP', 'TC', 'MK', 'UX'].includes(seatId)) {
+      const intent = classifyCeoIntent(body);
+      if (intent === 'task') return sendTask(seatId, body, auth.cfg, auth.id);
+      const answer = await (deps.answer ?? answerAsSeat)(seats[0].name, body);
+      debug.log('seat.dispatch', 'intent', { seat: seatId, intent, via: 'telegram', outcome: answer ? 'answered' : 'intake' });
+      if (answer) return answer.text;
+    }
+  }
+
   const reportTo = {
     channel: 'telegram' as const,
     chatId: msg.chatId,

package/src/intake-plane/telegram-work.ts

@@ -13,6 +13,7 @@ import {
 
 export interface TelegramWorkMessage {
   chatId: number;
+  userId?: number;
   messageId: number;
   botId?: string;
   threadId?: number;

package/src/maturity/cli-maturity.ts

@@ -0,0 +1,34 @@
+import type { Command } from 'commander';
+import { program } from '../index.js';
+import { FEATURE_MATURITY, type Maturity, type Role } from './feature-maturity.js';
+
+/** Commander owns aliases; the table contains canonical command names only. */
+export function cliRootMaturity(name: string, commands: readonly Command[] = program.commands): Maturity | undefined {
+  const command = commands.find((entry) => entry.name() === name || entry.aliases().includes(name));
+  const canonical = command?.name() ?? name;
+  return Object.prototype.hasOwnProperty.call(FEATURE_MATURITY.cliRoot, canonical)
+    ? FEATURE_MATURITY.cliRoot[canonical as keyof typeof FEATURE_MATURITY.cliRoot]
+    : undefined;
+}
+
+export function cliRootVisibleFor(name: string, role: Role, { showAll }: { showAll: boolean }, commands: readonly Command[] = program.commands): boolean {
+  const grade = cliRootMaturity(name, commands);
+  if (!grade || grade === 'system') return false;
+  if (showAll || role === 'owner') return true;
+  return grade === 'stable' || (role === 'contributor' && (grade === 'beta' || grade === 'tool'));
+}
+
+/** Only help is filtered: Commander still dispatches explicitly typed commands. */
+export function filterCliRootHelp(commands: readonly Command[], role: Role, showAll: boolean): { shown: number; hidden: number } {
+  let shown = 0;
+  let hidden = 0;
+  for (const command of commands) {
+    const grade = cliRootMaturity(command.name(), commands);
+    if (!grade) throw new Error(`cliRoot 에 등급 없는 명령: ${command.name()}`);
+    const visible = cliRootVisibleFor(command.name(), role, { showAll }, commands);
+    (command as Command & { _hidden: boolean })._hidden = !visible;
+    if (visible) shown++;
+    else hidden++;
+  }
+  return { shown, hidden };
+}

package/src/maturity/feature-maturity.ts

@@ -13,6 +13,7 @@ export const FEATURE_MATURITY = {
     '/setup/done': { pwa: 'stable' },
     '/consult': { pwa: 'stable' },
     '/chat': { pwa: 'stable' },
+    '/today': { pwa: 'stable' },
     '/term': { pwa: 'stable' },
     '/live': { pwa: 'stable' },
     '/market': { pwa: 'stable' },
@@ -38,6 +39,9 @@ export const FEATURE_MATURITY = {
     '/design-check': { pwa: 'tool' },
     '/control': { pwa: 'tool' },
     '/scheduler': { pwa: 'ops' },
+    '/ops/release': { pwa: 'ops' },
+    '/ops/seats': { pwa: 'ops' },
+    '/ops/checklist': { pwa: 'ops' },
     '/dashboard': { pwa: 'ops' },
     '/bots': { pwa: 'ops' },
     '/botlab': { pwa: 'ops' },
@@ -46,7 +50,101 @@ export const FEATURE_MATURITY = {
     '/workflows/chat-ui': { pwa: 'broken' },
     '/share': { pwa: 'system' },
   },
-} as const satisfies { pwaRoute: Record<string, SurfaceMaturity> };
+  // Canonical CLI command names only; aliases inherit their command's grade.
+  cliRoot: {
+    pty: 'beta', pr: 'beta', repo: 'beta', role: 'beta', machine: 'beta',
+    where: 'stable', shadow: 'beta', llm: 'beta', storage: 'beta', leader: 'beta',
+    pod: 'beta', browser: 'beta', questions: 'beta', usage: 'stable', live: 'beta',
+    research: 'beta', release: 'beta', seat: 'beta', coord: 'beta', 'model-watch': 'beta', doctor: 'stable',
+    control: 'beta', resources: 'beta', hooks: 'beta', setup: 'stable', start: 'stable',
+    grounding: 'beta', graph: 'beta', loop: 'stable', card: 'stable', 'launch-head': 'beta',
+    a2a: 'beta', plugin: 'stable', skills: 'beta', connect: 'beta', import: 'beta',
+    persona: 'beta', market: 'beta', directive: 'stable', connector: 'beta', storyboard: 'beta',
+    python: 'beta', 'self-update': 'stable', 'measure-fabric-arc-ab': 'beta', mcp: 'beta',
+    relay: 'beta', 'telegram-test': 'beta', telegram: 'beta', 'discord-test': 'beta',
+    sync: 'beta', status: 'beta', git: 'beta', gh: 'beta', repro: 'system',
+    theme: 'beta', history: 'beta', inspect: 'beta', autopilot: 'beta', memory: 'beta',
+    decide: 'beta', 'ax-screen': 'beta', 'decide-recipe': 'beta', signals: 'beta',
+    loops: 'beta', buzz: 'beta', harness: 'stable', self: 'beta', factcheck: 'beta',
+    provider: 'stable', 'provider:set': 'beta', 'provider:restore': 'beta',
+    'provider:rotate': 'beta', 'provider:use': 'beta', 'status-bar': 'beta',
+    schedule: 'beta', intake: 'beta', logs: 'stable', ad: 'beta', docs: 'beta',
+    decisions: 'beta', directives: 'beta', fleet: 'beta', ops: 'stable', publish: 'beta',
+    env: 'beta', 'agent-mission': 'beta', dev: 'beta', keys: 'beta', finance: 'beta',
+    config: 'stable', tasks: 'stable', labels: 'beta', msg: 'beta', ask: 'stable',
+    onboarding: 'beta', login: 'stable', session: 'beta', chat: 'stable', repl: 'stable',
+    agent: 'stable', registry: 'beta', tier: 'stable', local: 'beta', scheduler: 'beta',
+    attach: 'beta', wf: 'beta', nexus: 'stable', phone: 'beta', token: 'beta',
+    acp: 'beta', voice: 'beta',
+    'run-detached': 'system', dogfood: 'system', run: 'system',
+  },
+  // Canonical names only; aliases inherit their command's grade at lookup.
+  // Count: bun -e "import('./src/maturity/feature-maturity.ts').then(m=>console.log(Object.keys(m.FEATURE_MATURITY.tuiSlash).length))" (= SLASH_COMMANDS canonical names).
+  tuiSlash: {
+    help: 'stable',
+    resume: 'stable',
+    model: 'stable',
+    clear: 'stable',
+    status: 'stable',
+    remaining: 'stable',
+    setup: 'stable',
+    quit: 'stable',
+    'run-skill': 'stable',
+    ad: 'beta',
+    design: 'beta',
+    provider: 'stable',
+    reasoning: 'stable',
+    local: 'tool',
+    session: 'stable',
+    fork: 'stable',
+    rewind: 'stable',
+    mission: 'beta',
+    'resume-turn': 'beta',
+    context: 'stable',
+    paste: 'stable',
+    sync: 'tool',
+    plugin: 'tool',
+    widget: 'tool',
+    log: 'tool',
+    memory: 'beta',
+    export: 'stable',
+    delta: 'tool',
+    theme: 'stable',
+    debug: 'tool',
+    rebind: 'tool',
+    'api-allow': 'tool',
+    prompt: 'beta',
+    history: 'stable',
+    research: 'beta',
+    harness: 'ops',
+    plan: 'beta',
+    chat: 'stable',
+    dashboard: 'stable',
+    telegram: 'ops',
+    tablet: 'ops',
+    surface: 'ops',
+    term: 'tool',
+    claude: 'tool',
+    codex: 'tool',
+    gemini: 'tool',
+    acp: 'beta',
+    conv: 'beta',
+    handoff: 'ops',
+    'agent-room': 'ops',
+    showroom: 'ops',
+    reply: 'ops',
+    capture: 'ops',
+    inject: 'ops',
+    relay: 'ops',
+    lane: 'ops',
+    control: 'ops',
+    default: 'ops',
+    qc: 'ops',
+    'voice-chat': 'beta',
+    'auto-tts': 'beta',
+    directive: 'ops',
+  },
+} as const satisfies { pwaRoute: Record<string, SurfaceMaturity>; cliRoot: Record<string, Maturity>; tuiSlash: Record<string, Maturity> };
 
 /** Unregistered routes and surfaces are not implicitly mature. Desktop shares the PWA implementation. */
 export function maturityOn(route: string, surface: Surface): Maturity | undefined {
@@ -63,3 +161,4 @@ export function visibleOn(route: string, surface: Surface, role: Role): boolean
   if (route === '/settings') return true;
   return maturity === 'stable' || (role === 'contributor' && (maturity === 'beta' || maturity === 'tool'));
 }
+

package/src/maturity/tui-slash-maturity.ts

@@ -0,0 +1,31 @@
+// MAT1b — TUI slash suggestions use the same maturity source as PWA routes.
+// Kept out of feature-maturity.ts: the PWA bundles that file, and this one
+// needs the TUI command list.
+import { SLASH_COMMANDS } from '../chat/index.js';
+import { getUserConfig } from '../user-config.js';
+import { FEATURE_MATURITY, type Maturity, type Role } from './feature-maturity.js';
+
+export function readTuiSlashAudience(raw: unknown = getUserConfig().raw?.tui): { role: Role; showBeta: boolean } {
+  const tui = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw as Record<string, unknown> : {};
+  const role = tui.role === 'general' || tui.role === 'contributor' || tui.role === 'owner' ? tui.role : 'owner';
+  return { role, showBeta: tui.showBeta === true };
+}
+
+export function slashMaturity(name: string): Maturity | undefined {
+  const command = SLASH_COMMANDS.find((entry) => entry.name === name || entry.aliases?.includes(name));
+  if (!command) return undefined;
+  return FEATURE_MATURITY.tuiSlash[command.name as keyof typeof FEATURE_MATURITY.tuiSlash];
+}
+
+/** Visibility of a TUI slash suggestion, not permission to execute a typed command.
+ * general = stable (+ beta with showBeta) · contributor = stable·beta·tool · owner = all.
+ * Registered commands without a maturity grade remain visible to owner only in picker/help;
+ * unregistered names are never visible through this predicate. */
+export function slashVisibleFor(name: string, role: Role, { showBeta }: { showBeta: boolean }): boolean {
+  const grade = slashMaturity(name);
+  if (!grade) return false;
+  if (role === 'owner') return true;
+  if (grade === 'stable') return true;
+  if (role === 'contributor') return grade === 'beta' || grade === 'tool';
+  return grade === 'beta' && showBeta;
+}

package/src/memory.ts

@@ -35,6 +35,7 @@ import { randomUUID, createHash } from 'node:crypto';
 import { debug } from './debug/log.js';
 import { estimateTokens } from './tokens.js';
 import { budgetModel } from './llm/model-defaults.js';
+import { getAppliedGlobalTestRoot } from './cli/test-flag.js';
 
 /**
  * 임시 파일 → fsync → rename → 폴더 fsync. rename 만으로는 «원자적»이지만 «내구적»이 아니다.
@@ -86,14 +87,16 @@ export interface MemoryEntry {
    *  Use for core / safety / reference-location facts that must always be
    *  in context. Costs tokens every turn, so keep pinned bodies short. */
   pinned: boolean;
+  /** Optional pinned-memory freshness window; absent memories retain their original injection text. */
+  staleAfterMinutes?: number;
 }
 
 // ── Paths ────────────────────────────────────────────────────────────
 
 export function memoryRoot(): string {
-  const base = process.env.XDG_DATA_HOME && process.env.XDG_DATA_HOME.trim()
+  const base = getAppliedGlobalTestRoot() ?? (process.env.XDG_DATA_HOME && process.env.XDG_DATA_HOME.trim()
     ? process.env.XDG_DATA_HOME
-    : join(homedir(), '.local', 'share');
+    : join(homedir(), '.local', 'share'));
   return join(base, 'elanous', 'memory');
 }
 
@@ -124,6 +127,12 @@ function parseFrontmatter(raw: string): { fm: Record<string, string>; body: stri
   return { fm, body };
 }
 
+function parseStaleAfterMinutes(value: string | number | undefined): number | undefined {
+  if (value === undefined || value === '') return undefined;
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : undefined;
+}
+
 function renderFrontmatter(fm: Record<string, string>, body: string): string {
   const lines = ['---'];
   for (const [k, v] of Object.entries(fm)) lines.push(`${k}: ${v}`);
@@ -179,6 +188,8 @@ export interface SaveMemoryOpts {
   priority?: number;
   /** Always-inject (bypass keyword gate). Default false — or preserve on update. */
   pinned?: boolean;
+  /** Pinned injection warns after this many minutes; preserved on update. */
+  staleAfterMinutes?: number;
   /** Override the generated id (tests). */
   id?: string;
 }
@@ -195,16 +206,19 @@ export function saveMemory(opts: SaveMemoryOpts, root: string = memoryRoot()): M
   let createdAt = now;
   let existingPriority: number | undefined;
   let existingPinned: boolean | undefined;
+  let existingStaleAfterMinutes: number | undefined;
   if (existsSync(path)) {
     try {
       const parsed = parseFrontmatter(readFileSync(path, 'utf-8'));
       if (parsed.fm.created) createdAt = parsed.fm.created;
       if (parsed.fm.priority) existingPriority = parseInt(parsed.fm.priority, 10) || 0;
       if (parsed.fm.pinned) existingPinned = parsed.fm.pinned === 'true';
+      existingStaleAfterMinutes = parseStaleAfterMinutes(parsed.fm['stale-after-minutes']);
     } catch { /* keep new createdAt */ }
   }
   const priority = opts.priority ?? existingPriority ?? 0;
   const pinned = opts.pinned ?? existingPinned ?? false;
+  const staleAfterMinutes = parseStaleAfterMinutes(opts.staleAfterMinutes) ?? existingStaleAfterMinutes;
   const frontmatter: Record<string, string> = {
     name: opts.name,
     description: opts.description,
@@ -214,6 +228,7 @@ export function saveMemory(opts: SaveMemoryOpts, root: string = memoryRoot()): M
   };
   if (priority > 0) frontmatter.priority = String(Math.floor(priority));
   if (pinned) frontmatter.pinned = 'true';
+  if (staleAfterMinutes !== undefined) frontmatter['stale-after-minutes'] = String(staleAfterMinutes);
   const raw = renderFrontmatter(frontmatter, opts.body);
   writeFileDurable(path, raw);
 
@@ -232,6 +247,7 @@ export function saveMemory(opts: SaveMemoryOpts, root: string = memoryRoot()): M
     keywords: extractKeywords(`${opts.name} ${opts.description}`),
     priority,
     pinned,
+    staleAfterMinutes,
   };
 }
 
@@ -257,6 +273,7 @@ function parseMemoryFile(path: string): MemoryEntry | null {
     keywords: extractKeywords(`${fm.name} ${fm.description ?? ''}`),
     priority: fm.priority ? (parseInt(fm.priority, 10) || 0) : 0,
     pinned: fm.pinned === 'true',
+    staleAfterMinutes: parseStaleAfterMinutes(fm['stale-after-minutes']),
   };
 }
 
@@ -432,6 +449,17 @@ export function readIndex(root: string = memoryRoot()): string {
 
 // ── Injection heuristic ──────────────────────────────────────────────
 
+function pinnedChunk(e: MemoryEntry): string {
+  const header = `### 📌 [${e.type}] ${e.name}\n\n`;
+  const body = (e.body || '').trim() || e.description;
+  const updated = Date.parse(e.updatedAt);
+  if (e.staleAfterMinutes === undefined || !Number.isFinite(updated)) return header + body;
+  const ageMinutes = (Date.now() - updated) / 60_000;
+  if (ageMinutes <= e.staleAfterMinutes) return header + body;
+  const hours = Math.floor(ageMinutes / 60);
+  return header + `⚠️ 이 기억은 ${hours}시간 전 것이다 — 답하기 전에 원장 도구 release_status(판 일정·칸) · decisions_pending(미결 결정) · ops_seats(자리 현황)로 다시 확인하고, 확인 전에는 «확인 중»이라고 말한다.\n${body}`;
+}
+
 export interface InjectionResult {
   /** Markdown block to prepend to the system prompt (or '' when empty). */
   block: string;
@@ -490,7 +518,7 @@ export function buildMemoryInjection(
   const pinnedMems = listMemories({}, root).filter(m => m.pinned).sort((a, b) => b.priority - a.priority);
   const pinnedParts: string[] = [];
   for (const e of pinnedMems) {
-    const chunk = `### 📌 [${e.type}] ${e.name}\n\n${(e.body || '').trim() || e.description}`;
+    const chunk = pinnedChunk(e);
     const tok = estimateTokens(chunk);
     if (usedTokens + tok > maxTokens) break;
     pinnedParts.push(chunk);
@@ -653,7 +681,7 @@ export async function buildMemoryInjectionLLM(
   const pinnedMems = listMemories({}, root).filter((m) => m.pinned).sort((a, b) => b.priority - a.priority);
   const pinnedParts: string[] = [];
   for (const e of pinnedMems) {
-    const chunk = `### 📌 [${e.type}] ${e.name}\n\n${(e.body || '').trim() || e.description}`;
+    const chunk = pinnedChunk(e);
     const tok = estimateTokens(chunk);
     if (usedTokens + tok > maxTokens) break;
     pinnedParts.push(chunk); injected.push(e.id); usedTokens += tok;