elanous 0.2.9 → 0.2.10

package/src/decisions/decision-ledger.ts

@@ -1,6 +1,7 @@
 import { closeSync, existsSync, fstatSync, ftruncateSync, mkdirSync, openSync, readFileSync, realpathSync, statSync, unlinkSync, writeSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { readPendingQuestionAnswer, readPendingQuestions, writePendingQuestionAnswer } from '../ask-user-question/pending-questions.js';
 import { debug, redactSecretText } from '../debug/log.js';
 import { createVersionResolver, type VersionOptions, type Versions } from '../directives/version-at.js';
 import { getUserConfig } from '../user-config.js';
@@ -15,15 +16,27 @@ export interface DecisionEntry {
   options: DecisionOption[]; recommendation: Recommendation; raisedAt?: string; importedAt?: string;
   raisedBy: { agent: string; track?: DecisionTrack; session?: string }; version?: Versions;
   status: 'open' | 'decided' | 'withdrawn'; refs?: string[];
+  resume?: { questionId: string; runId?: string };
   /** DEC-TG — optional deadline (UTC). Cards remind the owner two hours before it. */
   dueAt?: string;
   decidedAt?: string; decidedBy?: DecisionActor; choice?: string; note?: string; versionAtDecision?: Versions;
   withdrawnAt?: string; withdrawReason?: string;
   history: Array<{ type: 'raised' | 'options-added' | 'decided' | 'withdrawn'; at?: string; by: string; version?: Versions; choice?: string; reason?: string }>;
 }
-export type RaiseInput = Pick<DecisionEntry, 'title' | 'category' | 'scqa' | 'options' | 'recommendation' | 'raisedBy' | 'refs' | 'dueAt'> & { raisedAt?: string };
+export type RaiseInput = Pick<DecisionEntry, 'title' | 'category' | 'scqa' | 'options' | 'recommendation' | 'raisedBy' | 'refs' | 'dueAt' | 'resume'> & { raisedAt?: string };
 type Event = { type: 'raised'; entry: DecisionEntry } | { type: 'options-added'; id: string; at: string; options: DecisionOption[]; by: string } | { type: 'decided'; id: string; at?: string; by: DecisionActor; choice?: string; version?: Versions; note?: string } | { type: 'withdrawn'; id: string; at: string; reason: string; version: Versions };
-export interface DecisionLedgerOptions extends VersionOptions { stateDir?: string; now?: () => Date; resolveVersion?: (at: string) => Versions }
+export interface DecisionLedgerOptions extends VersionOptions { stateDir?: string; now?: () => Date; resolveVersion?: (at: string) => Versions; writeAnswer?: typeof writePendingQuestionAnswer }
+
+/** null = the decision resumes no run; otherwise whether the answer file was written (or already matched). */
+export type AnswerDelivery = null | { ok: true; questionId: string } | { ok: false; questionId: string; reason: string };
+
+/** The decision is durable even when delivery fails; retryAnswer(id) only retries delivery. */
+export class DecisionAnswerDeliveryError extends Error {
+  constructor(readonly decisionId: string, readonly questionId: string) {
+    super(`decision ${decisionId} recorded but answer delivery failed for ${questionId}; retry with decisions retry-answer ${decisionId}`);
+    this.name = 'DecisionAnswerDeliveryError';
+  }
+}
 const CATEGORIES: readonly string[] = ['secret', 'publish', 'money', 'security', 'scope', 'irreversible', 'other'];
 const TRACKS: readonly string[] = ['S', 'T', 'F', 'O'];
 
@@ -73,7 +86,11 @@ function validate(input: RaiseInput, historical = false): RaiseInput {
     ? { skipped: true as const, reason: safe(single(input.recommendation.reason, 'skip reason')) }
     : { option: input.recommendation.option, why: safe(single(input.recommendation.why, 'recommendation why')) };
   if ('option' in recommendation && !options.some(o => o.key === recommendation.option)) throw new Error('recommended option not found');
+  if (input.resume && !/^auq:[0-9a-z]+:[0-9a-z]{5}(?![\s\S])/.test(input.resume.questionId)) throw new Error('invalid resume questionId');
+  const resume = input.resume ? { questionId: input.resume.questionId,
+    ...(input.resume.runId === undefined ? {} : { runId: single(input.resume.runId, 'resume runId') }) } : undefined;
   return { ...input, title, scqa: { s, c, ...(q ? { q } : {}), ...(a ? { a } : {}) }, options, recommendation,
+    ...(resume ? { resume } : {}),
     raisedBy: { agent: safe(single(input.raisedBy.agent, 'agent')), ...(input.raisedBy.track ? { track: input.raisedBy.track } : {}), ...(input.raisedBy.session ? { session: safe(single(input.raisedBy.session, 'session')) } : {}) },
     ...(input.refs ? { refs: input.refs.map(r => safe(single(r, 'ref'))) } : {}),
     ...(input.dueAt ? { dueAt: utc(input.dueAt) } : {}) };
@@ -83,12 +100,16 @@ export class DecisionLedger {
   readonly path: string;
   private readonly lockPath: string;
   private readonly now: () => Date;
+  private readonly writeAnswer: typeof writePendingQuestionAnswer;
+  private readonly stateDir: string;
   private versionResolver?: (at: string) => Versions;
   private readonly versionOptions: DecisionLedgerOptions;
   constructor(options: DecisionLedgerOptions = {}) {
-    this.path = join(options.stateDir ?? elanousStateRoot(), 'decisions', 'decisions.jsonl');
+    this.stateDir = options.stateDir ?? elanousStateRoot();
+    this.path = join(this.stateDir, 'decisions', 'decisions.jsonl');
     this.lockPath = `${this.path}.lock`;
     this.now = options.now ?? (() => new Date());
+    this.writeAnswer = options.writeAnswer ?? writePendingQuestionAnswer;
     this.versionOptions = options;
     this.versionResolver = options.resolveVersion;
   }
@@ -196,7 +217,14 @@ export class DecisionLedger {
       return entry;
     });
   }
+  /** Record the decision and say whether its answer reached the waiting run (null = the decision resumes nothing). */
+  decideWithDelivery(id: string, choice: string, by: DecisionActor, note?: string, decidedAt?: string): { entry: DecisionEntry; delivery: AnswerDelivery } {
+    return this.decideLocked(id, choice, by, note, decidedAt);
+  }
   decide(id: string, choice: string, by: DecisionActor, note?: string, decidedAt?: string): DecisionEntry {
+    return this.decideLocked(id, choice, by, note, decidedAt).entry;
+  }
+  private decideLocked(id: string, choice: string, by: DecisionActor, note?: string, decidedAt?: string): { entry: DecisionEntry; delivery: AnswerDelivery } {
     if (!by || (by.kind !== 'human' && by.kind !== 'auto')) throw new Error('decidedBy is required');
     if (by.kind === 'auto') {
       single(by.delegation, 'delegation'); single(by.agent, 'agent');
@@ -211,9 +239,52 @@ export class DecisionLedger {
       if (old.raisedAt && at < old.raisedAt) throw new Error('decision before raise');
       this.append({ type: 'decided', id, at, by, choice, version: this.version(at), ...(note ? { note: safe(single(note, 'note')) } : {}) });
       debug.log('decisions', 'decided', { id, category: old.category, by: by.kind });
-      return this.show(id);
+      const decided = this.show(id);
+      return { entry: decided, delivery: this.deliverAnswer(decided) };
     });
   }
+  /** Retry delivery of the recorded choice without adding another decided event or changing its actor/note. */
+  retryAnswer(id: string): DecisionEntry {
+    return this.locked(() => {
+      const entry = this.show(id);
+      if (entry.status !== 'decided' || !entry.resume || !entry.choice || !entry.decidedBy) throw new Error(`decision has no recorded resume answer: ${id}`);
+      this.deliverAnswer(entry, true);
+      return entry;
+    });
+  }
+  private deliverAnswer(entry: DecisionEntry, throwOnFailure = false): AnswerDelivery {
+    if (!entry.resume) return null;
+    const { questionId, runId } = entry.resume;
+    try {
+      const label = entry.options.find(option => option.key === entry.choice)?.label;
+      if (!label || !entry.choice) throw new Error('recorded choice not found');
+      const deps = { root: () => this.stateDir };
+      const pending = readPendingQuestions(deps);
+      if (!pending.ok) throw new Error(pending.error);
+      const target = pending.questions.find(item => item.id === questionId);
+      if (!target || target.questions.length !== 1 || !target.questions[0]?.id) throw new Error('pending question target not found or ambiguous');
+      const question = target.questions[0];
+      if (question.options.length !== entry.options.length || question.options.some((option, index) =>
+        entry.options[index]?.key !== String.fromCharCode(97 + index) || entry.options[index]?.label !== option.label)) {
+        throw new Error('pending question options differ from decision');
+      }
+      const answerKey = question.id;
+      const answer = { id: questionId, result: { answers: { [answerKey]: `${entry.choice}) ${label}` },
+        ...(entry.note ? { otherText: { [answerKey]: entry.note } } : {}) } };
+      const existing = readPendingQuestionAnswer(questionId, deps);
+      if (!existing.ok) throw new Error('existing answer unreadable');
+      if (existing.answer) {
+        if (JSON.stringify(existing.answer) !== JSON.stringify(answer)) throw new Error('pending question already answered differently');
+      } else this.writeAnswer(answer, deps);
+      debug.log('hitl.card-bridge', 'answered', { decisionId: entry.id, questionId, runId, via: entry.decidedBy?.kind });
+      return { ok: true, questionId };
+    } catch (error) {
+      const reason = error instanceof Error ? (error as NodeJS.ErrnoException).code ?? error.name : typeof error;
+      debug.log('hitl.card-bridge', 'answer-write-failed', { decisionId: entry.id, questionId, reason });
+      if (throwOnFailure) throw new DecisionAnswerDeliveryError(entry.id, questionId);
+      return { ok: false, questionId, reason: error instanceof Error ? error.message.slice(0, 120) : String(reason) };
+    }
+  }
   /** Import an open historical request with known alternatives and an unknown original time. */
   importOpen(input: RaiseInput): DecisionEntry {
     const clean = validate(input);

package/src/decisions/decision-linear-projection.ts

@@ -0,0 +1,157 @@
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, writeSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { createLinearIssue, commentLinearIssue, findLinearDecisionIssue, moveLinearIssueToStateType, resolveLinearProjectId } from '../connectors/linear.js';
+import { debug } from '../debug/log.js';
+import { getSecretAsync } from '../nexus/config/secrets/index.js';
+import { getUserConfig, type UserConfig } from '../user-config.js';
+import { DecisionLedger, type DecisionEntry } from './decision-ledger.js';
+
+interface ProjectionRecord { issue: string; closedAt?: string; commentPosted?: boolean }
+type ProjectionState = Record<string, ProjectionRecord>;
+export interface DecisionLinearProjectionDeps {
+  stateDir?: string;
+  ledger?: Pick<DecisionLedger, 'list'>;
+  config?: Pick<UserConfig, 'decisions' | 'coo'>;
+  getSecret?: (id: string) => Promise<string | undefined>;
+  fetch?: typeof fetch;
+  dryRun?: boolean;
+}
+export interface DecisionLinearProjectionResult {
+  created: number; closed: number; skipped: number; failed: number;
+  reason?: string;
+  plan?: Array<{ decisionId: string; action: 'create' | 'close'; issue?: string }>;
+}
+
+function readState(path: string): ProjectionState {
+  if (!existsSync(path)) return {};
+  const value: unknown = JSON.parse(readFileSync(path, 'utf8'));
+  if (!value || typeof value !== 'object' || Array.isArray(value) || Object.entries(value).some(([id, row]) =>
+    !/^D-\d{8}-\d+$/.test(id) || !row || typeof row !== 'object' || Array.isArray(row) ||
+    typeof (row as ProjectionRecord).issue !== 'string' || !(row as ProjectionRecord).issue ||
+    ((row as ProjectionRecord).closedAt !== undefined && typeof (row as ProjectionRecord).closedAt !== 'string') ||
+    ((row as ProjectionRecord).commentPosted !== undefined && typeof (row as ProjectionRecord).commentPosted !== 'boolean'))) {
+    throw new Error('invalid decision Linear projection state');
+  }
+  return value as ProjectionState;
+}
+
+function saveState(path: string, state: ProjectionState): void {
+  mkdirSync(join(path, '..'), { recursive: true });
+  const temp = `${path}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(temp, JSON.stringify(state), { mode: 0o600 });
+    renameSync(temp, path);
+  } finally { if (existsSync(temp)) unlinkSync(temp); }
+}
+
+function description(entry: DecisionEntry): string {
+  return [`카테고리: ${entry.category}`, ...(entry.dueAt ? [`기한: ${entry.dueAt}`] : []),
+    `결정 id: ${entry.id}`, '텔레그램/디스코드 카드에서 정한다',
+    ...(entry.refs ?? []).filter(ref => ref.startsWith('http'))].join('\n');
+}
+
+/** A single writer holds the file lock across remote creation and local persistence. */
+export async function projectDecisionsToLinear(deps: DecisionLinearProjectionDeps = {}): Promise<DecisionLinearProjectionResult> {
+  const result: DecisionLinearProjectionResult = { created: 0, closed: 0, skipped: 0, failed: 0 };
+  const config = deps.config ?? getUserConfig();
+  if (config.decisions?.linearProjection?.enabled !== true) {
+    result.reason = 'decisions.linearProjection.enabled 꺼짐';
+    debug.log('decisions.linear', 'skipped', { decisionId: null, issue: null, reason: 'disabled' });
+    return result;
+  }
+  // A dry run only reads the local ledger and state — it must work before a key is set.
+  const apiKey = (deps.dryRun ? '' : await (deps.getSecret ?? getSecretAsync)('connector.linear.apiKey')) ?? '';
+  if (!deps.dryRun && !apiKey) {
+    result.reason = 'Linear 키가 없습니다 — `elanous connector linear set-key`';
+    debug.log('decisions.linear', 'skipped', { decisionId: null, issue: null, reason: 'missing-key' });
+    return result;
+  }
+  const stateDir = deps.stateDir ?? elanousStateRoot();
+  const path = join(stateDir, 'decisions', 'linear-projection.json');
+  const ledger = deps.ledger ?? new DecisionLedger({ stateDir });
+  const entries = ledger.list({ status: 'all' });
+  const fetchFn = deps.fetch ?? fetch;
+  const lockPath = `${path}.lock`;
+  let lock: number | undefined;
+  if (!deps.dryRun) {
+    mkdirSync(join(path, '..'), { recursive: true });
+    const deadline = Date.now() + 10_000;
+    for (;;) {
+      try { lock = openSync(lockPath, 'wx', 0o600); writeSync(lock, `${process.pid}`); break; }
+      catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
+        try {
+          const pid = Number(readFileSync(lockPath, 'utf8'));
+          if (Number.isSafeInteger(pid) && pid > 0 && Date.now() - statSync(lockPath).mtimeMs > 30_000) {
+            try { process.kill(pid, 0); }
+            catch (e) { if ((e as NodeJS.ErrnoException).code === 'ESRCH') { unlinkSync(lockPath); continue; } }
+          }
+        } catch (e) { if ((e as NodeJS.ErrnoException).code === 'ENOENT') continue; }
+        if (Date.now() >= deadline) throw new Error('decision Linear projection lock timeout');
+        await Bun.sleep(25);
+      }
+    }
+  }
+  try {
+    const state = readState(path);
+    if (deps.dryRun) result.plan = [];
+    let projectId: string | undefined;
+    for (const entry of entries) {
+      let issue = state[entry.id]?.issue;
+      try {
+        const record = state[entry.id];
+        if (entry.status === 'open' && !record) {
+          if (deps.dryRun) {
+            result.plan!.push({ decisionId: entry.id, action: 'create' });
+            result.created++;
+          } else {
+            projectId ??= await resolveLinearProjectId({ apiKey, project: config.coo?.linearProject ?? '외부 행정·큰 일 (COO)', fetch: fetchFn });
+            const existing = await findLinearDecisionIssue({ apiKey, projectId, decisionId: entry.id, fetch: fetchFn });
+            issue = existing ?? await createLinearIssue({ apiKey, projectId, title: `[결정] ${entry.title}`, description: description(entry),
+              ...(entry.dueAt ? { dueDate: entry.dueAt.slice(0, 10) } : {}), fetch: fetchFn });
+            state[entry.id] = { issue };
+            saveState(path, state);
+            if (existing) {
+              result.skipped++;
+              debug.log('decisions.linear', 'skipped', { decisionId: entry.id, issue, reason: 'recovered' });
+              continue;
+            }
+            result.created++;
+          }
+          debug.log('decisions.linear', 'created', { decisionId: entry.id, issue: issue ?? null, reason: deps.dryRun ? 'dry-run' : 'created' });
+        } else if (entry.status !== 'open' && record && !record.closedAt) {
+          if (deps.dryRun) {
+            result.plan!.push({ decisionId: entry.id, action: 'close', issue: record.issue });
+          } else {
+            if (!record.commentPosted) {
+              const body = entry.status === 'withdrawn' ? '철회됨'
+                : `결정됨: ${entry.choice ?? '선택 키 미상'} · ${entry.decidedBy?.kind ?? '주체 미상'} · ${entry.decidedAt ?? '시각 미상'}`;
+              await commentLinearIssue({ apiKey, issueId: record.issue, body, fetch: fetchFn });
+              record.commentPosted = true;
+              saveState(path, state);
+            }
+            await moveLinearIssueToStateType({ apiKey, issueId: record.issue, type: entry.status === 'decided' ? 'completed' : 'canceled', fetch: fetchFn });
+            record.closedAt = new Date().toISOString();
+            saveState(path, state);
+          }
+          result.closed++;
+          debug.log('decisions.linear', 'closed', { decisionId: entry.id, issue: record.issue, reason: deps.dryRun ? 'dry-run' : entry.status });
+        } else {
+          result.skipped++;
+          debug.log('decisions.linear', 'skipped', { decisionId: entry.id, issue: issue ?? null, reason: record?.closedAt ? 'already-closed' : record ? 'already-created' : 'not-projected' });
+        }
+      } catch (error) {
+        result.failed++;
+        const reason = error instanceof Error
+          ? (error as NodeJS.ErrnoException).code ?? (/^Linear GraphQL HTTP \d{3}$/.test(error.message) ? error.message : error.name)
+          : 'unknown';
+        debug.log('decisions.linear', 'failed', { decisionId: entry.id, issue: issue ?? null, reason });
+      }
+    }
+    return result;
+  } finally {
+    if (lock !== undefined) { closeSync(lock); unlinkSync(lockPath); }
+  }
+}

package/src/decisions/web-push-decision-cards.ts

@@ -0,0 +1,50 @@
+import { debug } from '../debug/log.js';
+import { listSubscriptions } from '../web-push/subscriptions.js';
+import { sendPushToAll } from '../web-push/sender.js';
+import { type CardTransport, type CardView } from './decision-cards.js';
+import { DecisionLedger } from './decision-ledger.js';
+
+const ID_IN_CARD = /^🗳 결정 요청 (D-\d{8}-\d+)(?: ·|\n)/;
+const ID_IN_REMINDER = /^⏰ 기한 2시간 전 — (D-\d{8}-\d+) /;
+const TITLE_LIMIT = 60;
+
+export function webPushDecisionTransport(
+  ledger: DecisionLedger,
+  deps: { subscriptions?: typeof listSubscriptions; push?: typeof sendPushToAll } = {},
+): CardTransport {
+  const subscriptions = deps.subscriptions ?? listSubscriptions;
+  const push = deps.push ?? sendPushToAll;
+  const title = (prefix: string, name: string) => prefix + Array.from(name).slice(0, TITLE_LIMIT - Array.from(prefix).length).join('');
+  const url = (id: string) => `/approvals?decision=${encodeURIComponent(id)}`;
+  const tag = (id: string) => `decision-${id}`;
+  return {
+    platform: 'webpush',
+    ownerChats: async () => subscriptions().length ? ['webpush'] : [],
+    send: async (_chat, view: CardView) => {
+      const id = ID_IN_CARD.exec(view.text)?.[1];
+      if (!id || !subscriptions().length) return null;
+      const entry = ledger.show(id);
+      if (entry.status !== 'open') return null;
+      const recommendation = 'skipped' in entry.recommendation ? '추천안 없음' : `추천안: ${entry.recommendation.option.toUpperCase()}`;
+      const body = `${recommendation}${entry.dueAt ? ` · 기한: ${new Intl.DateTimeFormat('ko-KR', { timeZone: 'Asia/Seoul', month: 'numeric', day: 'numeric', hour: '2-digit', minute: '2-digit', hour12: false }).format(new Date(entry.dueAt))}` : ''}`;
+      const result = await push({ title: title('대표 결정 · ', entry.title), body, url: url(id), tag: tag(id) });
+      debug.log('decisions.webpush', 'card-sent', { id, delivered: result.delivered });
+      return result.delivered ? { chat: 'webpush', message: id } : null;
+    },
+    edit: async (ref, _view) => {
+      const id = ref.message;
+      const entry = ledger.show(id);
+      if (entry.status === 'open' || !subscriptions().length) return;
+      const result = await push({ title: title('결정됨 · ', entry.title), url: url(id), tag: tag(id), data: { silent: true } });
+      debug.log('decisions.webpush', 'card-closed', { id, delivered: result.delivered });
+    },
+    notify: async (_chat, text) => {
+      const id = ID_IN_REMINDER.exec(text)?.[1];
+      if (!id || !subscriptions().length) return;
+      const entry = ledger.show(id);
+      if (entry.status !== 'open') return;
+      const result = await push({ title: title('기한 알림 · ', entry.title), body: `기한 2시간 전 · ${id}`, url: url(id), tag: tag(id) });
+      debug.log('decisions.webpush', 'card-sent', { id, delivered: result.delivered });
+    },
+  };
+}

package/src/directive/interpretation-card.ts

@@ -0,0 +1,36 @@
+import { listChecklist, type ChecklistItem } from '../release-loop/checklist.js';
+
+export interface InterpretationCard {
+  what: string;
+  cell: string | null;
+  unknowns: string[];
+}
+
+export type CellCandidate = Pick<ChecklistItem, 'id' | 'title'>;
+
+/** The same SQLite-backed cells exposed by `elanous release checklist list --version <v>`. */
+export function readCellCandidates(version: string): CellCandidate[] {
+  return listChecklist(version).items.map(({ id, title }) => ({ id, title }));
+}
+
+/** Interpret a single directive without querying state or inventing a release cell. */
+export function interpretDirective(line: string, candidates: readonly CellCandidate[]): InterpretationCard {
+  if (/\r|\n/.test(line)) throw new Error('지시는 한 줄이어야 한다');
+  const what = line.trim();
+  if (!what) throw new Error('빈 지시는 해석할 수 없다');
+
+  const matches = candidates.filter(({ id, title }) =>
+    (id && new RegExp(`(^|[^\\p{L}\\p{N}])${id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?=$|[^\\p{L}\\p{N}]|[을를은는이가에의와과])`, 'u').test(what)) ||
+    (title && what.includes(title)));
+
+  if (matches.length === 1) return { what, cell: matches[0]!.id, unknowns: [] };
+  return {
+    what,
+    cell: null,
+    unknowns: [matches.length ? `칸 후보가 여럿이다: ${matches.map(({ id }) => id).join(', ')}` : '연결할 칸을 확인해야 한다'],
+  };
+}
+
+export function renderInterpretationCard(card: InterpretationCard): string {
+  return `무엇: ${card.what}\n칸: ${card.cell ?? '확인 필요'}\n미확인: ${card.unknowns.join(', ') || '없음'}`;
+}

package/src/discord.ts

@@ -837,13 +837,14 @@ export class DiscordBot {
     }
 
     // Addressed work is submitted only by configured owners; ordinary chat keeps its existing path.
-    if (this.allowedUsers.has(author.id) && parseSeatAddress(ctx.text)) {
+    if (this.allowedUsers.has(author.id) && (parseSeatAddress(ctx.text) || (ctx.isDm && ctx.text && !ctx.text.startsWith('/')))) {
       const threadId = typeof m.thread_id === 'string' && m.thread_id ? m.thread_id : undefined;
       const replyChannelId = threadId ?? ctx.channelId;
       try {
         const seatReply = await handleDiscordSeatWork(ctx.text, {
           channelId: replyChannelId,
           messageId: ctx.messageId,
+          userId: ctx.userId, isDm: ctx.isDm,
           ...(threadId ? { threadId } : {}),
         }, this.seatWorkDeps);
         if (seatReply !== null) {

package/src/domains/coo-admin-tool.ts

@@ -0,0 +1,62 @@
+import type { LLMToolSpec } from '../llm.js';
+import { debug } from '../debug/log.js';
+import { getUserConfig } from '../user-config.js';
+import { getSecretAsync } from '../nexus/config/secrets/index.js';
+import { fetchLinearProjectIssues, type LinearProjectIssue } from '../connectors/linear.js';
+import { formatElanousCard } from './elanous-card.js';
+
+export const COO_ADMIN_SPEC: LLMToolSpec = {
+  name: 'coo_admin',
+  description: '읽기 전용 Linear COO 행정 조회 — «행정 뭐 남았어 · COO 할 일 · 마감 다가오는 행정» 질문에 사용. 외부 행정 프로젝트의 열린 일을 마감 순으로 읽는다.',
+  parameters: { type: 'object', properties: {}, required: [] },
+};
+
+export interface CooAdminDeps {
+  getSecret?: (id: string) => Promise<string | undefined>;
+  fetch?: typeof fetch;
+  project?: string;
+  now?: Date;
+}
+
+/** Reads the configured Linear project without changing any Linear issue. */
+export async function dispatchCooAdmin(_args: Record<string, unknown>, deps: CooAdminDeps = {}): Promise<string> {
+  let count = 0;
+  let overdue = 0;
+  try {
+    const apiKey = await (deps.getSecret ?? getSecretAsync)('connector.linear.apiKey');
+    if (!apiKey) {
+      debug.log('coo.admin', 'failed', { count, overdue, reason: 'missing-key' });
+      return 'Linear 키가 없습니다 — `elanous connector linear set-key`';
+    }
+    const project = deps.project ?? getUserConfig().coo?.linearProject ?? '외부 행정·큰 일 (COO)';
+    const issues = await fetchLinearProjectIssues({ apiKey, project, fetch: deps.fetch ?? fetch });
+    const today = deps.now ?? new Date();
+    const todayUtc = Date.UTC(today.getUTCFullYear(), today.getUTCMonth(), today.getUTCDate());
+    const daysUntil = (date: string) => Math.round((Date.parse(`${date.slice(0, 10)}T00:00:00Z`) - todayUtc) / 86_400_000);
+    issues.sort((a, b) => {
+      const deadlineOrder = a.dueDate == null ? (b.dueDate == null ? 0 : 1)
+        : b.dueDate == null ? -1 : daysUntil(a.dueDate) - daysUntil(b.dueDate);
+      return deadlineOrder || (a.priority === 0 ? 5 : a.priority) - (b.priority === 0 ? 5 : b.priority);
+    });
+    count = issues.length;
+    const lines = issues.map((item: LinearProjectIssue) => {
+      const days = item.dueDate ? daysUntil(item.dueDate) : null;
+      if (days !== null && days < 0) overdue++;
+      const deadline = days === null ? '마감 없음' : days < 0 ? `지남 ${-days}일` : `D-${days}`;
+      return `${deadline} · ${item.title} · ${item.state.name} · ${item.assignee?.name ?? '미배정'}\n${item.url}`;
+    });
+    debug.log('coo.admin', 'read', { count, overdue, reason: 'ok' });
+    const scope = issues.truncated ? '최대 250건 중 조회한 항목만 마감 순으로 표시 (이후 항목은 포함되지 않음)\n' : '';
+    const prose = lines.length ? `${scope}${lines.join('\n')}` : '남은 행정 0건';
+    const card = formatElanousCard({ kind: 'coo-admin', items: issues.map(item => ({
+      title: item.title, due: item.dueDate?.slice(0, 10) ?? null,
+      daysLeft: item.dueDate ? daysUntil(item.dueDate) : null,
+      state: item.state.name, owner: item.assignee?.name ?? '미배정', url: item.url,
+    })) });
+    return `${prose}\n${card}`;
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    debug.log('coo.admin', 'failed', { count, overdue, reason: 'linear-read-failed' });
+    return `못 읽었습니다(${reason})`;
+  }
+}

package/src/domains/core-tools.ts

@@ -28,6 +28,9 @@ import { OPS_STATUS_SPEC, dispatchOpsStatus } from './ops-status-tool.js';
 import { SE_BUILD_SPEC, dispatchSeBuild } from './se-build-tool.js';
 import { LOGS_QUERY_SPEC, dispatchLogsQuery } from './logs-tool.js';
 import { MISSION_DECIDE_SPEC, dispatchMissionDecide } from '../autopilot/mission-decide-tool.js';
+import { COO_ADMIN_SPEC, dispatchCooAdmin } from './coo-admin-tool.js';
+import { RELEASE_STATUS_SPEC, RELEASE_CHANGE_SPEC, dispatchReleaseStatus, dispatchReleaseChange } from './release-tool.js';
+import { OPS_SEATS_SPEC, DECISIONS_PENDING_SPEC, dispatchOpsSeats, dispatchDecisionsPending } from './ops-facts-tool.js';
 
 /** memory_recall — 크로스서피스 기억(자기 발송 원장 회상). 도메인 무관(domain 필터는 옵션).
  *  finance-tools 에서 L2 로 이관(2026-07-08). */
@@ -118,6 +121,8 @@ const CORE_TOOL_HANDLERS: Record<string, (args: Record<string, unknown>, onParti
   se_build: dispatchSeBuild, // SE 격리 빌드 관측(빌드 안 뭐 하나·로그 tail·worktree diff)·코어
   logs_query: dispatchLogsQuery, // 크로스서피스 디버그 로그 조회(logs.db·LF3)·READ-ONLY 코어
   mission_decide: dispatchMissionDecide, // 미션 결정 기록(re-ground·defer·boundary…)·3박자 주입·코어
+  coo_admin: (args) => dispatchCooAdmin(args),
+  release_status: async (args) => dispatchReleaseStatus(args),
 };
 
 /** Worker-side search entry: dispatch must not re-enter its own budget wrapper. */
@@ -136,7 +141,7 @@ const SELF_RECALL_BUDGET_SPEC: LLMToolSpec = {
     },
   },
 };
-export const CORE_TOOL_SPECS: LLMToolSpec[] = [SCHEDULE_MANAGE_SPEC, SESSION_MANAGE_SPEC, MEMORY_RECALL_SPEC, FACT_CHECK_SPEC, SELF_RECALL_BUDGET_SPEC, AUTOPILOT_MISSION_SPEC, OPS_STATUS_SPEC, SE_BUILD_SPEC, LOGS_QUERY_SPEC, MISSION_DECIDE_SPEC];
+export const CORE_TOOL_SPECS: LLMToolSpec[] = [SCHEDULE_MANAGE_SPEC, SESSION_MANAGE_SPEC, MEMORY_RECALL_SPEC, FACT_CHECK_SPEC, SELF_RECALL_BUDGET_SPEC, AUTOPILOT_MISSION_SPEC, OPS_STATUS_SPEC, SE_BUILD_SPEC, LOGS_QUERY_SPEC, MISSION_DECIDE_SPEC, COO_ADMIN_SPEC, RELEASE_STATUS_SPEC, RELEASE_CHANGE_SPEC, OPS_SEATS_SPEC, DECISIONS_PENDING_SPEC];
 
 export interface CoreTools {
   specs: LLMToolSpec[];
@@ -153,11 +158,14 @@ export function buildCoreTools(recallSearch?: RecallSearch): CoreTools {
     names,
     dispatch: async (name, args, onPartial, context) => {
       const h = CORE_TOOL_HANDLERS[name];
-      if (!h) return { error: `unknown core tool: ${name}` };
+      if (!h && name !== 'release_change' && name !== 'ops_seats' && name !== 'decisions_pending') return { error: `unknown core tool: ${name}` };
+      if (name === 'release_change') return dispatchReleaseChange(args, context);
+      if (name === 'ops_seats') return dispatchOpsSeats(args, context);
+      if (name === 'decisions_pending') return dispatchDecisionsPending(context);
       if (name === 'memory_recall' || name === 'self_recall') {
         return runRecall(name, args, context ?? { surface: 'skill' }, recallSearch, onPartial);
       }
-      return h(args, onPartial);
+      return h!(args, onPartial);
     },
   };
 }

package/src/domains/elanous-card.ts

@@ -0,0 +1,29 @@
+export interface ElanousCard {
+  kind: 'coo-admin' | 'release-schedule' | 'release-checklist';
+  items: Array<{ title: string; due: string | null; daysLeft: number | null; state: string; owner: string; url?: string }>;
+  meta?: Record<string, unknown>;
+}
+
+export function formatElanousCard(card: ElanousCard): string {
+  return `\`\`\`elanous-card\n${JSON.stringify(card)}\n\`\`\``;
+}
+
+/** Reads every valid card block in a tool response; ignores unrelated prose and malformed blocks. */
+export function parseElanousCard(text: string): ElanousCard[] {
+  const cards: ElanousCard[] = [];
+  for (const match of text.matchAll(/```elanous-card\r?\n([^\r\n]+)\r?\n```/g)) {
+    try {
+      const value: unknown = JSON.parse(match[1]!);
+      if (!value || typeof value !== 'object') continue;
+      const card = value as Partial<ElanousCard>;
+      if (!['coo-admin', 'release-schedule', 'release-checklist'].includes(card.kind ?? '') || !Array.isArray(card.items)) continue;
+      if (!card.items.every(item => item && typeof item.title === 'string' &&
+        (item.due === null || /^\d{4}-\d{2}-\d{2}$/.test(item.due)) &&
+        (item.daysLeft === null || typeof item.daysLeft === 'number') &&
+        typeof item.state === 'string' && typeof item.owner === 'string' &&
+        (item.url === undefined || typeof item.url === 'string'))) continue;
+      cards.push(card as ElanousCard);
+    } catch { /* Other fenced content is not a card. */ }
+  }
+  return cards;
+}

package/src/domains/ops-facts-tool.ts

@@ -0,0 +1,76 @@
+import type { LLMToolSpec } from '../llm.js';
+import type { ToolRuntimeContext } from '../tool-runtime/types.js';
+import { debug } from '../debug/log.js';
+import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
+import { buildSeatsBoard, todayKst, type SeatsSources } from '../nexus/api/ops-seats.js';
+import { liveSeatsSources } from '../nexus/api/ops-seats-sources.js';
+
+export const OPS_SEATS_SPEC: LLMToolSpec = {
+  name: 'ops_seats',
+  description: '오너 전용 읽기 — 지금 자리(OP·TC·MK·UX)별 진행(now), 오늘 착지(landed), 빨강(red), 미결 결정 수를 원장에서 확인한다. null은 못 읽은 원천이며 0이나 빈 목록이 아니다.',
+  parameters: { type: 'object', properties: { date: { type: 'string', description: '조회할 KST 날짜 YYYY-MM-DD. 생략하면 KST 오늘.' } }, required: [] },
+};
+
+export const DECISIONS_PENDING_SPEC: LLMToolSpec = {
+  name: 'decisions_pending',
+  description: '오너 전용 읽기 — 결정 원장의 열린 결정을 기한 순으로 조회한다. 결정 선택·기록은 하지 않는다.',
+  parameters: { type: 'object', properties: {}, required: [] },
+};
+
+export interface OpsFactsDeps {
+  seatsSources?: () => SeatsSources;
+  listDecisions?: (filters: { status: 'open' }) => DecisionEntry[];
+  today?: () => string;
+}
+
+function ownerVerified(context?: ToolRuntimeContext): boolean {
+  return context?.requestOrigin !== 'external-agent' && !!context?.sessionId && !!context?.verifiedOwner?.id.trim();
+}
+
+function logCall(tool: 'ops_seats' | 'decisions_pending', ok: boolean, nulls: number): void {
+  debug.log('ops.facts', 'call', { tool, ok, nulls });
+}
+
+/** Unreadable seat sources remain null; only rename the board's `blocked` field to `red` for this tool. */
+export async function dispatchOpsSeats(args: Record<string, unknown>, context?: ToolRuntimeContext, deps: OpsFactsDeps = {}) {
+  if (!ownerVerified(context)) {
+    logCall('ops_seats', false, 0);
+    return { error: '오너 확인이 필요한 조회다' };
+  }
+  const date = args.date === undefined ? (deps.today ?? todayKst)() : args.date;
+  if (typeof date !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(date) ||
+    !Number.isFinite(Date.parse(`${date}T00:00:00Z`)) || new Date(`${date}T00:00:00Z`).toISOString().slice(0, 10) !== date) {
+    logCall('ops_seats', false, 0);
+    return { error: 'KST 날짜는 YYYY-MM-DD 여야 한다' };
+  }
+  try {
+    const board = await buildSeatsBoard(date, (deps.seatsSources ?? liveSeatsSources)());
+    const seats = board.seats.map(({ seat, role, now, landed, blocked, pendingDecisions }) =>
+      ({ seat, role, now, landed, red: blocked, pendingDecisions }));
+    const nulls = seats.reduce((n, row) => n + [row.now, row.landed, row.red, row.pendingDecisions].filter(v => v === null).length, 0);
+    logCall('ops_seats', true, nulls);
+    return { note: 'null = 못 읽음(없다가 아님); now는 오늘 기록이 없어도 null일 수 있다.', date: board.date, seats };
+  } catch {
+    logCall('ops_seats', false, 1);
+    return { error: '자리 현황을 읽지 못했다', seats: null };
+  }
+}
+
+/** Only the five requested fields leave the decision ledger. Undated entries follow dated entries. */
+export function dispatchDecisionsPending(context?: ToolRuntimeContext, deps: OpsFactsDeps = {}) {
+  if (!ownerVerified(context)) {
+    logCall('decisions_pending', false, 0);
+    return { error: '오너 확인이 필요한 조회다' };
+  }
+  try {
+    const entries = (deps.listDecisions ?? ((filters) => new DecisionLedger().list(filters)))({ status: 'open' });
+    const items = entries.filter(e => e.status === 'open')
+      .sort((a, b) => (a.dueAt ?? '\uffff').localeCompare(b.dueAt ?? '\uffff') || a.id.localeCompare(b.id))
+      .map(({ id, title, category, dueAt, raisedBy }) => ({ id, title, category, dueAt: dueAt ?? null, raisedBy: { track: raisedBy.track ?? null } }));
+    logCall('decisions_pending', true, items.reduce((n, item) => n + Number(item.dueAt === null) + Number(item.raisedBy.track === null), 0));
+    return { items };
+  } catch {
+    logCall('decisions_pending', false, 1);
+    return { error: '결정 원장을 읽지 못했다', items: null };
+  }
+}