@groeponline/pi-wishcraft 1.6.0 → 1.9.0

package/README.md

@@ -1,44 +1,54 @@
-<p>
-  <img src="https://raw.githubusercontent.com/GroepOnline/pi-wishcraft/main/banner.png" alt="pi-wishcraft" width="1100">
+<p align="center">
+  <img src="https://raw.githubusercontent.com/GroepOnline/pi-wishcraft/main/banner.png" alt="Pi Wishcraft" width="100%">
 </p>
 
-<p>
+<h1 align="center">Pi Wishcraft</h1>
+
+<p align="center"><strong>Your operator cockpit for Pi.</strong><br>See what the session is doing, park ideas without interrupting it, search skills, switch into Bash, and keep the important controls one keypress away.</p>
+
+<p align="center">
   <a href="https://www.npmjs.com/package/@groeponline/pi-wishcraft"><img src="https://img.shields.io/npm/v/@groeponline/pi-wishcraft.svg" alt="npm version"></a>
   <a href="https://www.npmjs.com/package/@groeponline/pi-wishcraft"><img src="https://img.shields.io/npm/dm/@groeponline/pi-wishcraft.svg?label=downloads" alt="npm downloads"></a>
   <a href="https://pi.dev/packages/@groeponline/pi-wishcraft"><img src="https://img.shields.io/badge/Pi-package-9b59b6.svg" alt="Pi package"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-555.svg" alt="MIT license"></a>
 </p>
 
-# pi-wishcraft
-
-Cockpit and harness for the [pi](https://github.com/badlogic/pi-mono) coding agent: a live status bar, overlay menus, skills, an idea inbox, sticky bash, hooks, and tool-input repairs. Stock pi stays the engine. This package is the operator layer.
-Kongming lanterns started as battlefield signals and later carried wishes. Wishcraft is that split in a coding session: telemetry on the bar, thoughts you can park without interrupting the run.
+<p align="center"><img src="https://raw.githubusercontent.com/GroepOnline/pi-wishcraft/main/docs/images/wishcraft-cockpit-map.svg" alt="Wishcraft cockpit map showing Signal, Deck, idea capture, skills, managed shell and local guardrails around Pi" width="100%"><br><sub>A map of the shipped operator surfaces. Pi remains the agent runtime.</sub></p>
 
-Install `@groeponline/pi-wishcraft`. It is listed on the [Pi package catalog](https://pi.dev/packages/@groeponline/pi-wishcraft). Grew out of [`nicobailon/pi-powerline-footer`](https://github.com/nicobailon/pi-powerline-footer). Maintained by [GroepOnline](https://github.com/GroepOnline).
+## Start in 10 seconds
 
-Guides live in [`docs/`](docs/index.md). This is the Pi extension contract: what ships, how to install it, and what can fail.
+```bash
+pi install npm:@groeponline/pi-wishcraft
+```
 
-## Quick start tutorial
+Reload Pi, then press `alt+p` to open the Deck.
 
-Install, restart Pi (or run `/reload`), then press `alt+p` for the Deck. Try `/signal menu`, `/skills`, `/ideas`, and `ctrl+shift+b`. Full setup: [docs/configuration.md](docs/configuration.md).
+Try the two flows that make Wishcraft click fastest:
 
-## v2 Platform (in this release)
+```text
+# remember to benchmark the new provider path
+/ideas
+```
 
-## Install
+The `#` line is captured as an idea instead of being sent as a prompt. Your active run keeps going.
 
-Pi package manager (usual path):
+Then open the skill picker:
 
-```bash
-pi install npm:@groeponline/pi-wishcraft
+```text
+/skills
 ```
 
-For a local checkout or CI environment, run the repository bootstrap script with Bash:
+Search, inspect and insert a skill without leaving the session.
 
-```bash
-bash ./scripts/install.sh
-```
+## Why Wishcraft
+
+Pi stays the engine. Wishcraft adds the operator layer around it: live status, overlays, idea capture, skill search, sticky Bash, hooks, policy controls and session UX.
+
+Kongming lanterns started as battlefield signals and later carried wishes. Wishcraft keeps both ideas in one place: telemetry while the work is moving, and thoughts you can park until you are ready for them.
+
+**Portfolio boundary:** Wishcraft owns the operator cockpit and lightweight idea capture. Promote durable work to [`pi-missions`](https://github.com/GroepOnline/pi-missions), then use [`pi-agent-orchestrator`](https://github.com/GroepOnline/pi-agent-orchestrator) when parallel or isolated execution adds value: `idea -> mission -> orchestration run`.
 
-Then restart Pi or `/reload`. Pi host packages are declared as `peerDependencies: "*"`, matching the Pi package contract.
+Guides live in [`docs/`](docs/index.md).
 
 ## What you get
 
@@ -81,12 +91,6 @@ Activates on load. `/signal` toggles it. `/signal <preset>` switches the informa
 /vibe star trek       themed working messages
 ```
 
-Queue:
-
-- `# <text>` current project; `# @global`, `# @current`, `# @alias`
-- `/idea`, `/ideas`, `/queue` for capture, send, retry, clear, archive
-- `/ideas` overlay: `reviewStatus` (`idea` / `in-progress` / `done`), tags, Run with skill X
-
 Keybinds (`powerlineShortcuts`, applied after `/reload`; `null` disables):
 
 ```json
@@ -115,10 +119,6 @@ Keybinds (`powerlineShortcuts`, applied after `/reload`; `null` disables):
 
 `chef` is muted colors, slash separators, live TPS in/out, and TCP port count. Built-in presets: `default`, `minimal`, `compact`, `full`, `nerd`, `ascii`, `chef`. Custom segments, labels, layout, and presets are documented in [docs/configuration.md](docs/configuration.md). For every setting at its default, see [`examples/settings.example.json`](examples/settings.example.json).
 
-Nerd Fonts auto-detect for iTerm, WezTerm, Kitty, Ghostty, and Alacritty; ASCII otherwise. `POWERLINE_NERD_FONTS=0` forces ASCII.
-
-Context turns warning above 70% and error above 90%. TPS is tokens in the last ~1s, not a session average. `/tps` reads that ring; it does not start a second sampler.
-
 Daily token budget (never blocks a turn):
 
 ```json
@@ -222,18 +222,18 @@ No shell commands — pure in-process regex. Evaluated before command hooks. `wi
 ```
 
 
+Privacy/network boundary: ideas, settings, usage ledgers, and normal cockpit state stay local; there is no package-owned telemetry backend. Optional exchange-rate/DeepWiki features and operator-defined hooks cross the network/process boundary only when used.
 ## Limits
 
 - No mouse on the live footer. Pi core owns that surface.
 - No second `alt+i` product. Ports stay on `alt+i`; other detail is `→` in the navigator.
-- ChefGroep status keys (`powerline.preset`, `powerline.tps`, `powerline.ports`) exist for other extensions. They are not the public pitch.
+- Compatibility status keys (`powerline.preset`, `powerline.tps`, `powerline.ports`) are available to peer extensions; normal Wishcraft use does not require them.
 - The legacy `@groeponline/pi-powerline-footer` package is deprecated in favor of `@groeponline/pi-wishcraft`.
 - Tags are not rewritten. 0.19.x through current stay on the timeline.
 
 ## vNext Direction
 
 Wishcraft is Pi's animated operator layer. See the [release plan](docs/design/vnext-release-plan.md) and [design corpus](docs/index.md#design-system--vnext-specifications).
-
 ## Docs
 
 - [Commands](docs/commands.md)

package/bash-mode/editor.ts

@@ -31,6 +31,24 @@ import type {
   GhostSuggestion,
 } from "./types.ts";
 
+const BRACKETED_PASTE_START = "\x1b[200~";
+const BRACKETED_PASTE_END = "\x1b[201~";
+
+function splitTrailingPasteMarkerPrefix(value: string): [string, string] {
+  let tail = "";
+  for (const marker of [BRACKETED_PASTE_START, BRACKETED_PASTE_END]) {
+    const max = Math.min(marker.length - 1, value.length);
+    for (let length = max; length > tail.length; length -= 1) {
+      const candidate = value.slice(-length);
+      if (marker.startsWith(candidate)) {
+        tail = candidate;
+        break;
+      }
+    }
+  }
+  return tail ? [value.slice(0, -tail.length), tail] : [value, ""];
+}
+
 export class BashModeEditor extends CustomEditor {
   private readonly keybindingsRef: KeybindingsManager;
   private readonly optionsRef: BashModeEditorOptions;
@@ -43,6 +61,10 @@ export class BashModeEditor extends CustomEditor {
   private ghostAbort: AbortController | null = null;
   private ghostToken = 0;
   private ghostSchedule: ReturnType<typeof setTimeout> | null = null;
+  /** A bracketed paste was split across input chunks while forwarding. */
+  private forwardPasteOpen = false;
+  /** Trailing prefix of a bracketed-paste delimiter awaiting the next input chunk. */
+  private forwardPasteMarkerTail = "";
 
   constructor(
     tui: any,
@@ -112,6 +134,25 @@ export class BashModeEditor extends CustomEditor {
   }
 
   handleInput(data: string): void {
+    // v2 forward-mode gate, shared by the paste branch (issue #72) and the
+    // per-keystroke forward further down: while a command runs, input
+    // belongs to the child stdin, never to the editor buffer behind it.
+    const forwardActive =
+      this.optionsRef.isBashModeActive() &&
+      this.optionsRef.isShellRunning() &&
+      (this.optionsRef.forwardWhileRunning?.() ?? false) &&
+      this.optionsRef.onForwardInput != null;
+    if (!forwardActive) {
+      this.forwardPasteOpen = false;
+      this.forwardPasteMarkerTail = "";
+    } else {
+      data = this.forwardPasteMarkerTail + data;
+      const [complete, tail] = splitTrailingPasteMarkerPrefix(data);
+      data = complete;
+      this.forwardPasteMarkerTail = tail;
+      if (!data) return;
+    }
+
     const droppedPathText = droppedPathTextFromInput(data);
     if (droppedPathText !== null) {
       this.insertTextAtCursor(droppedPathText);
@@ -125,8 +166,23 @@ export class BashModeEditor extends CustomEditor {
     }
 
     const pasteInProgress =
-      data.includes("\x1b[200~") || Reflect.get(this, "isInPaste") === true;
+      data.includes(BRACKETED_PASTE_START) ||
+      data.includes(BRACKETED_PASTE_END) ||
+      Reflect.get(this, "isInPaste") === true ||
+      (forwardActive && this.forwardPasteOpen);
     if (pasteInProgress) {
+      if (forwardActive) {
+        const startIndex = data.lastIndexOf(BRACKETED_PASTE_START);
+        const endIndex = data.lastIndexOf(BRACKETED_PASTE_END);
+        if (startIndex !== -1 || endIndex !== -1) {
+          this.forwardPasteOpen = startIndex > endIndex;
+        }
+        const payload = data
+          .replaceAll(BRACKETED_PASTE_START, "")
+          .replaceAll(BRACKETED_PASTE_END, "");
+        if (payload) this.optionsRef.onForwardInput?.(payload);
+        return;
+      }
       super.handleInput(data);
       if (Reflect.get(this, "isInPaste") === true) {
         return;
@@ -169,15 +225,14 @@ export class BashModeEditor extends CustomEditor {
       // (\x04) must also forward — line-oriented stdin programs (read,
       // sudo, git rebase -i) cannot proceed without a line terminator.
       // Opt-in via forwardWhileRunning so v1 run-blocked behavior unchanged.
+      // (forwardActive is computed above; bracketed pastes take the paste
+      // branch, which forwards the stripped payload too.)
       if (
-        bashMode &&
-        this.optionsRef.isShellRunning() &&
-        (this.optionsRef.forwardWhileRunning?.() ?? false) &&
-        this.optionsRef.onForwardInput != null &&
+        forwardActive &&
         !isKeyRelease(data) &&
         (isPrintableInput(data) || data === "\r" || data === "\n" || data === "\x04")
       ) {
-        this.optionsRef.onForwardInput(data);
+        this.optionsRef.onForwardInput?.(data);
         return;
       }
 
@@ -279,17 +334,34 @@ export class BashModeEditor extends CustomEditor {
       }
 
       if (
-        bashMode &&
+        (bashMode || oneOffBashCommand) &&
         this.keybindingsRef.matches(data, "tui.input.submit") &&
         !this.keybindingsRef.matches(data, "tui.input.newLine")
       ) {
+        // One-off bang prompts run the text after the prefix (mirrors pi's
+        // own !/!! handling in interactive-mode.js); anything else submits
+        // verbatim. Without the strip the bang would hit bash history
+        // expansion (`!cmd` = replay a previous command) instead of `cmd`.
+        const raw = this.getExpandedText().trim();
+        const oneOff = getOneOffBashCommandContext(raw);
+        const command = oneOff ? oneOff.command.trim() : raw;
+        if (!command) {
+          // Bash-off bare `!`: fall back to pi's own submit handling, whose
+          // `if (command)` guard turns an empty command into a normal prompt
+          // (pre-interception behavior). Full bash mode keeps the return.
+          // This must run before the shell-running guard: a bare `!` while a
+          // managed shell job runs should still delegate to pi, not be
+          // swallowed by the "already running" warning.
+          if (!bashMode) {
+            super.handleInput(data);
+          }
+          return;
+        }
+
         if (this.optionsRef.isShellRunning()) {
           this.optionsRef.onNotify("Shell command already running", "warning");
           return;
         }
-
-        const command = this.getExpandedText().trim();
-        if (!command) return;
         this.clearGhostSuggestion();
         resetShellHistoryBrowse(this);
         this.optionsRef.onEditorSubmit?.();

package/bash-mode/pty-session.ts

@@ -22,6 +22,38 @@ import { basename, join } from "node:path";
 import { randomBytes } from "node:crypto";
 import { spawn, spawnSync, type ChildProcessWithoutNullStreams } from "node:child_process";
 
+const MAX_PENDING_LINE_BYTES = 64 * 1024;
+const MAX_ESCAPE_TAIL_CHARS = 4096;
+const TRUNCATED_LINE_NOTICE = "[wishcraft] output line truncated; keeping tail";
+
+/**
+ * Restricts a string to its trailing UTF-8 bytes without splitting a multibyte character.
+ *
+ * @param value - The string to restrict
+ * @param maxBytes - The maximum number of UTF-8 bytes to retain
+ * @returns The UTF-8-safe trailing portion of `value`
+ */
+function utf8Tail(value: string, maxBytes: number): string {
+  if (maxBytes <= 0) return "";
+  const bytes = Buffer.from(value, "utf8");
+  if (bytes.length <= maxBytes) return value;
+  let start = bytes.length - maxBytes;
+  while (start < bytes.length && (bytes[start]! & 0xc0) === 0x80) start += 1;
+  return bytes.subarray(start).toString("utf8");
+}
+
+/**
+ * Limits a partial terminal escape sequence to the configured character bound while preserving its introducer.
+ *
+ * @param value - The partial escape sequence to limit
+ * @returns The original value or a bounded value with its escape introducer preserved
+ */
+function boundedEscapeTail(value: string): string {
+  if (value.length <= MAX_ESCAPE_TAIL_CHARS) return value;
+  const prefixLength = value.startsWith("\x1b") && value.length > 1 ? 2 : 1;
+  return value.slice(0, prefixLength) + value.slice(-(MAX_ESCAPE_TAIL_CHARS - prefixLength));
+}
+
 /**
  * Fresh per-command completion delimiter. The wrapper prints it after the
  * sourced script ends; because it is unpredictable, a command cannot forge
@@ -119,6 +151,10 @@ interface RunningCommand {
   buffer: string;
   /** Trailing partial escape sequence carried across chunks. */
   escapeTail: string;
+  /** Wrapper result observed on stdout; publication waits for child close. */
+  pendingResult: PtyRunResult | null;
+  /** Emit at most one notice when a single output line exceeds the pending cap. */
+  lineTruncated: boolean;
   resolve: (result: PtyRunResult) => void;
   settled: boolean;
 }
@@ -179,6 +215,8 @@ export class PtyShellSession {
         done,
         buffer: "",
         escapeTail: "",
+        pendingResult: null,
+        lineTruncated: false,
         resolve: (result) => {
           if (running.settled) return;
           running.settled = true;
@@ -224,9 +262,8 @@ export class PtyShellSession {
       child.stderr.on("data", (chunk: string) => this.handleChunk(String(chunk)));
       child.on("error", (error) => {
         // spawn itself failed (script removed between probe and spawn, dead
-        // SHELL path): surface the reason, then settle as a normal failure.
-        // The first script-path failure also flips the probe cache so the
-        // next command degrades to pipes instead of silently failing again.
+        // SHELL path): surface the reason, but do not publish completion until
+        // the matching child emits close. That preserves strict child ownership.
         console.warn(
           "[wishcraft] spawn failed:",
           error instanceof Error ? error.message : String(error),
@@ -234,20 +271,24 @@ export class PtyShellSession {
         if (usePty) {
           _resetScriptAvailableForTests();
         }
-        running.resolve({ exitCode: 1, cwd: this.state.cwd });
+        running.pendingResult = { exitCode: 1, cwd: this.state.cwd };
       });
       child.on("close", (code, signal) => {
-        this.child = null;
-        // No sentinel observed. An operator interrupt never lets the command
-        // complete, so it maps to 130 regardless of how `script` exits.
+        if (this.child === child) {
+          this.child = null;
+        }
+        // Completion is published only after this exact child closes, so a
+        // later run cannot have its child reference cleared by this callback.
         if (this.interrupted) {
           running.resolve({ exitCode: 130, cwd: this.state.cwd });
           return;
         }
-        running.resolve({
-          exitCode: getCloseExitCode(code, signal),
-          cwd: this.state.cwd,
-        });
+        running.resolve(
+          running.pendingResult ?? {
+            exitCode: getCloseExitCode(code, signal),
+            cwd: this.state.cwd,
+          },
+        );
       });
     });
   }
@@ -302,8 +343,9 @@ export class PtyShellSession {
     let work = merged;
     const partial = /(?:\x1b(?:\[[0-9;?]*[ -/]*|\][^\x07\x1b]*|[P^_][^\x07\x1b]*))$|\x1b$/.exec(work);
     if (partial) {
-      running.escapeTail = partial[0];
-      work = work.slice(0, work.length - running.escapeTail.length);
+      const rawTail = partial[0];
+      running.escapeTail = boundedEscapeTail(rawTail);
+      work = work.slice(0, work.length - rawTail.length);
     }
 
     const color = this.color && this.state.mode === "pty";
@@ -311,7 +353,13 @@ export class PtyShellSession {
 
     running.buffer += filtered;
     const parts = running.buffer.split("\n");
-    running.buffer = parts.pop() ?? "";
+    const remainder = parts.pop() ?? "";
+    const boundedRemainder = utf8Tail(remainder, MAX_PENDING_LINE_BYTES);
+    if (boundedRemainder !== remainder && !running.lineTruncated) {
+      running.lineTruncated = true;
+      this.onOutput(TRUNCATED_LINE_NOTICE);
+    }
+    running.buffer = boundedRemainder;
 
     for (const rawLine of parts) {
       const line = rawLine.replace(/\r$/, "");
@@ -322,10 +370,10 @@ export class PtyShellSession {
         if (firstColon !== -1) {
           const exitCode = Number.parseInt(rest.slice(0, firstColon), 10);
           const cwd = rest.slice(firstColon + 1);
-          running.resolve({
+          running.pendingResult = {
             exitCode: Number.isFinite(exitCode) ? exitCode : 1,
             cwd: cwd || this.state.cwd,
-          });
+          };
           return;
         }
         continue;

package/bash-mode/transcript.ts

@@ -4,6 +4,29 @@ function byteLength(value: string): number {
   return Buffer.byteLength(value, "utf8");
 }
 
+/**
+ * Extracts the end of a string within a UTF-8 byte limit.
+ *
+ * @param value - The source string
+ * @param maxBytes - The maximum number of UTF-8 bytes to include
+ * @returns The UTF-8-safe tail of `value`
+ */
+function utf8Tail(value: string, maxBytes: number): string {
+  if (maxBytes <= 0) return "";
+  const bytes = Buffer.from(value, "utf8");
+  if (bytes.length <= maxBytes) return value;
+
+  let start = bytes.length - maxBytes;
+  while (start < bytes.length && (bytes[start]! & 0xc0) === 0x80) start += 1;
+  return bytes.subarray(start).toString("utf8");
+}
+
+/**
+ * Normalizes lines by removing carriage returns and splitting embedded newline characters.
+ *
+ * @param lines - The lines to normalize
+ * @returns The normalized lines
+ */
 function compactLines(lines: string[]): string[] {
   const normalized: string[] = [];
   for (const line of lines) {
@@ -119,8 +142,50 @@ export class BashTranscriptStore {
       this.commandIndex.delete(removed.id);
       this.totalLines = Math.max(0, this.totalLines - removed.output.length);
       this.totalBytes = Math.max(0, this.totalBytes - removed.outputBytes);
-      this.truncatedCommands += 1;
-      removed.truncated = true;
+      this.markTruncated(removed);
+    }
+
+    // A single active command used to bypass both global limits because there
+    // was no older command to evict. Trim that command from the head instead:
+    // bash mode is a tail-oriented live view, so the newest output is the
+    // useful part and memory remains bounded even for multi-megabyte logs.
+    const oldest = this.commands[0];
+    if (!oldest) return;
+
+    while (oldest.output.length > 0 && this.totalLines > this.settings.transcriptMaxLines) {
+      this.dropOldestLine(oldest);
+    }
+    while (oldest.output.length > 1 && this.totalBytes > this.settings.transcriptMaxBytes) {
+      this.dropOldestLine(oldest);
     }
+
+    if (oldest.output.length === 1 && this.totalBytes > this.settings.transcriptMaxBytes) {
+      const previous = oldest.output[0]!;
+      const previousBytes = byteLength(previous) + 1;
+      const bytesOutsideLine = Math.max(0, this.totalBytes - previousBytes);
+      const lineBudget = Math.max(0, this.settings.transcriptMaxBytes - bytesOutsideLine - 1);
+      const tail = utf8Tail(previous, lineBudget);
+      const tailBytes = byteLength(tail) + 1;
+      oldest.output[0] = tail;
+      oldest.outputBytes = Math.max(0, oldest.outputBytes - previousBytes + tailBytes);
+      this.totalBytes = Math.max(0, this.totalBytes - previousBytes + tailBytes);
+      this.markTruncated(oldest);
+    }
+  }
+
+  private dropOldestLine(command: BashCommandRecord): void {
+    const removed = command.output.shift();
+    if (removed === undefined) return;
+    const removedBytes = byteLength(removed) + 1;
+    command.outputBytes = Math.max(0, command.outputBytes - removedBytes);
+    this.totalLines = Math.max(0, this.totalLines - 1);
+    this.totalBytes = Math.max(0, this.totalBytes - removedBytes);
+    this.markTruncated(command);
+  }
+
+  private markTruncated(command: BashCommandRecord): void {
+    if (command.truncated) return;
+    command.truncated = true;
+    this.truncatedCommands += 1;
   }
 }