@xynogen/pix-core 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-core",
-	"version": "0.1.1",
+	"version": "0.1.3",
 	"description": "Pi extension — core UI/UX bundle (welcome banner, footer, model picker, self-update)",
 	"type": "module",
 	"main": "src/index.ts",
@@ -42,6 +42,8 @@
 		"access": "public"
 	},
 	"dependencies": {
+		"@xynogen/pix-data": "^0.1.0",
+		"@xynogen/pix-skills": "^0.1.1",
 		"typebox": "^1.1.38"
 	},
 	"peerDependencies": {

package/src/commands/agent-sop/agent-sop.ts

@@ -0,0 +1,58 @@
+/**
+ * agent-sop — inject AGENT.md (from pix-skills) into system prompt
+ *
+ * Reads AGENT.md from the @xynogen/pix-skills package and appends it to the
+ * system prompt on every agent start via `before_agent_start`.
+ *
+ * This is the "register skill" mechanism for the agent operating spec — no
+ * static SKILL.md file needed. The content becomes part of the model's
+ * standing instructions.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { resolve } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+/** Resolve the absolute path to AGENT.md inside @xynogen/pix-skills. */
+function resolveAgentMdPath(): string | null {
+	try {
+		const require = createRequire(import.meta.url);
+		const pkgJson = require.resolve("@xynogen/pix-skills/package.json");
+		return resolve(pkgJson, "..", "AGENT.md");
+	} catch {
+		return null;
+	}
+}
+
+/** Read and return AGENT.md content, or null if unavailable. */
+function loadAgentMd(): string | null {
+	const p = resolveAgentMdPath();
+	if (!p || !existsSync(p)) return null;
+	try {
+		return readFileSync(p, "utf-8");
+	} catch {
+		return null;
+	}
+}
+
+export default function registerAgentSop(pi: ExtensionAPI): void {
+	// Load once at startup (content is static per session).
+	const agentMdContent = loadAgentMd();
+
+	if (!agentMdContent) {
+		// Silent skip — pix-skills might not be installed.
+		return;
+	}
+
+	pi.on("before_agent_start", async (event) => {
+		// Skip if already injected (idempotent check via a simple marker).
+		if (event.systemPrompt.includes("pix-agent-sop")) {
+			return;
+		}
+
+		return {
+			systemPrompt: `${event.systemPrompt}\n\n<pix-agent-sop>\n${agentMdContent}\n</pix-agent-sop>`,
+		};
+	});
+}

package/src/index.ts

@@ -16,6 +16,7 @@
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import registerAgentSop from "./commands/agent-sop/agent-sop.ts";
 import registerClear from "./commands/clear/clear.ts";
 import registerCopyAll from "./commands/copy-all/copy-all.ts";
 import registerDiff from "./commands/diff/diff.ts";
@@ -24,7 +25,7 @@ import registerModels from "./commands/models/models.ts";
 import registerUpdate from "./commands/update/update.ts";
 import registerYeet from "./commands/yeet/yeet.ts";
 import registerNudges from "./nudge/index.ts";
-import registerAsk from "./tool/ask/ask.ts";
+import registerAsk from "./tool/ask/index.ts";
 import registerTodo from "./tool/todo/todo.ts";
 import registerToolbox from "./tool/toolbox/toolbox.ts";
 import registerDiagnostics from "./ui/diagnostics.ts";
@@ -32,6 +33,7 @@ import registerFooter from "./ui/footer.ts";
 import registerWelcome from "./ui/welcome.ts";
 
 export default function (pi: ExtensionAPI): void {
+	registerAgentSop(pi);
 	registerWelcome(pi);
 	registerFooter(pi);
 	registerDiagnostics(pi);

package/src/lib/data.ts

@@ -1,241 +1,33 @@
 /**
  * data.ts — model data layer (shim)
  *
- * Re-exports shared data from pix-data (github.com/xynogen/pix-data).
- * Cache lives at ~/.cache/pi/ and is shared across all Pi extensions.
+ * Thin re-export of the shared data layer from @xynogen/pix-data
+ * (github.com/xynogen/pix-mono/tree/main/packages/pix-data). Cache lives at
+ * ~/.cache/pi/ and is shared across all Pi extensions — pix-data warms it on
+ * session start; this extension reads from it.
  *
  * Consumers in this extension dir:
  *   footer.ts  — lookupModelsDev, lookupBenchmark, ModelsDevModel
  *   models.ts  — lookupModelsDev, lookupBenchmark
  */
 
-import { existsSync, readFileSync } from "node:fs";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-
-// ── Types ─────────────────────────────────────────────────────────────────────
-
-export interface ModelsDevModel {
-	id: string;
-	name?: string;
-	reasoning?: boolean;
-	modalities?: { input?: string[]; output?: string[] };
-	limit?: { context?: number; output?: number };
-	cost?: {
-		input?: number;
-		output?: number;
-		cache_read?: number;
-		cache_write?: number;
-	};
-}
-
-export type ModelsDevApi = Record<
-	string,
-	{ models?: Record<string, ModelsDevModel> }
->;
-
-export interface BenchmarkEntry {
-	rank: number;
-	model: string;
-	creator: string;
-	sourceType?: string;
-	overallScore: number | null;
-	categoryScores?: Record<string, number | null>;
-	inputPrice: number | null;
-	outputPrice: number | null;
-}
-
-interface BenchmarkResponse {
-	lastUpdated?: string;
-	mode?: string;
-	models: BenchmarkEntry[];
-}
-
-// ── DataSource ─────────────────────────────────────────────────────────────────
-
-interface DataSourceOptions<T> {
-	url: string | (() => string);
-	headers?: () => Record<string, string> | undefined;
-	cachePath: string;
-	ttlMs?: number;
-	timeoutMs?: number;
-	parse: (raw: unknown) => T;
-	parseCache: (data: unknown) => T;
-	empty: T;
-	label: string;
-	skip?: () => boolean;
-}
-
-class DataSource<T> {
-	private _mem: T | null = null;
-	private _inflight: Promise<T> | null = null;
-	private readonly opts: Required<DataSourceOptions<T>>;
-
-	constructor(opts: DataSourceOptions<T>) {
-		this.opts = {
-			ttlMs: 24 * 60 * 60 * 1000,
-			timeoutMs: 10_000,
-			headers: () => undefined,
-			skip: () => false,
-			...opts,
-		};
-	}
-
-	async get(): Promise<T> {
-		if (this._inflight) return this._inflight;
-		this._inflight = this._load().finally(() => {
-			this._inflight = null;
-		});
-		return this._inflight;
-	}
-
-	getCached(): T {
-		if (this._mem) return this._mem;
-		try {
-			if (existsSync(this.opts.cachePath)) {
-				const raw = JSON.parse(readFileSync(this.opts.cachePath, "utf-8")) as {
-					data: unknown;
-				};
-				this._mem = this.opts.parseCache(raw.data);
-				return this._mem;
-			}
-		} catch {
-			// No cache file or parse error — return empty
-		}
-		return this.opts.empty;
-	}
-
-	private async _load(): Promise<T> {
-		if (this.opts.skip()) {
-			this._mem = this.opts.empty;
-			return this.opts.empty;
-		}
-		const cached = await this._readCache();
-		if (cached !== undefined && Date.now() - cached.ts < this.opts.ttlMs) {
-			const val = this.opts.parseCache(cached.data);
-			this._mem = val;
-			return val;
-		}
-		try {
-			const url =
-				typeof this.opts.url === "function" ? this.opts.url() : this.opts.url;
-			const controller = new AbortController();
-			const timer = setTimeout(() => controller.abort(), this.opts.timeoutMs);
-			const response = await fetch(url, {
-				signal: controller.signal,
-				headers: this.opts.headers(),
-			}).finally(() => clearTimeout(timer));
-			if (!response.ok)
-				throw new Error(`${this.opts.label} fetch failed: ${response.status}`);
-			const raw = await response.json();
-			const val = this.opts.parse(raw);
-			this._mem = val;
-			void this._writeCache(raw);
-			return val;
-		} catch (error) {
-			const msg = error instanceof Error ? error.message : String(error);
-			if (cached !== undefined) {
-				console.warn(
-					`${this.opts.label} fetch failed, using stale cache: ${msg}`,
-				);
-				const val = this.opts.parseCache(cached.data);
-				this._mem = val;
-				return val;
-			}
-			console.warn(`${this.opts.label} unavailable: ${msg}`);
-			return this.opts.empty;
-		}
-	}
-
-	private async _readCache(): Promise<
-		{ ts: number; data: unknown } | undefined
-	> {
-		try {
-			const raw = await readFile(this.opts.cachePath, "utf8");
-			const parsed = JSON.parse(raw) as { ts: number; data: unknown };
-			if (typeof parsed.ts !== "number") return undefined;
-			return parsed;
-		} catch {
-			return undefined;
-		}
-	}
-
-	private async _writeCache(data: unknown): Promise<void> {
-		try {
-			await mkdir(dirname(this.opts.cachePath), { recursive: true });
-			await writeFile(
-				this.opts.cachePath,
-				JSON.stringify({ ts: Date.now(), data }),
-			);
-		} catch {
-			// Write failure is non-fatal
-		}
-	}
-}
-
-// ── Cache dir ─────────────────────────────────────────────────────────────────
-
-const CACHE_DIR = join(
-	process.env.XDG_CACHE_HOME || join(homedir(), ".cache"),
-	"pi",
-);
-
-// ── Data sources (shared cache with pix-data) ─────────────────────────────────
-
-const modelsDev = new DataSource<ModelsDevApi>({
-	label: "models.dev",
-	url: "https://models.dev/api.json",
-	cachePath: join(CACHE_DIR, "models.json"),
-	parse: (raw) => raw as ModelsDevApi,
-	parseCache: (data) => (data as ModelsDevApi) ?? {},
-	empty: {},
-});
-
-const benchmark = new DataSource<BenchmarkEntry[]>({
-	label: "benchlm",
-	url: "https://benchlm.ai/api/data/leaderboard",
-	cachePath: join(CACHE_DIR, "benchlm.json"),
-	parse: (raw) => (raw as BenchmarkResponse).models ?? [],
-	parseCache: (data) => (data as BenchmarkResponse)?.models ?? [],
-	empty: [],
-});
-
-// ── Lookup helpers ─────────────────────────────────────────────────────────────
-
-export function lookupModelsDev(
-	provider: string,
-	id: string,
-): ModelsDevModel | undefined {
-	const data = modelsDev.getCached();
-	const canonical = id.includes("/") ? id.slice(id.lastIndexOf("/") + 1) : id;
-	const exact = data[provider]?.models?.[canonical];
-	if (exact) return exact;
-	for (const p of Object.keys(data)) {
-		const hit = data[p]?.models?.[canonical];
-		if (hit) return hit;
-	}
-	return undefined;
-}
-
-function normBench(s: string): string {
-	return s
-		.toLowerCase()
-		.replace(/[-_.]+/g, " ")
-		.replace(/\s+/g, " ")
-		.trim();
-}
-
-export function lookupBenchmark(modelName: string): BenchmarkEntry | undefined {
-	const entries = benchmark.getCached();
-	const needle = normBench(modelName);
-	return (
-		entries.find((e) => normBench(e.model) === needle) ??
-		entries.find((e) => normBench(e.model).includes(needle)) ??
-		entries.find((e) => needle.includes(normBench(e.model)))
-	);
-}
+export {
+	benchmark,
+	buildModelsDevIndex,
+	CACHE_DIR,
+	DataSource,
+	fetchModelsDevIndex,
+	lookupBenchmark,
+	lookupInIndex,
+	lookupModelsDev,
+	modelsDev,
+} from "@xynogen/pix-data";
+export type {
+	BenchmarkEntry,
+	ModelsDevApi,
+	ModelsDevModel,
+} from "@xynogen/pix-data";
 
 export default function (_pi: unknown): void {
-	// pix-data warms this cache on startup — nothing to do here
+	// pix-data warms this cache on startup — nothing to do here.
 }

package/src/nudge/capability.test.ts

@@ -1,8 +1,11 @@
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { describe, expect, test } from "bun:test";
 import {
 	buildOrientation,
 	CAPABILITY_REMINDER,
 	countInvocableSkills,
+	graphifyHint,
 	partitionTools,
 } from "./capability.ts";
 
@@ -45,8 +48,14 @@ describe("CAPABILITY_REMINDER", () => {
 		expect(CAPABILITY_REMINDER.toLowerCase()).toContain("improvis");
 	});
 
-	test("points at the toolbox tool for discovery", () => {
-		expect(CAPABILITY_REMINDER).toContain("toolbox");
+	test("nudges model to call skill() when a skill matches", () => {
+		expect(CAPABILITY_REMINDER).toContain("skill()");
+	});
+
+	test("points at /toolbox slash command for discovery (not a function call)", () => {
+		expect(CAPABILITY_REMINDER).toContain("/toolbox");
+		// must NOT imply toolbox is a callable function
+		expect(CAPABILITY_REMINDER).not.toContain("toolbox(");
 		expect(CAPABILITY_REMINDER).toContain("function definitions");
 	});
 });
@@ -123,10 +132,13 @@ describe("buildOrientation", () => {
 		expect(out).toContain("2 skills");
 	});
 
-	test("explains how to explore via the toolbox tool", () => {
+	test("explains how to use skill() and /toolbox for discovery", () => {
 		const out = buildOrientation([tool("read", "builtin")], []);
-		expect(out).toContain("toolbox(query");
-		expect(out.toLowerCase()).toMatch(/fuzzy|search|discover/);
+		expect(out).toContain("skill()");
+		expect(out).toContain("/toolbox");
+		// toolbox must NOT appear as a function call
+		expect(out).not.toContain("toolbox(");
+		expect(out.toLowerCase()).toMatch(/discover|enable/);
 	});
 
 	test("calls out gated tools and points at toolbox to enable them", () => {
@@ -192,4 +204,32 @@ describe("buildOrientation", () => {
 		const out = buildOrientation([tool("read", "builtin")], []);
 		expect(out.toLowerCase()).toContain("improvis");
 	});
+
+	test("frames the block as non-actionable so the model acts on the prompt", () => {
+		const out = buildOrientation([tool("read", "builtin")], []);
+		const last = out.trim().split("\n").at(-1) ?? "";
+		expect(last.toLowerCase()).toContain("not a task");
+		expect(last.toLowerCase()).toContain("do not reply");
+	});
+});
+
+describe("graphifyHint", () => {
+	const tmpDir = join(import.meta.dir, ".graphify-hint-test-tmp");
+
+	test("returns undefined when graphify-out/graph.json absent", () => {
+		expect(graphifyHint(tmpDir)).toBeUndefined();
+	});
+
+	test("returns hint string when graphify-out/graph.json exists", () => {
+		try {
+			mkdirSync(join(tmpDir, "graphify-out"), { recursive: true });
+			writeFileSync(join(tmpDir, "graphify-out", "graph.json"), "{}");
+			const hint = graphifyHint(tmpDir);
+			expect(hint).toBeTypeOf("string");
+			expect(hint).toContain("graphify");
+			expect(hint).toContain("graphify query");
+		} finally {
+			rmSync(tmpDir, { recursive: true, force: true });
+		}
+	});
 });

package/src/nudge/capability.ts

@@ -9,13 +9,19 @@
  * Two modes:
  *   1. FIRST prompt of the session — an orientation block: a high-level
  *      description of WHAT is available (counts of tools / MCP tools / skills)
- *      and HOW to explore it on demand via the `toolbox` tool. We deliberately
- *      do NOT dump the whole inventory every turn — that is what `toolbox`
- *      (fuzzy search over names + descriptions) is for.
+ *      and HOW to explore it. We deliberately do NOT dump the whole inventory
+ *      every turn — the model should call skill() for skills and use /toolbox
+ *      (slash command, user-facing) to discover/enable gated tools.
  *   2. EVERY subsequent prompt — the terse one-line CAPABILITY_REMINDER, a
- *      cheap (~40 tok) reinforcement that points back at toolbox.
+ *      cheap (~40 tok) reinforcement that steers toward skill() and /toolbox.
+ *
+ * NOTE: `toolbox` is a slash command only (/toolbox) — NOT a model-callable
+ * function tool. The model cannot call toolbox() in function definitions.
+ * The `skill` tool IS model-callable: skill() lists/loads bundled skills.
  */
 
+import { existsSync } from "node:fs";
+import { join } from "node:path";
 import type {
 	BuildSystemPromptOptions,
 	ExtensionAPI,
@@ -26,10 +32,25 @@ type LoadedSkill = NonNullable<BuildSystemPromptOptions["skills"]>[number];
 
 /** The standing per-turn reminder. Kept terse — it ships on every turn. */
 export const CAPABILITY_REMINDER =
-	"Reminder — always check your knowledge resources " +
+	"Reminder — check knowledge resources " +
 	"(skills/tools/MCP/web/user) before improvising. " +
-	"`toolbox(query)` finds the right one; enable gated tools via toolbox. " +
-	"All tools are always callable via function definitions.";
+	"Matching skill? Call skill() first. " +
+	"Use /toolbox to discover/enable gated tools. " +
+	"All tools callable via function definitions.";
+
+/**
+ * Build the optional graphify hint line.
+ * Returns a string if graphify-out/graph.json exists in cwd, else undefined.
+ */
+export function graphifyHint(cwd: string): string | undefined {
+	if (existsSync(join(cwd, "graphify-out", "graph.json"))) {
+		return (
+			"graphify-out/graph.json exists — for codebase questions (how does X work, " +
+			'where is Y, trace Z) run `graphify query "<question>"` before reading files.'
+		);
+	}
+	return undefined;
+}
 
 /** Count model-invocable skills (excludes user-only /skill:name entries). */
 export function countInvocableSkills(
@@ -107,11 +128,21 @@ export function buildOrientation(
 	if (gateLine) lines.push(gateLine);
 	lines.push(
 		"Don't improvise what a capability covers — ask the user, search the web, or pull docs first.",
-		"toolbox is the gateway: `toolbox(query)` searches tools/MCP/skills/commands; `toolbox(action:'enable'|'disable', name)` toggles a gated tool prompt-visible or gated. Empty query lists all.",
+		"`skill()` lists/loads bundled skills — call it when a skill matches your task. " +
+			"/toolbox (slash command) discovers and enables gated tools.",
 	);
 	if (skillNames.length) {
 		lines.push(`Skills: ${skillNames.join(", ")}.`);
 	}
+	// Graphify hint — only when a graph is already built for this project
+	const gHint = graphifyHint(process.cwd());
+	if (gHint) lines.push(gHint);
+	// Framing — this block is orientation context, not a task. Without it the
+	// model can mistake the first-turn orientation for the prompt and reply
+	// "Ready, waiting for task" instead of acting on the user's request.
+	lines.push(
+		"(Orientation only — not a task. Act on the user's request now; do not reply to this notice.)",
+	);
 	return lines.join("\n");
 }
 
@@ -140,7 +171,12 @@ export default function registerCapabilityNudge(pi: ExtensionAPI): void {
 			}
 			content = buildOrientation(tools, skills, activeToolNames);
 		} else {
-			content = CAPABILITY_REMINDER;
+			// Per-turn reminder — append graphify hint when graph exists
+			const cwd = process.cwd();
+			const gHint = graphifyHint(cwd);
+			content = gHint
+				? `${CAPABILITY_REMINDER}\n${gHint}`
+				: CAPABILITY_REMINDER;
 		}
 
 		return {

package/src/tool/ask/ask.test.ts

@@ -13,7 +13,7 @@ import {
 	type OptionData,
 	type QuestionData,
 	sentinelsFor,
-} from "./ask.ts";
+} from "./index.ts";
 
 // ── Fixtures ──────────────────────────────────────────────────────────
 
@@ -237,7 +237,7 @@ describe("buildResponseText", () => {
 
 describe("registerAsk", () => {
 	test("exports a default function", async () => {
-		const mod = await import("./ask.ts");
+		const mod = await import("./index.ts");
 		expect(typeof mod.default).toBe("function");
 	});
 });

package/src/tool/ask/components.ts

@@ -0,0 +1,55 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { type Component, truncateToWidth } from "@earendil-works/pi-tui";
+import type { QuestionData } from "./schema.js";
+
+// ── Color helpers ──────────────────────────────────────────────────────
+
+export function borderColor(theme: Theme): (s: string) => string {
+	return (s: string) => theme.fg("accent", s);
+}
+
+export function dim(theme: Theme): (s: string) => string {
+	return (s: string) => theme.fg("dim", s);
+}
+
+// ── TabBar ─────────────────────────────────────────────────────────────
+
+export class TabBar implements Component {
+	private questions: QuestionData[];
+	private activeIndex: number;
+	private theme: Theme;
+
+	constructor(questions: QuestionData[], activeIndex: number, theme: Theme) {
+		this.questions = questions;
+		this.activeIndex = activeIndex;
+		this.theme = theme;
+	}
+
+	invalidate(): void {}
+
+	render(width: number): string[] {
+		const t = this.theme;
+		const inner = Math.max(10, width - 2);
+
+		const parts: string[] = [];
+		for (let i = 0; i < this.questions.length; i++) {
+			const active = i === this.activeIndex;
+			const num = `${i + 1}`;
+			const tag = `${num}.${this.questions[i]?.header}`;
+			parts.push(active ? t.fg("accent", t.bold(tag)) : t.fg("dim", tag));
+		}
+		const line = parts.join(t.fg("dim", "  "));
+		return [
+			truncateToWidth(
+				t.fg("accent", "╭─") +
+					line +
+					t.fg(
+						"accent",
+						`${"─".repeat(Math.max(0, inner - line.length - 1))}╮`,
+					),
+				width,
+				"",
+			),
+		].filter(Boolean);
+	}
+}

package/src/tool/ask/helpers.ts

@@ -0,0 +1,77 @@
+import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
+import type { MarkdownTheme } from "@earendil-works/pi-tui";
+import type { OptionData, QuestionData } from "./schema.js";
+import { SENTINEL_CHAT, SENTINEL_FREEFORM, SENTINEL_NEXT } from "./schema.js";
+import type { AnswerKind, QuestionAnswer } from "./types.js";
+
+// ── Markdown theme ─────────────────────────────────────────────────────
+
+export function safeMarkdownTheme(): MarkdownTheme | undefined {
+	try {
+		const md = getMarkdownTheme();
+		if (!md) return undefined;
+		md.bold("");
+		return md;
+	} catch {
+		return undefined;
+	}
+}
+
+// ── Option / question helpers ──────────────────────────────────────────
+
+export function hasAnyPreview(q: QuestionData): boolean {
+	return q.options.some(
+		(o) => typeof o.preview === "string" && o.preview.length > 0,
+	);
+}
+
+/** Which sentinel rows are auto-appended for a question. */
+export function sentinelsFor(
+	q: QuestionData,
+): Array<{ kind: string; label: string }> {
+	const out: Array<{ kind: string; label: string }> = [];
+	if (q.multiSelect) {
+		out.push({ kind: "next", label: SENTINEL_NEXT });
+	} else if (!hasAnyPreview(q)) {
+		out.push({ kind: "other", label: SENTINEL_FREEFORM });
+	}
+	return out;
+}
+
+// ── Answer formatting ──────────────────────────────────────────────────
+
+export function formatAnswerScalar(a: QuestionAnswer): string {
+	if (a.kind === "multi") return (a.selected ?? []).join(", ");
+	if (a.kind === "custom") return a.answer ?? "(custom)";
+	if (a.kind === "chat") return "(chat)";
+	return a.answer ?? "(selected)";
+}
+
+export function buildResponseText(
+	answers: QuestionAnswer[],
+	questions: QuestionData[],
+): string {
+	const segs: string[] = [];
+	for (const a of answers) {
+		const q = questions[a.questionIndex]?.question ?? `Q${a.questionIndex + 1}`;
+		let s = `"${q}"="${formatAnswerScalar(a)}"`;
+		if (a.preview) s += `. selected preview: ${a.preview}`;
+		segs.push(s);
+	}
+	return segs.length
+		? `User answered: ${segs.join(". ")}.`
+		: "User declined to answer questions.";
+}
+
+// ── Scroll indicator ───────────────────────────────────────────────────
+
+export function scrollIndicator(index: number, total: number): string {
+	if (total <= 1) return "";
+	const pos = Math.round((index / (total - 1)) * 6);
+	const bar = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦"][pos] ?? "·";
+	return ` ${bar} ${index + 1}/${total}`;
+}
+
+export type { AnswerKind, OptionData, QuestionData };
+// Re-export sentinel constants so callers don't need to import schema directly
+export { SENTINEL_CHAT, SENTINEL_FREEFORM, SENTINEL_NEXT };