pi-umbra 0.3.1 → 0.4.0

package/node_modules/pi-umbra-subagents/extensions/umbra-subagents/fan/worktree.ts

@@ -0,0 +1,156 @@
+import { execFileSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, rmdirSync, rmSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type { GitResult } from "../skills/delegate/state.ts";
+
+// A `[write]` branch's own copy of the repo. It starts from what the user sees, uncommitted and
+// untracked work included, taken once per run as one base commit, so the branch's own changes
+// are exactly `base..branch` and can be applied onto the user's working tree without dragging
+// the user's work along a second time. Nothing here merges: the main session asks the user
+// first, every time.
+//
+// Commits are plumbing (write-tree, commit-tree, update-ref): no hook runs and nothing is
+// signed, so nothing can stop on a prompt while pi's thread waits. Worktrees live under the git
+// directory, where test runners, linters, watchers and `git clean` never look.
+// ponytail: every call is synchronous on pi's thread, about 0.1 s per branch on a few hundred
+// files. Move to async execFile if users run [write] in repos with tens of thousands of files.
+
+export type Repo = { root: string; prefix: string; common: string };
+export type Worktree = { root: string; path: string; cwd: string; branch: string; base: string };
+
+// git's own reason, not node's "Command failed: <argv>" line above it.
+const git = (cwd: string, args: string[], env?: Record<string, string>) => {
+	try {
+		return execFileSync("git", ["-C", cwd, ...args], {
+			encoding: "utf8",
+			stdio: ["ignore", "pipe", "pipe"],
+			windowsHide: true,
+			...(env ? { env: { ...process.env, ...env } } : {}),
+		}).trim();
+	} catch (error) {
+		const stderr = (error as { stderr?: string }).stderr?.trim();
+		throw stderr ? new Error(stderr) : error;
+	}
+};
+
+const tryGit = (cwd: string, args: string[]) => {
+	try {
+		return git(cwd, args);
+	} catch {
+		return "";
+	}
+};
+
+/** The repo the session sits in, or undefined outside one. `prefix` is the session's folder
+ *  inside it, as git spells it, so a symlinked or 8.3 cwd still lands in the right place. */
+export const gitRepo = (cwd: string): Repo | undefined => {
+	const [common, root, prefix = ""] = tryGit(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir", "--show-toplevel", "--show-prefix"]).split("\n");
+	return common && root ? { root, prefix, common } : undefined;
+};
+
+// The user's identity when git has one. Without it commit-tree refuses, and these commits never
+// reach the user's history anyway: a merge applies the diff, it does not merge the commit.
+const identity = (cwd: string) =>
+	tryGit(cwd, ["var", "GIT_COMMITTER_IDENT"])
+		? undefined
+		: { GIT_AUTHOR_NAME: "pi fan", GIT_AUTHOR_EMAIL: "fan@localhost", GIT_COMMITTER_NAME: "pi fan", GIT_COMMITTER_EMAIL: "fan@localhost" };
+
+/** The user's tree as they see it, as one commit on top of HEAD, or HEAD itself when nothing is
+ *  uncommitted. Built in a scratch index, so the user's own index, diff settings and hooks never
+ *  come into it, symlinks stay symlinks and a nested repo stays a gitlink. */
+export const snapshot = (repo: Repo): string => {
+	const head = tryGit(repo.root, ["rev-parse", "--verify", "-q", "HEAD"]);
+	const index = join(repo.common, `fan-index-${process.pid}`);
+	const own = git(repo.root, ["rev-parse", "--path-format=absolute", "--git-path", "index"]);
+	// Seeded from the real index, so `add -A` only rehashes what changed.
+	if (existsSync(own)) copyFileSync(own, index);
+	try {
+		const env = { GIT_INDEX_FILE: index };
+		try {
+			git(repo.root, ["add", "-A", "--ignore-errors"], env);
+		} catch (error) {
+			// A nested repo with no commit yet, or a file this user cannot read, has nothing
+			// git can record, so the branch starts without it. Anything else is a real failure.
+			if (!/unable to index file/.test((error as Error).message)) throw error;
+		}
+		const tree = git(repo.root, ["write-tree"], env);
+		if (head && tree === git(repo.root, ["rev-parse", `${head}^{tree}`])) return head;
+		return git(repo.root, ["commit-tree", tree, ...(head ? ["-p", head] : []), "-m", "fan: the uncommitted work the branches started from"], identity(repo.root));
+	} finally {
+		rmSync(index, { force: true });
+	}
+};
+
+/** A new branch at `base` in its own worktree. The session's folder is made when the checkout
+ *  lacks it: a folder holding only ignored files, or nothing yet, is not in any commit. */
+export const openWorktree = (repo: Repo, base: string, path: string, branch: string): Worktree => {
+	const worktree = { root: repo.root, path, cwd: join(path, repo.prefix), branch, base };
+	// A hooks path that does not exist: post-checkout would run here, on pi's thread. Outside the
+	// try: when add fails, the path or branch may be another run's, and is not this one's to drop.
+	git(repo.root, ["-c", `core.hooksPath=${join(repo.common, "fan-no-hooks")}`, "worktree", "add", "-q", "-b", branch, path, base]);
+	try {
+		mkdirSync(worktree.cwd, { recursive: true });
+		return worktree;
+	} catch (error) {
+		dropWorktree(worktree);
+		throw error;
+	}
+};
+
+const removeWorktree = ({ root, path }: Worktree) => {
+	try {
+		git(root, ["worktree", "remove", "--force", path]);
+		// The run's folder under fan-worktrees, once its last branch is gone.
+		rmdirSync(dirname(path));
+	} catch {
+		// Already gone, a sibling still there, or a file the branch left locked: the work is on
+		// the branch either way, and `git worktree prune` clears the rest.
+	}
+};
+
+/** The worktree and its branch, gone. For a branch that never ran or changed nothing. */
+export const dropWorktree = (worktree: Worktree) => {
+	removeWorktree(worktree);
+	tryGit(worktree.root, ["branch", "-D", worktree.branch]);
+};
+
+/** "+12 −3 · 2 files" from git's "2 files changed, 12 insertions(+), 3 deletions(-)". */
+export const compactStat = (shortstat: string) => {
+	const count = (pattern: RegExp) => Number(pattern.exec(shortstat)?.[1] ?? 0);
+	const files = count(/(\d+) files? changed/);
+	return files ? `+${count(/(\d+) insertions?/)} −${count(/(\d+) deletions?/)} · ${files} ${files === 1 ? "file" : "files"}` : "";
+};
+
+/** Commit what the branch left, drop the worktree, keep the branch. A branch that changed
+ *  nothing is dropped whole, so only branches worth a question are left. */
+export const closeWorktree = (worktree: Worktree, message: string): GitResult => {
+	const { root, path, branch, base } = worktree;
+	let stat: string;
+	try {
+		git(path, ["add", "-A"]);
+		const tree = git(path, ["write-tree"]);
+		// On top of the branch's HEAD, not base: a branch that committed on its own keeps that.
+		if (tree !== git(path, ["rev-parse", "HEAD^{tree}"])) {
+			const commit = git(path, ["commit-tree", tree, "-p", "HEAD", "-m", message], identity(path));
+			git(path, ["update-ref", `refs/heads/${branch}`, commit]);
+		}
+		stat = compactStat(git(root, ["diff", "--shortstat", base, branch]));
+	} catch (error) {
+		// The worktree stays, so nothing the branch wrote is lost.
+		return { root, branch, base, stat: "", error: (error as Error).message.split("\n")[0] };
+	}
+	if (stat) removeWorktree(worktree);
+	else dropWorktree(worktree);
+	return { root, branch, base, stat };
+};
+
+const quote = (text: string) => `'${text.replaceAll("'", `'\\''`)}'`;
+
+/** The merge the main session offers. Run at the repo root, so no path outside the session's
+ *  folder is skipped; a plumbing diff, so no diff setting changes the patch; binary-safe; a
+ *  plain apply onto the working tree, so the user's own uncommitted edits stay where they are
+ *  and nothing is staged. It applies whole or not at all, and the branch goes only after. */
+export const mergeCommand = ({ root, base, branch }: GitResult) =>
+	`git -C ${quote(root)} diff-tree -p --binary ${base} ${branch} | git -C ${quote(root)} apply && git -C ${quote(root)} branch -D ${branch}`;
+
+export const discardCommand = ({ root, branch }: GitResult) => `git -C ${quote(root)} branch -D ${branch}`;

package/node_modules/pi-umbra-subagents/extensions/umbra-subagents/skills/delegate/state.ts

@@ -98,8 +98,15 @@ export type BranchView = BranchState & {
     alive: boolean;
     /** Finished for any reason. The N in "N/M agents". */
     settled: boolean;
+    /** A `[write]` branch's git branch, from `state/<stem>.git`, written when its worktree
+     *  closes. Absent on a read-only branch and on one still running. */
+    git?: GitResult;
 };
 
+/** What a write branch left behind: its branch, the base it started from, and "+N −M · K files"
+ *  ("" when it changed nothing), or why its work could not be committed. */
+export type GitResult = { root: string; branch: string; base: string; stat: string; error?: string };
+
 export type RunState = {
     dir: string;
     name: string;
@@ -178,6 +185,15 @@ const latestRun = (cwd: string): { dir: string; run: Run } | undefined => {
     return undefined;
 };
 
+const readGit = (path: string): GitResult | undefined => {
+    try {
+        // SAFETY: written only by fan/store.ts through JSON.stringify of a GitResult.
+        return JSON.parse(readFileSync(path, "utf8")) as GitResult;
+    } catch {
+        return undefined;
+    }
+};
+
 const readStates = (stateDir: string): BranchState[] => {
     let files: string[];
     try {
@@ -256,6 +272,8 @@ export function readRun(cwd: string, now = Date.now()): RunState | undefined {
     const branches: BranchView[] = order(readStates(stateDir)).map(({ state, depth }) => {
         const stem = stemOf(state);
         const exit = readExit(join(stateDir, `${stem}.exit`));
+        // Written just before the exit, so there is nothing to read until the exit is there.
+        const git = exit === undefined ? undefined : readGit(join(stateDir, `${stem}.git`));
         // A seeded branch whose pid is still null has not booted yet: it is pending, not
         // finished, or every row would count as done the instant the run started. Pending is
         // only honest while the owner is still around to launch it — an abandoned run's later
@@ -274,6 +292,7 @@ export function readRun(cwd: string, now = Date.now()): RunState | undefined {
             timedOut: exit?.code === 124,
             alive,
             settled,
+            ...(git ? { git } : {}),
         };
     });
 

package/node_modules/pi-umbra-subagents/extensions/umbra-subagents/skills/fan/SKILL.md

@@ -1,13 +1,13 @@
 ---
 name: fan
-description: Fan independent read-only work out to parallel pi branches and watch them live in the agent panel. Use whenever a task splits into 2+ lookups that do not need each other, or when the user writes "fan", "delegate", "subagent", or "in parallel".
+description: Fan independent work out to parallel pi branches and watch them live in the agent tree. Branches are read-only unless marked [write]. Use whenever a task splits into 2+ lookups that do not need each other, or when the user writes "fan", "delegate", "subagent", or "in parallel".
 ---
 
 # Fan
 
 There is no subagent tool and nothing is added to this prompt. A branch is a
 separate `pi -p` process the fan extension spawns and owns; each one writes a
-small live state file, so the panel above the input box shows what every branch
+small live state file, so the agent tree under the input box shows what every branch
 is doing while it does it, not only what it concluded.
 
 ## Run
@@ -35,13 +35,17 @@ proposal: Given the Map results, write the design.
   phase's answers.
 - `label@provider/model: task` picks a model for that branch. Without it a
   branch runs on this session's model.
+- `label [write]: task` (or `label@model [write]: task`) lets that branch edit
+  files and run commands, in its own git worktree on a new `fan/<run>/<branch>`
+  branch. See Write branches below.
 - 2 to 6 branches per phase. Each task names the files or directory and says
   exactly what to return.
 
 ## Rules
 
-- Branches are read-only: `read`, `grep`, `find`, `ls`, nothing else. Work that
-  edits files stays in this session.
+- Branches are read-only by default: `read`, `grep`, `find`, `ls`, nothing else.
+  Work that edits files stays in this session, unless the user asked for
+  parallel implementation; then use `[write]`.
 - A branch has an empty context. Repeating what you already know in the task
   text is the only way it learns it.
 - One run at a time. A second block while a run is live is ignored.
@@ -50,3 +54,20 @@ proposal: Given the Map results, write the design.
   they had already written stays on disk. `.pi-out/` is gitignored scratch.
 - A branch gets 5 minutes and is then cut off, so one wedged branch cannot
   hold the run open. Keep each task small enough to finish in that time.
+
+## Write branches
+
+- Use `[write]` only when the user wants work done in parallel and each branch's
+  change is independent. Most runs stay read-only.
+- The worktree starts from the user's working tree, uncommitted work included,
+  and only works inside a git repository; outside one the run does not start.
+- A write branch gets `edit`, `write` and `bash`. It must not push, publish or
+  commit; its changes are committed to its branch when it ends, and its row
+  shows `Changed +N −M · K files on fan/...`.
+- Nothing is merged. When the results arrive, ask the user, one question per
+  branch, whether to merge it, and only then run the command the follow-up gives.
+- A write branch cannot stop on a question: its worktree closes when it ends.
+  Put every decision it needs in its task.
+- Every write branch starts from the same snapshot, taken when the run starts:
+  a later phase does not see an earlier phase's changes. Work that builds on
+  another branch's change waits for that change to be merged, in a new run.

package/node_modules/pi-umbra-subagents/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-umbra-subagents",
-  "version": "0.1.2",
-  "description": "Parallel read-only pi branches with a live panel above the input box, the delegate skill that starts them, and /umb-loop, which resubmits a prompt on a count or a timer.",
+  "version": "0.2.0",
+  "description": "Parallel pi branches with a live agent tree under the input box, read-only or in their own git worktree, the delegate skill that starts them, and /umb-loop, which resubmits a prompt on a count or a timer.",
   "keywords": [
     "pi-package",
     "pi",

package/node_modules/pi-umbra-theme/checks/umbra-background.check.ts

@@ -4,6 +4,7 @@
 //
 //   bun run umbra-background.check.ts
 import assert from "node:assert";
+import { TuiAltScreen, TuiMainScreen } from "@earendil-works/pi-tui";
 import { mkdtempSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -46,7 +47,12 @@ const notices: string[] = [];
 // The terminal as the TUI sees it: it answers the OSC 11 query with this colour, or never.
 let answer: { r: number; g: number; b: number } | undefined;
 const setWidget = (_key: string, factory: (tui: unknown) => unknown) =>
-    factory({ queryTerminalBackgroundColor: async () => answer });
+    factory({ queryTerminalColors: async () => ({ background: answer }) });
+// The stand-in above is only as good as its method name: pi 1.0 renamed the old query, the check
+// kept passing and pi crashed at start. So the name is checked against the real TUI too.
+for (const screen of [TuiMainScreen, TuiAltScreen]) {
+    assert.equal(typeof screen.prototype.queryTerminalColors, "function", `${screen.name} still has queryTerminalColors`);
+}
 // Real pi hands the extension a Theme with NO sourcePath; the file it was read from is only on
 // the list getAllThemes() returns, under the name `path`. The check used to invent a sourcePath
 // and then assert against its own invention, which is why it passed while nothing happened on

package/node_modules/pi-umbra-theme/extensions/umbra-background.ts

@@ -106,7 +106,8 @@ export default function umbraBackground(pi: ExtensionAPI) {
 
     const verify = async (ctx: ExtensionContext, hex: string) => {
         // No reply means a terminal that answers no queries: unknown, not ignored.
-        const rgb = await tui?.queryTerminalBackgroundColor({ timeoutMs: 1000 });
+        // pi 1.0 asks for every theme colour at once; queryTerminalBackgroundColor is gone.
+        const rgb = (await tui?.queryTerminalColors({ timeoutMs: 1000 }))?.background;
         if (rgb === undefined || current !== hex) return;
         const status: BackgroundStatus = { wanted: hex, ignored: !sameColour(hex, rgb), howTo: backgroundHowTo(process.env, hex) };
         (globalThis as { __umbraBackground?: BackgroundStatus }).__umbraBackground = status;

package/node_modules/pi-umbra-theme/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-umbra-theme",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "pi's look in one package: seven umbra themes and the terminal background they set, a status footer, a gutter beside model text, every tool call drawn as a card with rich diffs, and a working line that names the running tool.",
   "keywords": [
     "pi-package",
@@ -40,8 +40,8 @@
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-tui": "*"
+    "@earendil-works/pi-coding-agent": ">=1.0.0",
+    "@earendil-works/pi-tui": ">=1.0.0"
   },
   "dependencies": {
     "@shikijs/cli": "^4.0.2"

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-umbra",
-  "version": "0.3.1",
-  "description": "Every small thing pi does not build in, in one install: seven themes and the chrome around them, the input bar, session rename, a shimmer through the working indicator, mid-prompt skill completion, ask, copy-chat, preview, help, and parallel read-only branches with a live panel.",
+  "version": "0.4.0",
+  "description": "Every small thing pi does not build in, in one install: seven themes and the chrome around them, the input bar, a shimmer through the working indicator, mid-prompt skill completion, ask, copy-chat, preview, help, and parallel pi branches (read-only, or editing in their own git worktree) with a live agent tree.",
   "keywords": [
     "pi-package",
     "pi-theme",
@@ -31,7 +31,6 @@
       "./node_modules/pi-umbra-help/extensions",
       "./node_modules/pi-umbra-inputbar/extensions",
       "./node_modules/pi-umbra-preview/extensions",
-      "./node_modules/pi-umbra-rename/extensions",
       "./node_modules/pi-umbra-shimmer/extensions",
       "./node_modules/pi-umbra-skill-matcher/extensions",
       "./node_modules/pi-umbra-subagents/extensions/umbra-subagents.ts",
@@ -45,16 +44,15 @@
     ]
   },
   "dependencies": {
-    "pi-umbra-theme": "0.2.1",
+    "pi-umbra-theme": "0.3.0",
     "pi-umbra-ask": "0.1.2",
-    "pi-umbra-copy-chat": "0.1.2",
-    "pi-umbra-help": "0.1.4",
-    "pi-umbra-inputbar": "0.1.4",
+    "pi-umbra-copy-chat": "0.1.3",
+    "pi-umbra-help": "0.1.5",
+    "pi-umbra-inputbar": "0.1.5",
     "pi-umbra-preview": "0.1.3",
-    "pi-umbra-rename": "0.1.3",
-    "pi-umbra-shimmer": "0.1.5",
-    "pi-umbra-skill-matcher": "0.1.4",
-    "pi-umbra-subagents": "0.1.2"
+    "pi-umbra-shimmer": "0.1.6",
+    "pi-umbra-skill-matcher": "0.1.5",
+    "pi-umbra-subagents": "0.2.0"
   },
   "bundledDependencies": [
     "pi-umbra-theme",
@@ -63,7 +61,6 @@
     "pi-umbra-help",
     "pi-umbra-inputbar",
     "pi-umbra-preview",
-    "pi-umbra-rename",
     "pi-umbra-shimmer",
     "pi-umbra-skill-matcher",
     "pi-umbra-subagents"

package/node_modules/pi-umbra-rename/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 grkn
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/node_modules/pi-umbra-rename/README.md

@@ -1,18 +0,0 @@
-# pi-umbra-rename
-
-`/umb-rename` sets the session name and the terminal title in one step. pi keeps them apart,
-so after `/name` the window tab still shows the old title.
-
-```sh
-pi install npm:pi-umbra-rename
-```
-
-| Command | Effect |
-|---|---|
-| `/umb-rename api refactor` | rename straight away |
-| `/umb-rename` | ask for the name first; an empty answer changes nothing |
-
-The session name shows in `/resume` and, with pi-umbra-inputbar, on the input border. The
-terminal title becomes `π - api refactor - <folder>`.
-
-MIT.

package/node_modules/pi-umbra-rename/checks/umbra-rename.check.ts

@@ -1,55 +0,0 @@
-// /umb-rename writes two names through two different APIs, and the terminal title is built from
-// a third value. A fake pi is enough to pin all three, because the command is the whole extension.
-//
-//   bun run umbra-rename.check.ts
-import assert from "node:assert";
-import rename from "../extensions/umbra-rename.ts";
-
-type Handler = (args: string, ctx: unknown) => Promise<void>;
-
-const load = (sessionName?: string) => {
-	const calls = { name: undefined as string | undefined, title: undefined as string | undefined, notice: "" };
-	let handler: Handler | undefined;
-	const pi = {
-		registerCommand: (_name: string, options: { handler: Handler }) => void (handler = options.handler),
-		getSessionName: () => sessionName,
-		setSessionName: (value: string) => void (calls.name = value),
-	};
-	rename(pi as never);
-	const ctx = {
-		ui: {
-			setTitle: (value: string) => void (calls.title = value),
-			notify: (value: string) => void (calls.notice = value),
-			input: async () => prompted,
-		},
-		sessionManager: { getCwd: () => "/home/me/projects/real-estate" },
-	};
-	return { calls, run: (args: string) => handler!(args, ctx) };
-};
-
-let prompted: string | undefined;
-
-// The argument form. The prefix goes on the terminal title only: pi already spells the session
-// name on the input bar, so a π in the name itself would show up three times in two places.
-const given = load();
-await given.run("  ledger  ");
-assert.equal(given.calls.name, "ledger", "the name is trimmed and carries no prefix");
-assert.equal(given.calls.title, "π - ledger - real-estate", "the title carries the prefix and the cwd");
-assert.equal(given.calls.notice, "renamed: ledger");
-
-// No argument: pi asks, and the current name is the prefill.
-prompted = "ledger";
-const asked = load("old-name");
-await asked.run("");
-assert.equal(asked.calls.name, "ledger", "the answer to the prompt is the new name");
-
-// Nothing typed, or the prompt dismissed, must leave both names alone rather than blanking them.
-for (const answer of [undefined, "", "   "]) {
-	prompted = answer;
-	const cancelled = load("old-name");
-	await cancelled.run("");
-	assert.equal(cancelled.calls.name, undefined, `"${answer}" must not rename`);
-	assert.equal(cancelled.calls.title, undefined, `"${answer}" must not retitle`);
-}
-
-console.log("umbra-rename.check.ts ok - argument form, prompt form, 3 cancel cases");

package/node_modules/pi-umbra-rename/extensions/umbra-rename.ts

@@ -1,22 +0,0 @@
-import { basename } from "node:path";
-import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-
-// /umb-rename sets both names at once: the session display name (session selector,
-// /resume) and the terminal window/tab title, which are separate APIs in pi.
-export default function (pi: ExtensionAPI) {
-	pi.registerCommand("umb-rename", {
-		description: "Rename this session and the terminal title: /umb-rename <name>",
-		handler: async (args: string, ctx: ExtensionCommandContext) => {
-			// setSessionName lives on the API object; setTitle lives on the command context's UI.
-			let newName = args.trim() || (await ctx.ui.input("Rename session", pi.getSessionName() ?? ""))?.trim();
-			if (!newName) return;
-
-			// The prefix belongs to the terminal title only. pi builds that title itself as
-			// `π - <session name> - <cwd>`, so putting π in the session name too spelled it twice
-			// in the tab and once more on the input bar, which shows the session name alone.
-			pi.setSessionName(newName);
-			ctx.ui.setTitle(`π - ${newName} - ${basename(ctx.sessionManager.getCwd())}`);
-			ctx.ui.notify(`renamed: ${newName}`);
-		},
-	});
-}

package/node_modules/pi-umbra-rename/package.json

@@ -1,36 +0,0 @@
-{
-  "name": "pi-umbra-rename",
-  "version": "0.1.3",
-  "description": "One command that renames a pi session and the terminal window title together, which pi keeps behind two separate APIs.",
-  "keywords": [
-    "pi-package",
-    "pi",
-    "pi-extension",
-    "session",
-    "rename",
-    "title"
-  ],
-  "author": "grkn",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/grknbyk/pi-umbra.git",
-    "directory": "pi-umbra-rename"
-  },
-  "homepage": "https://github.com/grknbyk/pi-umbra/tree/main/pi-umbra-rename#readme",
-  "bugs": "https://github.com/grknbyk/pi-umbra/issues",
-  "files": [
-    "extensions",
-    "checks",
-    "README.md",
-    "LICENSE"
-  ],
-  "pi": {
-    "extensions": [
-      "./extensions"
-    ]
-  },
-  "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "*"
-  }
-}