@nredd/pi-session-kit 0.8.0 → 0.9.0

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+- Make the portable stats CLI import-safe: importing `dist/pi-stats-export.mjs` no longer runs an operation; direct Node execution still runs it
+
+- Replace `/mon`'s ambiguous non-free label with `total-free` (`T-F` compact); accept additive native App+Wired+Compressed and swap metrics without silently substituting free-page subtraction
+- Accept native macOS interval CPU and footprint; add `f` to toggle the labelled byte column between `RSS` and `FOOT`, with failed measurements shown as `--`
+- Explain RSS versus footprint, compressed pages, executable names (`pi` as `node`), strong native identity and unavailable-CPU fallback in `?`; native metrics require the subsequent published sampler dependency bump
+
+- Raise the `monitor_start` `timeout_s` cap from 24h to 7 days (`604800`) so monitors can outlive long jobs
+
 ## 0.8.0
 
 - Add `/mon`: a read-only TUI dashboard of host CPU history, non-free memory, load and sampled processes, on by default (`mon.enabled`)

package/README.md

@@ -15,7 +15,9 @@ session branch. Closing pi stops its work.
 
 `/mon` opens a read-only, full-pane view of local CPU, memory, load and processes, sampled
 every ~2s by the shared `@nredd/pi-resource-sampler` library only while it is open. Details and
-limits (macOS process CPU is unavailable, macOS names keep 16 bytes, memory is non-free, partial coverage) are in
+limits (macOS native CPU/footprint require the upcoming sampler pin, executable names keep 16 bytes,
+RSS excludes compressed pages, `f` toggles a labelled footprint column,
+and memory labels state their measurement basis) are in
 [docs/mon-dashboard.md](docs/mon-dashboard.md). It is not a second `/monitor` process runner.
 
 ## Install and config
@@ -69,13 +71,17 @@ persistent cron is installed. Deferred-tool configurations need `goal_update` in
 ## Monitor
 
 - `monitor_start({argv, name, match?, wake?, timeout_s?})`: run an argv command with stdin closed,
-  no implicit shell. Five active monitors maximum, one-hour default timeout. Explicitly passing a
+  no implicit shell. Five active monitors maximum, one-hour default timeout, 7 day (`604800` s) maximum. Explicitly passing a
   shell remains arbitrary command execution; this is not a sandbox.
 - `monitor_read({id, since?})`: numbered output since a cursor. Ring buffers retain 2000 lines.
 - `monitor_stop({id})`, `/monitor list`, `/monitor stop <id|all>`: stop and inspect owned monitors.
 - Output batches every two seconds into the bounded ring buffer (with dropped-line reporting). Passive batches neither start turns nor create transcript/model-context entries; call `monitor_read` to fetch them. A regex match, natural exit, timeout or `wake: true` emits one compact visible wake with a cursor after the output the model last saw through a wake or read, not a replay of buffered output. A bounded batch preserves its first and latest dropped matching lines as wake evidence even if later output evicts them from the ring.
 - Children run in process groups: SIGTERM, then SIGKILL. Exit cleanup and pidfiles cover orderly quit
-  and later recovery after SIGKILL. Files live at
+  and later recovery after SIGKILL. Sweeps reauthenticate the leader after enumerating members;
+  uncertain identities or guards never authorize signaling. Reap checks are bounded to 20 polls
+  after escalation; a timeout keeps authenticated recovery on disk rather than claiming cleanup.
+  Spawn failures after child creation kill the child; matcher initialization failures also remove
+  its pidfile. A spawn completing after session disposal is killed without registration. Files live at
   `$TMPDIR/pi-monitors-<uid>/<sessionId>.<ownerPid>/<monitorId>.json`. Startup checks dead-owner
   records, including a resumed session, and validates process identity before signalling. It never
   sweeps a live owner's monitors. Two panes resuming the same session have separate directories.
@@ -219,8 +225,17 @@ the kit does not append a second reminder or request another continuation.
 `test/scenarios/` drives the real kit through core's in-process session harness under Vitest and Bun,
 covering goals, file-backed restore, child rename/reload, read-rule injection, titles,
 monitor output/wakes/cursors/caps/timeouts and loop scheduling with same-cwd session isolation.
+Command completion scenarios resolve public runner suggestions and execute the selected `/goal`,
+`/loop` and `/monitor` commands, checking persisted state, timer removal and the selected child.
+Loop resume starts from a provider-error pause: ticks stay quiet until the selected resume command
+restores dispatch. Git setup uses child-only scratch HOME/config and empty hooks/templates, with
+hostile config/template/hook controls; it never changes the parent process HOME.
+Pidfile age-boundary fixtures pin file/directory mtimes to the injected sweep clock and check the
+24-hour threshold under both past and future wall clocks.
 The interactive host/VirtualTerminal covers `/diff`, `/stats` and real `/name`, including width/resize
-matrices, chart glyph ports/colours and file-backed titles. Stats histories use a fixed clock;
+matrices, chart glyph ports/colours and file-backed titles. Mounted command callbacks also verify
+live-theme invalidation, empty Models ranges, help page boundaries, source-failure reopening,
+stale deferred factories and stats load-error cleanup without replacing the interactive host. Stats histories use a fixed clock;
 `createSessionKit({ agentDir, clock })` scopes both offline loading and displayed time ranges.
 Terminal fixtures route input chunks through pi-tui's real `StdinBuffer`, matching ProcessTerminal's
 keypress splitting (complete keys only; lone Escape is flushed immediately). Stats scroll-to-clamp
@@ -229,6 +244,18 @@ tabs and exact provider totals remain covered at every width. Each stats-view bo
 and disposes it in `finally`, so runner timeout teardown cannot race a still-running callback.
 Monitor scenarios use a shared fake clock and controlled children; native `test/monitor/` keeps real
 workers/processes, and process-group kill/orphan recovery stays in the assembled integration tier.
-`npm run check` runs Biome, TypeScript, the full Vitest suite and `bun test test/scenarios` (Bun 1.3.14).
+Native stop/dispose checks assert direct children are reaped when the operation resolves, then
+observe orphaned descendants disappearing with the existing bounded liveness check. Leader exit
+and pipe closure do not synchronize PID 1's reaping; on Linux, `kill(pid, 0)` can still succeed
+for a terminated zombie. No extra signal, fixed delay or larger timeout is needed.
+The native diff descendant timeout fixture gates its fake deadline on real stdout readiness, so
+slow process startup cannot race a fixed wall-clock deadline. Adapter fault tests cover monitor
+startup/sweep/widget failures, post-spawn errors, worker startup timeout, rejected sampler cleanup,
+first/latest dropped-match evidence, title-stream failure and real rule reinjection after tree
+navigation. Synthetic PIDs are never passed to real signal capabilities. Native Promise construction
+initializes the monitor exit resolver before child handlers register; synchronous close/error
+registration fixtures lock that ordering. The overwritten no-op resolver initializer is removed,
+not a reachable validation or lifecycle path.
+`npm run check` runs Biome, TypeScript, the full Vitest suite and `bun test test/scenarios` (Bun 1.4.4).
 Cross-extension Plan/subagent/todo interactions and OS terminal boundaries remain in the integration tier;
 `docs/verification-rebuild.md` at the monorepo root tracks their destinations.

package/dist/pi-stats-export.mjs

@@ -1,5 +1,7 @@
 // src/stats/cli.ts
+import { realpathSync } from "node:fs";
 import { resolve as resolve2 } from "node:path";
+import { pathToFileURL } from "node:url";
 
 // src/stats/load.ts
 import { createHash, randomUUID } from "node:crypto";
@@ -651,7 +653,23 @@ async function main() {
       "usage: export --agent-dir DIR --output OUT [--sessions-dir DIR] | import --agent-dir DIR --input REPO"
     );
 }
-main().catch((error) => {
-  console.error(error instanceof Error ? error.message : "Stats operation failed");
-  process.exitCode = 1;
-});
+async function run() {
+  try {
+    await main();
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : "Stats operation failed");
+    process.exitCode = 1;
+  }
+}
+function isEntrypoint() {
+  try {
+    return !!process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href;
+  } catch {
+    return false;
+  }
+}
+if (isEntrypoint()) void run();
+export {
+  main,
+  run
+};

package/docs/mon-dashboard.md

@@ -33,9 +33,12 @@ sample, including its `ps` child on macOS. Mapping rules:
   `(unknown)` (Linux hides other users' `/proc/PID/exe` without ptrace access). macOS `p_comm` keeps
   16 bytes, so a macOS name of 16+ UTF-8 bytes ends in a dim `…` (`Google Chrome He…`): possibly cut,
   never claimed complete. Names stay untrusted text: sanitized, never interpreted.
-- macOS process interval CPU is always unavailable (the sampler's `ps` start time has one-second
-  precision, so PID reuse cannot be excluded). The view says so, explains it in help, and orders by
-  RSS until the user picks a sort. Linux first samples are warming, so CPU order stays stable.
+- Upcoming sampler source supplies macOS native interval CPU and footprint via builtin FFI and
+  libproc, with process-start absolute ticks plus microsecond identity. Inaccessible PIDs and
+  unsupported runtimes have unknown metrics. The existing published `0.1.1` remains entirely
+  unavailable for process CPU; `ps` whole-second start times alone never authenticate CPU. The
+  view orders by RSS only when every process CPU is unavailable, until the user picks a sort.
+  Linux first samples are warming, so CPU order stays stable.
 - History spacing uses the sampler's monotonic `monotonicTimeMs`, so wall-clock steps (NTP, manual
   changes) cannot invent or hide gaps; the wall `wallTimeMs` is only displayed (header clock and
   last-success UTC).
@@ -53,7 +56,9 @@ sample, including its `ps` child on macOS. Mapping rules:
   The last row reserves close/help. Below 60 columns the header
   keeps the update clock over the tagline.
 - Columns: `PID`, `CPU%` (100 = one core), `RSS`, `MEM%` (RSS over total RAM, 60+ columns),
-  `NAME` last so long names never push numbers off screen. `--` is dimmed. A `▸` marks the
+  `NAME` last so long names never push numbers off screen. `f` toggles the byte column between
+  `RSS` and `FOOT` (native physical footprint, including compressed memory); unavailable/failed
+  PIDs show `--`, never zero. `MEM%` and `m` sorting remain RSS-based in either view. `--` is dimmed. A `▸` marks the
   selection; a theme scrollbar appears only when the list overflows. The memory card adds 1-minute
   load per logical CPU.
 - Host CPU severity colors the value (success under 50%, warning under 85%, error above) next to
@@ -67,13 +72,25 @@ sample, including its `ps` child on macOS. Mapping rules:
   columns before it are blank, including the warming baseline. Stale snapshots add no point. The caption states the actual span. The latest sample in a bucket wins.
   Stale views show the last successful capture's UTC timestamp (or `none`). Waiting/live/stale and
   CPU warming/unavailable use semantic theme colors and text, so meaning does not depend on color.
-- Memory is total minus free, explicitly **non-free**, not available memory or a pressure score
-  (on macOS free pages are small by design). Load averages are not percentages. Process CPU is
-  interval CPU, where 100% is one logical CPU and multithreaded processes can exceed 100%.
+- Memory labels its actual basis. Older samplers report **total-free** (`T-F` in the compact
+  summary), which includes cached files and is NOT Activity Monitor's Memory Used. Additive v1
+  `memory.usage` metrics instead render **used (A+W+C)** (`A+W+C` compact), an estimate of resident
+  App + Wired + Compressed physical RAM. A failed native metric stays `--`, never total-free under
+  a used label. Cards also show free pages and swap used/allocated; missing swap stays `--/--`.
+  `?` explains each basis, RSS excluding compressed pages versus Activity Monitor's footprint,
+  executable names (`pi` runs as `node`), and decaying `ps %cpu` versus interval CPU.
+  Load averages are not percentages. Process CPU is interval CPU, where 100% is one logical CPU and
+  multithreaded processes can exceed 100%.
+- Release sequencing: the registry dependency remains `0.1.1`, which lacks native host-memory
+  metrics. This adapter accepts the new optional memory/footprint fields and tests them, but production
+  remains honestly labelled total-free with unavailable process CPU/footprint until a new sampler
+  is published, its common dependency pin
+  and nested registry lock entries are updated, and both consumer registry tests pass. Do NOT claim
+  the new native used/swap line is active with the old registry pin.
 - The process viewport preserves selection by sampler identity, not PID or sorted row.
   Exited identities choose a bounded neighboring row; PID reuse cannot inherit selection.
   Unknown/non-finite measurements sort last with deterministic PID/identity tie breaks.
-- `j/k` and arrows select; PageUp/PageDown page; `g/G` jump first/last; `c/m/p` sort
+- `j/k` and arrows select; PageUp/PageDown page; `g/G` jump first/last; `f` toggles RSS/FOOT; `c/m/p` sort
   CPU/RSS/PID; `s` cycles sort; `?` toggles help; `q`/Escape close. CPU/RSS descend,
   PID ascends. Help has a bounded, wrapped viewport with a visible range and scroll hint;
   `j/k`, arrows, PageUp/PageDown and `g/G` scroll help without moving the process selection.

package/docs/stats-snapshots.md

@@ -3,7 +3,14 @@
 Build the committed `dist/pi-stats-export.mjs` with `npm ci && npm run build:stats-export`.
 The exact esbuild version and dependencies are locked; tests assert byte-identical rebuilds.
 Copy only that file. Runtime is Node 22+ with builtins only, no Pi install, extension, private
-repository, package install, auth or network access.
+repository, package install, auth or network access. Importing the artifact is silent, even when
+an importing process supplies a nonexistent entrypoint argument; direct and symlinked Node execution
+still run the CLI. Packed-CLI tests explicitly launch `node`, including when their Vitest
+host is Bun; this tests the artifact's declared runtime, not Bun's entry-module resolver.
+
+Chart tick steps parse decimal powers directly rather than using implementation-approximated
+exponentiation, keeping large finite ticks consistent between Node and Bun. Steps above the
+numeric range retain infinite headroom.
 
 ```
 node ARTIFACT export --agent-dir DIR --output OUT [--sessions-dir ROOT]
@@ -36,10 +43,16 @@ Installation state, never synced:
 - `DIR/pi-session-kit/stats-cache.json`: local parser cache v2, including file paths and compact
   usage tuples. Version 1 entries for deleted files stay intact; existing files reparse even if
   their mtime/size match. Strong identities are not invented for inaccessible legacy files.
+  Failed stat/parse operations count as incomplete history; a failed reparse retains the last-good
+  cached record. Invalid cached identities and raw provider/model pairs are discarded. Persisted
+  child markers apply only to the matching session ID, surviving user-visible renames.
 - `DIR/pi-session-kit/stats-global.json`: one atomically replaced document containing validated
   last-good machine snapshots, last successful import time and coverage problems. Imports do not
   mutate local usage or installation identity. A wholly failed import does not advance the sync
-  time; a partial import records valid updates and marks coverage incomplete.
+  time; a partial import records valid updates and marks coverage incomplete. The assembled cache
+  accepts up to 128 MiB; exceeding that limit fails before replacement and retains its last-good
+  bytes. Tests inject final-document byte accounting at the exact limit and one byte over, while
+  retaining real import validation and atomic publication.
 
 Snapshot version 1:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nredd/pi-session-kit",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "publishConfig": {
     "access": "public"
   },
@@ -27,7 +27,7 @@
     "pi-extension"
   ],
   "dependencies": {
-    "@nredd/pi-resource-sampler": "0.1.1"
+    "@nredd/pi-resource-sampler": "0.2.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",
@@ -39,15 +39,16 @@
     "format": "biome check --write src/ test/",
     "typecheck": "tsc --noEmit",
     "build:stats-export": "esbuild src/stats/cli.ts --bundle --platform=node --format=esm --target=node22 --outfile=dist/pi-stats-export.mjs",
-    "test": "npm run build:stats-export && vitest run",
-    "test:bun": "bun test test/scenarios",
+    "test": "npm run build:stats-export && vitest run --coverage",
+    "test:bun": "bun test test/scenarios --coverage --coverage-reporter=text --coverage-reporter=lcov --coverage-dir=coverage/bun",
     "check": "npm run lint && npm run typecheck && npm run test && npm run test:bun"
   },
   "devDependencies": {
     "@biomejs/biome": "2.5.15",
-    "@earendil-works/pi-coding-agent": "https://github.com/nredd/pi/releases/download/v1.3.0-nredd.7/earendil-works-pi-coding-agent-1.3.0.tgz",
-    "@earendil-works/pi-tui": "https://github.com/nredd/pi/releases/download/v1.3.0-nredd.7/earendil-works-pi-tui-1.3.0.tgz",
+    "@earendil-works/pi-coding-agent": "https://github.com/nredd/pi/releases/download/v1.3.0-nredd.8/earendil-works-pi-coding-agent-1.3.0.tgz",
+    "@earendil-works/pi-tui": "https://github.com/nredd/pi/releases/download/v1.3.0-nredd.8/earendil-works-pi-tui-1.3.0.tgz",
     "@types/node": "26.6.5",
+    "@vitest/coverage-v8": "5.0.3",
     "@xterm/headless": "5.5.0",
     "esbuild": "0.28.2",
     "typebox": "1.3.36",

package/src/mon/component.ts

@@ -45,6 +45,7 @@ const HELP = [
 	" c CPU  m RSS    descending",
 	" p PID           ascending",
 	" s               cycle sort",
+	" f               toggle RSS / FOOT",
 	" ?               back to dashboard",
 	" q/Esc           close",
 	"",
@@ -56,7 +57,12 @@ const HELP = [
 	" CPU is interval usage, not lifetime.",
 	" Process CPU can exceed 100% (one core).",
 	" -- is unavailable, never zero.",
-	" RAM is total minus free, not pressure.",
+	" T-F / RAM total-free includes cache;",
+	" it is NOT Activity Monitor Memory Used.",
+	" macOS used (A+W+C) estimates resident",
+	" app + wired + compressed physical RAM.",
+	" Free is free pages, not available RAM.",
+	" Swap is used / allocated, not RAM.",
 	" MEM% is RSS over total RAM.",
 	" Load 1/5/15 min: not percent.",
 	" History: elapsed time, newest right;",
@@ -65,18 +71,34 @@ const HELP = [
 	"*Processes",
 	" Names are executable files, never",
 	" arguments; still untrusted text.",
+	" pi runs as node: executable, not title.",
+	" RSS excludes compressed pages.",
+	" Activity Monitor's Memory column:",
+	" footprint, not RSS, with compression.",
+	" f shows FOOT bytes; MEM% stays RSS.",
+	" Failed/unsupported footprint is --.",
 	" (unknown): no access, e.g. another",
 	" user's process on Linux.",
 	" macOS keeps 16 bytes of a name;",
 	" a trailing … marks a possible cut.",
-	" macOS: ps start time is whole seconds,",
-	" so process CPU stays -- (sort: RSS).",
+	" macOS CPU: native cumulative time;",
+	" Start ticks + usec reject PID reuse.",
+	" No native access/builtin FFI: --.",
+	" Node <26.1 lacks builtin FFI; Bun uses",
+	" bun:ffi. ps start is whole seconds.",
+	" Older sampler releases also lack CPU.",
+	" Same PID/parent/name/time is NOT proof.",
+	" ps %cpu is decaying, NOT interval CPU.",
 	" Lists can be partial; notices say why.",
 	" Selection follows identity, not row.",
 	" No kill, locks or scheduling.",
 ];
 
-/** Local wall clock `HH:MM:SS`, display only. */
+/**
+ * Format local wall clock for display only.
+ * @param ms Unix epoch milliseconds.
+ * @returns Local HH:MM:SS time.
+ */
 function clock(ms: number): string {
 	const d = new Date(ms);
 	return [d.getHours(), d.getMinutes(), d.getSeconds()].map((n) => String(n).padStart(2, "0")).join(":");
@@ -95,16 +117,27 @@ export class MonView implements Component {
 	private sort: MonSort = "cpu";
 	private sortChosen = false;
 	private help = false;
+	private footprint = false;
 	private scroll = 0;
 	private pageSize = 1;
 	private cache: { width: number; height: number; lines: string[] } | undefined;
 
+	/**
+	 * Initialize a single-interaction dashboard.
+	 * @param options Theme, terminal dimensions and lifecycle callbacks.
+	 */
 	constructor(private readonly options: MonViewOptions) {}
 
+	/** @returns Readonly diagnostic selection/sort/history/scroll values. */
 	get state(): { selected: string | undefined; sort: MonSort; historyLength: number; scroll: number } {
 		return { selected: this.selected, sort: this.sort, historyLength: this.history.length, scroll: this.scroll };
 	}
 
+	/**
+	 * Accept the sole sampler-data ingress and update selection/history.
+	 * @param snapshot Current live/stale/waiting observation.
+	 * @returns Nothing; requests a render.
+	 */
 	update(snapshot: MonSnapshot): void {
 		this.snapshot = snapshot;
 		// Collector success is independent of CPU: a warming sample still carries fresh memory/processes.
@@ -123,15 +156,18 @@ export class MonView implements Component {
 		this.refresh();
 	}
 
+	/** @returns Nothing; discard cached rendering without collecting data. */
 	invalidate(): void {
 		this.cache = undefined;
 	}
 
+	/** @returns Nothing; invalidate rendering and request a redraw. */
 	private refresh(): void {
 		this.invalidate();
 		this.options.requestRender();
 	}
 
+	/** @returns Nothing; sort rows while retaining selection by identity when possible. */
 	private reorder(): void {
 		const oldIndex = Math.max(
 			0,
@@ -143,6 +179,11 @@ export class MonView implements Component {
 		}
 	}
 
+	/**
+	 * Handle navigation, help, sorting, byte-column toggle and close keys.
+	 * @param data Terminal key input.
+	 * @returns Nothing; requests rendering for recognized view changes.
+	 */
 	handleInput(data: string): void {
 		if (data === "q" || matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
 			this.options.onClose();
@@ -162,6 +203,8 @@ export class MonView implements Component {
 			else if (data === "G" || matchesKey(data, Key.end)) this.helpScroll = this.helpLength;
 			else return;
 			this.helpScroll = Math.max(0, Math.min(this.helpScroll, this.helpLength - this.helpPageSize));
+		} else if (data === "f") {
+			this.footprint = !this.footprint;
 		} else if (data === "c" || data === "m" || data === "p" || data === "s") {
 			this.sortChosen = true;
 			this.sort =
@@ -186,17 +229,33 @@ export class MonView implements Component {
 		this.refresh();
 	}
 
-	/** `--` reads as absent, not as a value: dim it everywhere. */
+	/**
+	 * Dim unknown values consistently.
+	 * @param text Preformatted metric.
+	 * @param width Minimum cell width.
+	 * @returns Left-padded, right-aligned text with unknown styling.
+	 */
 	private value(text: string, width: number): string {
 		const padded = text.padStart(width);
 		return text === "--" ? this.options.theme.fg("dim", padded) : padded;
 	}
 
-	/** Host CPU severity, always paired with the number so meaning never depends on color. */
+	/**
+	 * Choose severity, always paired with a number or unknown marker.
+	 * @param value Host CPU percentage or null.
+	 * @returns Theme color for the CPU state.
+	 */
 	private cpuColor(value: number | null): Color {
 		return value === null ? "dim" : value >= 85 ? "error" : value >= 50 ? "warning" : "success";
 	}
 
+	/**
+	 * Frame a dashboard card at fixed width.
+	 * @param title Card heading.
+	 * @param lines Already formatted body rows.
+	 * @param width Outer card columns.
+	 * @returns Framed rows fitted to the card.
+	 */
 	private panel(title: string, lines: string[], width: number): string[] {
 		const { theme } = this.options;
 		const inner = Math.max(0, width - 2);
@@ -210,7 +269,11 @@ export class MonView implements Component {
 		];
 	}
 
-	/** Compact mode omits capacity and the stale suffix; the header already labels every metric STALE. */
+	/**
+	 * Format CPU state; compact mode relies on the header's stale label.
+	 * @param capacity Whether to include logical-core capacity and stale suffix.
+	 * @returns Styled CPU summary.
+	 */
 	private cpuSummary(capacity = true): string {
 		const t = this.options.theme;
 		const s = this.snapshot;
@@ -226,11 +289,17 @@ export class MonView implements Component {
 		return `${head}${state} ${t.fg("muted", `${state ? "·" : "of"} ${s?.logicalCpus || "--"} logical CPUs`)}`;
 	}
 
+	/** @returns Formatted 1/5/15-minute loads, or unknown markers. */
 	private loads(): string {
 		const load = this.snapshot?.load ?? [];
 		return load.length ? load.map((n) => (Number.isFinite(n) ? n.toFixed(2) : "--")).join(" ") : "--";
 	}
 
+	/**
+	 * Render wide CPU and memory cards with explicit measurement basis.
+	 * @param width Available dashboard columns.
+	 * @returns Side-by-side card rows including free/swap and CPU history.
+	 */
 	private cards(width: number): string[] {
 		const s = this.snapshot;
 		const t = this.options.theme;
@@ -251,14 +320,16 @@ export class MonView implements Component {
 				` ${this.cpuSummary()}`,
 				...timeHistoryRows(this.history, chartWidth, 2).map((row) => ` ${t.fg("accent", row)}`),
 				` ${t.fg("dim", this.historyLabel())}`,
+				"", // Match the memory panel's added free/swap row.
 			],
 			leftWidth,
 		);
 		const memory = this.panel(
 			"MEMORY / load",
 			[
-				` ${t.bold(bytes(used))} ${t.fg("muted", `/ ${bytes(total)} non-free`)}`,
+				` ${t.bold(bytes(used))} ${t.fg("muted", `/ ${bytes(total)} ${s?.memoryBasis === "app+wired+compressed" ? "used (A+W+C)" : "total-free"}`)}`,
 				` ${t.fg("accent", "━".repeat(full))}${t.fg("borderMuted", "─".repeat(meterWidth - full))} ${ratio === null ? t.fg("dim", "--") : `${Math.round(ratio * 100)}%`}`,
+				` ${t.fg("muted", "free")} ${bytes(s?.memoryFreeBytes ?? null)} ${t.fg("muted", "swap")} ${bytes(s?.swapUsedBytes ?? null)}/${bytes(s?.swapTotalBytes ?? null)}`,
 				` ${t.fg("muted", "load")} ${this.loads()}`,
 				` ${t.fg("muted", "1/5/15 min ·")} ${perCpu === "--" ? t.fg("dim", perCpu) : perCpu} ${t.fg("muted", "per CPU")}`,
 			],
@@ -268,6 +339,11 @@ export class MonView implements Component {
 	}
 
 	/** Compact three-line summary when cards do not fit. */
+	/**
+	 * Render the compact metric/history summary.
+	 * @param width Available dashboard columns.
+	 * @returns Fitted summary rows with explicit RAM basis labels.
+	 */
 	private summary(width: number): string[] {
 		const s = this.snapshot;
 		const t = this.options.theme;
@@ -276,7 +352,7 @@ export class MonView implements Component {
 		const ram = `${bytes(used)}/${bytes(total)}`;
 		const metrics = [
 			`${t.fg("muted", "CPU")} ${this.cpuSummary(false)}`,
-			`${t.fg("muted", "RAM")} ${ram}`,
+			`${t.fg("muted", s?.memoryBasis === "total-free" ? "T-F" : s?.memoryBasis === "app+wired+compressed" ? "A+W+C" : "RAM")} ${ram}`,
 			`${t.fg("muted", "load")} ${this.loads().split(" ")[0]}`,
 		];
 		const spaced = ` ${metrics.join("  ")}`;
@@ -287,19 +363,24 @@ export class MonView implements Component {
 		];
 	}
 
-	/** Why host CPU reads `--`; textual, so meaning never depends on color. */
+	/** @returns Textual reason for unknown/stale host CPU, or an empty suffix. */
 	private cpuState(): string {
 		if (this.snapshot?.status === "stale") return ` ${this.options.theme.fg("muted", "last value")}`;
 		const state = this.snapshot?.cpuState;
 		return state === "warming" || state === "unavailable" ? ` ${this.options.theme.fg("warning", state)}` : "";
 	}
 
+	/** @returns Fixed CPU scale and actual monotonic history span label. */
 	private historyLabel(): string {
 		const span = Math.max(0, (this.history.at(-1)?.sampledAtMs ?? 0) - (this.history[0]?.sampledAtMs ?? 0));
 		return `0..100% · ${(span / 1000).toFixed(1)}s span · time →`;
 	}
 
-	/** Title, collector state, and when the shown data was collected. */
+	/**
+	 * Format title, collector state and capture freshness.
+	 * @param width Available dashboard columns.
+	 * @returns Responsive styled header.
+	 */
 	private header(width: number): string {
 		const t = this.options.theme;
 		const status = this.snapshot?.status ?? "waiting";
@@ -325,6 +406,11 @@ export class MonView implements Component {
 		return gap >= 2 ? `${left}${" ".repeat(gap)}${right}` : left;
 	}
 
+	/**
+	 * Format reachable close/help/navigation keys.
+	 * @param width Available dashboard columns.
+	 * @returns Responsive footer text, fitted by the render caller.
+	 */
 	private footer(width: number): string {
 		const t = this.options.theme;
 		const keys: [string, string][] = this.help
@@ -349,7 +435,11 @@ export class MonView implements Component {
 		return ` ${keys.map(([key, label]) => `${t.fg("accent", key)} ${t.fg("muted", label)}`).join("  ")}`;
 	}
 
-	/** Process name cell: dim `(unknown)` for no name, dim `…` where the OS may have cut it. */
+	/**
+	 * Format a safe executable name with unknown/truncation markers.
+	 * @param p Process row carrying sanitized name semantics.
+	 * @returns Styled display name, never interpreted as terminal input.
+	 */
 	private nameCell(p: MonProcess): string {
 		const t = this.options.theme;
 		if (p.nameState === "unknown" || p.name === "") return t.fg("dim", "(unknown)");
@@ -357,6 +447,11 @@ export class MonView implements Component {
 		return p.nameState === "truncated" ? `${name}${t.fg("dim", "…")}` : name;
 	}
 
+	/**
+	 * Render help/dashboard within terminal bounds without collecting data.
+	 * @param width Available terminal columns.
+	 * @returns Exactly the configured terminal-height rows, each fitted to width.
+	 */
 	render(width: number): string[] {
 		const height = Math.max(1, this.options.rows());
 		width = Math.max(1, width);
@@ -422,7 +517,13 @@ export class MonView implements Component {
 		return result;
 	}
 
-	/** Column header, the visible page of rows with a scrollbar when it overflows, and a position line. */
+	/**
+	 * Append header, visible process page, scrollbar and position line.
+	 * @param lines Mutable dashboard output prefix to extend.
+	 * @param width Available terminal columns.
+	 * @param height Available terminal rows including reserved footer.
+	 * @returns Nothing; updates page/scroll state and appends formatted rows.
+	 */
 	private table(lines: string[], width: number, height: number): void {
 		const t = this.options.theme;
 		const compact = width < 60;
@@ -435,6 +536,16 @@ export class MonView implements Component {
 		const overflow = this.processes.length > this.pageSize;
 		const rowWidth = width - (overflow ? 1 : 0);
 		const nameWidth = Math.max(1, rowWidth - 1 - pidWidth - cpuWidth - rssWidth - memWidth - 2);
+		/**
+		 * Fit preformatted table cells into one terminal row.
+		 * @param mark Selection marker.
+		 * @param pid Process identifier text.
+		 * @param cpu CPU percentage text.
+		 * @param rss Selected RSS/footprint bytes text.
+		 * @param mem RSS share text, omitted in compact mode.
+		 * @param name Safe executable display name.
+		 * @returns Row fitted to the available table width.
+		 */
 		const row = (mark: string, pid: string, cpu: string, rss: string, mem: string, name: string) =>
 			fitCols(
 				`${mark}${fitCols(pid, pidWidth)}${cpu}${rss}${memWidth ? mem : ""}  ${fitCols(name, nameWidth)}`,
@@ -443,7 +554,14 @@ export class MonView implements Component {
 		lines.push(
 			t.fg(
 				"muted",
-				row(" ", "PID", "CPU%".padStart(cpuWidth), "RSS".padStart(rssWidth), "MEM%".padStart(memWidth), "NAME"),
+				row(
+					" ",
+					"PID",
+					"CPU%".padStart(cpuWidth),
+					(this.footprint ? "FOOT" : "RSS").padStart(rssWidth),
+					"MEM%".padStart(memWidth),
+					"NAME",
+				),
 			),
 		);
 		const index = Math.max(
@@ -465,7 +583,7 @@ export class MonView implements Component {
 				selected ? t.fg("accent", "▸") : " ",
 				String(p.pid),
 				this.value(percent(p.cpuPercent).replace("%", ""), cpuWidth),
-				this.value(bytes(p.rssBytes), rssWidth),
+				this.value(bytes(this.footprint ? (p.footprintBytes ?? null) : p.rssBytes), rssWidth),
 				this.value(share(p.rssBytes, total), memWidth),
 				this.nameCell(p),
 			);

package/src/mon/model.ts

@@ -9,6 +9,8 @@ export interface MonProcess {
 	nameState?: "unknown" | "truncated";
 	cpuPercent: number | null;
 	rssBytes: number | null;
+	/** Native macOS physical footprint, including compression; undefined/null is not zero. */
+	footprintBytes?: number | null;
 }
 
 /** No process arguments, environment, working directories or host identifiers enter the view. */
@@ -17,6 +19,11 @@ export interface MonSnapshot {
 	logicalCpus: number;
 	memoryUsedBytes: number | null;
 	memoryTotalBytes: number | null;
+	/** Explicit measurement basis; older fixtures/producers default to total-free. */
+	memoryBasis?: "total-free" | "app+wired+compressed";
+	memoryFreeBytes?: number | null;
+	swapUsedBytes?: number | null;
+	swapTotalBytes?: number | null;
 	load: readonly number[];
 	processes: readonly MonProcess[];
 	/** Wall-clock capture time, for display only (it can jump). Never persisted. */
@@ -40,7 +47,12 @@ export interface MonSnapshot {
 export type MonSort = "cpu" | "rss" | "pid";
 export const SORTS: readonly MonSort[] = ["cpu", "rss", "pid"];
 
-/** Unknown/non-finite measurements sort last; ties are deterministic across refreshes. */
+/**
+ * Sort unknown/nonfinite measurements last, with deterministic ties.
+ * @param processes Readonly input rows.
+ * @param sort Requested CPU/RSS/PID ordering.
+ * @returns Sorted copy, leaving input untouched.
+ */
 export function sortProcesses(processes: readonly MonProcess[], sort: MonSort): MonProcess[] {
 	return [...processes].sort((a, b) => {
 		const av = sort === "cpu" ? a.cpuPercent : sort === "rss" ? a.rssBytes : a.pid;
@@ -53,16 +65,31 @@ export function sortProcesses(processes: readonly MonProcess[], sort: MonSort):
 	});
 }
 
+/**
+ * Format a percentage without inventing zero for unknown input.
+ * @param value Percentage or null.
+ * @returns One decimal plus percent sign, or --.
+ */
 export function percent(value: number | null): string {
 	return value === null || !Number.isFinite(value) ? "--" : `${value.toFixed(1)}%`;
 }
 
-/** Process share of total RAM, from the same sample's RSS and total. */
+/**
+ * Format process RSS share of the same sample's total RAM.
+ * @param part Resident bytes or null.
+ * @param total Physical RAM bytes or null.
+ * @returns One decimal percentage without its sign, or --.
+ */
 export function share(part: number | null, total: number | null): string {
 	if (part === null || total === null || !Number.isFinite(part) || !Number.isFinite(total) || total <= 0) return "--";
 	return `${((part / total) * 100).toFixed(1)}`;
 }
 
+/**
+ * Format binary byte quantities for bounded dashboard cells.
+ * @param value Bytes or null.
+ * @returns GiB/MiB quantity with compact G/M suffix, or --.
+ */
 export function bytes(value: number | null): string {
 	if (value === null || !Number.isFinite(value)) return "--";
 	return value >= 1024 ** 3 ? `${(value / 1024 ** 3).toFixed(1)}G` : `${(value / 1024 ** 2).toFixed(0)}M`;
@@ -80,6 +107,9 @@ export interface MonHistoryPoint {
  * after the first capture without a CPU value are real gaps (`null`), never interpolated CPU; the
  * leading `blank` columns precede the first capture because no history exists yet. The latest sample
  * in a bucket wins.
+ * @param history Monotonic ordered CPU observations.
+ * @param width Available chart columns.
+ * @returns Leading blank count and measured/gap buckets.
  */
 function historyBuckets(
 	history: readonly MonHistoryPoint[],
@@ -108,7 +138,12 @@ function historyBuckets(
 	return { blank: oldest, buckets: buckets.slice(oldest) };
 }
 
-/** One-row history: blank before data, `·` for gaps. */
+/**
+ * Render one-row history: blank before data, dots for gaps.
+ * @param history Monotonic ordered CPU observations.
+ * @param width Available chart columns.
+ * @returns Time-proportional CPU sparkline.
+ */
 export function timeHistory(history: readonly MonHistoryPoint[], width: number): string {
 	if (!history.length || width < 1) return "";
 	const { blank, buckets } = historyBuckets(history, width);
@@ -118,6 +153,10 @@ export function timeHistory(history: readonly MonHistoryPoint[], width: number):
 /**
  * Multi-row history (top row first), `rows * 8` levels on the same fixed 0..100 scale. A gap is `·`
  * on the bottom row only; zero keeps a `▁` baseline so a quiet host never looks like missing data.
+ * @param history Monotonic ordered CPU observations.
+ * @param width Available chart columns.
+ * @param rows Chart height.
+ * @returns Top-first rendered chart rows.
  */
 export function timeHistoryRows(history: readonly MonHistoryPoint[], width: number, rows: number): string[] {
 	if (rows <= 1) return [timeHistory(history, width)];
@@ -143,7 +182,12 @@ export function timeHistoryRows(history: readonly MonHistoryPoint[], width: numb
 	return lines;
 }
 
-/** Fixed 0..100 host CPU scale: a quiet history must not look saturated. */
+/**
+ * Render a fixed 0..100 CPU scale so quiet history does not look saturated.
+ * @param history CPU percentages or unknown samples.
+ * @param width Maximum newest samples to show.
+ * @returns Sparkline with dots for unknown/nonfinite samples.
+ */
 export function sparkline(history: readonly (number | null)[], width: number): string {
 	const ticks = "▁▂▃▄▅▆▇█";
 	const values = history.slice(-Math.max(0, width));

package/src/mon/source.ts

@@ -1,6 +1,7 @@
 /** Production /mon source: a thin mapping over the published shared sampler. No collector lives here. */
 import {
 	createResourceSampler,
+	type Metric,
 	type ResourceSampler,
 	type ResourceSnapshot,
 	type SamplerOptions,
@@ -20,28 +21,57 @@ const REASONS: Readonly<Record<string, string>> = {
 	"byte-limit": "read budget",
 	"file-byte-limit": "read budget",
 	[ROUTINE_SKIP]: "unreadable or exited",
-	"command-unavailable": "ps unavailable",
-	"command-failed": "ps failed",
+	"command-unavailable": "OS reader unavailable",
+	"command-failed": "OS reader failed",
 	"malformed-process-row": "unparsed rows",
 	"process-collection-unavailable": "process list unavailable",
 };
 const utf8 = new TextEncoder();
 
+/** Additive v1 fields for registry 0.1.1 compatibility; remove this shim at the owner-gated 0.2.0 pin. */
+type MemorySnapshot = Omit<ResourceSnapshot, "memory" | "processes"> & {
+	processes: (ResourceSnapshot["processes"][number] & { footprint?: Metric<number> })[];
+	memory: ResourceSnapshot["memory"] & {
+		usage?: Metric<{ usedBytes: number; availableBytes: number; basis: "app+wired+compressed" }>;
+		swap?: Metric<{ usedBytes: number; totalBytes: number }>;
+	};
+};
+
+/**
+ * Convert nonfinite producer values to the view's unknown sentinel.
+ * @param value Producer number.
+ * @returns Finite value or null.
+ */
 function finite(value: number): number | null {
 	return Number.isFinite(value) ? value : null;
 }
 
-/** Every observed process lacks interval CPU by platform design, not because it is warming. */
+/**
+ * Distinguish unavailable process CPU from initial warming.
+ * @param snapshot Producer snapshot.
+ * @returns Whether a nonempty process list has no supported interval CPU metrics.
+ */
 function processCpuUnavailable(snapshot: ResourceSnapshot): boolean {
 	return snapshot.processes.length > 0 && snapshot.processes.every((p) => p.cpu.state === "unavailable");
 }
 
+/**
+ * Annotate unknown or potentially truncated executable names.
+ * @param snapshot Snapshot supplying platform semantics.
+ * @param name Producer's sanitized executable basename.
+ * @returns Unknown/truncated marker, or undefined for a complete known name.
+ */
 function nameState(snapshot: ResourceSnapshot, name: string): "unknown" | "truncated" | undefined {
 	if (name === "") return "unknown";
 	return snapshot.platform === "darwin" && utf8.encode(name).length >= DARWIN_NAME_BYTES ? "truncated" : undefined;
 }
 
-/** Limits that hide data the user would expect: budget caps, collector failures, unavailable host CPU. */
+/**
+ * Explain budget caps, collector failures and unavailable host CPU.
+ * @param snapshot Producer snapshot and coverage.
+ * @param baseline Whether this is the first observation.
+ * @returns User-facing limit notice, or undefined when unnecessary.
+ */
 function notice(snapshot: ResourceSnapshot, baseline: boolean): string | undefined {
 	const parts: string[] = [];
 	const { coverage } = snapshot;
@@ -57,7 +87,11 @@ function notice(snapshot: ResourceSnapshot, baseline: boolean): string | undefin
 	return parts.length ? parts.join(" · ") : undefined;
 }
 
-/** Expected platform limits, stated once so `--` and `(unknown)` are never mistaken for zero or a bug. */
+/**
+ * Explain expected platform limits so unknown metrics are not mistaken for zero.
+ * @param snapshot Producer snapshot and availability states.
+ * @returns User-facing platform hint, or undefined when unnecessary.
+ */
 function hint(snapshot: ResourceSnapshot): string | undefined {
 	const parts: string[] = [];
 	const { coverage } = snapshot;
@@ -73,17 +107,38 @@ function hint(snapshot: ResourceSnapshot): string | undefined {
 /**
  * Map one typed sampler snapshot without inventing zeros for warming/unavailable values.
  * `baseline` marks a source's first observation, whose warming CPU needs no explanation.
+ * @param snapshot Typed producer snapshot including optional native metrics.
+ * @param baseline Whether this is the source's first observation.
+ * @returns View snapshot preserving unknown/failed metrics and measurement basis.
  */
-export function toMonSnapshot(snapshot: ResourceSnapshot, baseline = true): MonSnapshot {
+export function toMonSnapshot(snapshot: MemorySnapshot, baseline = true): MonSnapshot {
 	const total = finite(snapshot.memory.totalBytes);
 	const free = finite(snapshot.memory.freeBytes);
+	const usage = snapshot.memory.usage;
+	const swap = snapshot.memory.swap;
+	const measuredUsed = usage?.state === "available" ? finite(usage.value.usedBytes) : null;
+	const nativeUsed =
+		measuredUsed !== null && measuredUsed >= 0 && total !== null && total > 0 && measuredUsed <= total
+			? measuredUsed
+			: null;
+	const swapUsed = swap?.state === "available" ? finite(swap.value.usedBytes) : null;
+	const swapTotal = swap?.state === "available" ? finite(swap.value.totalBytes) : null;
+	const validSwap = swapUsed !== null && swapTotal !== null && swapUsed >= 0 && swapTotal >= swapUsed;
 	const text = notice(snapshot, baseline);
 	const note = hint(snapshot);
 	return {
 		cpuPercent: snapshot.cpu.state === "available" ? finite(snapshot.cpu.value) : null,
 		logicalCpus: snapshot.logicalCpus,
-		memoryUsedBytes: total !== null && total > 0 && free !== null ? Math.max(0, total - free) : null,
+		memoryUsedBytes: usage
+			? nativeUsed
+			: total !== null && total > 0 && free !== null && free >= 0 && free <= total
+				? total - free
+				: null,
 		memoryTotalBytes: total !== null && total > 0 ? total : null,
+		memoryBasis: usage ? "app+wired+compressed" : "total-free",
+		memoryFreeBytes: free !== null && free >= 0 ? free : null,
+		swapUsedBytes: validSwap ? swapUsed : null,
+		swapTotalBytes: validSwap ? swapTotal : null,
 		load: snapshot.loadAverage,
 		processes: snapshot.processes.map((p) => {
 			const state = nameState(snapshot, p.name);
@@ -94,6 +149,7 @@ export function toMonSnapshot(snapshot: ResourceSnapshot, baseline = true): MonS
 				...(state ? { nameState: state } : {}),
 				cpuPercent: p.cpu.state === "available" ? finite(p.cpu.value) : null,
 				rssBytes: finite(p.rssBytes),
+				footprintBytes: p.footprint?.state === "available" && p.footprint.value >= 0 ? finite(p.footprint.value) : null,
 			};
 		}),
 		capturedAt: snapshot.wallTimeMs,
@@ -108,7 +164,11 @@ export function toMonSnapshot(snapshot: ResourceSnapshot, baseline = true): MonS
 	};
 }
 
-/** One sampler per open interaction; its baseline and child cleanup end with the view. */
+/**
+ * Own one sampler per open interaction; its baseline/cleanup end with the view.
+ * @param create Sampler factory, injectable for lifecycle tests.
+ * @returns Disposable view source with first-observation baseline tracking.
+ */
 export function createSamplerSource(
 	create: (options?: SamplerOptions) => ResourceSampler = createResourceSampler,
 ): MonSource {

package/src/monitor/process.ts

@@ -78,7 +78,8 @@ function wrap(child: ChildProcess, opts: SpawnOptions): MonitorProcess {
 	let hardTimer: NodeJS.Timeout | undefined;
 	let drainTimer: NodeJS.Timeout | undefined;
 	let exit: ExitInfo | undefined;
-	let finish: (info: ExitInfo) => void = () => {};
+	// The native Promise executor assigns this synchronously, before any child handlers register.
+	let finish!: (info: ExitInfo) => void;
 	const exited = new Promise<ExitInfo>((resolve) => {
 		finish = resolve;
 	});

package/src/monitor/validate.ts

@@ -2,7 +2,7 @@
 
 export const MAX_MONITORS = 5;
 export const DEFAULT_TIMEOUT_S = 3600;
-export const MAX_TIMEOUT_S = 86_400;
+export const MAX_TIMEOUT_S = 604_800;
 export const MAX_NAME_LENGTH = 40;
 export const MAX_MATCH_LENGTH = 500;
 const NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;

package/src/stats/chart.ts

@@ -96,7 +96,9 @@ export function bucketize(
  */
 export function niceStep(x: number): number {
 	if (!(x > 1)) return 1;
-	const exp = 10 ** Math.floor(Math.log10(x));
+	if (!Number.isFinite(x)) return Number.POSITIVE_INFINITY;
+	// Parse decimal powers directly: exponentiation accuracy differs across JS engines.
+	const exp = Number(`1e${Math.floor(Math.log10(x))}`);
 	for (const m of NICE) {
 		const step = m * exp;
 		if (Number.isInteger(step) && step >= x - 1e-9 * exp) return step;

package/src/stats/cli.ts

@@ -1,9 +1,12 @@
 /** Standalone data-only CLI. Bundles the parser; never imports Pi or the private extension entrypoint. */
+import { realpathSync } from "node:fs";
 import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
 import { agentDir } from "./load.ts";
 import { exportStats, importStats } from "./snapshot.ts";
 
-async function main(): Promise<void> {
+/** Parse the portable CLI argv, run its selected operation, and report JSON to stdout. */
+export async function main(): Promise<void> {
 	const [command, ...args] = process.argv.slice(2);
 	const options = new Map<string, string>();
 	for (let i = 0; i < args.length; i += 2) {
@@ -44,7 +47,23 @@ async function main(): Promise<void> {
 			"usage: export --agent-dir DIR --output OUT [--sessions-dir DIR] | import --agent-dir DIR --input REPO",
 		);
 }
-main().catch((error: unknown) => {
-	console.error(error instanceof Error ? error.message : "Stats operation failed");
-	process.exitCode = 1;
-});
+/** Run `main`, converting failures to one diagnostic and a nonzero process exit code. */
+export async function run(): Promise<void> {
+	try {
+		await main();
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : "Stats operation failed");
+		process.exitCode = 1;
+	}
+}
+
+/** Importers may supply an absent or unresolvable entrypoint, which must not prevent import. */
+function isEntrypoint(): boolean {
+	try {
+		return !!process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href;
+	} catch {
+		return false;
+	}
+}
+
+if (isEntrypoint()) void run();