elanous 0.2.8 → 0.2.10

package/src/dashboard/provider-slash-runtime.ts

@@ -8,7 +8,7 @@ export interface DashboardProviderRotationEntryView {
 export interface DashboardProviderAvailabilityView {
   available: boolean;
   name: string;
-  model: string;
+  model: string | undefined;
 }
 
 export interface DashboardProviderSlashRuntimeDeps {
@@ -31,6 +31,7 @@ export interface DashboardProviderSlashRuntime {
   overviewLines(
     rotationEntries: readonly DashboardProviderRotationEntryView[],
     providers: readonly DashboardProviderAvailabilityView[],
+    catalogModelIds?: ReadonlySet<string>,
   ): string[];
 }
 
@@ -48,25 +49,41 @@ export function createDashboardProviderSlashRuntime(
     switchedLine: (label, provider, model) => deps.success(`  ✓ switched → ${label}  (${providerDetail(provider, model)})`),
     resetEmptyLine: () => deps.warning('  rotation empty — nothing to reset'),
     resetLine: (label) => deps.success(`  ✓ reset → ${label}`),
-    overviewLines: (rotationEntries, providers) => {
+    overviewLines: (rotationEntries, providers, catalogModelIds) => {
       const lines = ['', deps.accent('\u276f /provider')];
       if (rotationEntries.length > 0) {
-        lines.push(deps.muted('  Rotation (cycle with `/provider next` or `/provider use <label>`):'));
+        lines.push(deps.muted('  회전(바꾸기: /provider next · /provider use <이름>)'));
         for (const entry of rotationEntries) {
           const marker = entry.current ? deps.success('▸') : ' ';
-          lines.push(`  ${marker} ${entry.label.padEnd(14)} ${deps.subtext(entry.provider)}  ${deps.muted(entry.model)}`);
+          const missing = catalogModelIds && entry.model !== '(provider default)' && !catalogModelIds.has(entry.model)
+            ? deps.muted(' · 목록에 없는 모델 — /provider use 로 바꾸기')
+            : '';
+          lines.push(`  ${marker} ${entry.label.padEnd(14)} ${deps.subtext(entry.provider)}  ${deps.muted(entry.model)}${missing}`);
         }
         lines.push('');
       }
-      lines.push(deps.muted('  Available providers (env-detected):'));
+      lines.push(deps.muted('  쓸 수 있는 공급자'));
+      // PROVIDERS has anthropic, not claude; collapse the legacy claude display alias.
+      const canonicalName = (name: string): string => {
+        const lower = name.toLowerCase();
+        return lower === 'claude' ? 'anthropic' : lower;
+      };
+      const unique = new Map<string, DashboardProviderAvailabilityView>();
       for (const provider of providers) {
-        const mark = provider.available ? deps.success('\u2713') : deps.muted('\u00B7');
-        const label = provider.available ? deps.text(provider.name) : deps.muted(provider.name);
-        const hint = !provider.available
-          ? deps.muted(`  (set ${provider.name.toUpperCase()}_API_KEY${provider.name === 'local' ? ' or LOCAL_LLM_URL' : ''})`)
-          : '';
-        lines.push(`  ${mark} ${label.padEnd(20)} ${deps.subtext(provider.model)}${hint}`);
+        const key = canonicalName(provider.name);
+        const previous = unique.get(key);
+        if (!previous || (!previous.available && provider.available) || (key === provider.name && previous.name !== key && previous.available === provider.available)) {
+          unique.set(key, provider);
+        }
+      }
+      let unavailable = 0;
+      for (const provider of unique.values()) {
+        if (!provider.available) { unavailable++; continue; }
+        lines.push(`  ${deps.success('\u2713')} ${deps.text(provider.name).padEnd(20)} ${deps.subtext(provider.model ?? '')}`);
       }
+      if (unavailable > 0) lines.push(deps.muted(`  그 밖 ${unavailable}개는 키·로그인 필요 — elanous setup llm`));
+      // Keep the old English search terms as a subordinate hint, not section headings.
+      lines.push(deps.muted('  · Rotation (cycle with /provider next) · Available providers'));
       return lines;
     },
   };

package/src/dashboard/slash-runtime/dashboard-handlers.ts

@@ -301,6 +301,7 @@ import {
 import type { LLMProviderName } from '../../user-config.js';
 import { lookupLlmTierSpec } from '../../model-tier/index.js';
 import { listProviders } from '../../llm.js';
+import { enabledModels, loadCatalog } from '../../intelligence-map/model-catalog.js';
 import { selfOrchestrateRuntime } from '../../self-dev/self-orchestrate-runtime.js';
 import type { ToolRuntime } from '../../tool-runtime/types.js';
 import { getSessionCwd } from '../../session/working-dir.js';
@@ -742,6 +743,7 @@ export interface DashboardSlashContext {
       overviewLines(
         rotation: readonly { label: string; provider: string; model: string; current: boolean }[],
         providers: readonly { available: boolean; name: string; model: string | undefined }[],
+        catalogModelIds?: ReadonlySet<string>,
       ): readonly string[];
     };
     /** 2026-05-05 — open the visual model picker programmatically.
@@ -3993,6 +3995,13 @@ export function buildDashboardSlashRegistry(): SlashCommandRegistry<DashboardSla
     }
 
     if (seSub === 'new' || seSub === 'clear') {
+      if (seSub === 'new') {
+        try {
+          const { suggestProjectForFolder } = await import('../../project/project-store.js');
+          const project = suggestProjectForFolder(process.cwd());
+          if (project) ctx.chatLines.push(ctx.muted(`  Project suggestion: ${project.name} (${project.id})`));
+        } catch { /* suggestions must not interrupt a new conversation */ }
+      }
       // Clear the in-memory history and detach if attached. Doesn't
       // delete any session files — those stay on disk for
       // /session list to enumerate.
@@ -5281,6 +5290,13 @@ export function buildDashboardSlashRegistry(): SlashCommandRegistry<DashboardSla
     const cfgNow = getUserConfig();
     const rot = cfgNow.llm.rotation;
     const curIdx = rot && rot.length > 0 ? currentRotationIndex(cfgNow) : -1;
+    let catalogModelIds: Set<string> | undefined;
+    try {
+      const loaded = loadCatalog();
+      if (loaded.source !== 'fallback') {
+        catalogModelIds = new Set(enabledModels(loaded.catalog).map((model) => model.id));
+      }
+    } catch { /* catalog unreadable: no stale-model verdict */ }
     ctx.chatLines.push(...ctx.provider.slashRuntime.overviewLines(
       (rot ?? []).map((entry, index) => ({
         label: rotationEntryLabel(entry),
@@ -5293,6 +5309,7 @@ export function buildDashboardSlashRegistry(): SlashCommandRegistry<DashboardSla
         name: provider.name,
         model: provider.model,
       })),
+      catalogModelIds,
     ));
     const currentRoute = currentRouteDecision('dashboard');
     if (currentRoute) ctx.chatLines.push(ctx.muted(`  current route: ${formatRouteDecisionSummary(currentRoute)}`));

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/dashboard/turn-stream-formatter.ts

@@ -236,7 +236,7 @@ export function createTurnStreamFormatter(
     },
     onToolCall(call: TurnStreamCall): void {
       toolCallCount += 1;
-      deps.thinking.update(`Streaming ${call.name} (${toolCallCount} tools)`);
+      deps.thinking.update(`Streaming ${call.name} (${toolCallCount} ${toolCallCount === 1 ? 'tool' : 'tools'})`);
       const ptyLine = deps.ptyCallLine(call.name, call.args);
       if (ptyLine) {
         nonGenericCallIds.add(call.id);

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 }
@@ -99,6 +100,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 +151,52 @@ 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: question.question, c: 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];
@@ -277,7 +325,7 @@ export function ghPrReplier(target: string, run: (args: string[], stdin: string)
 
 /** Post as the automation App (not the machine's personal gh login — that would make 대표 a participant and mail them),
  *  with proxy variables removed (they break gh on the ops host). TC review #22660. */
-async function runGh(args: string[], stdin: string): Promise<number> {
+export async function runGh(args: string[], stdin: string): Promise<number> {
   const env: Record<string, string> = {};
   for (const [k, v] of Object.entries(process.env)) if (v !== undefined && !/^(https?|all|no)_proxy$/i.test(k)) env[k] = v;
   try {

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); }
+  }
+}