pi-squire 0.18.1 → 0.18.3

package/CHANGELOG.md

@@ -6,6 +6,42 @@ follows [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.18.3] - 2026-11-01
+
+### Changed
+
+- Model-facing delegate completion messages link the task copy instead of
+  quoting it, omit the workspace launch summary, and keep only the checkout
+  summary without path categories. Result bodies, errors, identity and file
+  pointers are unchanged. Task previews, workspace facts, and full snapshots
+  remain in saved message details and the expanded view. Tests that pinned the
+  previous model-facing wording now assert this shorter projection.
+
+## [0.18.2] - 2026-11-01
+
+### Fixed
+
+- Agents without a `tools:` field inherit available deferred and codemode tools
+  from root sessions, just as they already did from nested delegates. Inactive
+  direct tools and hidden tools remain excluded. Pi initially declares the
+  selected tools in the child; extensions that enable optional tools on demand
+  must deselect them during child startup. This can increase initial declarations
+  for root-launched delegates whose extensions do not deselect those tools.
+- Creating a companion session no longer saves the first delegate's environment,
+  including `PI_UNATTENDED` and API keys, into the session for later windows to
+  inherit. Each delegate still receives its own launch environment. Existing
+  polluted sessions are not changed. The fresh-companion argument test now pins
+  window-local environment delivery instead of session-level `-e` options.
+  Launches still pass only Squire's environment and `session:launch` additions,
+  never a copy of the parent's full process environment.
+- tmux failures report a bounded subcommand error instead of raw process errors
+  or stderr that could expose launch arguments or environment values. The two
+  failed ownership-recheck tests now expect the bounded error wording.
+- The discovery-count regression uses a controlled clock so additional parallel
+  test load does not turn its structural count assertion into a timing failure.
+  The separate real-time discovery deadline test and 200 ms product bound are
+  unchanged.
+
 ## [0.18.1] - 2026-11-01
 
 ### Changed
@@ -1024,7 +1060,9 @@ 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.18.1...HEAD
+[Unreleased]: https://github.com/gvanderclay/pi-squire/compare/v0.18.3...HEAD
+[0.18.3]: https://github.com/gvanderclay/pi-squire/compare/v0.18.2...v0.18.3
+[0.18.2]: https://github.com/gvanderclay/pi-squire/compare/v0.18.1...v0.18.2
 [0.18.1]: https://github.com/gvanderclay/pi-squire/compare/v0.18.0...v0.18.1
 [0.18.0]: https://github.com/gvanderclay/pi-squire/compare/v0.17.0...v0.18.0
 [0.17.0]: https://github.com/gvanderclay/pi-squire/compare/v0.16.0...v0.17.0

package/README.md

@@ -76,7 +76,7 @@ Then, from a Pi session running in tmux, hand it a task:
 
 A detached tmux window named `scout-first` opens in your working directory.
 When the delegate finishes, its answer reaches the parent as one `[delegate]`
-message that quotes the task (see [Results](#results)), and the delegate then
+message that links the task copy (see [Results](#results)), and the delegate then
 closes its own window ([auto-exit](#auto-exit)).
 
 `/delegate` with no arguments opens a form instead: pick an agent, write the
@@ -992,11 +992,14 @@ are not checked against the parent's tools, at top level or nested: normal Pi
 extension discovery or `session:launch` customization can provide tools in the
 child.
 
-- No `tools` field: the delegate gets the parent session's tools as they are
-  when the launch (or resume) starts: active tools for a top-level launch, or
-  available tools including codemode/deferred operations for a nested one, passed as
-  `--tools`, plus the `delegateTools` entries. A parent limited to `read`
-  gives such a delegate only `read`.
+- No `tools` field: the delegate gets the parent session's available tools
+  when the launch (or resume) starts, at any depth: active tools plus registered
+  codemode/deferred operations, excluding hidden tools and inactive direct tools,
+  passed as `--tools`, plus the `delegateTools` entries. Pi initially declares
+  these selected tools in the child, even when their exposure is codemode or
+  deferred. An extension can deselect optional tools during child startup and
+  enable them later. A parent with only `read` available gives such a delegate
+  only `read`.
 - An empty `tools` field, `tools:` or `tools: []`: the delegate gets no tools
   except the `delegateTools` entries. With none of those either, it starts
   with `--no-tools`.
@@ -1447,16 +1450,9 @@ the parent one message labelled delegate output:
 ```
 [delegate] Result from scout (provider/model), delegation <id>, request <request id>.
 Status: done
-Task, quoted from <sent/ copy>:
-> the task
+Task: <sent/ copy>
 Working directory: <the directory its window opened in>
-Workspace: <how the directory was chosen and its Git checkout at launch>
 Checkout when the result arrived: <branch, head, launch commit, commits since launch, clean or dirty>
-  committed since launch: <paths>
-  staged: <paths>
-  unstaged: <paths>
-  untracked: <paths>
-  conflicted: <paths>
 Envelope: <cur/ path>
 Delegate session: <session file or id>
 
@@ -1498,19 +1494,22 @@ Delegate session: <session file or id>
   delegations skip it.` (a model scope reads `on model provider/id`; a mark
   that has since cleared reads `it was marked until …`). A failed reply with
   no such mark is unchanged.
-- The task is quoted from the request copy the provider puts on the payload,
-  capped at 2 KiB with the copy's `sent/` path. A request with no copy is
-  named by id alone.
+- `Task:` points to the full request copy in `sent/`. The message details
+  and expanded view retain a task preview capped at 2 KiB. A request with no
+  copy gets a diagnostic with its request id.
 - The working directory is the one recorded at launch, or
-  `unknown (not recorded)` for a delegation recorded before it was kept. The
-  `Workspace:` line repeats the recorded [workspace](#working-directory), and
-  is left out for records from before it was kept; the closed-without-a-result
-  message carries the same two lines.
-- `Checkout when the result arrived:` is the [snapshot](#checkout-snapshots)
-  taken as the reply was claimed, also recorded with the result and in the
-  message details and expanded view. The reply is claimed first, so a slow or
-  failing Git cannot lose or duplicate it; the snapshot is then unknown. A
-  non-Git directory reads `not a Git checkout`.
+  `unknown (not recorded)` for a delegation recorded before it was kept.
+  The recorded [workspace](#working-directory) remains in message details
+  and the expanded view, but the model-facing result omits its launch summary.
+  Closed-without-a-result messages still include that summary when recorded.
+- `Checkout when the result arrived:` summarizes the
+  [snapshot](#checkout-snapshots) taken as the reply was claimed. Git summaries
+  keep the branch or detached HEAD, full head and launch commit, commits since
+  launch, and working-tree state. Path categories remain in the saved snapshot,
+  message details, and expanded view, not the model-facing result.
+  The reply is claimed first, so a slow or failing Git cannot lose or duplicate
+  it. An unknown snapshot includes the reason. A non-Git directory reads
+  `not a Git checkout`.
 - The envelope path is the claimed reply in the parent's `cur/`; the
   delegate's session path is found by the delegation id in the session
   directory recorded at launch (the parent's current one for older records),
@@ -1692,6 +1691,11 @@ An empty final set also receives `--no-tools` and an empty allowlist so earlier
 selection flags cannot restore tools. Do all work synchronously: the emitter
 reads the payload the moment `emit` returns.
 
+Environment additions are not a secret transport. They can be visible in tmux
+command arguments and a fresh companion's first pane start command to anyone
+with access to its socket. pi-squire never copies the parent's full process
+environment into these arguments.
+
 `cwd`, the trust flag (`--approve` or `--no-approve`), `--session-dir` and the
 session choice (`--session-id` for a new delegate, `--session` for a [resumed](#resuming-a-delegation)
 one) are launch invariants that `pi-squire` chooses. The window opens in its own `cwd`,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-squire",
-	"version": "0.18.1",
+	"version": "0.18.3",
 	"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

@@ -807,13 +807,13 @@ export default function delegate(
 	/**
 	 * The delegate's tools for a launch or resume starting now: the agent's
 	 * named tools, or the parent's current tools (including indirect callable
-	 * tools when nested, less any `-name` entries), then `delegateTools`.
+	 * tools, less any `-name` entries), then `delegateTools`.
 	 * Throws, naming the file, on an invalid setting.
 	 */
 	function childTools(agent: Agent): string[] {
 		const selected = toolSelection(
 			agent,
-			agent.tools === undefined ? (identity.current() ? availableTools(pi) : pi.getActiveTools()) : [],
+			agent.tools === undefined ? availableTools(pi) : [],
 			delegateTools(getAgentDir()),
 		);
 		if (grantsNesting(agent, (identity.current()?.depth ?? 0) + 1)) selected.push(...DELEGATION_TOOLS);

package/src/result-message.ts

@@ -1,6 +1,6 @@
 // The text and details of the one message the parent receives for a settled delegation.
 import { readMarks } from "./limits.ts";
-import { cwdLine, modelLabel, snapshotLines, workspaceLine } from "./render.ts";
+import { cwdLine, modelLabel, snapshotLines } from "./render.ts";
 import { sessionIdOf } from "./result-sessions.ts";
 import type { StartedRecorded } from "./result-types.ts";
 import type { Inbound, MessageDetails, TaskQuote } from "./results.ts";
@@ -88,29 +88,21 @@ export function resultDetails(
 	};
 }
 
-/** The snapshot lines of the result text: a heading line, then its path lists indented. */
 function checkoutText(snapshot: WorkspaceSnapshot): string[] {
-	const [first, ...rest] = snapshotLines(snapshot);
-	return [`Checkout when the result arrived: ${first}`, ...rest.map((line) => `  ${line}`)];
+	const [first] = snapshotLines(snapshot);
+	return [`Checkout when the result arrived: ${first}`];
 }
 
 /** The one message the parent model reads for a settled delegation. */
 export function resultText(details: ResultDetails): string {
 	const { task } = details;
-	const quote =
-		"note" in task
-			? task.note
-			: `Task, quoted from ${task.path}:\n${task.text
-					.split("\n")
-					.map((line) => `> ${line}`)
-					.join("\n")}`;
+	const taskLine = "note" in task ? task.note : `Task: ${task.path}`;
 	return [
 		`[delegate] Result from ${details.agent} (${modelLabel(details.model, details.finishedModel)}), delegation ${details.id}${details.resumedFrom === undefined ? "" : ` (resumed from ${details.resumedFrom})`}, request ${details.requestId}.`,
 		`Status: ${details.status}`,
 		...(details.limit === undefined ? [] : [details.limit]),
-		quote,
+		taskLine,
 		`Working directory: ${cwdLine(details.cwd)}`,
-		...(details.workspace === undefined ? [] : [`Workspace: ${workspaceLine(details.workspace)}`]),
 		...(details.workspaceSnapshot === undefined ? [] : checkoutText(details.workspaceSnapshot)),
 		`Envelope: ${details.envelopePath}`,
 		`Delegate session: ${details.sessionPath ?? details.sessionId ?? details.id}`,

package/src/tmux.ts

@@ -18,7 +18,6 @@ export type TmuxWindow = { id: string; session: string; name: string; exited: bo
 /** A window just opened: its id and the name of the session it is in, when known. */
 export type OpenedWindow = { id: string; session: string | undefined };
 
-/** The oldest tmux delegate windows need: `new-session -e` arrived in 3.2. */
 export const MIN_TMUX = { major: 3, minor: 2 } as const;
 
 export type TmuxVersion = { text: string; major: number; minor: number };
@@ -124,8 +123,8 @@ function runTmux(args: string[], timeout: number): Promise<string> {
 					reject(new Error(`tmux ${args[0]} timed out after ${timeout / 1000} s`));
 					return;
 				}
-				const detail = typeof stderr === "string" && stderr.trim() !== "" ? stderr.trim() : error.message;
-				reject(new Error(detail));
+				const reason = ["duplicate session", "can't find session"].find((text) => stderr.includes(text));
+				reject(new Error(`tmux ${args[0]} failed${reason === undefined ? "" : `: ${reason}`}`));
 				return;
 			}
 			resolve(stdout);
@@ -215,8 +214,17 @@ async function openCompanion(run: Run, spec: WindowSpec, base: string): Promise<
 				continue;
 			}
 		}
-		const args = ["new-session", "-d", "-s", session, "-n", spec.name, "-c", spec.cwd, ...envArgs(spec)];
-		args.push("-P", "-F", "#{window_id}", "--", ...spec.argv);
+		const args = ["new-session", "-d", "-s", session, "-n", spec.name, "-c", spec.cwd];
+		// new-session -e persists in the session; env confines these values to its first window.
+		args.push(
+			"-P",
+			"-F",
+			"#{window_id}",
+			"--",
+			"env",
+			...Object.entries(spec.env).map(([key, value]) => `${key}=${value}`),
+			...spec.argv,
+		);
 		args.push(";", "set-option", "-t", `=${session}:`, COMPANION_OPTION, "1");
 		args.push(";", "set-option", "-t", `=${session}:`, "detach-on-destroy", "off");
 		certainty = "unknown";

package/src/tool-names.ts

@@ -12,7 +12,7 @@ export function toolMatches(pattern: string, name: string): boolean {
 
 /**
  * The operations this session can reach: active tools plus codemode and
- * deferred ones, never hidden ones. A nested delegate with no `tools` field
+ * deferred ones, never hidden ones. A delegate with no `tools` field
  * inherits these. Includes active model-only operations, though
  * ctx.executeTool cannot call those.
  */