decorated-pi 0.8.0 → 0.8.1

package/README.md

@@ -32,13 +32,11 @@ Multiple layers of token savings that compound across every session.
 **Cache‑friendly Design** — stable system prompt prefix:
 
 - tool definitions, guidelines, and skills are sorted alphabetically so the system prompt is identical across sessions
-- volatile elements like `Current date: …` are stripped before prompt assembly
 - MCP tool schemas are persisted to a local cache, so the tool list stays stable regardless of network conditions or server availability
 
 **Pi Native Prompt Slimming**
 
 - move the default Pi documentation block out of the system prompt and into a builtin `pi-docs` skill, so the docs reference loads on demand instead of sitting in every turn's prompt
-- unregister the native `write` tool, since `bash` can handle it
 
 **Large Result Externalization**
 

package/hooks/image-vision.ts

@@ -4,7 +4,9 @@
  */
 
 import { fileTypeFromFile } from "file-type";
+import { Buffer } from "node:buffer";
 import * as fs from "node:fs";
+import * as os from "node:os";
 import { extname, resolve } from "node:path";
 import OpenAI from "openai";
 import type { Model } from "@earendil-works/pi-ai";
@@ -13,6 +15,12 @@ import type { Module, Skeleton } from "./skeleton.js";
 
 const SUPPORTED_IMAGE_TYPES = new Set(["image/jpeg", "image/png", "image/gif", "image/webp"]);
 
+function expandHome(filePath: string): string {
+  if (filePath.startsWith("~/")) return resolve(os.homedir(), filePath.slice(2));
+  if (filePath === "~") return os.homedir();
+  return filePath;
+}
+
 async function detectImageMimeType(filePath: string): Promise<string | null> {
   try {
     const type = await fileTypeFromFile(filePath);
@@ -32,6 +40,9 @@ export async function analyzeImage(
   if (model.api === "anthropic-messages") {
     return analyzeAnthropic(model, imageBase64, mediaType, apiKey, extraHeaders);
   }
+  if (model.api === "openai-codex-responses") {
+    return analyzeCodex(model, imageBase64, mediaType, apiKey, extraHeaders);
+  }
   return analyzeOpenAI(model, imageBase64, mediaType, apiKey, extraHeaders);
 }
 
@@ -51,6 +62,99 @@ async function analyzeOpenAI(
   return resp.choices[0]?.message?.content ?? "No analysis returned.";
 }
 
+function codexResponsesUrl(baseUrl?: string): string {
+  const base = (baseUrl || "https://chatgpt.com/backend-api").replace(/\/+$/, "");
+  return base.endsWith("/codex/responses") ? base
+    : base.endsWith("/codex") ? `${base}/responses`
+    : `${base}/codex/responses`;
+}
+
+function extractCodexAccountId(apiKey: string): string {
+  try {
+    const parts = apiKey.split(".");
+    if (parts.length !== 3) return "";
+    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
+    return payload?.["https://api.openai.com/auth"]?.chatgpt_account_id ?? "";
+  } catch {
+    return "";
+  }
+}
+
+function appendCodexSseDelta(outputText: string, line: string): string {
+  if (!line.startsWith("data: ")) return outputText;
+  const data = line.slice(6).trim();
+  if (data === "[DONE]") return outputText;
+  try {
+    const parsed = JSON.parse(data);
+    if (parsed.type === "response.output_text.delta") {
+      return outputText + (parsed.delta ?? "");
+    }
+  } catch { /* skip malformed */ }
+  return outputText;
+}
+
+async function analyzeCodex(
+  model: Model<any>, imageBase64: string, mediaType: string,
+  apiKey: string, extraHeaders: Record<string, string>,
+): Promise<string> {
+  // Codex uses /codex/responses, not the standard /responses path.
+  const url = codexResponsesUrl(model.baseUrl);
+
+  // Codex auth: extract accountId from JWT, set special headers.
+  const accountId = extractCodexAccountId(apiKey);
+
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    "Authorization": `Bearer ${apiKey}`,
+    "Originator": "pi",
+    "OpenAI-Beta": "responses=experimental",
+    "accept": "text/event-stream",
+    ...extraHeaders,
+  };
+  if (accountId) headers["chatgpt-account-id"] = accountId;
+
+  const resp = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      model: model.id,
+      store: false,
+      stream: true,
+      input: [{
+        role: "user",
+        content: [
+          { type: "input_text", text: DEFAULT_PROMPT },
+          { type: "input_image", image_url: `data:${mediaType};base64,${imageBase64}`, detail: "auto" },
+        ],
+      }],
+      text: { format: { type: "text" } },
+    }),
+    signal: AbortSignal.timeout(60_000),
+  });
+  if (!resp.ok) {
+    const text = await resp.text().catch(() => "");
+    throw new Error(`Codex API error ${resp.status}: ${text.slice(0, 300)}`);
+  }
+  // Codex only supports SSE streaming; read the event stream.
+  const reader = resp.body?.getReader();
+  if (!reader) throw new Error("No response body");
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let outputText = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split(/\r?\n/);
+    buffer = lines.pop() ?? "";
+    for (const line of lines) outputText = appendCodexSseDelta(outputText, line);
+  }
+  buffer += decoder.decode();
+  for (const line of buffer.split(/\r?\n/)) outputText = appendCodexSseDelta(outputText, line);
+  return outputText || "No analysis returned.";
+}
+
+
 async function analyzeAnthropic(
   model: Model<any>, imageBase64: string, mediaType: string,
   apiKey: string, extraHeaders: Record<string, string>,
@@ -83,10 +187,20 @@ export const imageVisionModule: Module = {
         if (event.toolName !== "read") return;
         const filePath: string | undefined = (event.input as any)?.file ?? (event.input as any)?.path;
         if (!filePath) return;
-        const mimeType = await detectImageMimeType(resolve(ctx.cwd, filePath));
+        const mimeType = await detectImageMimeType(resolve(ctx.cwd, expandHome(filePath)));
         if (!mimeType) return;
-        if (!getImageModelKey()) return;
+        const imageKey = getImageModelKey();
+        if (!imageKey) return;
         pendingImageFallbacks.add(event.toolCallId);
+        if (ctx.hasUI) {
+          const p = parseModelKey(imageKey);
+          if (p) {
+            ctx.ui.notify(
+              `🖼️ Analyzing image with ${p.provider}/${p.modelId}...`,
+              "info",
+            );
+          }
+        }
       },
     ],
     tool_result: [
@@ -101,7 +215,7 @@ export const imageVisionModule: Module = {
         const imageModel = ctx.modelRegistry.find(parsed.provider, parsed.modelId);
         if (!imageModel) return;
         try {
-          const absPath = resolve(ctx.cwd, filePath);
+          const absPath = resolve(ctx.cwd, expandHome(filePath));
           const imageData = fs.readFileSync(absPath);
           const imageBase64 = imageData.toString("base64");
           const mimeType = (await detectImageMimeType(absPath)) ?? "image/png";
@@ -113,13 +227,19 @@ export const imageVisionModule: Module = {
           );
           return {
             ...event,
-            content: [{ type: "text", text: `[Image analysis via ${parsed.provider}/${parsed.modelId}]\n\n${analysis}` }],
+            content: [{ type: "text", text: analysis }],
             details: { imageModel: imageKey, originalPath: filePath },
           };
         } catch (error) {
+          if (ctx.hasUI) {
+            ctx.ui.notify(
+              `Image analysis failed: ${error instanceof Error ? error.message : error}`,
+              "warning",
+            );
+          }
           return {
             ...event,
-            content: [{ type: "text", text: `Image analysis failed: ${error instanceof Error ? error.message : error}` }],
+            content: [{ type: "text", text: `Image analysis failed` }],
           };
         }
       },
@@ -130,3 +250,5 @@ export const imageVisionModule: Module = {
 export function setupImageVision(sk: Skeleton): void {
   sk.register(imageVisionModule);
 }
+
+export const __imageVisionTest = { expandHome, analyzeCodex, appendCodexSseDelta, codexResponsesUrl, extractCodexAccountId };

package/hooks/mcp.ts

@@ -360,9 +360,17 @@ export const mcpModule: Module = {
 
         // connectAll runs in the background so the watchdog tests
         // that mock hung connections don't block session_start.
+        //
+        // Capture hasUI / notify synchronously: connectAll may resolve
+        // after the session is replaced or reloaded, at which point `ctx`
+        // is stale and its `hasUI` getter throws via assertActive.
+        // Using the captured plain values avoids touching the stale ctx
+        // in the .then callback.
+        const hasUI = ctx.hasUI;
+        const notify = ctx.ui?.notify?.bind(ctx.ui);
         void connectAll(toConnect, ctx.modelRegistry, ctx).then(({ schemaChanges }) => {
-          if (schemaChanges.length > 0 && ctx.hasUI) {
-            ctx.ui.notify(`mcp schema changed! please '/reload'`, "warning");
+          if (schemaChanges.length > 0 && hasUI && notify) {
+            notify(`mcp schema changed! please '/reload'`, "warning");
           }
         });
       },

package/hooks/pi-tool-filter.ts

@@ -1,16 +1,12 @@
 /**
  * pi-tool-filter — unregister pi native tools that are replaced by our extensions.
  *
- *   edit   → replaced by patch
- *   write  → replaced by patch
- *   grep   → replaced by bash
- *   find   → replaced by bash
- *   ls     → replaced by bash
+ *   edit  → replaced by patch
  */
 
 import type { Module, Skeleton } from "./skeleton.js";
 
-const TOOLS_TO_DROP = new Set(["edit", "write", "grep", "find", "ls"]);
+const TOOLS_TO_DROP = new Set(["edit"]);
 
 export const piToolFilterModule: Module = {
   name: "pi-tool-filter",

package/index.ts

@@ -198,8 +198,7 @@ function installBuiltinSkills(pi: ExtensionAPI): void {
 }
 
 /** Install a single before_agent_start handler that appends every
- *  guideline in order, stripping the volatile "Current date: …" line
- *  for cache stability. Idempotent — re-injection is a no-op via marker. */
+ *  guideline in order. Idempotent — re-injection is a no-op via marker. */
 function installGuidelines(pi: ExtensionAPI): void {
     const blocks = buildGuidelines();
     const joined = blocks.join("\n\n");
@@ -209,7 +208,6 @@ function installGuidelines(pi: ExtensionAPI): void {
         if (!event.systemPrompt) return undefined;
         let prompt: string = stripPiDocsBlock(event.systemPrompt);
         prompt = sortSkillsInSystemPrompt(prompt);
-        prompt = prompt.replace(/\nCurrent date: \d{4}-\d{2}-\d{2}/, "");
         if (prompt.includes(marker)) return undefined; // already injected this turn
         return { systemPrompt: `${prompt}\n\n${joined}` };
     });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "decorated-pi",
-    "version": "0.8.0",
+    "version": "0.8.1",
     "description": "decorated-pi is a practical enhancement pack for pi coding agent — token-efficient workflow, cache-friendly design, and smarter tools.",
     "keywords": [
         "pi",

package/skills/pi-docs/SKILL.md

@@ -4,10 +4,9 @@ description: pi docs resources
 ---
 
 Pi documentation (read only when the user asks about pi itself, its SDK, extensions, themes, skills, or TUI):
-- Main documentation: /home/liuchang/.local/share/fnm/node-versions/v24.14.0/installation/lib/node_modules/@earendil-works/pi-coding-agent/README.md
-- Additional docs: /home/liuchang/.local/share/fnm/node-versions/v24.14.0/installation/lib/node_modules/@earendil-works/pi-coding-agent/docs
-- Examples: /home/liuchang/.local/share/fnm/node-versions/v24.14.0/installation/lib/node_modules/@earendil-works/pi-coding-agent/examples (extensions, custom tools, SDK)
-- When reading pi docs or examples, resolve docs/... under Additional docs and examples/... under Examples, not the current working directory
+- Main documentation: `$(npm root -g)/@earendil-works/pi-coding-agent/README.md`
+- Additional docs: `$(npm root -g)/@earendil-works/pi-coding-agent/docs`
+- Examples: `$(npm root -g)/@earendil-works/pi-coding-agent/examples` (extensions, custom tools, SDK)
 - When asked about: extensions (docs/extensions.md, examples/extensions/), themes (docs/themes.md), skills (docs/skills.md), prompt templates (docs/prompt-templates.md), TUI components (docs/tui.md), keybindings (docs/keybindings.md), SDK integrations (docs/sdk.md), custom providers (docs/custom-provider.md), adding models (docs/models.md), pi packages (docs/packages.md)
 - When working on pi topics, read the docs and examples, and follow .md cross-references before implementing
 - Always read pi .md files completely and follow links to related docs (e.g., tui.md for TUI API details)

package/tools/patch/core.ts

@@ -74,6 +74,8 @@ export interface ReplacementInfo {
   normStart?: number;
   /** Offset one past the matched region in normalized content (writeback). */
   normEnd?: number;
+  /** Anchor was provided but appeared multiple times; matcher fell back to a global old_str search. */
+  anchorNotUnique?: boolean;
   /** Optional anchor text (first line only, for hunk display) */
   anchor?: string;
   /** Anchor was provided but not found, and patch fell back to global old_str search */
@@ -202,6 +204,7 @@ type LocateEditResult =
       matchIdx: number;
       displayAnchor?: string;
       anchorMissing: boolean;
+      anchorNotUnique: boolean;
     }
   | {
       found: false;
@@ -225,6 +228,7 @@ function locateEdit(
   let searchFrom = 0;
   let displayAnchor: string | undefined;
   let anchorMissing = false;
+  let anchorNotUnique = false;
   let anchorState: "ok" | "missing" | "not_unique" = "ok";
   let anchorMessage: string | undefined;
 
@@ -253,7 +257,11 @@ function locateEdit(
   // ── Global exact match fallback (when anchor was missing/unusable) ──
   if (matchIdx === -1 && anchorMessage) {
     displayAnchor = edit.anchor;
-    anchorMissing = true;
+    // Distinguish the two degradation modes: a not-unique anchor still
+    // appeared in the file (just more than once), whereas a missing anchor
+    // did not appear at all. The diff label differs accordingly.
+    if (anchorState === "not_unique") anchorNotUnique = true;
+    else anchorMissing = true;
     matchIdx = content.indexOf(oldNorm, 0);
     if (matchIdx !== -1) {
       const secondGlobalMatch = content.indexOf(oldNorm, matchIdx + 1);
@@ -288,7 +296,7 @@ function locateEdit(
     }
   }
 
-  return { found: true, oldNorm, newNorm, matchIdx, displayAnchor, anchorMissing };
+  return { found: true, oldNorm, newNorm, matchIdx, displayAnchor, anchorMissing, anchorNotUnique };
 }
 
 async function applyEdits(
@@ -363,7 +371,7 @@ async function applyEdits(
         );
       }
 
-      const { oldNorm, newNorm, matchIdx, displayAnchor, anchorMissing } = located;
+      const { oldNorm, newNorm, matchIdx, displayAnchor, anchorMissing, anchorNotUnique } = located;
 
       const oldStartLine = lineAtOffset(lineOffsets, matchIdx - cumulativeOffset);
       const oldEndLine = lineAtOffset(lineOffsets, matchIdx - cumulativeOffset + oldNorm.length - 1);
@@ -389,6 +397,7 @@ async function applyEdits(
         normEnd,
         anchor: displayAnchor ? displayAnchor.split("\n")[0] : undefined,
         anchorMissing,
+        anchorNotUnique,
       });
     }
 
@@ -490,6 +499,7 @@ async function applyEdits(
       newLines: p.newNorm.split("\n").filter((l, i, arr) => !(i === arr.length - 1 && l === "")),
       anchor: p.displayAnchor ? p.displayAnchor.split("\n")[0] : undefined,
       anchorMissing: p.anchorMissing,
+      anchorNotUnique: p.anchorNotUnique,
     });
 
     neededRanges.push({
@@ -588,60 +598,26 @@ export async function computePatchPreview(
 
       for (const edit of patch.edits) {
         if (!edit.old_str) continue;
-        let oldNorm = normalizeLineEndings(edit.old_str);
-        let newNorm = normalizeLineEndings(edit.new_str);
-
-        let searchFrom = 0;
-        let displayAnchor: string | undefined;
-        let anchorMissing = false;
-        let anchorNotFoundMessage: string | undefined;
-        if (edit.anchor) {
-          const anchorNorm = normalizeLineEndings(edit.anchor);
-          const idx = content.indexOf(anchorNorm);
-          if (idx === -1) {
-            anchorNotFoundMessage = `Anchor not found: "${truncate(edit.anchor)}"`;
-          } else {
-            const secondAnchor = content.indexOf(anchorNorm, idx + 1);
-            if (secondAnchor !== -1) {
-              anchorNotFoundMessage = `Anchor is not unique: "${truncate(edit.anchor)}"`;
-            } else {
-              searchFrom = Math.max(0, idx - (oldNorm.length - 1));
-              displayAnchor = edit.anchor;
-              anchorMissing = false;
-            }
-          }
-        }
 
-        let matchIdx = anchorNotFoundMessage ? -1 : content.indexOf(oldNorm, searchFrom);
-        if (matchIdx === -1 && anchorNotFoundMessage) {
-          displayAnchor = edit.anchor;
-          anchorMissing = true;
-          matchIdx = content.indexOf(oldNorm, 0);
-          if (matchIdx !== -1) {
-            const secondGlobalMatch = content.indexOf(oldNorm, matchIdx + 1);
-            if (secondGlobalMatch !== -1) {
-              const dupDiag = diagnoseOldStrNotUnique(oldNorm, content);
-              return { error: `${anchorNotFoundMessage}\n${dupDiag}` };
-            }
-          }
+        // Reuse the shared locator so preview and apply can never drift
+        // apart on anchor / fuzzy / uniqueness semantics. The only
+        // difference is error reporting: apply throws, preview returns.
+        let located: LocateEditResult;
+        try {
+          located = locateEdit(edit, content, patch.path);
+        } catch (e) {
+          return { error: e instanceof Error ? e.message : String(e) };
         }
-
-        if (matchIdx === -1) {
-          const searchLine = 0;
-          const fuzzy = tryFuzzyLineMatch(oldNorm, content, searchLine);
-          if (fuzzy) {
-            oldNorm = fuzzy.matched;
-            matchIdx = fuzzy.idx;
-            newNorm = normalizeIndentForFuzzy(fuzzy.matched.split("\n")[0] ?? "", newNorm);
-          } else if (anchorNotFoundMessage) {
-            const diag = diagnoseOldStrMismatch(oldNorm, content);
-            return { error: `${anchorNotFoundMessage}\nold_str not found: "${truncate(edit.old_str)}"\n${diag}` };
-          } else {
-            const diag = diagnoseOldStrMismatch(oldNorm, content);
-            return { error: `old_str not found: "${truncate(edit.old_str)}".\n${diag}` };
+        if (!located.found) {
+          const diag = diagnoseOldStrMismatch(located.oldNorm, content);
+          if (located.anchorState === "missing" || located.anchorState === "not_unique") {
+            return { error: `${located.anchorMessage}\nold_str not found: "${truncate(edit.old_str)}"\n${diag}` };
           }
+          return { error: `old_str not found: "${truncate(edit.old_str)}".${edit.anchor ? ` after anchor "${truncate(edit.anchor)}"` : ""}\n${diag}` };
         }
 
+        const { oldNorm, newNorm, matchIdx, displayAnchor, anchorMissing, anchorNotUnique } = located;
+
         const origMatchIdx = matchIdx - cumulativeOffset;
         const oldStartLine = lineAtOffset(lineOffsets, origMatchIdx);
         const oldEndLine = lineAtOffset(lineOffsets, origMatchIdx + oldNorm.length - 1);
@@ -655,7 +631,7 @@ export async function computePatchPreview(
           startLine: Math.max(1, oldStartLine - CONTEXT_LINES),
           endLine: Math.min(totalLines, oldEndLine + CONTEXT_LINES),
         });
-        allReplacements.push({ oldStartLine, oldEndLine, newStartLine, newEndLine, oldLines, newLines, anchor: displayAnchor ? displayAnchor.split("\n")[0] : undefined, anchorMissing });
+        allReplacements.push({ oldStartLine, oldEndLine, newStartLine, newEndLine, oldLines, newLines, anchor: displayAnchor ? displayAnchor.split("\n")[0] : undefined, anchorMissing, anchorNotUnique });
         cumulativeOffset += newNorm.length - oldNorm.length;
       }
 
@@ -744,6 +720,7 @@ function buildReplacementChunks(
 interface ChunkAnchor {
   text: string;
   missing: boolean;
+  notUnique?: boolean;
 }
 
 function getChunkAnchors(chunk: ReplacementChunk): ChunkAnchor[] {
@@ -756,9 +733,13 @@ function getChunkAnchors(chunk: ReplacementChunk): ChunkAnchor[] {
     for (const text of texts) {
       const existing = byText.get(text);
       if (!existing) {
-        byText.set(text, { text, missing: Boolean(rep.anchorMissing) });
-      } else if (!rep.anchorMissing) {
-        existing.missing = false;
+        byText.set(text, { text, missing: Boolean(rep.anchorMissing), notUnique: Boolean(rep.anchorNotUnique) });
+      } else {
+        // A later rep with the same anchor text that did NOT degrade clears
+        // the stale flag — the anchor is usable in at least one rep, so
+        // don't keep a stale warning for the other.
+        if (!rep.anchorMissing) existing.missing = false;
+        if (!rep.anchorNotUnique) existing.notUnique = false;
       }
     }
   }
@@ -766,7 +747,9 @@ function getChunkAnchors(chunk: ReplacementChunk): ChunkAnchor[] {
 }
 
 function formatAnchorLabel(anchor: ChunkAnchor): string {
-  return anchor.text + (anchor.missing ? " (missing)" : "");
+  if (anchor.notUnique) return anchor.text + " (not unique)";
+  if (anchor.missing) return anchor.text + " (missing)";
+  return anchor.text;
 }
 
 function formatChunkHeader(chunk: ReplacementChunk): string {
@@ -1292,6 +1275,7 @@ function collapseSequentialReplacements(
         normEnd: merged.normEnd,
         anchor: undefined,
         anchorMissing: merged.anchorMissing || next.anchorMissing,
+        anchorNotUnique: merged.anchorNotUnique || next.anchorNotUnique,
       };
       j++;
     }

package/tools/patch/index.ts

@@ -162,13 +162,17 @@ function createSingleLineComponent(text: string) {
     };
 }
 
-function formatPatchMetaLine(line: string, theme: any): string {
-    const missingSuffix = " (missing)";
-    if (line.endsWith(missingSuffix)) {
-        return (
-            theme.fg("accent", line.slice(0, -missingSuffix.length)) +
-            theme.fg("warning", missingSuffix)
-        );
+export function formatPatchMetaLine(line: string, theme: any): string {
+    // Anchor status suffixes share the same warning color so a degraded
+    // anchor (missing or not-unique) stands out from the diff body.
+    const suffixes = [" (missing)", " (not unique)"];
+    for (const suffix of suffixes) {
+        if (line.endsWith(suffix)) {
+            return (
+                theme.fg("accent", line.slice(0, -suffix.length)) +
+                theme.fg("warning", suffix)
+            );
+        }
     }
     return theme.fg("accent", line);
 }

package/ui/ask.ts

@@ -18,7 +18,7 @@
  */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import { Container, Spacer, Text, type TUI, type Component, getKeybindings } from "@earendil-works/pi-tui";
+import { Container, Spacer, Text, matchesKey, Key, type TUI, type Component, getKeybindings } from "@earendil-works/pi-tui";
 
 export type AskQuestionType = "text" | "single" | "multi";
 
@@ -37,25 +37,30 @@ export interface AskAnswer {
 
 interface QuestionState {
   value: string | string[];
+  /** Cursor position within value for text type (0 = before first char). */
+  textCursor: number;
   cursor: number; // option cursor; opts.length maps to the "Other" row
   /** Typed text when the cursor sits on the "Other" row (single or multi). */
   customText: string;
+  /** Cursor position within customText (0 = before first char). */
+  customCursor: number;
   /** Multi only: whether "Other" is currently toggled into the selection. */
   customSelected: boolean;
 }
 
 function parseDefault(type: AskQuestionType, options: string[] | undefined, defaultValue: string | undefined): QuestionState {
   if (type === "text") {
-    return { value: defaultValue ?? "", cursor: 0, customText: "", customSelected: false };
+    const v = defaultValue ?? "";
+    return { value: v, textCursor: v.length, cursor: 0, customText: "", customCursor: 0, customSelected: false };
   }
   const opts = options ?? [];
   if (type === "single") {
     const idx = defaultValue ? Math.max(0, opts.indexOf(defaultValue)) : 0;
-    return { value: opts[idx] ?? "", cursor: idx, customText: "", customSelected: false };
+    return { value: opts[idx] ?? "", textCursor: 0, cursor: idx, customText: "", customCursor: 0, customSelected: false };
   }
   // multi: comma-separated default, or empty
   const selected = defaultValue ? defaultValue.split(",").map(s => s.trim()).filter(Boolean) : [];
-  return { value: selected, cursor: 0, customText: "", customSelected: false };
+  return { value: selected, textCursor: 0, cursor: 0, customText: "", customCursor: 0, customSelected: false };
 }
 
 /** Returns true for single/multi choice questions, which always get an
@@ -307,13 +312,23 @@ export class AskComponent extends Container {
     const state = this.currentState();
 
     if (q.type === "text") {
+      const tc = state.textCursor;
+      const val = state.value as string;
       if (data === "\x7f" || data === "backspace") {
-        state.value = (state.value as string).slice(0, -1);
+        if (tc > 0) {
+          state.value = val.slice(0, tc - 1) + val.slice(tc);
+          state.textCursor--;
+        }
+      } else if (matchesKey(data, Key.left)) {
+        if (tc > 0) state.textCursor--;
+      } else if (matchesKey(data, Key.right)) {
+        if (tc < val.length) state.textCursor++;
       } else if (data.length > 0 && data.charCodeAt(0) >= 0x20) {
         // Accept any printable character: ASCII, Latin-1, CJK, emoji
         // surrogate pairs. The earlier `>= " " && <= "~"` filter
         // rejected every code point above U+007F (i.e. all Chinese).
-        state.value = (state.value as string) + data;
+        state.value = val.slice(0, tc) + data + val.slice(tc);
+        state.textCursor += data.length;
       }
     } else if (q.type === "single" && q.options) {
       const opts = q.options;
@@ -328,18 +343,26 @@ export class AskComponent extends Container {
         const next = (state.cursor + 1) % totalLen;
         state.cursor = next;
         state.value = next < opts.length ? opts[next] : "";
+      } else if (onCustomRow) {
+        if (data === "\x7f" || data === "backspace") {
+          if (state.customCursor > 0) {
+            state.customText = state.customText.slice(0, state.customCursor - 1) + state.customText.slice(state.customCursor);
+            state.customCursor--;
+          }
+        } else if (matchesKey(data, Key.left)) {
+          if (state.customCursor > 0) state.customCursor--;
+        } else if (matchesKey(data, Key.right)) {
+          if (state.customCursor < state.customText.length) state.customCursor++;
+        } else if (data.length > 0 && data.charCodeAt(0) >= 0x20) {
+          state.customText = state.customText.slice(0, state.customCursor) + data + state.customText.slice(state.customCursor);
+          state.customCursor += data.length;
+        }
       } else if (data >= "1" && data <= "9") {
         const idx = parseInt(data, 10) - 1;
         if (idx < totalLen) {
           state.cursor = idx;
           state.value = idx < opts.length ? opts[idx] : "";
         }
-      } else if (onCustomRow) {
-        if (data === "\x7f" || data === "backspace") {
-          state.customText = state.customText.slice(0, -1);
-        } else if (data.length > 0 && data.charCodeAt(0) >= 0x20) {
-          state.customText += data;
-        }
       }
     } else if (q.type === "multi" && q.options) {
       const opts = q.options;
@@ -360,6 +383,21 @@ export class AskComponent extends Container {
           else selected.add(opt);
           state.value = Array.from(selected);
         }
+      } else if (onCustomRow) {
+        if (data === "\x7f" || data === "backspace") {
+          if (state.customCursor > 0) {
+            state.customText = state.customText.slice(0, state.customCursor - 1) + state.customText.slice(state.customCursor);
+            state.customCursor--;
+          }
+        } else if (matchesKey(data, Key.left)) {
+          if (state.customCursor > 0) state.customCursor--;
+        } else if (matchesKey(data, Key.right)) {
+          if (state.customCursor < state.customText.length) state.customCursor++;
+        } else if (data.length > 0 && data.charCodeAt(0) >= 0x20) {
+          state.customSelected = true;
+          state.customText = state.customText.slice(0, state.customCursor) + data + state.customText.slice(state.customCursor);
+          state.customCursor += data.length;
+        }
       } else if (data >= "1" && data <= "9") {
         const idx = parseInt(data, 10) - 1;
         if (idx < totalLen) {
@@ -372,15 +410,6 @@ export class AskComponent extends Container {
             state.value = Array.from(selected);
           }
         }
-      } else if (onCustomRow && data.length > 0 && data.charCodeAt(0) >= 0x20) {
-        // Typing on the "Other" row auto-selects it and feeds customText.
-        // Backspace never enters this branch (handled below).
-        if (data !== "\x7f" && data !== "backspace") {
-          state.customSelected = true;
-          state.customText += data;
-        } else {
-          state.customText = state.customText.slice(0, -1);
-        }
       }
     }
 
@@ -415,8 +444,11 @@ export class AskComponent extends Container {
 
     if (q.type === "text") {
       const value = state.value as string;
-      const cursor = this.theme.fg("accent", "_");
-      lines.push(value + cursor);
+      const tc = state.textCursor;
+      const before = value.slice(0, tc);
+      const after = value.slice(tc);
+      const cursor = this.theme.fg("accent", "|");
+      lines.push(`${before}${cursor}${after}`);
     } else if (q.type === "single" && q.options) {
       const opts = q.options;
       const totalLen = effectiveOptionCount(q);
@@ -432,12 +464,16 @@ export class AskComponent extends Container {
         let line: string;
         if (isCustomRow) {
           const text = state.customText;
-          const cmark = atCursor ? "_" : "";
-          line = `  ${icon} ${optLabel}: ${text}${cmark}`;
+          const cc = state.customCursor;
+          const before = text.slice(0, cc);
+          const after = text.slice(cc);
+          const cmark = atCursor ? this.theme.fg("accent", "|") : "";
+          const hl = atCursor ? this.theme.fg("accent", `  ${icon} ${optLabel}: `) : `  ${icon} ${optLabel}: `;
+          line = `${hl}${before}${cmark}${after}`;
         } else {
-          line = `  ${icon} ${optLabel}`;
+          line = atCursor ? this.theme.fg("accent", `  ${icon} ${optLabel}`) : `  ${icon} ${optLabel}`;
         }
-        lines.push(atCursor ? this.theme.fg("accent", line) : line);
+        lines.push(line);
       }
     } else if (q.type === "multi" && q.options) {
       const opts = q.options;
@@ -452,12 +488,16 @@ export class AskComponent extends Container {
         let line: string;
         if (isCustomRow) {
           const text = state.customText;
-          const cmark = atCursor ? "_" : "";
-          line = `  ${icon} ${optLabel}: ${text}${cmark}`;
+          const cc = state.customCursor;
+          const before = text.slice(0, cc);
+          const after = text.slice(cc);
+          const cmark = atCursor ? this.theme.fg("accent", "|") : "";
+          const hl = atCursor ? this.theme.fg("accent", `  ${icon} ${optLabel}: `) : `  ${icon} ${optLabel}: `;
+          line = `${hl}${before}${cmark}${after}`;
         } else {
-          line = `  ${icon} ${optLabel}`;
+          line = atCursor ? this.theme.fg("accent", `  ${icon} ${optLabel}`) : `  ${icon} ${optLabel}`;
         }
-        lines.push(atCursor ? this.theme.fg("accent", line) : line);
+        lines.push(line);
       }
     }