pi-squire 0.19.0 → 0.19.1

package/CHANGELOG.md

@@ -6,6 +6,17 @@ follows [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.19.1] - 2026-11-02
+
+### Removed
+
+- Fresh sessions no longer report other sessions' running delegates at
+  startup, and the "owner discovery unavailable" and "discovery is limited"
+  warnings are gone with that check. A session only ever reports its own tree;
+  to collect the delegates of a session you closed, reopen that session. The
+  tests that pinned the startup notices now pin that a fresh session reports
+  nothing, and the notice-budget tests are removed.
+
 ## [0.19.0] - 2026-11-02
 
 ### Changed
@@ -1083,7 +1094,8 @@ author's dotfiles; the changes below are against that copy.
 
 - The published file list includes `child.ts`, which `index.ts` imports.
 
-[Unreleased]: https://github.com/gvanderclay/pi-squire/compare/v0.19.0...HEAD
+[Unreleased]: https://github.com/gvanderclay/pi-squire/compare/v0.19.1...HEAD
+[0.19.1]: https://github.com/gvanderclay/pi-squire/compare/v0.19.0...v0.19.1
 [0.19.0]: https://github.com/gvanderclay/pi-squire/compare/v0.18.4...v0.19.0
 [0.18.4]: https://github.com/gvanderclay/pi-squire/compare/v0.18.3...v0.18.4
 [0.18.3]: https://github.com/gvanderclay/pi-squire/compare/v0.18.2...v0.18.3

package/README.md

@@ -323,21 +323,9 @@ one Pi process per session. Ownership refusals name the PID and owner file; if
 stale/corrupt, verify the original owner has ended, stop affected Squire runtimes
 and repair only that record. Never remove live lock tickets or force adoption.
 
-Fresh sessions do not adopt earlier trees. At startup a fresh root inspects only
-this agent directory's newest **64** registry files, and only entries using its
-current session-storage directory. It reports at most **10** direct owners with
-positively matched live windows and explains reopening the owning session (or
-returning to its existing owner). Registry-content reads are limited to 1 MiB
-per tree and one **200 ms total cooperative notice budget**, which starts once
-tmux has listed its windows, with registry lock waits capped at the remaining
-budget or 20 ms. Discovery runs after `session_start` returns, so it never
-delays startup or a session switch; the tmux listing is bounded by the tmux
-client's own timeout, and a session that ends first reports nothing. The scan
-yields between trees and reports, once, a tmux failure with its message,
-unreadable owner records or truncated scope. Individual filesystem operations cannot be preempted.
-Directory names/mtimes are enumerated, but no recursive
-session search, mailbox search or other agent-directory search occurs. Exact-id
-restoration is not restricted by this notice budget.
+Fresh sessions neither adopt nor report earlier trees. Each session sees only
+its own tree; to collect the delegates of a session you closed, reopen that
+exact session, which restores its full tree.
 
 Both `delegation_status` and `/delegates` show descendants: a root sees its tree;
 a coordinator sees only its own subtree, not siblings or unrelated roots.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-squire",
-	"version": "0.19.0",
+	"version": "0.19.1",
 	"description": "Starts a delegate Pi session in a background tmux window, sends it the task over message:*, and shows the parent its result",
 	"keywords": [
 		"pi-package",

package/src/index.ts

@@ -80,7 +80,6 @@ import { registerTaskReplies } from "./task-replies.ts";
 import { createTmuxClient, type OpenedWindow, requireTmuxVersion, type TmuxClient, WindowOpenError } from "./tmux.ts";
 import { availableTools } from "./tool-names.ts";
 import { createTracking, toolResult } from "./tracking.ts";
-import { treeNotice } from "./tree-notice.ts";
 import {
 	assertParentPlacement,
 	bindTree,
@@ -741,15 +740,6 @@ export default function delegate(
 	pi.on("session_start", (_event, ctx) => {
 		viewContext = ctx;
 	});
-	// Discovery is advisory: it runs after session_start returns, so tmux never delays startup or a session switch.
-	pi.on("session_start", (_event, ctx) => {
-		if (!identity.current() && results.list().length === 0) {
-			const active = () => owner.active();
-			treeNotice(ctx, tmux, active).catch((error: unknown) => {
-				if (active()) ctx.ui.notify(`delegate: owner discovery unavailable: ${String(error)}`, "warning");
-			});
-		}
-	});
 	const viewResults = {
 		...results,
 		list: () => (viewContext ? visibleRecords(results, viewContext) : results.list()),

package/src/tree-registry.ts

@@ -1,7 +1,3 @@
-// One registry per root owns structural/admission accounting. Parent-local
-// child facts and frozen worker replies remain semantic authorities. No bodies,
-// mailboxes, processing inboxes, or ancestor-liveness policy live here.
-import { readdirSync } from "node:fs";
 import { join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { readChildRecords } from "./child-tasks.ts";
@@ -24,17 +20,6 @@ export type { Reservation, TreeCounts, TreeEntry, TreeIntent, TreeState } from "
 export function treePath(root: string): string {
 	return join(getAgentDir(), "squire", "trees", `${encodeURIComponent(root)}.json`);
 }
-/** Discovery only; callers choose notice/view scope, never adopt another root. */
-export function listTreeRoots(): string[] {
-	try {
-		return readdirSync(join(getAgentDir(), "squire", "trees"))
-			.filter((name) => name.endsWith(".json"))
-			.map((name) => decodeURIComponent(name.slice(0, -5)));
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
-		throw error;
-	}
-}
 function load(root: string): TreeState {
 	const saved: TreeState | undefined = readState<TreeState>(treePath(root));
 	const state: TreeState = saved === undefined ? { version: 1, root, entries: [] } : saved;

package/src/tree-notice.ts

@@ -1,132 +0,0 @@
-// Bounded discovery is a notice only. Exact-session restore never uses this budget.
-// Callers start it without awaiting, so a slow tmux never holds session_start; the
-// tmux client's own timeout bounds the listing, and the budget bounds only the scan.
-import { statSync } from "node:fs";
-import { performance } from "node:perf_hooks";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { findSession } from "./result-sessions.ts";
-import { ownerDetails, sessionIsOwned } from "./session-owner.ts";
-import type { TmuxClient, TmuxWindow } from "./tmux.ts";
-import { listTreeRoots, readTree, type TreeEntry, treePath } from "./tree-registry.ts";
-
-export const NOTICE_TREES = 64;
-export const NOTICE_OWNERS = 10;
-export const NOTICE_MS = 200;
-export async function treeNotice(
-	ctx: ExtensionContext,
-	tmux: TmuxClient,
-	active: () => boolean = () => true,
-): Promise<void> {
-	const session: string = ctx.sessionManager.getSessionId();
-	const dir: string = ctx.sessionManager.getSessionDir();
-	const roots: string[] = listTreeRoots().filter((root) => root !== session);
-	const newest: string[] = newestRoots(roots);
-	if (!newest.length) return;
-	const windows: TmuxWindow[] | undefined = await noticeWindows(ctx, tmux, active);
-	if (!windows || !active()) return;
-	// The scan budget starts once tmux has answered.
-	const deadline: number = performance.now() + NOTICE_MS;
-	const owners: Map<string, TreeEntry> = new Map();
-	let unavailable = 0,
-		scanned = 0,
-		ownerErrors = 0;
-	for (const root of newest) {
-		if (!active() || remaining(deadline) <= 0 || owners.size >= NOTICE_OWNERS) break;
-		try {
-			collectOwners(root, session, dir, windows, owners, deadline);
-		} catch {
-			unavailable++;
-		}
-		scanned++;
-		await new Promise<void>((resolve) => setImmediate(resolve));
-	}
-	if (!active()) return;
-	ownerErrors = reportOwners(ctx, dir, owners, deadline);
-	if (roots.length > NOTICE_TREES || scanned < newest.length || unavailable || ownerErrors)
-		ctx.ui.notify(
-			`delegate: discovery is limited to newest ${NOTICE_TREES} trees and ${NOTICE_OWNERS} owners in this agent/session directory, with a ${NOTICE_MS} ms total budget and 1 MiB per tree; ${unavailable} registries unavailable and ${ownerErrors} owner records unreadable. Reopen an exact owner to restore its full tree.`,
-			"warning",
-		);
-}
-function reportOwners(ctx: ExtensionContext, dir: string, owners: Map<string, TreeEntry>, deadline: number): number {
-	let ownerErrors = 0;
-	for (const [parent, entry] of [...owners].slice(0, NOTICE_OWNERS)) {
-		const path: string | undefined = remaining(deadline) > 0 ? findSession(dir, parent) : undefined;
-		let action: string;
-		try {
-			action = sessionIsOwned(parent)
-				? "Its Squire owner is already open; return to that process."
-				: `Reopen the owning Pi session with pi --session ${shellArg(path ?? parent)} --session-dir ${shellArg(dir)}.`;
-		} catch {
-			ownerErrors++;
-			action = `Owner status is unavailable: ${ownerDetails(parent)}. Inspect it before reopening.`;
-		}
-		ctx.ui.notify(
-			`delegate: earlier session ${parent} has running delegates (tree ${entry.identity.root}). ${action} This session does not adopt them.`,
-			"info",
-		);
-	}
-	return ownerErrors;
-}
-/** The newest roots first; each tree is stat'ed once, not on every sort comparison. */
-function newestRoots(roots: string[]): string[] {
-	return roots
-		.map((root) => ({ root, mtime: modified(root) }))
-		.sort((a, b) => b.mtime - a.mtime)
-		.slice(0, NOTICE_TREES)
-		.map(({ root }) => root);
-}
-/** tmux's windows, or undefined after warning (while still active) that tmux failed. */
-async function noticeWindows(
-	ctx: ExtensionContext,
-	tmux: TmuxClient,
-	active: () => boolean,
-): Promise<TmuxWindow[] | undefined> {
-	try {
-		return await tmux.listWindows();
-	} catch (error) {
-		if (!active()) return undefined;
-		const reason: string = error instanceof Error ? error.message : String(error);
-		ctx.ui.notify(
-			`delegate: owner discovery unavailable: tmux could not be asked: ${reason}; no absence or ownership was inferred.`,
-			"warning",
-		);
-		return undefined;
-	}
-}
-function remaining(deadline: number): number {
-	return Math.max(0, deadline - performance.now());
-}
-function collectOwners(
-	root: string,
-	session: string,
-	dir: string,
-	windows: TmuxWindow[],
-	owners: Map<string, TreeEntry>,
-	deadline: number,
-): void {
-	if (statSync(treePath(root)).size > 1024 * 1024) throw new Error("tree exceeds notice byte budget");
-	for (const entry of readTree(root, Math.min(20, remaining(deadline))).entries) {
-		if (owners.size >= NOTICE_OWNERS || remaining(deadline) <= 0) return;
-		if (entry.identity.parent !== session && entry.sessionDir === dir && live(entry, windows))
-			owners.set(entry.identity.parent, entry);
-	}
-}
-function shellArg(value: string): string {
-	return `'${value.replaceAll("'", "'\\''")}'`;
-}
-function modified(root: string): number {
-	try {
-		return statSync(treePath(root)).mtimeMs;
-	} catch {
-		return 0;
-	}
-}
-function live(entry: TreeEntry, windows: TmuxWindow[]): boolean {
-	return (
-		entry.phase === "started" &&
-		!entry.finished &&
-		!entry.closed &&
-		windows.some((window) => window.id === entry.windowId && window.name === entry.windowName && !window.exited)
-	);
-}