elanous 0.2.9 → 0.2.10

package/src/connectors/linear.ts

@@ -122,6 +122,152 @@ export async function fetchLinearIssues({ apiKey, teamKey, labelOrPrefix, since,
   return events.sort((a, b) => PRIORITY_RANK[a.priority ?? 'none'] - PRIORITY_RANK[b.priority ?? 'none']);
 }
 
+export interface LinearProjectIssue {
+  identifier: string;
+  title: string;
+  url: string;
+  state: { name: string; type: string };
+  dueDate: string | null;
+  priority: number;
+  assignee: { name: string } | null;
+  updatedAt: string;
+}
+
+type LinearRequestOptions = { apiKey: string; fetch?: typeof fetch };
+
+async function linearRequest<T>({ apiKey, fetch: fetchFn = fetch }: LinearRequestOptions, query: string, variables: Record<string, unknown>): Promise<T> {
+    let response: Response;
+    try {
+      response = await fetchFn('https://api.linear.app/graphql', {
+        method: 'POST', headers: { Authorization: apiKey, 'Content-Type': 'application/json' },
+        body: JSON.stringify({ query, variables }),
+      });
+    } catch (error) {
+      throw new Error(`Linear GraphQL request failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!response.ok) throw new Error(`Linear GraphQL HTTP ${response.status}`);
+    let body: { data?: T; errors?: Array<{ message?: string }> };
+    try { body = await response.json() as typeof body; }
+    catch { throw new Error('Linear GraphQL invalid JSON response'); }
+    if (body.errors?.length) throw new Error(`Linear GraphQL: ${body.errors.map(e => e.message ?? 'unknown error').join('; ')}`);
+    if (!body.data) throw new Error('Linear GraphQL missing data');
+    return body.data;
+}
+
+/** Shared unique name → project id lookup for COO reads and decision writes. */
+export async function resolveLinearProjectId({ apiKey, project, fetch: fetchFn = fetch }: LinearRequestOptions & { project: string }): Promise<string> {
+  const cursors = new Set<string>();
+  let projectId = project;
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(project)) {
+    const matches: string[] = [];
+    let after: string | null = null;
+    do {
+      const data: { projects?: { nodes?: Array<{ id: string; name: string }>; pageInfo?: { hasNextPage: boolean; endCursor: string | null } } } = await linearRequest({ apiKey, fetch: fetchFn },
+        `query CooProjects($after: String) { projects(first: 100, after: $after) { nodes { id name } pageInfo { hasNextPage endCursor } } }`, { after });
+      if (!Array.isArray(data.projects?.nodes)) throw new Error('Linear GraphQL missing projects');
+      for (const candidate of data.projects.nodes) if (candidate.name === project) matches.push(candidate.id);
+      const page = data.projects.pageInfo;
+      if (page?.hasNextPage && (!page.endCursor || cursors.has(page.endCursor))) throw new Error('Linear GraphQL pagination cursor missing or repeated');
+      after = page?.hasNextPage ? page.endCursor : null;
+      if (after) cursors.add(after);
+    } while (after);
+    if (matches.length > 1) throw new Error('프로젝트 이름이 여럿과 맞습니다');
+    if (!matches.length) throw new Error('프로젝트 이름과 맞는 항목이 없습니다');
+    projectId = matches[0]!;
+  }
+  return projectId;
+}
+
+/** Read-only project lookup. A name is resolved uniquely before querying its issues. */
+export async function fetchLinearProjectIssues({ apiKey, project, includeDone = false, fetch: fetchFn = fetch }: {
+  apiKey: string; project: string; includeDone?: boolean; fetch?: typeof fetch;
+}): Promise<LinearProjectIssue[] & { truncated: boolean }> {
+  const projectId = await resolveLinearProjectId({ apiKey, project, fetch: fetchFn });
+  const issues: LinearProjectIssue[] = [];
+  const cursors = new Set<string>();
+  let after: string | null = null;
+  do {
+    const stateFilter = includeDone ? '' : ', state: { type: { nin: ["completed", "canceled"] } }';
+    const data: { issues?: { nodes?: LinearProjectIssue[]; pageInfo?: { hasNextPage: boolean; endCursor: string | null } } } = await linearRequest({ apiKey, fetch: fetchFn },
+      `query CooProjectIssues($projectId: ID!, $after: String, $first: Int!) {
+        issues(filter: { project: { id: { eq: $projectId } }${stateFilter} }, first: $first, after: $after) {
+          nodes { identifier title url state { name type } dueDate priority assignee { name } updatedAt }
+          pageInfo { hasNextPage endCursor }
+        }
+      }`, { projectId, after, first: Math.min(100, 250 - issues.length) });
+    if (!Array.isArray(data.issues?.nodes)) throw new Error('Linear GraphQL missing issues');
+    for (const node of data.issues.nodes) {
+      if (!includeDone && (node.state?.type === 'completed' || node.state?.type === 'canceled')) continue;
+      if (issues.length < 250) issues.push(node);
+    }
+    const page = data.issues.pageInfo;
+    if (page?.hasNextPage && (!page.endCursor || cursors.has(page.endCursor))) throw new Error('Linear GraphQL pagination cursor missing or repeated');
+    after = page?.hasNextPage ? page.endCursor : null;
+    if (after) cursors.add(after);
+  } while (after && issues.length < 250);
+  Object.defineProperty(issues, 'truncated', { value: after !== null, enumerable: false });
+  return issues as LinearProjectIssue[] & { truncated: boolean };
+}
+
+/** Find a previously created decision issue after a crash between Linear creation and the local rename. */
+export async function findLinearDecisionIssue({ apiKey, projectId, decisionId, fetch: fetchFn = fetch }: LinearRequestOptions & { projectId: string; decisionId: string }): Promise<string | null> {
+  const cursors = new Set<string>();
+  let after: string | null = null;
+  let match: string | null = null;
+  do {
+    const data: { issues?: { nodes?: Array<{ id: string; description: string | null }>; pageInfo?: { hasNextPage: boolean; endCursor: string | null } } } = await linearRequest({ apiKey, fetch: fetchFn },
+      'query DecisionIssue($projectId: ID!, $decisionId: String!, $after: String) { issues(filter: { project: { id: { eq: $projectId } }, description: { contains: $decisionId } }, first: 100, after: $after) { nodes { id description } pageInfo { hasNextPage endCursor } } }',
+      { projectId, decisionId, after });
+    if (!Array.isArray(data.issues?.nodes)) throw new Error('Linear GraphQL missing issues');
+    for (const node of data.issues.nodes) {
+      if (!node.description?.split('\n').includes(`결정 id: ${decisionId}`)) continue;
+      if (match) throw new Error('Linear decision issue duplicated');
+      match = node.id;
+    }
+    const page = data.issues.pageInfo;
+    if (page?.hasNextPage && (!page.endCursor || cursors.has(page.endCursor))) throw new Error('Linear GraphQL pagination cursor missing or repeated');
+    after = page?.hasNextPage ? page.endCursor : null;
+    if (after) cursors.add(after);
+  } while (after);
+  return match;
+}
+
+/** Create in the COO project; Linear requires a team from that project for issueCreate. */
+export async function createLinearIssue({ apiKey, projectId, title, description, dueDate, fetch: fetchFn = fetch }: LinearRequestOptions & {
+  projectId: string; title: string; description: string; dueDate?: string;
+}): Promise<string> {
+  const data = await linearRequest<{ project?: { teams?: { nodes?: Array<{ id: string }> } } }>({ apiKey, fetch: fetchFn },
+    'query DecisionProjectTeam($id: String!) { project(id: $id) { teams { nodes { id } } } }', { id: projectId });
+  const teams = data.project?.teams?.nodes;
+  if (!teams?.[0]?.id) throw new Error('Linear project has no team');
+  const created = await linearRequest<{ issueCreate?: { success?: boolean; issue?: { id?: string } } }>({ apiKey, fetch: fetchFn },
+    'mutation DecisionIssueCreate($input: IssueCreateInput!) { issueCreate(input: $input) { success issue { id } } }',
+    { input: { teamId: teams[0].id, projectId, title, description, ...(dueDate ? { dueDate } : {}) } });
+  const id = created.issueCreate?.issue?.id;
+  if (!created.issueCreate?.success || !id) throw new Error('Linear issueCreate did not return an issue id');
+  return id;
+}
+
+export async function commentLinearIssue({ apiKey, issueId, body, fetch: fetchFn = fetch }: LinearRequestOptions & { issueId: string; body: string }): Promise<void> {
+  const data = await linearRequest<{ commentCreate?: { success?: boolean; comment?: { id?: string } } }>({ apiKey, fetch: fetchFn },
+    'mutation DecisionComment($input: CommentCreateInput!) { commentCreate(input: $input) { success comment { id } } }',
+    { input: { issueId, body } });
+  if (!data.commentCreate?.success || !data.commentCreate.comment?.id) throw new Error('Linear commentCreate failed');
+}
+
+export async function moveLinearIssueToStateType({ apiKey, issueId, type, fetch: fetchFn = fetch }: LinearRequestOptions & {
+  issueId: string; type: 'completed' | 'canceled';
+}): Promise<void> {
+  const data = await linearRequest<{ issue?: { team?: { states?: { nodes?: Array<{ id: string; type: string }> } } } }>({ apiKey, fetch: fetchFn },
+    'query DecisionIssueStates($id: String!) { issue(id: $id) { team { states { nodes { id type } } } } }', { id: issueId });
+  const state = data.issue?.team?.states?.nodes?.find(node => node.type === type);
+  if (!state?.id) throw new Error(`Linear team workflow state not found: ${type}`);
+  const updated = await linearRequest<{ issueUpdate?: { success?: boolean } }>({ apiKey, fetch: fetchFn },
+    'mutation DecisionIssueClose($id: String!, $input: IssueUpdateInput!) { issueUpdate(id: $id, input: $input) { success } }',
+    { id: issueId, input: { stateId: state.id } });
+  if (!updated.issueUpdate?.success) throw new Error('Linear issueUpdate failed');
+}
+
 export function toTaskRequest(event: ExternalTaskEvent): {
   title: string; description: string; priority: 'high' | 'medium' | 'low';
   external: { provider: 'linear'; ref: string; url?: string; team?: string };

package/src/context-bus/coord-events.ts

@@ -0,0 +1,115 @@
+import type { Database } from 'bun:sqlite';
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { debug, redactSecretText } from '../debug/log.js';
+import { openSurfaceEventsDb, recordEvent, surfaceEventsDbPath } from '../domains/surface-events.js';
+
+export interface CoordEventInput {
+  seat: string;
+  recipients: string[];
+  all: boolean;
+  kind: string | null;
+  slot: string | null;
+  deadline: string | null;
+  url: string | null;
+  headline: string;
+  at?: string;
+}
+
+export interface CoordEvent {
+  id: string;
+  at: string;
+  text: string;
+  summary: string;
+  kind: string;
+  refs: Pick<CoordEventInput, 'seat' | 'recipients' | 'all' | 'kind' | 'slot' | 'deadline' | 'url'>;
+}
+
+function seatIds(): Set<string> {
+  return new Set((JSON.parse(readFileSync(resolve(import.meta.dir, '../../scripts/coord-tracks.json'), 'utf8')) as
+    { tracks: Array<{ id: string }> }).tracks.map((track) => track.id));
+}
+const kinds = new Set(['요청', '결정', '사고', '보고', '정정']);
+
+/** Mirror the sender's ordered envelope fields; only the first line enters this parser. */
+export function parseCoordHeader(seat: string, header: string): Omit<CoordEventInput, 'url' | 'at'> {
+  const first = header.split(/\r?\n/, 1)[0] ?? '';
+  if (!first.startsWith(`**[${seat}]**`)) throw new Error('조율 글 신원 접두 불일치');
+  const headline = first.slice(`**[${seat}]**`.length)
+    .replace(/^\s*(?:📌안내\s*)?\d{4}-\d\d-\d\d\s+\d\d:\d\d\s+KST\s*/, '').trim();
+  const headerBody = first.slice(`**[${seat}]**`.length);
+  const arrow = headerBody.indexOf('→');
+  const envelope = arrow >= 0 && !headerBody.slice(0, arrow).includes(' · ') ? headerBody.slice(arrow + 1).trim() : '';
+  const fields = envelope ? envelope.split(' · ') : [];
+  const ids = seatIds();
+  const recipients: string[] = [];
+  let all = false;
+  let i = 0;
+  for (; i < fields.length; i++) {
+    const field = fields[i]!.trim().split(' — ')[0]!;
+    const tokens = field.replaceAll(',', ' ').split(/\s+/).filter(Boolean);
+    if (!tokens.length || !tokens.every((t) => t === '전원' || ids.has(t))) break;
+    for (const token of tokens) {
+      if (token === '전원') all = true;
+      else recipients.push(token);
+    }
+    if (fields[i]!.includes(' — ')) { i++; break; }
+  }
+  const candidate = fields[i]?.trim() ?? '';
+  const kind = kinds.has(candidate) ? candidate : null;
+  const slot = fields[i + 1]?.trim() || null;
+  const deadline = fields.slice(i + 1).map((f) => f.trim()).find((f) => /^기한\s+\S/.test(f)) ?? null;
+  return { seat, recipients, all, kind, slot, deadline, headline };
+}
+
+/** Atomic lookup+insert makes retries safe, including URL-less posts in the same minute. */
+export function recordCoordEvent(input: CoordEventInput, deps: { db?: Database } = {}): string {
+  const hasUrl = !!input.url;
+  let db: Database | undefined;
+  try {
+    db = deps.db ?? openSurfaceEventsDb();
+    const at = input.at ?? new Date().toISOString();
+    const first = input.headline.split(/\r?\n/, 1)[0] ?? '';
+    const withoutPrefix = first.replace(/^\*\*\[[A-Z]+\]\*\*\s*/, '')
+      .replace(/^(?:📌안내\s*)?\d{4}-\d\d-\d\d\s+\d\d:\d\d\s+KST\s*/, '');
+    const headline = redactSecretText(withoutPrefix).trim().slice(0, 120);
+    const safe = (value: string) => redactSecretText(value.split(/\r?\n/, 1)[0] ?? '');
+    const refs = { seat: safe(input.seat), recipients: input.recipients.map(safe), all: input.all,
+      kind: input.kind === null ? null : safe(input.kind), slot: input.slot === null ? null : safe(input.slot),
+      deadline: input.deadline === null ? null : safe(input.deadline), url: input.url ? safe(input.url) : null };
+    const result = db.transaction(() => {
+      const prior = (refs.url
+        ? db!.prepare(`SELECT id FROM events WHERE surface='coord:channel' AND json_extract(refs,'$.url')=? LIMIT 1`).get(refs.url)
+        : db!.prepare(`SELECT id FROM events WHERE surface='coord:channel' AND json_extract(refs,'$.url') IS NULL
+            AND json_extract(refs,'$.seat')=? AND summary=? AND substr(ts,1,16)=? LIMIT 1`)
+          .get(refs.seat, headline, at.slice(0, 16))) as { id: string } | null;
+      if (prior) return { id: prior.id, dedup: true };
+      return { id: recordEvent(db!, { surface: 'coord:channel', direction: 'outbound', kind: refs.kind ?? 'unknown',
+        domain: 'elanous', category: 'coordination', text: headline, summary: headline,
+        refs: JSON.stringify(refs), ts: at }), dedup: false };
+    }).immediate();
+    try { debug.log('context.coord', result.dedup ? 'dedup' : 'recorded', { seat: refs.seat, kind: refs.kind, hasUrl }); }
+    catch { /* observation cannot turn a successful write into a failed send */ }
+    return result.id;
+  } catch (error) {
+    try { debug.log('context.coord', 'failed', { seat: redactSecretText(input.seat), kind: input.kind && redactSecretText(input.kind), hasUrl }); }
+    catch { /* preserve the original write error */ }
+    throw error;
+  } finally { if (!deps.db) db?.close(); }
+}
+
+/** Read-only chronological list; a missing store is an empty ledger, not a newly created one. */
+export function listCoordEvents(opts: { since: string; seat?: string }, deps: { db?: Database } = {}): CoordEvent[] {
+  if (!deps.db && !existsSync(surfaceEventsDbPath())) return [];
+  const db = deps.db ?? openSurfaceEventsDb();
+  try {
+    const rows = db.prepare(`SELECT id, ts, text, summary, kind, refs FROM events
+      WHERE surface='coord:channel' AND direction='outbound' AND ts>=?
+      ${opts.seat ? "AND json_extract(refs,'$.seat')=?" : ''} ORDER BY ts ASC, rowid ASC`)
+      .all(...(opts.seat ? [opts.since, opts.seat] : [opts.since])) as Array<{
+        id: string; ts: string; text: string; summary: string; kind: string; refs: string;
+      }>;
+    return rows.map((r) => ({ id: r.id, at: r.ts, text: r.text, summary: r.summary, kind: r.kind,
+      refs: JSON.parse(r.refs) as CoordEvent['refs'] }));
+  } finally { if (!deps.db) db.close(); }
+}

package/src/dashboard/dashboard-boot-fixture.ts

@@ -0,0 +1,23 @@
+import { showDashboard } from './index.js';
+
+const expected = process.env.DASHBOARD_BOOT_SUGGESTION;
+if (!expected) throw new Error('DASHBOARD_BOOT_SUGGESTION is required');
+
+const originalWrite = process.stdout.write.bind(process.stdout);
+let screen = '';
+process.stdout.write = ((chunk: string | Uint8Array, ...args: unknown[]) => {
+  screen += typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8');
+  if (screen.includes(expected)) {
+    originalWrite(`FIRST_SCREEN_SUGGESTION=${expected}\n`);
+    process.exit(0);
+  }
+  return true;
+}) as typeof process.stdout.write;
+
+setTimeout(() => {
+  originalWrite(`FIRST_SCREEN_TIMEOUT=${screen.slice(-2000)}\n`);
+  process.exit(1);
+}, 20_000).unref();
+
+await showDashboard();
+throw new Error('dashboard exited before suggestion appeared');

package/src/dashboard/index.ts

@@ -17,6 +17,7 @@ import type { CommandRunner } from '../ad-pipeline/higgsfield-backend.js';
 import type { ShootRunOptions } from '../ad-pipeline/shoot-run.js';
 import type { QcThresholds } from '../ad-pipeline/qc.js';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { suggestProjectForFolder } from '../project/project-store.js';
 
 const dashboardDefaultShootRunOptions: Required<Pick<ShootRunOptions, 'pollIntervalMs' | 'maxPollsPerJob' | 'submitStaggerMs'>> = {
   pollIntervalMs: 3_000,
@@ -425,7 +426,6 @@ import {
   renderTurnTypeaheadEcho,
 } from '../chat/turn-typeahead.js';
 import { dispatchStreamingTurnTypeaheadSubmission } from './input/streaming-turn-typeahead.js';
-import { wireDashboardTurnTypeaheadEcho } from './turn-typeahead-echo.js';
 import { composeVertical, type LayoutZone } from '../layout/composer.js';
 import type { CoreTurnDispatchTool } from '../core-turn/index.js';
 // streamGrok kept as back-compat shim in chat.ts — not imported here
@@ -2656,6 +2656,41 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     }
     chatScrollOffset = -1;
   };
+  const liveTypeaheadEchoes: { at: number; lines: string[] }[] = [];
+  const restoreLiveTypeaheadEchoes = (): void => {
+    let after = 0;
+    for (const echo of liveTypeaheadEchoes) {
+      let found = -1;
+      for (let i = after; i <= chatLines.length - echo.lines.length; i++) {
+        if (echo.lines.every((line, offset) => chatLines[i + offset] === line)) {
+          found = i;
+          break;
+        }
+      }
+      if (found < 0) {
+        found = Math.max(after, Math.min(echo.at, chatLines.length));
+        chatLines.splice(found, 0, ...echo.lines);
+      }
+      echo.at = found;
+      after = found + echo.lines.length;
+    }
+  };
+  const echoSubmittedUserText = (text: string, opts?: { live?: boolean }): void => {
+    const echoStart = chatLines.length;
+    chatLines.push('');
+    if (opts?.live) chatLines.push(C.muted('  ↳ 이어서'));
+    const echoWrapCols = Math.max(20, termSize().cols - 6);
+    const echoRows = wrapAnsiByWidth(`❯ ${text}`, echoWrapCols);
+    if (echoRows.length === 0) {
+      chatLines.push(C.accent('❯ '));
+    } else {
+      echoRows.forEach((row, i) => {
+        chatLines.push(C.accent(i === 0 ? row : `  ${row}`));
+      });
+    }
+    if (opts?.live) liveTypeaheadEchoes.push({ at: echoStart, lines: chatLines.slice(echoStart) });
+    chatScrollOffset = -1;
+  };
   const pushDebugLine = (line: string): void => {
     debugLines.push(line);
     const dropCount = trimLogBuffer(debugLines, DEBUG_LOG_BUFFER_SOFT_LIMIT);
@@ -6907,7 +6942,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             turnTypeaheadRef.state = r.state;
             if (r.submissionDisposition) {
               debug.log('dashboard.turn-typeahead', 'submission-classified', {
-                text: r.immediateSubmission ?? turnTypeaheadRef.state.queuedSubmissions.at(-1),
+                length: (r.immediateSubmission ?? turnTypeaheadRef.state.queuedSubmissions.at(-1))?.length ?? 0,
                 disposition: r.submissionDisposition,
               });
               // ⭐⭐⭐ `B3`(2026-08-19 · 대표 지시 ②) — FIFO 로 «턴 종료 후» 나가던 것을,
@@ -6934,6 +6969,11 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
                     // 배수된 만큼을 앞에서부터 떨어낸다(FIFO · 순서 보존).
                     const remaining = turnTypeaheadRef.state.queuedSubmissions.slice(drained.length);
                     turnTypeaheadRef.state = { ...turnTypeaheadRef.state, queuedSubmissions: remaining };
+                    for (const text of drained) {
+                      echoSubmittedUserText(text, { live: true });
+                      debug.log('dashboard.turn-typeahead', 'echoed', { path: 'live', length: text.length });
+                    }
+                    if (drained.length > 0) draw();
                     debug.log('dashboard.turn-typeahead', 'drained-into-live-turn', {
                       drained: drained.length, remaining: remaining.length,
                     });
@@ -15751,6 +15791,12 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
         chatLines.push(C.muted(`    ${resume.turns} turns restored. Next turn continues this conversation.`));
       }
     }
+    if (dashboardAcpBootResult.mode !== 'resumed' && !chat.history.some((message) => message.role !== 'system')) {
+      try {
+        const project = suggestProjectForFolder(process.cwd());
+        if (project) chatLines.push(C.muted(`  Project suggestion: ${project.name} (${project.id})`));
+      } catch { /* suggestions must not interrupt the dashboard conversation */ }
+    }
     chatScrollOffset = -1;
     void renderDashboardFirstScreenBand({
       history: chat.history,
@@ -16820,8 +16866,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
           lastTurnFinalStatus = undefined;
           turnTypeaheadRef.state = drained.state;
           nextInitial = drained.nextInitial;
-          const turnTypeaheadEcho = wireDashboardTurnTypeaheadEcho(drained);
-          if (turnTypeaheadEcho) chatLines.push(C.muted(turnTypeaheadEcho));
+          const queuedTurnEndText = drained.injectEnter ? drained.nextInitial : undefined;
           if (interrupted && queuedBeforeDrain > 0) {
             debug.log('dashboard.turn-typeahead', 'restored-after-interrupt', { count: queuedBeforeDrain });
           }
@@ -18655,25 +18700,11 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
           // pattern. Without this draw(), the echo sits in the chatLines
           // array but doesn't paint until after the skill router's
           // classifier LLM call returns (~1-2s of visual silence).
-          chatLines.push('');
-          // Wrap the echoed user message to the log width so long input
-          // soft-wraps onto continuation rows instead of being truncated
-          // with a `\u2026+N` marker by the log-pane renderer (which keeps a
-          // strict 1-line-per-row invariant and only truncates lines that
-          // weren't pre-wrapped). termCols-6 leaves room for the log
-          // pane's 2-col left margin plus the 2-col hanging indent on
-          // continuation rows; the \u276f marker stays on the first row only.
-          const echoWrapCols = Math.max(20, termSize().cols - 6);
-          const echoRows = wrapAnsiByWidth(`\u276f ${tok.text}`, echoWrapCols);
-          if (echoRows.length === 0) {
-            chatLines.push(C.accent('\u276f '));
-          } else {
-            echoRows.forEach((row, i) => {
-              chatLines.push(C.accent(i === 0 ? row : `  ${row}`));
-            });
+          echoSubmittedUserText(tok.text);
+          if (queuedTurnEndText !== undefined && input.text === queuedTurnEndText) {
+            debug.log('dashboard.turn-typeahead', 'echoed', { path: 'turn-end', length: queuedTurnEndText.length });
           }
           renderAttachmentSummary(tok.added);
-          chatScrollOffset = -1;
           draw();
 
           // Start the animated thinking indicator BEFORE the router so
@@ -19031,6 +19062,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             createTurnStreamRuntime: (initialAssistantStart) => {
               latestTurnUsage = undefined;
               createDashboardTurnStreamRuntimeEscBoundary(escAbortToolState);
+              liveTypeaheadEchoes.length = 0;
               const toolRendering = {
                 ...getUserConfig().chat.rendering.tool,
                 expandHint: false,
@@ -19070,6 +19102,11 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
               });
               return {
                 ...turnStreamRuntime,
+                onText: (chunk, accumulated) => {
+                  turnStreamRuntime.onText(chunk, accumulated);
+                  restoreLiveTypeaheadEchoes();
+                  draw();
+                },
                 onToolCall: (call) => {
                   const toolCall = call as DashboardTurnStreamCall;
                   trackEscAbortToolCall(escAbortToolState, toolCall);

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

@@ -3995,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.

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 }
@@ -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];