@gavin-hu/my-pi-agent 0.17.0 → 0.18.0

package/extensions/file-browse/live.ts

@@ -3,17 +3,20 @@
  *
  * A page that stays open holds one event stream; this module builds the snapshot
  * it is sent, the frame that carries it, and the channel that fans it out on a
- * tick. The git and diff providers already memoize, so a tick re-reads at most
- * one `git status`, and every read failure degrades to `null`: a status feed
- * must never be able to fail a page or the server that serves it.
+ * tick. A tick costs one `git status` and one `git diff --stat`: the providers'
+ * 2 s memo only coalesces a tick with a page render in the same window, so the
+ * cadence is what bounds the reads. Every read failure degrades to `null`: a
+ * status feed must never be able to fail a page or the server that serves it.
  *
  * The channel opens no socket of its own — the caller hands it a `write`/`end`
  * pair — so the whole feed is tested without one.
  */
 
 import { defaultInterval, defaultTimer } from "../../lib/timer.ts";
+import { LIVE_MAX_CLIENTS } from "./config.ts";
 import { changeDirs } from "./diff.ts";
 import type { DiffList, GitDiffProvider, GitStatus, GitStatusProvider } from "./git.ts";
+import { changeRevision } from "./rev.ts";
 
 /**
  * The changed-path index the pages render from: the totals the changes chip
@@ -50,12 +53,27 @@ export interface LiveChanges {
 	deletions: number;
 	files: string[];
 	dirs: string[];
+	/**
+	 * Identity of this change set, counts included. A page that painted the same
+	 * revision repaints nothing when the next frame arrives.
+	 */
+	rev: string;
+}
+
+/** A change index as it goes over the wire, with its revision. */
+function changesOf(index: ChangeIndex): LiveChanges {
+	const changes = {
+		count: index.count,
+		insertions: index.insertions,
+		deletions: index.deletions,
+		files: [...index.files].sort(),
+		dirs: [...index.dirs].sort(),
+	};
+	return { ...changes, rev: changeRevision(changes) };
 }
 
 /** One status frame's payload. */
 export interface LiveSnapshot {
-	/** Server wall clock when the snapshot was taken, in ms. */
-	at: number;
 	/** How long the server has been listening, in ms. */
 	uptimeMs: number;
 	/** Requests the server has answered so far, this one included. */
@@ -112,15 +130,7 @@ export function createLiveStatus(options: LiveStatusOptions): LiveStatusSource {
 				uptimeMs: Math.max(0, at - options.startedAt),
 				requests: options.requests(),
 				git,
-				changes: index
-					? {
-							count: index.count,
-							insertions: index.insertions,
-							deletions: index.deletions,
-							files: [...index.files].sort(),
-							dirs: [...index.dirs].sort(),
-						}
-					: null,
+				changes: index ? changesOf(index) : null,
 			};
 		},
 	};
@@ -158,6 +168,8 @@ export interface LiveChannelOptions {
 	intervalMs: number;
 	/** How long the last page's departure is held before `onIdle` is called, in ms. */
 	idleMs: number;
+	/** How many pages may attach at once; defaults to `LIVE_MAX_CLIENTS`. */
+	maxClients?: number;
 	/** Called once the last page has been gone for `idleMs`; omitted, the channel only idles. */
 	onIdle?: () => void;
 	/** Timer seam; defaults to an unref'd interval. */
@@ -172,6 +184,11 @@ export interface LiveChannel {
 	attach(client: LiveClient): () => void;
 	/** End every connected page, stop the ticker, and drop a pending idle stop. */
 	close(): void;
+	/**
+	 * Whether another page must be refused. The caller asks before it opens the
+	 * stream, so a refusal never has to take back a head it already wrote.
+	 */
+	atCapacity(): boolean;
 }
 
 /**
@@ -183,6 +200,7 @@ export interface LiveChannel {
 export function createLiveChannel(options: LiveChannelOptions): LiveChannel {
 	const timer = options.timer ?? defaultTicker;
 	const timeout = options.timeout ?? defaultTimeout;
+	const maxClients = options.maxClients ?? LIVE_MAX_CLIENTS;
 	const clients = new Set<LiveClient>();
 	let cancel: (() => void) | undefined;
 	let cancelIdle: (() => void) | undefined;
@@ -252,5 +270,8 @@ export function createLiveChannel(options: LiveChannelOptions): LiveChannel {
 			for (const client of clients) client.end();
 			clients.clear();
 		},
+		atCapacity() {
+			return clients.size >= maxClients;
+		},
 	};
 }

package/extensions/file-browse/rev.ts

@@ -0,0 +1,42 @@
+/**
+ * Revisions for the browse live status.
+ *
+ * A revision is a short digest of something a page already drew — the change set
+ * a frame carries, or the names a listing holds — so a client can tell "nothing
+ * moved" from "paint again" without comparing the payload it was sent. A
+ * collision costs one skipped repaint and is corrected by the next frame or a
+ * reload, which is the trade a 12-character digest makes for a small frame.
+ */
+
+import { createHash } from "node:crypto";
+
+/**
+ * A digest of the parts, cut to 12 hex characters. The parts are joined with NUL,
+ * which no filename can contain, so two different lists cannot run together into
+ * the same text.
+ */
+function digest(parts: readonly string[]): string {
+	return createHash("sha1").update(parts.join("\u0000")).digest("hex").slice(0, 12);
+}
+
+/** The change set a frame carries: its totals and paths, in a stable order. */
+export interface RevisionInput {
+	count: number;
+	insertions: number;
+	deletions: number;
+	files: readonly string[];
+	dirs: readonly string[];
+}
+
+/**
+ * The revision of a change set. The totals are part of it, so an edit that moves
+ * no path still moves the revision and the chip's `+A −D` stays honest.
+ */
+export function changeRevision(changes: RevisionInput): string {
+	return digest([`${changes.count}:${changes.insertions}:${changes.deletions}`, ...changes.files, ...changes.dirs]);
+}
+
+/** The revision of a listing's names, independent of the order they arrived in. */
+export function listingRevision(names: readonly string[]): string {
+	return digest([...names].sort());
+}

package/extensions/file-browse/router.ts

@@ -22,6 +22,7 @@ import {
 } from "../../lib/http/index.ts";
 import { THEME_JS, THEME_JS_PATH } from "../../lib/web/index.ts";
 import { CLIENT_JS } from "./client.ts";
+import type { LivePage } from "./chrome.ts";
 import type { ServeConfig } from "./config.ts";
 import { isDiffMode, type DiffMode } from "./diff.ts";
 import type { DiffList, GitDiffProvider, GitStatus, GitStatusProvider } from "./git.ts";
@@ -43,6 +44,7 @@ import { fuzzySearch } from "./fuzzy.ts";
 import { renderDirectoryPage, renderDiffPage, renderErrorPage, renderFileDiffPage, renderFilePage } from "./html.ts";
 import type { ChangeSummary } from "./html.ts";
 import { encodePath, HttpError, relativePath, resolveDecodedPath, resolveRequestPath } from "./paths.ts";
+import { listingRevision } from "./rev.ts";
 
 export interface ServeContext {
 	root: string;
@@ -108,9 +110,13 @@ function summaryOf(list: DiffList): ChangeSummary {
 	};
 }
 
-/** The live chrome a page renders, or `undefined` when live status is off. */
-function liveOf(ctx: ServeContext): { intervalMs: number } | undefined {
-	return ctx.config.live && ctx.live ? { intervalMs: ctx.config.liveIntervalMs } : undefined;
+/**
+ * The live chrome a page renders, or `undefined` when live status is off. A
+ * listing page also passes the revision of what it drew, which is what its
+ * reload control compares against; every other page has nothing to compare.
+ */
+function liveOf(ctx: ServeContext, folder?: { dir: string; rev: string }): LivePage | undefined {
+	return ctx.config.live && ctx.live ? { intervalMs: ctx.config.liveIntervalMs, ...folder } : undefined;
 }
 
 /** The `head` change summary, for the header chip, tree markers, and file action. */
@@ -184,7 +190,10 @@ async function directoryResponse(ctx: ServeContext, rel: string): Promise<ServeR
 			maxThumbBytes: ctx.config.maxThumbBytes,
 			git,
 			summary: changes,
-			live: liveOf(ctx),
+			live: liveOf(
+				ctx,
+				listing.truncated ? undefined : { dir: rel, rev: listingRevision(listing.entries.map((entry) => entry.name)) },
+			),
 		}),
 	);
 }
@@ -312,6 +321,17 @@ async function treeApi(ctx: ServeContext, decodedPath: string): Promise<ServeRes
 	return jsonResponse(200, { path: rel, entries: listing.entries.map(treeApiEntry) });
 }
 
+/** The revision of one folder's listing: what a page's reload control compares against. */
+async function dirRevApi(ctx: ServeContext, decodedPath: string): Promise<ServeResponse> {
+	const abs = await resolveDecodedPath(ctx.root, decodedPath);
+	const rel = relativePath(ctx.root, abs);
+	const listing = await listDirectory(ctx.root, rel, ctx.config.maxDirEntries);
+	// A truncated listing is a prefix whose boundary moves, so its revision is not
+	// comparable with what the page drew: `null` says "cannot tell".
+	const names = listing.entries.map((entry) => entry.name);
+	return jsonResponse(200, { path: rel, rev: listing.truncated ? null : listingRevision(names) });
+}
+
 /** Fuzzy file search for the quick-open palette, over the cached index. */
 async function filesApi(ctx: ServeContext, query: string): Promise<ServeResponse> {
 	const index = ctx.index ? await ctx.index() : await buildFileIndex(ctx.root, ctx.config.maxIndexEntries);
@@ -355,6 +375,7 @@ export async function handleRequest(
 		if (pathname === THEME_JS_PATH) return { status: 200, headers: scriptHeaders(), body: THEME_JS };
 		if (pathname === "/favicon.ico") return { status: 204, headers: pageHeaders(), body: "" };
 		if (pathname === "/api/tree") return await treeApi(ctx, search.get("path") ?? "");
+		if (pathname === "/api/dir-rev") return await dirRevApi(ctx, search.get("path") ?? "");
 		if (pathname === "/api/files") return await filesApi(ctx, search.get("q") ?? "");
 		if (pathname === "/events") return liveEvents(ctx);
 		const rawMode = search.get("mode");

package/extensions/file-browse/server.ts

@@ -103,6 +103,13 @@ export async function createFileServer(options: FileServerOptions): Promise<File
 				respond(request, response, result);
 				return;
 			}
+			// Checked before the head is written: a refusal must not leave a stream the
+			// client would wait on. `204` is the one status an event source does not
+			// reconnect after, so a page beyond the cap goes quiet instead of retrying.
+			if (live.atCapacity()) {
+				respond(request, response, { status: 204, headers: { "Cache-Control": "no-store" }, body: "" });
+				return;
+			}
 			openEventStream(response, result);
 			const detach = live.attach({
 				write: (frame) => {

package/extensions/file-browse/styles.ts

@@ -47,6 +47,8 @@ body.palette-open{overflow:hidden}
    swap only changes the colour, and the footer line reads as one muted clause. */
 .browse-live{font-family:var(--font-mono);border:1px solid currentColor;border-radius:var(--radius-pill);padding:2px 10px}
 .browse-live__glyph{font-size:9px;line-height:1}
+.browse-reload{border:1px solid currentColor;border-radius:var(--radius-pill);padding:2px 10px;cursor:pointer;font-family:var(--font-mono)}
+.browse-reload:hover{text-decoration:underline}
 .browse-live-line{color:var(--muted);font-variant-numeric:tabular-nums}
 .browse-live-line::after{content:" · "}
 .browse-diff-totals{font-family:var(--font-mono)}

package/extensions/goal/plan-route.ts

@@ -19,7 +19,8 @@
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { isPursuedGoal } from "../../lib/goal-state.ts";
-import { PLAN_CONSENT, requestPlanMode } from "../../lib/plan-entry.ts";
+import { isRemoteTurn, remoteLanguage } from "../../lib/interaction.ts";
+import { PLAN_CONSENT, PLAN_CONSENT_SHORT, PLAN_CONSENT_SHORT_ZH, requestPlanMode } from "../../lib/plan-entry.ts";
 import { isPlanModeEnabled } from "../../lib/plan-state.ts";
 import { PLAN_ENTER_TOOL } from "../../lib/tool-names.ts";
 import type { Goal, GoalStatus } from "./types.ts";
@@ -45,7 +46,12 @@ export async function goalPhase(
 	if (!options.ask || !ctx.hasUI) return "active";
 	// Do not ask about a phase this session cannot enter.
 	if (!pi.getAllTools().some((tool) => tool.name === PLAN_ENTER_TOOL)) return "active";
-	const approved = await ctx.ui.confirm(PLAN_ASK, PLAN_CONSENT);
+	const consent = isRemoteTurn(ctx)
+		? remoteLanguage(ctx) === "zh"
+			? PLAN_CONSENT_SHORT_ZH
+			: PLAN_CONSENT_SHORT
+		: PLAN_CONSENT;
+	const approved = await ctx.ui.confirm(PLAN_ASK, consent);
 	if (!approved) return "active";
 	return (await requestPlanMode(pi, ctx)) ? "planning" : "active";
 }

package/extensions/job/README.md

@@ -37,7 +37,8 @@ How the `job` call and its result look in the transcript — the call line as a
   chip for this session's jobs, plus a `/jobs` screen for selecting, tailing,
   killing, and clearing.
 - Reports finished jobs to the model at the start of the next turn, or — for
-  jobs started with `wake: true` — by triggering one turn.
+  jobs started with `wake: true` — by triggering one turn as soon as the agent is
+  idle, including right after a running turn settles.
 - Kills session-owned jobs on shutdown so no process is left behind; on POSIX,
   start a job with `detached: true` to keep it running and reattach next session.
   A detached job points its own output straight at its log file, so it keeps
@@ -338,13 +339,14 @@ rewritten.
   extension keeps only what is job-shaped — the durable registry, rotation,
   stdin, and the job vocabulary. The report coordinator is also why a wake can
   never stack two turns: it owns the guard for the window between the triggered
-  send and `agent_start`.
+  send and `agent_start`, and it retries a wake the running turn suppressed.
 - **Notify by default, wake opt-in.** A failed job raises one `ctx.ui.notify`
   (a clean exit is left to the list and chips). Finished jobs are also posted
   as a shared transcript notice — model-facing text plus the notice block — at the
-  next `before_agent_start`. A `wake: true` job (or `wakeOnFinish`) additionally
-  triggers one turn when the agent is idle; auto-wake is not the default because
-  it easily loops and burns tokens.
+  next `before_agent_start`, or in the wake turn it raises. A `wake: true` job (or
+  `wakeOnFinish`) additionally triggers one turn as soon as the agent is idle,
+  including right after a running turn settles; auto-wake is not the default
+  because it easily loops and burns tokens.
 - **Width-1 glyphs and cached latest line.** The running chip is `▸ N` and the
   failure chip `✗ N`, each a two-token badge under its own status key, so the
   status bar compacts each independently (`▸N` / `✗N`) and an unreported

package/extensions/job/index.ts

@@ -5,7 +5,8 @@
  * processes with their output streamed to log files; the status chip shows
  * running and unreported-failure counts, and finished jobs are reported to the
  * model — and shown as a bytefly notice — at the next turn, or by triggering one
- * turn for a `wake` job.
+ * turn for a `wake` job as soon as the agent is idle, including right after a
+ * running turn settles.
  *
  * Load with:  pi --extension ./extensions/job
  */
@@ -13,7 +14,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { isExtensionEnabled } from "../../lib/env.ts";
 import { JOB_FINISHED_CHANNEL, type JobFinishedEvent } from "../../lib/events.ts";
-import { noticeMessage, type NoticeMessage } from "../../lib/notice.ts";
+import { burstText, noticeMessage, type NoticeMessage } from "../../lib/notice.ts";
 import { createPendingReporter, registerPendingChannel } from "../../lib/report.ts";
 import { registerCommands } from "./commands.ts";
 import { formatCompletion, jobOutcome, shortLabel } from "./format.ts";
@@ -25,8 +26,13 @@ import type { JobRecord } from "./types.ts";
 const JOB_CONTEXT_MARKER = "[BACKGROUND JOBS]";
 
 function buildContext(jobs: JobRecord[]): string {
-	const lines = jobs.map((job) => formatCompletion(job));
-	return `${JOB_CONTEXT_MARKER}\n${jobs.length} background job${jobs.length === 1 ? "" : "s"} finished:\n${lines.join("\n")}\nRun \`job logs <id>\` for output.`;
+	const count = jobs.length;
+	return burstText({
+		marker: JOB_CONTEXT_MARKER,
+		headline: `${count} background job${count === 1 ? "" : "s"} finished`,
+		lines: jobs.map((job) => formatCompletion(job)),
+		hint: "Run `job logs <id>` for output.",
+	});
 }
 
 /** The shared notice for pending completions: model text plus renderer details. */
@@ -66,15 +72,17 @@ export default function jobs(pi: ExtensionAPI, deps: JobsDeps = {}): void {
 	if (!isExtensionEnabled("job")) return;
 	const runtime = deps.runtime ?? createJobsRuntime();
 
-	// Opt-in wake: a `wake` job finished while the agent is idle. The reporter
-	// reports *all* pending completions, not just the waking one, so a job that
-	// finished earlier is not silently marked seen and dropped.
+	// Opt-in wake: a `wake` job finished. The reporter reports *all* pending
+	// completions, not just the waking one, so a job that finished earlier is not
+	// silently marked seen and dropped, and it retries a completion that arrived
+	// mid-turn once the run settles.
 	const reporter = createPendingReporter<JobRecord>({
 		wake: (notice) => pi.sendMessage(notice, { triggerTurn: true }),
 		pending: () => runtime.pendingCompletions(),
 		markReported: (records) => runtime.markReported(records.map((job) => job.id)),
 		buildNotice: jobNotice,
 		source: "job",
+		wakeRequested: () => runtime.pendingCompletions().some((job) => job.wake),
 	});
 
 	registerTools(pi, runtime);

package/extensions/memory/README.md

@@ -169,9 +169,9 @@ skill. Mitigations:
   injection, and rendering.
 - Reads are capped at 256 KiB and the injected body at `maxInjectBytes`.
 - The path is a fixed constant; a symlink at the memory path is refused.
-- The files are ordinary user-owned markdown. They are **not** self-ignored like
-  `.pi/plans`, so committing or sharing them is the user's choice; review
-  project memory before trusting a repository.
+- The files are ordinary user-owned markdown, so committing or sharing them is
+  the user's choice; review project memory before trusting a repository. Notes
+  stay in the project, unlike plans, which live in the agent directory.
 
 ## Limitations