@elliotsystems/eai 0.1.2 → 0.1.4

package/plugin/opencode-plugin/src/tui/format.ts

@@ -0,0 +1,73 @@
+/**
+ * Display formatting for the Elliot TUI chrome. Pure functions only, so the
+ * decisions that are easy to get subtly wrong — where a path gets cut, what a
+ * missing branch renders as — are unit-testable without a terminal.
+ */
+
+/** Separator-agnostic: the worktree arrives with `\` on Windows, `/` elsewhere. */
+const SEPARATOR = /[\\/]+/g
+
+/**
+ * A path short enough to sit on one line of chrome, without lying about it.
+ *
+ * Truncation happens on the LEFT and is marked with `…/`, because the
+ * informative end of a project path is its tail. A `home` prefix collapses to
+ * `~` first — that is both shorter and the form a developer recognises.
+ *
+ * Returns forward slashes on every platform: this string is chrome, not a path
+ * to hand back to the filesystem, and mixed separators in one line of UI read
+ * as a bug.
+ */
+export function shortenPath(directory: string, home?: string, maxSegments = 3): string {
+  if (!directory) return ""
+
+  const normalized = directory.replace(SEPARATOR, "/").replace(/\/+$/, "")
+  const collapsed = collapseHome(normalized, home)
+  if (collapsed !== normalized) return collapsed
+
+  const segments = normalized.split("/").filter(Boolean)
+  if (segments.length <= maxSegments) return normalized
+  return `…/${segments.slice(-maxSegments).join("/")}`
+}
+
+/**
+ * Replace a `home` prefix with `~`, matching whole segments only.
+ *
+ * The segment check is the point: a plain `startsWith` would turn
+ * `C:/Users/ganesh-old/repo` into `~-old/repo` when home is `C:/Users/ganesh`.
+ * Comparison is case-insensitive because Windows paths are.
+ */
+function collapseHome(normalized: string, home?: string): string {
+  if (!home) return normalized
+  const prefix = home.replace(SEPARATOR, "/").replace(/\/+$/, "")
+  if (!prefix) return normalized
+  if (normalized.toLowerCase() === prefix.toLowerCase()) return "~"
+  if (!normalized.toLowerCase().startsWith(`${prefix.toLowerCase()}/`)) return normalized
+  return `~${normalized.slice(prefix.length)}`
+}
+
+/**
+ * The home directory, or `undefined` where the runtime does not expose one.
+ *
+ * `process` is reached through `globalThis` rather than imported: this module is
+ * loaded into the TUI plugin runtime, whose shared module list does not include
+ * `node:process`, and an absent global must degrade to a full path rather than
+ * throwing during slot render.
+ */
+export function homeDirectory(): string | undefined {
+  const env = (globalThis as { process?: { env?: Record<string, string | undefined> } }).process?.env
+  return env?.HOME || env?.USERPROFILE || undefined
+}
+
+/** `+12 −3`, with either side omitted when it is zero. Empty when both are. */
+export function formatDiffStat(additions: number, deletions: number): string {
+  const parts: string[] = []
+  if (additions > 0) parts.push(`+${additions}`)
+  if (deletions > 0) parts.push(`−${deletions}`)
+  return parts.join(" ")
+}
+
+/** `n thing` / `n things` — an English plural, not `n thing(s)`. */
+export function pluralize(count: number, singular: string, plural = `${singular}s`): string {
+  return `${count} ${count === 1 ? singular : plural}`
+}

package/plugin/opencode-plugin/src/tui/home.tsx

@@ -0,0 +1,88 @@
+/**
+ * The welcome screen's copy, filling `home_bottom`.
+ *
+ * Three deliberate reductions from what shipped before. The four-key hint row is
+ * gone: the same keys are named in the tips, and printing them twice is the kind
+ * of chrome this redesign exists to remove. The context line is new, and is the
+ * one thing a terminal welcome genuinely owes the reader — where am I, on what
+ * branch. And the tips are numbered rather than bulleted, which is what makes a
+ * short list read as "here are three things" instead of as decoration.
+ *
+ * `tui.json` disables `internal:home-tips`; without that, upstream's tips
+ * carousel stacks under this block and the screen carries two tip lists.
+ */
+import { For, Show } from "solid-js"
+
+import type { TuiPluginApi } from "./api.js"
+import { homeDirectory, shortenPath } from "./format.js"
+
+const TAGLINE = "the engineering terminal"
+
+/**
+ * Three tips, in the order a new user needs them.
+ *
+ * The first names Elliot's actual differentiator rather than a generic prompt
+ * idea. The second says `/init` and `AGENTS.md` — AGENTS.md is the file OpenCode
+ * really reads (`session/instruction.ts`); the original design's "AGENT.md" was
+ * a bug wearing a designer's clothes. The third collapses the old hint row.
+ */
+const TIPS: ReadonlyArray<readonly [string, string]> = [
+  ["Ask about this repo", "Elliot searches your organisation's indexed sources"],
+  ["Run /init", "generates an AGENTS.md so every session starts informed"],
+  ["Press / or @", "commands and file context; tab switches agents"],
+]
+
+/** `~/Documents/Elliot-AI · feat/tui-elliot-redesign` */
+function ContextLine(props: { api: TuiPluginApi }) {
+  const theme = props.api.theme.current
+  const state = props.api.state
+  const directory = () => shortenPath(state.path.directory || state.path.worktree, homeDirectory())
+  const branch = () => state.vcs?.branch
+
+  return (
+    <box flexDirection="row" gap={1}>
+      <text fg={theme.textMuted} selectable={false}>
+        {directory()}
+      </text>
+      <Show when={branch()}>
+        <text fg={theme.border} selectable={false}>
+          ·
+        </text>
+        <text fg={theme.textMuted} selectable={false}>
+          {branch()}
+        </text>
+      </Show>
+    </box>
+  )
+}
+
+export function HomeBottom(props: { api: TuiPluginApi }) {
+  const theme = props.api.theme.current
+  return (
+    <box paddingTop={1} gap={1}>
+      <text fg={theme.textMuted} selectable={false}>
+        {TAGLINE}
+      </text>
+
+      <ContextLine api={props.api} />
+
+      <box>
+        <For each={TIPS}>
+          {(tip, index) => (
+            <box flexDirection="row" gap={1}>
+              <text fg={theme.border} selectable={false}>
+                {`${index() + 1}.`}
+              </text>
+              <text fg={theme.text} selectable={false}>
+                {tip[0]}
+              </text>
+              <text fg={theme.textMuted} selectable={false}>
+                {`— ${tip[1]}`}
+              </text>
+            </box>
+          )}
+        </For>
+      </box>
+    </box>
+  )
+}

package/plugin/opencode-plugin/src/tui/host.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Ambient declarations for the host modules this TUI plugin imports at runtime.
+ *
+ * `solid-js`, `solid-js/store`, `@opentui/core` and `@opentui/solid/jsx-runtime`
+ * are provided to runtime-loaded plugins by the host — verified in
+ * `@opentui/solid/scripts/runtime-plugin-support-configure.js`, whose shared
+ * specifier list is exactly:
+ *   @opentui/core, @opentui/core/runtime-plugin, @opentui/solid,
+ *   @opentui/solid/components, @opentui/solid/jsx-runtime,
+ *   @opentui/solid/jsx-dev-runtime, solid-js, solid-js/store, bun
+ *
+ * They are therefore not RUNTIME dependencies of this package: they are declared
+ * as peers, and installed here only so the package type-checks and tests on its
+ * own. Declaring the handful of members we use keeps `tsc` meaningful without
+ * pulling the whole opencode workspace onto the module path — the same approach
+ * `src/index.ts` already takes for the server plugin's host types.
+ *
+ * Note `@opencode-ai/plugin/tui` is deliberately absent from the shared list, so
+ * the plugin's own API types are mirrored structurally in `index.tsx` rather than
+ * imported. The host validates plugins by shape, not by nominal type.
+ */
+
+declare module "solid-js" {
+  export function For<T>(props: {
+    each: readonly T[] | undefined
+    children: (item: T, index: () => number) => unknown
+  }): unknown
+
+  /**
+   * Solid's conditional. `when` is truthiness-tested, and `children` may be an
+   * element or a function of the narrowed value — only the element form is
+   * declared, because that is the only form this chrome uses.
+   */
+  export function Show<T>(props: {
+    when: T | undefined | null | false
+    fallback?: unknown
+    children?: unknown
+  }): unknown
+}
+
+declare module "@opentui/core" {
+  /**
+   * Mostly opaque: produced by the host theme and handed straight back. Not
+   * FULLY opaque, though, and the difference matters -- `wordmark.tsx` has to
+   * construct one. A plain object of the same shape is rejected at opentui's FFI
+   * boundary ("Expected ArrayBufferView but received Cell"), so the constructor
+   * is declared here and the real class must be used.
+   */
+  export class RGBA {
+    readonly r: number
+    readonly g: number
+    readonly b: number
+    readonly a: number
+    static fromValues(r: number, g: number, b: number, a?: number): RGBA
+  }
+  export const TextAttributes: { readonly BOLD: number }
+}
+
+declare namespace JSX {
+  type Element = unknown
+
+  interface BoxProps {
+    flexDirection?: "row" | "column"
+    flexGrow?: number
+    flexShrink?: number
+    alignItems?: "center" | "flex-start" | "flex-end" | "stretch" | "baseline"
+    justifyContent?: "center" | "flex-start" | "flex-end" | "space-between"
+    gap?: number
+    width?: number | string
+    maxWidth?: number
+    height?: number
+    minHeight?: number
+    paddingTop?: number
+    paddingLeft?: number
+    paddingRight?: number
+    children?: unknown
+  }
+
+  interface TextProps {
+    fg?: unknown
+    bg?: unknown
+    attributes?: number
+    selectable?: boolean
+    children?: unknown
+  }
+
+  interface IntrinsicElements {
+    box: BoxProps
+    text: TextProps
+  }
+
+  interface ElementChildrenAttribute {
+    children: {}
+  }
+}

package/plugin/opencode-plugin/src/tui/index.tsx

@@ -0,0 +1,99 @@
+/**
+ * Elliot AI TUI chrome.
+ *
+ * Fills the host's public plugin slots — nothing here edits OpenCode. That is
+ * what keeps the whole redesign at zero fork divergence, and it is also the
+ * ceiling on it: the session transcript exposes no slot but the prompt, so
+ * message and tool-call rendering stay upstream's. The boundary, with call
+ * sites, is documented in `docs/opencode/TUI-REDESIGN.md`.
+ *
+ * Registration happens in two passes because `order` is per-registration, not
+ * per-slot, and the sidebar needs a different position than everything else.
+ */
+import { HomeBottom } from "./home.js"
+import { HomePrompt, SessionPrompt } from "./prompt.js"
+import { SidebarContent, SidebarFooter, SidebarTitle } from "./sidebar.js"
+import { Wordmark } from "./wordmark.js"
+import type { SessionSlotProps, TuiPluginApi, TuiPlugin } from "./api.js"
+
+/**
+ * Ahead of every built-in sidebar section (context 100, mcp 200, lsp 300,
+ * todo 400, files 500), so what Elliot adds is read before what OpenCode
+ * reports.
+ */
+const SIDEBAR_ORDER = 50
+
+/**
+ * Above the built-in home plugins (`internal:home-tips` and `internal:which-key`
+ * both register at 100–200) so Elliot's chrome sorts after theirs in append
+ * slots, and wins the `single_winner` ones.
+ */
+const CHROME_ORDER = 200
+
+/**
+ * The theme file, relative to the plugin root.
+ *
+ * Installing it is REQUIRED, not a nicety. Theme discovery scans only
+ * `themes/*.json` under the global config directory and each `.opencode`
+ * directory up from the cwd (`packages/tui/src/context/theme.tsx:38`), so
+ * `opencode-plugin/themes/elliot.json` is never found on its own — which is why
+ * `tui.json`'s `"theme": "elliot"` silently fell back to the default palette and
+ * the Elliot theme had never actually applied. `api.theme.install` copies the
+ * file to a scanned location, which is what the package's `oc-themes` field was
+ * always gesturing at.
+ */
+const THEME_FILE = "themes/elliot.json"
+
+/**
+ * Required, not optional, and it must also be carried on the DEFAULT export
+ * below -- `readV1Plugin` (`plugin/shared.ts:278`) hands the host `mod.default`,
+ * so a bare named export is never read. `tui.json` names this plugin by a relative path, so
+ * the host classifies it `source: "file"` (`plugin/shared.ts:57`) and
+ * `resolvePluginId` (`:306`) THROWS for a path plugin that exports no `id`.
+ * That throw is reported via `console.error`, which the alternate screen
+ * swallows -- so the plugin silently did not load, and the missing `id` was
+ * read for months as "TUI plugin loading is broken in the runtime"
+ * (docs/opencode/TUI-REDESIGN.md 6.2). It is not: this export is the fix.
+ */
+export const id = "@elliotsystems/opencode-plugin"
+
+export const tui: TuiPlugin = async (api) => {
+  // Never fatal: a chrome that refuses to load because a colour file could not
+  // be copied is worse than one that renders in the default palette.
+  await api.theme.install(THEME_FILE).catch(() => {})
+
+  api.slots.register({
+    order: SIDEBAR_ORDER,
+    slots: {
+      sidebar_content: (_context: unknown, slot: SessionSlotProps) => (
+        <SidebarContent api={api} slot={slot} />
+      ),
+    },
+  })
+
+  api.slots.register({
+    order: CHROME_ORDER,
+    slots: {
+      home_logo: () => <Wordmark api={api} />,
+      home_bottom: () => <HomeBottom api={api} />,
+      home_prompt: (_context: unknown, slot: { ref?: (ref: unknown) => void }) => (
+        <HomePrompt api={api} slot={slot} />
+      ),
+      session_prompt: (_context: unknown, slot: SessionSlotProps) => (
+        <SessionPrompt api={api} slot={slot} />
+      ),
+      sidebar_title: (_context: unknown, slot: SessionSlotProps & { title: string }) => (
+        <SidebarTitle api={api} slot={slot} />
+      ),
+      sidebar_footer: () => <SidebarFooter api={api} />,
+    },
+  })
+}
+
+/**
+ * The host requires a default export with `tui()` — and refuses a module that
+ * default-exports both `server()` and `tui()` (`plugin/shared.ts:294`). That is
+ * why this lives behind its own export subpath instead of the package root,
+ * which keeps default-exporting the server plugin.
+ */
+export default { id, tui }

package/plugin/opencode-plugin/src/tui/knowledge.ts

@@ -0,0 +1,243 @@
+/**
+ * Reading Elliot's knowledge activity out of what the TUI already has.
+ *
+ * The sidebar shows two things a stock OpenCode sidebar cannot: whether the
+ * knowledge boundary is actually up, and which sources Elliot cited in THIS
+ * session. Both are derived from `api.state` alone — MCP status and the
+ * session's own tool parts.
+ *
+ * It deliberately does NOT call Elliot's backend. The server plugin's contract
+ * (`src/index.ts`) is that OAuth lifecycle belongs to OpenCode's native MCP
+ * client and a second credential path must not exist; a sidebar that fetched
+ * `get_index_stats` itself would be exactly that second path. So index totals
+ * are absent here rather than approximated, and everything below is either
+ * proven from session state or not shown.
+ */
+
+import { knowledgeToolKey } from "../mcp-keys.js"
+
+// ------------------------------------------------------------- host shapes --
+
+/** `TuiSidebarMcpItem` (packages/plugin/src/tui.ts) — the fields we read. */
+export interface McpItem {
+  readonly name: string
+  readonly status: string
+  readonly error?: string
+}
+
+/** A `ToolPart` in its completed state, narrowed to what a citation needs. */
+export interface ToolPartLike {
+  readonly type: string
+  readonly tool?: string
+  readonly state?: {
+    readonly status?: string
+    readonly output?: string
+  }
+}
+
+// ------------------------------------------------------- connection status --
+
+export type KnowledgeConnection = {
+  /** `undefined` when no Elliot MCP server is configured at all. */
+  readonly status: "connected" | "failed" | "pending" | undefined
+  readonly name?: string
+  readonly error?: string
+}
+
+/**
+ * Which MCP server is Elliot's.
+ *
+ * Matched by name rather than by URL because the name is what the operator
+ * chose in `opencode.json` and what the agent sees prefixed onto the tool
+ * (`elliot_knowledge_search`). A substring match keeps `elliot`, `elliot-dev`
+ * and `elliot-staging` all recognised.
+ */
+function isElliotServer(name: string): boolean {
+  return name.toLowerCase().includes("elliot")
+}
+
+/**
+ * The knowledge boundary's real state.
+ *
+ * A failed server outranks a connected one when several match: the panel exists
+ * to surface the problem, and reporting "connected" while a configured Elliot
+ * server is down is the one output that would actively mislead.
+ */
+export function knowledgeConnection(items: readonly McpItem[]): KnowledgeConnection {
+  const elliot = items.filter((item) => isElliotServer(item.name))
+  if (elliot.length === 0) return { status: undefined }
+
+  const failed = elliot.find((item) => item.status === "failed")
+  if (failed) return { status: "failed", name: failed.name, error: failed.error }
+
+  const connected = elliot.find((item) => item.status === "connected")
+  if (connected) return { status: "connected", name: connected.name }
+
+  return { status: "pending", name: elliot[0]!.name }
+}
+
+// -------------------------------------------------------------- citations --
+
+/** One source Elliot cited, as rendered by the backend's evidence formatter. */
+export interface Citation {
+  readonly path: string
+  readonly symbol?: string
+}
+
+export type KnowledgeResult = {
+  readonly status: "ok" | "no_results" | "repo_not_authorized" | "unavailable"
+  readonly repoScope?: string
+  readonly resultCount: number
+  readonly citations: readonly Citation[]
+}
+
+/** The Elliot-looking MCP servers currently configured, by name. */
+export function elliotServerNames(items: readonly McpItem[]): string[] {
+  return items.filter((item) => isElliotServer(item.name)).map((item) => item.name)
+}
+
+/**
+ * Is this agent-visible tool key an Elliot knowledge lookup?
+ *
+ * Exact composed-key match against the configured servers, mirroring
+ * `isElliotKnowledgeTool` in `policy.ts` rather than matching the
+ * `knowledge_search` suffix. Suffix matching is rejected there because it would
+ * let an unrelated server named e.g. `not-elliot` be treated as ours; the same
+ * reasoning applies to a panel that would otherwise attribute a third party's
+ * results to Elliot.
+ */
+export function isKnowledgeTool(tool: string | undefined, serverNames: readonly string[]): boolean {
+  if (typeof tool !== "string") return false
+  return serverNames.some((name) => tool === knowledgeToolKey(name))
+}
+
+/**
+ * Parse one completed `knowledge_search` output.
+ *
+ * The output string is the backend's envelope, JSON-encoded
+ * (`backend/app/routers/mcp_v1.py:229` wraps `render_knowledge_evidence` in a
+ * single text content block): `{status, repo_scope?, result_count?, evidence}`.
+ *
+ * This is a real coupling to that shape, so it is written to go SILENT rather
+ * than wrong if the shape changes — every branch returns `undefined` on
+ * anything unexpected, and `test/tui-knowledge.test.ts` locks the contract so a
+ * backend change breaks a test instead of the sidebar.
+ */
+export function parseKnowledgeOutput(output: string | undefined): KnowledgeResult | undefined {
+  if (!output) return undefined
+
+  let envelope: unknown
+  try {
+    envelope = JSON.parse(output)
+  } catch {
+    return undefined
+  }
+  if (typeof envelope !== "object" || envelope === null) return undefined
+
+  const record = envelope as Record<string, unknown>
+  const status = record["status"]
+  if (
+    status !== "ok" &&
+    status !== "no_results" &&
+    status !== "repo_not_authorized" &&
+    status !== "unavailable"
+  ) {
+    return undefined
+  }
+
+  const repoScope = typeof record["repo_scope"] === "string" ? record["repo_scope"] : undefined
+  const resultCount = typeof record["result_count"] === "number" ? record["result_count"] : 0
+  const evidence = typeof record["evidence"] === "string" ? record["evidence"] : ""
+
+  return {
+    status,
+    repoScope,
+    resultCount,
+    citations: status === "ok" ? parseEvidence(evidence, resultCount) : [],
+  }
+}
+
+/** The backend joins evidence entries with this exact delimiter. */
+const ENTRY_DELIMITER = "\n---\n"
+
+/** `path` or `path — symbol`, as `_render_knowledge_result` builds the header. */
+const HEADER = /^(\S+)(?: — (.+))?$/
+
+/**
+ * Pull the header line out of each evidence entry.
+ *
+ * `limit` is load-bearing, not defensive tidying. Chunk CONTENT is embedded in
+ * the same string, so a markdown chunk containing a `---` horizontal rule
+ * produces extra delimiters and therefore phantom entries. `result_count` is
+ * the backend's authoritative count, so honouring it caps the damage, and the
+ * header regex rejects the rest — a prose line has spaces and so cannot match.
+ */
+function parseEvidence(evidence: string, limit: number): Citation[] {
+  if (!evidence || limit <= 0) return []
+
+  const citations: Citation[] = []
+  const seen = new Set<string>()
+
+  for (const entry of evidence.split(ENTRY_DELIMITER)) {
+    if (citations.length >= limit) break
+
+    const header = entry.split("\n", 1)[0]?.trim()
+    if (!header) continue
+    const match = HEADER.exec(header)
+    if (!match) continue
+
+    const path = match[1]!
+    // Several chunks from one file are one source to a reader. The key is a
+    // JSON tuple rather than a joined string: any separator character could
+    // legitimately appear in a path or a symbol name, so joining risks two
+    // different (path, symbol) pairs collapsing into one key.
+    const key = JSON.stringify([path, match[2] ?? ""])
+    if (seen.has(key)) continue
+    seen.add(key)
+    citations.push(match[2] ? { path, symbol: match[2] } : { path })
+  }
+
+  return citations
+}
+
+/**
+ * Every knowledge lookup in this session, oldest first.
+ *
+ * Running and errored calls are skipped rather than shown as empty results:
+ * "cited nothing" and "has not finished" are different facts, and the sidebar
+ * must not merge them.
+ */
+export function collectKnowledgeResults(
+  parts: readonly ToolPartLike[],
+  serverNames: readonly string[],
+): KnowledgeResult[] {
+  const results: KnowledgeResult[] = []
+  for (const part of parts) {
+    if (part.type !== "tool") continue
+    if (!isKnowledgeTool(part.tool, serverNames)) continue
+    if (part.state?.status !== "completed") continue
+    const parsed = parseKnowledgeOutput(part.state.output)
+    if (parsed) results.push(parsed)
+  }
+  return results
+}
+
+/**
+ * The distinct sources cited across a session, most recent lookup first.
+ *
+ * Ordering matters for a panel that is height-bounded: the sources backing the
+ * answer currently on screen are the ones worth the rows.
+ */
+export function distinctCitations(results: readonly KnowledgeResult[], limit: number): Citation[] {
+  const out: Citation[] = []
+  const seen = new Set<string>()
+  for (const result of [...results].reverse()) {
+    for (const citation of result.citations) {
+      if (out.length >= limit) return out
+      if (seen.has(citation.path)) continue
+      seen.add(citation.path)
+      out.push(citation)
+    }
+  }
+  return out
+}

package/plugin/opencode-plugin/src/tui/prompt.tsx

@@ -0,0 +1,62 @@
+/**
+ * Elliot's prompt, filling `home_prompt` and `session_prompt`.
+ *
+ * It REUSES the host's `api.ui.Prompt` rather than rebuilding an editor. That is
+ * not a shortcut: the host's prompt carries autocomplete, file attachment,
+ * history, frecency, shell mode, paste handling and the leader-key layer
+ * (`component/prompt/index.tsx`, 1,716 lines). Reimplementing it to change the
+ * placeholder text would trade all of that away for copy.
+ *
+ * What Elliot changes is the copy, which is the most-read text in the whole TUI:
+ * upstream suggests "Fix a TODO in the codebase", which says nothing about why
+ * this terminal is different. The chrome around the input stays the host's, and
+ * is quieted through the theme instead — the rail is painted from `theme.border`
+ * (`component/prompt/index.tsx:1289`), so `themes/elliot.json` already softened
+ * it without a fork.
+ *
+ * Both slots are `mode="replace"`, so these components stand in for the host's
+ * own render. Every prop the host passes MUST therefore be forwarded. `ref` in
+ * particular is load-bearing: `routes/home.tsx` binds it to set and auto-submit
+ * `--prompt`, so dropping it would silently break `eai --prompt "..."` while the
+ * interactive TUI kept working.
+ *
+ * Props are passed as JSX attributes rather than by calling `Prompt(props)` or
+ * spreading an object: Solid compiles attributes into getters, and only that
+ * form keeps `visible` and `disabled` reactive as the session changes state.
+ */
+import type { SessionSlotProps, TuiPluginApi } from "./api.js"
+
+/**
+ * Placeholders that describe Elliot's actual capability.
+ *
+ * Knowledge-shaped, not TODO-shaped: the first thing a user tries should be the
+ * thing only this terminal can do. Shell placeholders stay as upstream's — shell
+ * mode is upstream's feature and its examples are already the right ones.
+ */
+const PLACEHOLDERS = {
+  normal: [
+    "Ask why this service is built the way it is",
+    "Which PRs changed the auth flow?",
+    "Summarise what this repo does for a new joiner",
+  ],
+  shell: ["git status", "ls -la", "pwd"],
+}
+
+export function HomePrompt(props: { api: TuiPluginApi; slot: { ref?: (ref: unknown) => void } }) {
+  const Prompt = props.api.ui.Prompt
+  return <Prompt ref={props.slot.ref} placeholders={PLACEHOLDERS} />
+}
+
+export function SessionPrompt(props: { api: TuiPluginApi; slot: SessionSlotProps }) {
+  const Prompt = props.api.ui.Prompt
+  return (
+    <Prompt
+      sessionID={props.slot.session_id}
+      visible={props.slot.visible}
+      disabled={props.slot.disabled}
+      onSubmit={props.slot.on_submit}
+      ref={props.slot.ref}
+      placeholders={PLACEHOLDERS}
+    />
+  )
+}