elanous 0.2.8 → 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/dashboard-status-lines.ts

@@ -0,0 +1,45 @@
+export interface DashboardStatusLinesInput {
+  readonly provider?: string | null;
+  readonly model?: string | null;
+  readonly reasoning?: string | null;
+  readonly daemonAddress?: string | null;
+  readonly daemonConnected: boolean;
+  readonly accountName?: string | null;
+  readonly sessionSurfaceLines: readonly string[];
+  readonly view: string;
+  readonly focus: string;
+  readonly cwd: string;
+  readonly preview: string;
+  readonly starterClosed: string;
+  readonly chatOnly: string;
+  readonly acp: string;
+}
+
+export function buildDashboardStatusLines(input: DashboardStatusLinesInput): string[] {
+  const known = (value?: string | null): string => value?.trim() || '모름';
+  // A remote URL can contain credentials or query parameters. Neither belongs in /status.
+  let address = '모름';
+  if (input.daemonAddress?.trim()) {
+    try {
+      const url = new URL(input.daemonAddress);
+      address = `${url.protocol}//${url.host}`;
+    } catch {
+      address = '모름';
+    }
+  }
+  return [
+    `모델: ${known(input.provider)}/${known(input.model)} (${known(input.reasoning)})`,
+    `연결: 데몬 ${address} ${input.daemonConnected ? '붙음' : '안 붙음'}`,
+    `계정: ${input.accountName?.trim() === 'default' ? '기본' : known(input.accountName)}`,
+    '',
+    '자세히',
+    ...input.sessionSurfaceLines.map(line => `  ${line}`),
+    `  view: ${input.view}`,
+    `  focus: ${input.focus}`,
+    `  cwd: ${input.cwd}`,
+    `  preview: ${input.preview}`,
+    `  starterClosed: ${input.starterClosed}`,
+    `  chatOnly: ${input.chatOnly}`,
+    `  acp: ${input.acp}`,
+  ];
+}

package/src/dashboard/first-screen-band.ts

@@ -0,0 +1,35 @@
+export interface FirstScreenBandInput {
+  readonly width: number;
+  readonly daemon: boolean;
+  readonly pwa?: {
+    readonly tailnet?: string | null;
+    readonly lan?: string | null;
+    readonly loopback?: string | null;
+  };
+}
+
+/** A startup transcript band; never includes credentials or a partial address. */
+export function buildFirstScreenBand(input: FirstScreenBandInput): string[] {
+  const width = Number.isFinite(input.width) ? Math.max(0, Math.floor(input.width)) : 0;
+  const fit = (text: string): string => text.slice(0, width);
+  const address = [input.pwa?.tailnet, input.pwa?.lan, input.pwa?.loopback]
+    .map((candidate) => {
+      if (!candidate) return null;
+      try {
+        const url = new URL(candidate);
+        if (!['http:', 'https:'].includes(url.protocol) || !url.hostname) return null;
+        return `${url.origin}${url.pathname === '/app/' ? '/app/' : ''}`;
+      } catch {
+        return null;
+      }
+    })
+    .find((candidate) => candidate !== null);
+  const fallback = input.pwa === undefined ? 'PWA: not checked' : 'PWA: unavailable';
+  const addressLine = address ? `PWA: ${address}` : fallback;
+
+  return [
+    fit(`elanous | daemon: ${input.daemon ? 'online' : 'offline'}`),
+    addressLine.length <= width ? addressLine : fit(address ? 'PWA: address available' : fallback),
+    fit('Type a message to begin | /help for commands'),
+  ];
+}

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
@@ -881,6 +881,10 @@ import { getModelFamily, getModelTier } from '../models/prompts.js';
 import { buildPromptInjection, getPromptBankStore } from '../prompt-bank/index.js';
 import { getInputHistoryStore, inputHistoryDbPath, inputHistoryJsonPath } from '../input-history.js';
 import { inspectActiveProvider } from '../provider-summary.js';
+import { activeCodexAccountView } from '../oauth/codex-account-store.js';
+import { buildDashboardStatusLines } from './dashboard-status-lines.js';
+import { buildFirstScreenBand } from './first-screen-band.js';
+import { runNexusShow, type NexusShowResult } from '../cli/nexus-show.js';
 import {
   workingDirSegment, sessionCwdSegment, modelSegment, gitSegment,
   ctxBarSegment, costSegment, speedSegment, elapsedSegment, cacheSegment,
@@ -2100,6 +2104,35 @@ export function createDashboardLogSearchOpener(deps: {
   };
 }
 
+export function renderDashboardFirstScreenBand(input: {
+  readonly history: ReadonlyArray<{ role: string }>;
+  readonly lines: string[];
+  readonly width: number;
+  readonly draw: () => void;
+  readonly observe: (data: { daemon: boolean; hasPwa: boolean; hasTailnet: boolean }) => void;
+  readonly show?: () => Promise<Pick<NexusShowResult, 'status' | 'urls'>>;
+}): Promise<void> {
+  if (input.history.some((message) => message.role !== 'system')) return Promise.resolve();
+  const band = buildFirstScreenBand({ width: input.width, daemon: false });
+  input.lines.unshift(...band);
+  const show = input.show ?? (() => runNexusShow({ format: 'json', out: { log: () => {}, error: () => {} } }));
+  const observe = (data: { daemon: boolean; hasPwa: boolean; hasTailnet: boolean }): void => {
+    try { input.observe(data); } catch { /* observation cannot interrupt the transcript */ }
+  };
+  return Promise.resolve().then(show).then((result) => {
+    const daemon = result.status !== 'absent';
+    const pwa = result.urls?.pwa;
+    const hasPwa = !!pwa;
+    const hasTailnet = !!pwa?.tailnet;
+    observe({ daemon, hasPwa, hasTailnet });
+    if (input.lines[1] !== band[1]) return;
+    input.lines[1] = buildFirstScreenBand({ width: input.width, daemon, pwa })[1]!;
+    try { input.draw(); } catch { /* screen may have closed */ }
+  }).catch(() => {
+    observe({ daemon: false, hasPwa: false, hasTailnet: false });
+  });
+}
+
 export async function showDashboard(opts: ShowDashboardOptions = {}): Promise<DashboardAction> {
   const dashboardQuitConfirmationState = createQuitConfirmationState();
   const signalQuitConfirmationState = createQuitConfirmationState();
@@ -2623,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);
@@ -6330,19 +6398,34 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     draw,
   });
 
-  const getDashboardStatusLines = () => [
-    'Dashboard status',
-    ...buildSessionDashboardStatusLines(resolveSessionSurfaceStatus({ chatModeState })).map(
-      line => `  ${line}`,
-    ),
-    `  view: ${workingDir.view}`,
-    `  focus: ${workingDir.focus}`,
-    `  cwd: ${workingDir.cwd}`,
-    `  preview: ${dockedPreview.sourceMode}`,
-    `  starterClosed: ${closedStarterPanes().length ? closedStarterPanes().map((pane) => paneLabel(pane)).join(', ') : 'none'}`,
-    `  chatOnly: ${effectiveChatOnlyMode() ? 'on' : 'off'}${chatOnlyMode ? ' (manual)' : ''}`,
-    `  acp: ${dashboardAcpChat.isBusy() ? 'busy' : 'idle'}`,
-  ];
+  let daemonAttached = false;
+  const getDashboardStatusLines = () => {
+    const cfg = getUserConfig();
+    const active = inspectActiveProvider(cfg);
+    const reasoningProvider = (['openai-codex', 'openai', 'anthropic', 'gemini', 'grok', 'local', 'openrouter'] as const)
+      .find(provider => active.provider === provider || active.provider === `auto:${provider}`);
+    return buildDashboardStatusLines({
+      provider: active.provider,
+      model: active.model,
+      reasoning: reasoningProvider
+        ? modelSupportsReasoning(reasoningProvider, active.model)
+          ? reasoningLevelLabel(effectiveReasoningLevel(cfg.llm, reasoningProvider, active.model))
+          : '미지원'
+        : undefined,
+      daemonAddress: opts.remote?.url,
+      daemonConnected: daemonAttached,
+      accountName: active.provider === 'openai-codex' || active.provider === 'auto:openai-codex'
+        ? activeCodexAccountView().name : undefined,
+      sessionSurfaceLines: buildSessionDashboardStatusLines(resolveSessionSurfaceStatus({ chatModeState })),
+      view: String(workingDir.view),
+      focus: workingDir.focus,
+      cwd: workingDir.cwd,
+      preview: dockedPreview.sourceMode,
+      starterClosed: closedStarterPanes().length ? closedStarterPanes().map((pane) => paneLabel(pane)).join(', ') : 'none',
+      chatOnly: `${effectiveChatOnlyMode() ? 'on' : 'off'}${chatOnlyMode ? ' (manual)' : ''}`,
+      acp: dashboardAcpChat.isBusy() ? 'busy' : 'idle',
+    });
+  };
 
   bootDashboardSlashExecutor({
     initDashboardSlashExecutor,
@@ -6859,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 로 «턴 종료 후» 나가던 것을,
@@ -6886,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,
                     });
@@ -15397,6 +15485,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
         ...(opts.remote ? {
           remote: opts.remote,
           onRemoteDisconnect: () => {
+            daemonAttached = false;
             pushChatLine(C.warning('  ⚠ 데몬 연결이 끊겼다 · 입력 중인 글은 그대로다 · 다시 붙으려면 TUI 를 다시 띄워라'));
             draw();
           },
@@ -15610,6 +15699,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
         },
     });
     const dashboardAcpSession: DashboardSession = dashboardAcpBootResult.session;
+    daemonAttached = !!opts.remote && dashboardAcpBootResult.mode !== 'in-process';
     // ⭐ `B3` — 턴 중 발화를 «도는 턴»에 넣을 때 쓰는 키.
     try { acpSessionIdRef.current = dashboardAcpSession.currentSessionId ?? null; } catch { /* 없으면 넣지 않는다 */ }
     pushDebugLine(C.muted('[acp-boot] dashboard ACP session ready'));
@@ -15701,7 +15791,20 @@ 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,
+      lines: chatLines,
+      width: Math.max(0, termSize().cols - 4),
+      draw: () => draw(),
+      observe: (data) => { try { debug.log('dashboard.first-screen-band', 'resolved', data); } catch { /* observation is best-effort */ } },
+    });
 
     while (true) {
       draw();
@@ -16763,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 });
           }
@@ -18598,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
@@ -18974,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,
@@ -19013,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);