elanous 0.2.31 → 0.2.34

package/src/dashboard/log-click-runtime.ts

@@ -1,6 +1,6 @@
 import type { Attachment, ContextRegistry } from '../context.js';
 import { debug } from '../debug/log.js';
-import type { FoldStack } from '../fold-stack.js';
+import type { FoldStack, FoldTarget } from '../fold-stack.js';
 import type { AttachmentRowMap } from '../log-pane/attachment-row-map.js';
 import type { LogClickDispatchDeps } from '../log-pane/click-dispatch.js';
 import type { AttachmentPopupAction } from '../log-pane/attachment-popup.js';
@@ -43,6 +43,113 @@ export interface DashboardLogClickRuntimeDeps {
    *  `toggleAtLine` decides). Hosts
    *  that omit it keep the legacy attachment/pill-only behavior. */
   foldStack?: FoldStack;
+  /** Keeps the viewport where the click happened while a click toggles a
+   *  fold (#81). Hosts that omit it keep FoldStack's own scroll policy. */
+  foldClickAnchor?: FoldClickScrollAnchor;
+}
+
+/** Scroll state the fold-click anchor reads and writes. Offsets are the
+ *  log pane's visual-row offsets (`-1` = pinned to the tail). */
+export interface FoldClickScrollState {
+  getScrollOffset: () => number;
+  setScrollOffset: (offset: number) => void;
+  /** Max visual-row offset for the current chatLines (after a splice). */
+  maxScroll: () => number;
+  getFrozenTail: () => number | null;
+  setFrozenTail: (index: number | null) => void;
+  /** chatLines length — tells new output from the fold's own splice. */
+  lineCount: () => number;
+}
+
+export interface FoldClickScrollAnchor {
+  /** Current top visual row and raw offset — the click's frame. */
+  viewport(): { top: number; scrollOffset: number };
+  /** Run a click toggle with the viewport top held in place. */
+  run<T>(toggle: () => T): T;
+  /** FoldStack `onAfterToggle` hook: inside `run` it keeps the top row;
+   *  outside (the `f` key, bulk toggles) it falls back to `otherwise`. */
+  onAfterToggle(target: FoldTarget, delta: number): void;
+  /** Call before each paint: a pane that was following the tail when the
+   *  click expanded a block goes back to the tail as soon as new output
+   *  arrives (the click must not leave the pane stuck off the tail). */
+  reconcile(): void;
+}
+
+/** #81 — the old `onAfterToggle` pinned every toggle to the tail, so a
+ *  click that expanded a block near the bottom pushed its header up the
+ *  screen and a second click on the same spot landed in the body (rejected
+ *  as `expanded-body`). A click toggle now keeps the top row; it only
+ *  returns to the tail when the kept top would be past the new bottom. */
+export function createFoldClickScrollAnchor(
+  state: FoldClickScrollState,
+  otherwise: (target: FoldTarget, delta: number) => void,
+): FoldClickScrollAnchor {
+  let heldTop: number | null = null;
+  // Set when a click moved a tail-following pane off the tail: the offset
+  // it set and the line count right after the splice.
+  let followTail: { offset: number; lineCount: number } | null = null;
+  const viewport = (): { top: number; scrollOffset: number } => {
+    const scrollOffset = state.getScrollOffset();
+    const max = state.maxScroll();
+    return { top: scrollOffset < 0 ? max : Math.min(scrollOffset, max), scrollOffset };
+  };
+  return {
+    viewport,
+    run<T>(toggle: () => T): T {
+      const prev = heldTop;
+      heldTop = viewport().top;
+      try {
+        return toggle();
+      } finally {
+        heldTop = prev;
+      }
+    },
+    onAfterToggle(target, delta) {
+      if (heldTop === null) {
+        otherwise(target, delta);
+        return;
+      }
+      // The splice moved every line after the block; a frozen tail past it
+      // must move with them or the pane would cut the expanded rows short.
+      const frozen = state.getFrozenTail();
+      if (frozen !== null && target.kind === 'static' && target.lineStart < frozen) {
+        state.setFrozenTail(frozen + delta);
+      }
+      const offsetBefore = state.getScrollOffset();
+      const wasFollowing = offsetBefore < 0 || followTail?.offset === offsetBefore;
+      const max = state.maxScroll();
+      const next = heldTop >= max ? -1 : heldTop;
+      state.setScrollOffset(next);
+      if (next < 0) state.setFrozenTail(null);
+      // No freeze here: the pane still follows the tail (see reconcile).
+      followTail = next >= 0 && wasFollowing ? { offset: next, lineCount: state.lineCount() } : null;
+      debug.log('log.fold', 'fold-click-anchor', {
+        lineStart: target.kind === 'static' ? target.lineStart : null,
+        delta,
+        topBefore: heldTop,
+        scrollOffsetAfter: next,
+        maxScrollAfter: max,
+        followTail: followTail !== null,
+      });
+    },
+    reconcile() {
+      if (followTail === null) return;
+      // Someone else moved the pane (scroll keys, search, tail pin) — theirs.
+      if (state.getScrollOffset() !== followTail.offset) {
+        followTail = null;
+        return;
+      }
+      if (state.lineCount() <= followTail.lineCount) return;
+      debug.log('log.fold', 'fold-click-follow-tail', {
+        offset: followTail.offset,
+        lineCountBefore: followTail.lineCount,
+        lineCountNow: state.lineCount(),
+      });
+      followTail = null;
+      state.setScrollOffset(-1);
+      state.setFrozenTail(null);
+    },
+  };
 }
 
 export function createDashboardLogClickDeps(
@@ -97,6 +204,13 @@ export function createDashboardLogClickDeps(
       ? {
           tryFoldToggle: (absIdx: number): boolean => {
             const fold = deps.foldStack!;
+            const anchor = deps.foldClickAnchor;
+            // Screen frame of the click — lets the log tell «same spot again»
+            // from «a different row» (#81 had no way to).
+            const frame = anchor ? (() => {
+              const v = anchor.viewport();
+              return { screenRow: absIdx - v.top, top: v.top, scrollOffset: v.scrollOffset };
+            })() : {};
             // Collapse from the first/last line of an expanded range or
             // the row whose click expanded it (#16 — same spot again folds).
             // Other lines of that range are rejected first so a body
@@ -114,6 +228,7 @@ export function createDashboardLogClickDeps(
                       reason: 'expanded-body',
                       lineStart: t.lineStart,
                       lineEnd: t.lineEnd,
+                      ...frame,
                     });
                     return false;
                   }
@@ -121,7 +236,8 @@ export function createDashboardLogClickDeps(
                 }
               }
             }
-            const toggled = fold.toggleAtLine(absIdx);
+            const toggle = (): boolean => fold.toggleAtLine(absIdx, frame);
+            const toggled = anchor ? anchor.run(toggle) : toggle();
             if (toggled) deps.draw();
             return toggled;
           },

package/src/dashboard/seat-boot-preamble.ts

@@ -84,7 +84,7 @@ function buildCardMessages(cwd: string, deps: SeatBootDeps): { messages: LLMMess
   const content =
     `## 자리 부트 카드 — 너는 이 작업 디렉터리의 ${detection.seat} 자리에서 일한다\n` +
     `(판정: ${detection.source === 'cwd' ? `cwd 의 /seats/${detection.seat}` : 'COORD_ID'} · 세션 시작 스냅샷 ${at} · 이후 바뀐 값은 다시 조회하라)\n` +
-    `사람이 다른 일을 먼저 시키지 않았다면, 첫 답에서 자리와 안 읽은 우편 수를 짚고 처리할 일을 제안하라.\n\n` +
+    `사람이 다른 일을 먼저 시키지 않았다면, 첫 답에서 자리 이름·'자리 역할' 절의 역할·안 읽은 우편 수를 각각 명시하고 처리할 일을 제안하라. 역할이 미관측이면 추측하지 말고 미관측이라고 말하라.\n\n` +
     card;
   return {
     messages: [{ role: 'system', content }],

package/src/dashboard/slash-runtime/ask-clarification.ts

@@ -0,0 +1,48 @@
+import type { SurfaceUx } from '../../agent/surface-ux/types.js';
+import type { AskUserQuestionRequest } from '../../ask-user-question/types.js';
+import { DASHBOARD_CLARIFICATION_REQUEST } from '../../esc-abort-gate.js';
+import type { GoalDocumentClarification } from '../../self-implement/goal-author-clarification.js';
+
+/**
+ * Converts the line-oriented self-dev clarification seam into the existing
+ * structured SurfaceUx question contract. A missing, cancelled, or failed
+ * surface answer becomes an empty line, which preserves clarification's
+ * existing "unanswered → deferred" behavior without exposing answer text to
+ * the observation payload emitted by SurfaceUx.
+ */
+export async function readDashboardAskClarification(
+  clarification: GoalDocumentClarification,
+  surfaceUx: Pick<SurfaceUx, 'question'> | undefined,
+  notify?: (line: string) => void,
+): Promise<string> {
+  if (!surfaceUx) return '';
+  const request: AskUserQuestionRequest = {
+    questions: [{
+      id: clarification.questionId,
+      header: 'Clarify goal',
+      question: clarification.question,
+      options: clarification.options.map((option) => ({
+        label: option.label,
+        description: option.description,
+      })),
+      includeOther: clarification.includeOther,
+    }],
+  };
+  Object.defineProperty(request, DASHBOARD_CLARIFICATION_REQUEST, { value: true });
+  try {
+    const pending = surfaceUx.question(request);
+    const id = clarification.questionId;
+    notify?.('하니스가 묻는다 — 창에서 고르거나 Esc 로 답 없이 진행');
+    const result = await pending;
+    if (!result || result.cancelled) return '';
+    const answer = result.answers[id];
+    const selectedLabel = Array.isArray(answer) ? answer[0] : answer;
+    const optionIndex = clarification.options.findIndex((option) => option.label === selectedLabel);
+    if (optionIndex >= 0) return String(optionIndex);
+    const other = clarification.includeOther ? result.otherText?.[id]?.trim() : '';
+    return other || '';
+  } catch {
+    return '';
+  }
+}
+

package/src/dashboard/slash-runtime/dashboard-delegated-slashes.ts

@@ -0,0 +1,68 @@
+import type { DashboardSlashContext, DashboardSlashReturn } from './dashboard-handlers.js';
+import type { SlashCommandRegistry } from './registry.js';
+import { defaultControlSignalObserver } from '../../input/control-signal-observer.js';
+
+/** Register the slash handlers that delegate to showDashboard-local runtimes. */
+export function registerDashboardDelegatedSlashes(
+  registry: SlashCommandRegistry<DashboardSlashContext, DashboardSlashReturn>,
+): void {
+  registry.register(['signals', 'signal'], (args, ctx) => {
+    const sub = (args[0] || 'status').toLowerCase();
+    const rt = ctx.controlSignalSlashRuntime;
+    ctx.chatLines.push('');
+    ctx.chatLines.push(ctx.accent(`❯ /signals ${args.join(' ').trim() || 'status'}`));
+    if (sub === 'help') {
+      for (const line of rt.usageLines()) ctx.chatLines.push(line);
+    } else if (sub === 'status') {
+      for (const line of rt.statusLines()) ctx.chatLines.push(line);
+    } else if (sub === 'clear') {
+      defaultControlSignalObserver().clear();
+      ctx.chatLines.push(rt.clearLine());
+    } else if (sub === 'latest') {
+      const parsed = rt.parseFilterTokens(args.slice(1));
+      for (const line of rt.latestLines(parsed.filter)) ctx.chatLines.push(line);
+    } else if (sub === 'list' || sub === 'ls') {
+      const parsed = rt.parseFilterTokens(args.slice(1));
+      for (const line of rt.listLines(parsed.limit, parsed.filter)) ctx.chatLines.push(line);
+    } else if (sub === 'emit') {
+      for (const line of rt.emitLines(args.slice(1))) ctx.chatLines.push(line);
+    } else {
+      for (const line of rt.usageLines()) ctx.chatLines.push(line);
+    }
+    ctx.setChatScrollOffset(-1);
+  });
+
+  registry.register(['widget', 'widgets', 'w'], async (args, ctx) => {
+    const sub = (args[0] || 'list').toLowerCase();
+    const host = ctx.widgetHost;
+    ctx.chatLines.push('');
+    ctx.chatLines.push(ctx.accent(`❯ /widget ${sub}${args.slice(1).length ? ' ' + args.slice(1).join(' ') : ''}`));
+    try {
+      if (sub === 'list' || sub === 'ls') {
+        const items = host.available();
+        if (items.length === 0) {
+          ctx.chatLines.push(ctx.muted('  (no widgets found — drop one in ~/.claude/widgets/<name>/widget.ts)'));
+        } else {
+          for (const it of items) {
+            const src = it.source === 'builtin' ? ctx.muted('[built-in]') : ctx.info('[user]');
+            // The original used `C.bold` but ctx doesn't expose `bold`;
+            // we substitute `accent` (visually similar) since handlers
+            // module's color contract is the published ctx subset.
+            ctx.chatLines.push(`  ▢ ${ctx.accent(it.def.type)} ${src}  ${ctx.muted(it.def.description)}`);
+          }
+        }
+      } else if (sub === 'reload' || sub === 'r') {
+        await host.discover();
+        ctx.chatLines.push(ctx.success(`  reloaded — ${host.available().length} widget type(s) discovered`));
+      } else if (sub === 'instances' || sub === 'i') {
+        const count = host.instanceCount();
+        ctx.chatLines.push(`  ${count} widget instance(s) alive`);
+      } else {
+        ctx.chatLines.push(ctx.warning(`  unknown subcommand: ${sub} (try list|reload|instances)`));
+      }
+    } catch (err: unknown) {
+      ctx.chatLines.push(ctx.error(`  error: ${err instanceof Error ? err.message : String(err)}`));
+    }
+    ctx.setChatScrollOffset(-1);
+  });
+}