elanous 0.2.9 → 0.2.11

package/src/dashboard/slash-runtime/help-from-registry.ts

@@ -1,4 +1,6 @@
 import type { SlashCommand } from '../../chat/index.js';
+import { readTuiSlashAudience, slashMaturity, slashVisibleFor } from '../../maturity/tui-slash-maturity.js';
+import type { Role } from '../../maturity/feature-maturity.js';
 import { visibleWidth } from '../../tui.js';
 
 const ESSENTIAL_KEYS = [
@@ -34,46 +36,59 @@ export function buildEssentialHelpLines({
   names,
   descriptions,
   width,
+  audience = readTuiSlashAudience(),
 }: {
   names: readonly string[];
   descriptions: readonly Pick<SlashCommand, 'name' | 'aliases' | 'description'>[];
   width: number;
+  audience?: { role: Role; showBeta: boolean };
 }): string[] {
-  const descriptionsByName = new Map<string, string>();
-  for (const command of descriptions) {
-    for (const name of [command.name, ...(command.aliases ?? [])]) {
-      descriptionsByName.set(name, command.description);
-    }
-  }
-  const entries = [...new Set(names)]
-    .sort((a, b) => a.localeCompare(b))
-    .flatMap((name) => {
-      // Removing border glyphs from a name would invent a different, unregistered slash.
-      if (/[│╭╮╰╯┌┐└┘─]/.test(name)) return [];
-      const description = descriptionsByName.get(name)?.replace(/\s+/g, ' ').trim();
-      return description ? [{ name, description }] : [];
-    });
-  // Pack alphabetically in reading order across columns; the handler checks
-  // the modal's row budget and uses scrollable chat if the result outgrows it.
-  const longestName = Math.max(22, ...entries.map(({ name }) => visibleWidth(`/${name}  `) + 1));
-  const columns = Math.max(1, Math.min(Math.ceil(entries.length / 20), Math.floor(width / longestName)));
+  const registered = new Set(names);
+  const entries = descriptions
+    .filter((command) => registered.has(command.name) &&
+      ((audience.role === 'owner' && slashMaturity(command.name) === undefined) || slashVisibleFor(command.name, audience.role, { showBeta: audience.showBeta })))
+    .map((command) => {
+      const aliases = [...new Set(command.aliases ?? [])].filter((alias) => registered.has(alias) && alias !== command.name);
+      const label = `/${command.name}${aliases.length ? ` (${aliases.join(', ')})` : ''}`;
+      const description = command.description.replace(/\s+/g, ' ').trim()
+        .replace(/^(?:(?:H\d+\s+P\d+|CV-\d+|Sprint\s+\d+|Showroom\s+v2)(?:\s*[·—:]\s*|\s+))+/i, '')
+        .trim();
+      return { label, name: command.name, description };
+    })
+    .filter(({ label, description }) => description && !/[│╭╮╰╯┌┐└┘─]/.test(label))
+    .sort((a, b) => a.name.localeCompare(b.name));
+  // Reserve the longest label, 28 description characters, and an ellipsis
+  // in each cell. Never trade a missing label for a shorter modal.
+  const widestLabel = Math.max(0, ...entries.map(({ label }) => visibleWidth(label)));
+  const readableCellWidth = widestLabel + 2 + 28 + 1;
+  const columns = entries.length >= 40 && width >= 100
+    ? Math.max(1, Math.floor(width / (readableCellWidth + 1)))
+    : 1;
   const columnWidth = Math.floor(width / columns);
   const commandLines: string[] = [];
   for (let start = 0; start < entries.length; start += columns) {
-    const cells = entries.slice(start, start + columns).map(({ name, description }) => {
+    const cells = entries.slice(start, start + columns).map(({ label, description }) => {
       const cellWidth = columnWidth - (columns > 1 ? 1 : 0);
-      if (visibleWidth(`/${name}  `) > cellWidth) return '';
-      return fitLine(`/${name}  ${description}`, cellWidth);
+      return visibleWidth(`${label}  `) > cellWidth ? '' : fitLine(`${label}  ${description}`, cellWidth);
     });
     commandLines.push(cells.map((cell, index) =>
       index === cells.length - 1 ? cell : cell + ' '.repeat(columnWidth - visibleWidth(cell)),
     ).join('').trimEnd());
   }
-  return [
-    fitLine('Commands', width),
-    ...commandLines,
-    '',
-    fitLine('Keys', width),
-    ...ESSENTIAL_KEYS.map(([key, description]) => fitLine(`${key}  ${description}`, width)),
-  ];
+  const keyItems = ESSENTIAL_KEYS.map(([key, description]) => `${key}  ${description}`);
+  const keyLines: string[] = [];
+  if (entries.length >= 40 && width >= 100) {
+    let keyRow = '';
+    for (const item of keyItems) {
+      if (keyRow && visibleWidth(keyRow) + 2 + visibleWidth(item) > width) {
+        keyLines.push(keyRow);
+        keyRow = '';
+      }
+      keyRow += (keyRow ? '  ' : '') + fitLine(item, width);
+    }
+    if (keyRow) keyLines.push(keyRow);
+  } else {
+    keyLines.push(...keyItems.map((item) => fitLine(item, width)));
+  }
+  return [fitLine('Commands', width), ...commandLines, '', fitLine('Keys', width), ...keyLines];
 }

package/src/decisions/decision-cards.ts

@@ -6,9 +6,10 @@
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { debug } from '../debug/log.js';
+import { readPendingQuestions } from '../ask-user-question/pending-questions.js';
 import { DecisionLedger, type DecisionEntry } from './decision-ledger.js';
 
-export type CardPlatform = 'telegram' | 'discord';
+export type CardPlatform = 'telegram' | 'discord' | 'webpush';
 export interface CardButton { label: string; data: string }
 export interface CardView { text: string; buttons: CardButton[][] }
 export interface CardRef { chat: string; message: string }
@@ -42,6 +43,7 @@ export function renderCardText(e: DecisionEntry, extra: { note?: string; confirm
     '',
     `상황: ${e.scqa.s}`,
     `문제: ${e.scqa.c}`,
+    ...(e.pendingQuestion ? ['', `대기 질문 전문:\n${e.pendingQuestion}`] : []),
     ...(e.scqa.q ? [`질문: ${e.scqa.q}`] : []),
     ...(e.scqa.a ? [`제안: ${e.scqa.a}`] : []),
     '',
@@ -99,6 +101,7 @@ export interface DecisionCardServiceOptions {
   /** Owner user ids for this platform — taps from anyone else are refused and observed. */
   ownerIds: readonly string[];
   ledger?: DecisionLedger;
+  pendingQuestions?: typeof readPendingQuestions;
   /** Where this platform keeps which card it sent (one file per platform — the two bots may run in different processes). */
   statePath?: string;
   now?: () => Date;
@@ -149,6 +152,53 @@ export class DecisionCardService {
     }
     let dirty = false;
     if (!state.since) { state.since = this.now().toISOString(); dirty = true; debug.log('decisions.telegram', 'baseline', { platform, since: state.since }); }
+    // Same state root as the ledger — the H2 answer writer delivers under the ledger's stateDir, so the questions are read there too.
+    const pending = this.opts.pendingQuestions ? this.opts.pendingQuestions() : readPendingQuestions({ root: () => join(this.ledger.path, '..', '..') });
+    if (pending.ok) {
+      const seen = new Set(all.flatMap(entry => entry.resume ? [entry.resume.questionId] : []));
+      for (const record of pending.questions) {
+        for (const question of record.questions) {
+          const data = { questionId: record.id, runId: record.runId };
+          if (record.expiresAt && record.expiresAt <= this.now().toISOString()) {
+            debug.log('hitl.card-bridge', 'skipped', { ...data, reason: 'expired' });
+            continue;
+          }
+          if (question.impact !== 'high' && question.impact !== 'critical') {
+            debug.log('hitl.card-bridge', 'skipped', { ...data, reason: 'impact' });
+            continue;
+          }
+          if (record.questions.length !== 1 || question.options.length < 2 || question.options.length > 4) {
+            debug.log('hitl.card-bridge', 'skipped', { ...data, reason: 'options' });
+            continue;
+          }
+          if (seen.has(record.id)) {
+            debug.log('hitl.card-bridge', 'dedup', { ...data, decisionId: all.find(entry => entry.resume?.questionId === record.id)?.id, reason: 'already-raised' });
+            continue;
+          }
+          try {
+            const keys = ['a', 'b', 'c', 'd'];
+            const recommended = question.recommendedIndex;
+            const entry = this.ledger.raise({
+              title: question.question.split(/\r?\n/, 1)[0]!.slice(0, 120),
+              category: question.impact === 'critical' ? 'irreversible' : 'scope',
+              scqa: { s: Array.from(question.question.split(/\r?\n/, 1)[0]!).slice(0, 200).join(''), c: 'The requesting run is waiting for this choice.' },
+              pendingQuestion: question.question,
+              options: question.options.map((option, index) => ({ key: keys[index]!, label: option.label, consequence: option.description })),
+              recommendation: recommended !== undefined && Number.isInteger(recommended) && recommended >= 0 && recommended < question.options.length
+                ? { option: keys[recommended]!, why: '런이 추천' } : { skipped: true, reason: '추천 없음' },
+              raisedBy: { agent: 'harness' },
+              resume: { questionId: record.id, ...(record.runId === undefined ? {} : { runId: record.runId }) },
+              ...(record.expiresAt ? { dueAt: record.expiresAt } : {}),
+            });
+            seen.add(record.id);
+            all.unshift(entry);
+            debug.log('hitl.card-bridge', 'raised', { ...data, decisionId: entry.id });
+          } catch (error) {
+            debug.log('hitl.card-bridge', 'skipped', { ...data, reason: error instanceof Error ? error.name : 'unknown' });
+          }
+        }
+      }
+    } else debug.log('hitl.card-bridge', 'skipped', { reason: 'pending-unreadable' });
     const chats = await this.opts.transport.ownerChats().catch(() => [] as string[]);
     for (const e of all) {
       const card = state.cards[e.id];
@@ -203,9 +253,12 @@ export class DecisionCardService {
       return { kind: 'confirm', view: renderCard(entry, { confirm: parsed.key, ...(card?.note ? { note: card.note } : {}) }), toast: '되돌릴 수 없는 결정 — 한 번 더 확인해 주세요' };
     }
     let decided: DecisionEntry;
+    let answerDelivery: ReturnType<DecisionLedger['decideWithDelivery']>['delivery'] = null;
     try {
       // Same ledger method the CLI `decide` uses — one record path.
-      decided = this.ledger.decide(entry.id, parsed.key, { kind: 'human' }, card?.note);
+      const recorded = this.ledger.decideWithDelivery(entry.id, parsed.key, { kind: 'human' }, card?.note);
+      decided = recorded.entry;
+      answerDelivery = recorded.delivery;
     } catch (error) {
       debug.log('decisions.telegram', 'decide-failed', { platform, id: entry.id, reason: error instanceof Error ? error.message.slice(0, 80) : 'unknown' }, { level: 'warn' });
       try { const now = this.ledger.show(entry.id); if (now.status !== 'open') return { kind: 'closed', view: renderCard(now), toast: '이미 정해진 결정입니다' }; } catch { /* fall through */ }
@@ -221,7 +274,9 @@ export class DecisionCardService {
     await this.opts.replyToRaiser?.(decided, platform).catch((error: unknown) => {
       debug.log('decisions.telegram', 'reply-failed', { platform, id: decided.id, reason: error instanceof Error ? error.message.slice(0, 80) : 'unknown' }, { level: 'warn' });
     });
-    return { kind: 'decided', view, toast: `결정했습니다: ${decided.choice?.toUpperCase()}` };
+    return { kind: 'decided', view, toast: answerDelivery && !answerDelivery.ok
+      ? `결정은 기록됐지만 런 답 전달 실패 — decisions retry-answer ${decided.id}`
+      : `결정했습니다: ${decided.choice?.toUpperCase()}` };
   }
 
   /** Store a memo typed after «메모 달기»; the card shows it and the eventual decision carries it. */

package/src/decisions/decision-ledger.ts

@@ -1,12 +1,14 @@
 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';
 
 export type DecisionCategory = 'secret' | 'publish' | 'money' | 'security' | 'scope' | 'irreversible' | 'other';
-export type DecisionTrack = 'S' | 'T' | 'F' | 'O';
+/** Old track letters (S·T·F·O) stay readable; seat names (OP·MK·TC·UX) are the current identities. */
+export type DecisionTrack = 'S' | 'T' | 'F' | 'O' | 'OP' | 'MK' | 'TC' | 'UX';
 export interface DecisionOption { key: string; label: string; consequence: string }
 export type Recommendation = { option: string; why: string } | { skipped: true; reason: string };
 export type DecisionActor = { kind: 'human' } | { kind: 'auto'; agent: string; track?: DecisionTrack; delegation: string };
@@ -15,17 +17,31 @@ 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 };
+  /** Original pending question, including its newlines; SCQA fields are short summaries. */
+  pendingQuestion?: 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' | 'pendingQuestion'> & { 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'];
+const TRACKS: readonly string[] = ['S', 'T', 'F', 'O', 'OP', 'MK', 'TC', 'UX'];
 
 function required(value: string, name: string): string {
   if (typeof value !== 'string' || !value.trim()) throw new Error(`${name} is required`);
@@ -73,7 +89,13 @@ 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}|execution:[A-Za-z0-9_-]+:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?![\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;
+  if (input.pendingQuestion !== undefined) required(input.pendingQuestion, 'pending question');
   return { ...input, title, scqa: { s, c, ...(q ? { q } : {}), ...(a ? { a } : {}) }, options, recommendation,
+    ...(input.pendingQuestion === undefined ? {} : { pendingQuestion: safe(input.pendingQuestion) }),
+    ...(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 +105,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 +222,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 +244,55 @@ 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');
+      if (questionId.startsWith('execution:') && (!runId || target.runId !== runId || !questionId.startsWith(`execution:${runId}:`))) throw new Error('pending question run differs from decision');
+      if (!questionId.startsWith('execution:') && runId !== undefined && target.runId !== undefined && target.runId !== runId) throw new Error('pending question run differs from decision');
+      if (target.expiresAt && Date.parse(target.expiresAt) <= this.now().getTime()) throw new Error('pending question expired');
+      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]: questionId.startsWith('execution:') ? label : `${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/sprint21-runtime.ts

@@ -21,6 +21,7 @@
 //   ⏳ Mention parser → persona LLM dispatch wire
 
 import { debug } from '../debug/log.js';
+import { botAudienceFor, gateDiscordSchemas } from '../maturity/bot-command-maturity.js';
 import type { DiscordBot } from '../discord.js';
 import {
   loadLayeredPersonaDirs,
@@ -204,7 +205,10 @@ export async function wireSprint21Runtime(opts: WireSprint21Opts): Promise<Sprin
   // 6. Slash command registration
   const cmdRest = makeCommandRest({ token: opts.token, fetchImpl: opts.fetchImpl });
   async function registerSlashCommands(): Promise<number> {
-    const schemas = router.schemas();
+    const allSchemas = router.schemas();
+    const audience = botAudienceFor('discord');
+    const { schemas, hidden } = gateDiscordSchemas(allSchemas, audience);
+    debug.log('discord.command', 'menu-filtered', { total: allSchemas.length, shown: schemas.length - hidden, ...audience });
     if (opts.devGuildId) {
       const out = await cmdRest.bulkOverwriteGuild(opts.appId, opts.devGuildId, schemas);
       log(`[sprint21-wire] registered ${out.length} slash commands to guild ${opts.devGuildId}`);