@first-tree-ai/context-tree 0.1.12 → 0.1.14-alpha.202609140819

package/README.md

@@ -28,7 +28,8 @@ skill directory of every agent you already have:
 
 ```text
 ✓ claude  → ~/.claude/skills/   (8 skills)
-✓ codex   → ~/.codex/skills/    (8 skills)
+✓ codex   → ~/.agents/skills/   (8 skills)
+✓ pi      → ~/.agents/skills/   (8 skills)
 ```
 
 Restart your agent so it discovers them, then try asking:
@@ -43,7 +44,7 @@ new agent, or scope it to one project:
 ```bash
 context-tree install                       # every agent you have
 context-tree install --host codex          # one agent
-context-tree install --project .           # ./.claude/skills and ./.codex/skills
+context-tree install --project .           # ./.claude/skills and ./.agents/skills
 context-tree uninstall                     # remove context-tree-* skills
 ```
 
@@ -51,7 +52,9 @@ Install and uninstall own exactly the `context-tree-*` skill directories.
 Install never touches skills it does not own or creates a configuration directory
 for an agent that is not present; uninstall removes every owned-prefix directory
 and nothing else. Adding support for another agent is one entry in the host table
-in `src/core/install.ts`.
+in `src/core/install.ts`. Codex and Pi share the cross-agent `.agents/skills`
+location, so that directory is written and removed once and reported for both
+hosts.
 
 `create` and `connect` leave project instructions unchanged. When a project has
 a regular `AGENTS.md` and no `CLAUDE.md` entry, they best-effort create a
@@ -190,6 +193,9 @@ $context-tree-schedule-cleanup every 2 hours
 
 # Claude Code
 /context-tree-schedule-cleanup every 2 hours
+
+# Pi
+/skill:context-tree-schedule-cleanup every 2 hours
 ```
 
 The CLI manages one schedule per tree on this machine:
@@ -197,6 +203,7 @@ The CLI manages one schedule per tree on this machine:
 ```bash
 context-tree cleanup schedule --project-path /absolute/project --agent codex
 context-tree cleanup schedule --project-path /absolute/project --agent claude --every 2h
+context-tree cleanup schedule --project-path /absolute/project --agent pi --model anthropic/claude-haiku-4-5
 context-tree cleanup status --project-path /absolute/project
 context-tree cleanup run --project-path /absolute/project
 context-tree cleanup remove --project-path /absolute/project
@@ -218,11 +225,14 @@ installation, daemon, or Linux lingering is needed. Cancel any previously create
 Codex desktop task or Claude Desktop routine before replacing it: the CLI cannot
 inspect or remove those tasks. Keep one designated cleaner per tree across machines.
 
-Agents use existing CLI authentication. Defaults are `gpt-5.6-luna` with low
-reasoning effort and `claude-haiku-4-5`; `--model` selects an explicit override.
-Codex uses workspace-write sandboxing and Claude uses file-editing permissions
-with a restricted tool list. Permission and authentication failures stop the run;
-models are never silently substituted. See [Codex noninteractive mode](https://learn.chatgpt.com/docs/non-interactive-mode)
+Agents use existing CLI authentication. Codex defaults to `gpt-5.6-luna` with
+low reasoning effort and Claude to `claude-haiku-4-5`; Pi uses its configured
+default model. `--model` selects an explicit override (Pi also accepts a
+`provider/model` value). Codex uses workspace-write sandboxing, Claude uses
+file-editing permissions, and Pi runs ephemeral with extensions disabled.
+Claude and Pi use restricted editing tool lists with no shell. Permission and
+authentication failures stop the run; models are never silently substituted.
+See [Codex noninteractive mode](https://learn.chatgpt.com/docs/non-interactive-mode)
 and the [Claude CLI reference](https://code.claude.com/docs/en/cli-reference).
 
 Scheduling opens a 24-hour activity window. Successful ordinary `create`,
@@ -304,3 +314,23 @@ pnpm check:package
 
 See [docs/specification.md](docs/specification.md) for contracts and safety
 invariants.
+
+Cleanup runner history is available with `context-tree cleanup logs` (latest output),
+`context-tree cleanup logs --list` (newest runs first), or
+`context-tree cleanup logs --run <run-id>`. Each accepts `--project-path` and
+`--json`; `--list` and `--run` are mutually exclusive. JSON returns one versioned
+result containing run summaries and the selected run's events. Reading logs does
+not refresh activity or contact the scheduler. Active runs return a snapshot;
+runs without a terminal outcome are shown as incomplete.
+
+History lives under `~/.context-tree/cleanup/logs/<tree-id>/<run-id>/` and is shared
+by projects connected to the same tree. Removing a schedule preserves history.
+The runner keeps 50 runs, pruning oldest completed runs; incomplete entries are
+protected. Each run holds at most 5 MiB of serialized output, with truncation
+reported separately from its final outcome. Logs label lifecycle events, stdout,
+and stderr in observed line order. Agent CLIs differ in how much progress and
+final output they emit. Credentials and terminal controls are sanitized, and
+oversized lines are suppressed. Prompts and environment configuration are not
+recorded by the runner. History covers scheduled and explicit `cleanup run`
+attempts, including skips; previous transcripts cannot be recovered, and cleanup
+performed directly through a host skill is outside this runner.

package/dist/cli/index.mjs

@@ -3,12 +3,13 @@ import { createRequire } from "node:module";
 import path, { basename, delimiter, dirname, isAbsolute, join, parse, posix, relative, resolve, sep } from "node:path";
 import { EventEmitter } from "node:events";
 import childProcess, { spawn, spawnSync } from "node:child_process";
-import fs, { accessSync, chmodSync, constants, copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, rmdirSync, statSync, symlinkSync, writeFileSync } from "node:fs";
+import fs, { accessSync, chmodSync, closeSync, constants, copyFileSync, existsSync, fstatSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, rmdirSync, statSync, symlinkSync, writeFileSync, writeSync } from "node:fs";
 import process$1 from "node:process";
 import { stripVTControlCharacters } from "node:util";
 import { createHash, randomUUID } from "node:crypto";
 import { homedir, tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
+import { StringDecoder } from "node:string_decoder";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
@@ -7352,7 +7353,11 @@ const contextContentClassCountsSchema = object({
 	member: number().int().nonnegative(),
 	"repo-infra": number().int().nonnegative()
 }).strict();
-const SKILL_HOSTS = ["claude", "codex"];
+const SKILL_HOSTS = [
+	"claude",
+	"codex",
+	"pi"
+];
 const skillHostSchema = _enum(SKILL_HOSTS);
 const skillInstallationSchema = object({
 	host: skillHostSchema,
@@ -7469,13 +7474,17 @@ object({
 	ok: literal(false),
 	schemaVersion: literal(1)
 }).strict();
-const cleanupAgentSchema = union([literal("codex"), literal("claude")]);
+const cleanupAgentSchema = union([
+	literal("codex"),
+	literal("claude"),
+	literal("pi")
+]);
 const cleanupScheduleSchema = object({
 	id: string$2().regex(/^[a-f0-9]{64}$/u),
 	projectPath: string$2().refine(isAbsolute),
 	identity: string$2(),
 	agent: cleanupAgentSchema,
-	model: string$2().min(1),
+	model: string$2().min(1).optional(),
 	everyMinutes: number().int().positive().max(525600),
 	nodePath: string$2().refine(isAbsolute),
 	cliPath: string$2().refine(isAbsolute),
@@ -7485,6 +7494,7 @@ const cleanupScheduleSchema = object({
 }).strict();
 const cleanupOutcomeSchema = object({
 	at: number(),
+	runId: string$2().uuid().optional(),
 	outcome: union([
 		literal("inactive"),
 		literal("unchanged"),
@@ -7509,6 +7519,29 @@ const cleanupResultSchema = object({
 	latest: cleanupOutcomeSchema.nullable()
 }).strict();
 const cleanupRunResultSchema = cleanupOutcomeSchema.extend({ schemaVersion: literal(1) }).strict();
+const cleanupLogEventSchema = object({
+	at: number().finite(),
+	source: union([
+		literal("runner"),
+		literal("stdout"),
+		literal("stderr")
+	]),
+	text: string$2()
+}).strict();
+const cleanupRunMetadataSchema = object({
+	runId: string$2().uuid(),
+	startedAt: number().finite(),
+	agent: cleanupAgentSchema,
+	model: string$2().optional(),
+	truncated: boolean(),
+	terminal: cleanupOutcomeSchema.optional()
+}).strict();
+const cleanupLogsResultSchema = object({
+	schemaVersion: literal(1),
+	runs: array(cleanupRunMetadataSchema),
+	selectedRunId: string$2().uuid().nullable(),
+	events: array(cleanupLogEventSchema)
+}).strict();
 //#endregion
 //#region src/core/internal/errors.ts
 /**
@@ -7525,18 +7558,27 @@ var ContextTreeError = class extends Error {
 };
 //#endregion
 //#region src/core/internal/git.ts
-function defaultRunner(command, args) {
+function defaultRunner(command, args, timeoutMs = 12e4) {
 	const result = spawnSync(command, args, {
 		encoding: "utf8",
 		stdio: [
 			"ignore",
 			"pipe",
 			"pipe"
-		]
+		],
+		timeout: timeoutMs,
+		killSignal: "SIGKILL",
+		detached: process.platform !== "win32"
 	});
+	const timedOut = result.error !== void 0 && "code" in result.error && result.error.code === "ETIMEDOUT";
+	if (timedOut && process.platform !== "win32" && result.pid) try {
+		process.kill(-result.pid, "SIGKILL");
+	} catch (error) {
+		if (!(error instanceof Error && "code" in error && error.code === "ESRCH")) throw error;
+	}
 	return {
 		status: result.status,
-		stderr: typeof result.stderr === "string" ? result.stderr : "",
+		stderr: timedOut ? `Command timed out after ${timeoutMs} ms.` : result.error ? "Unable to start command." : typeof result.stderr === "string" ? result.stderr : "",
 		stdout: typeof result.stdout === "string" ? result.stdout : ""
 	};
 }
@@ -26008,23 +26050,36 @@ function reclaimAbandonedWrites(root, checkoutBranch, runner) {
 }
 //#endregion
 //#region src/core/cleanup/agent.ts
+/** Pi built-in tools mirroring the Claude editing allowlist; Bash stays disabled. */
+const PI_CLEANUP_TOOLS = "read,edit,write,grep,find,ls";
 function agentArguments(config) {
-	return config.agent === "codex" ? [
-		"exec",
-		"--sandbox",
-		"workspace-write",
-		"-c",
-		"approval_policy=\"never\"",
-		"-c",
-		"model_reasoning_effort=\"low\"",
-		"--model",
-		config.model,
-		"--ephemeral",
-		"-"
-	] : [
+	if (config.agent === "codex") {
+		const args = [
+			"exec",
+			"--sandbox",
+			"workspace-write",
+			"-c",
+			"approval_policy=\"never\"",
+			"-c",
+			"model_reasoning_effort=\"low\""
+		];
+		if (config.model !== void 0) args.push("--model", config.model);
+		args.push("--ephemeral", "-");
+		return args;
+	}
+	if (config.agent === "pi") {
+		const args = [
+			"-p",
+			"--tools",
+			PI_CLEANUP_TOOLS,
+			"--no-session",
+			"--no-extensions"
+		];
+		if (config.model !== void 0) args.push("--model", config.model);
+		return args;
+	}
+	const args = [
 		"-p",
-		"--model",
-		config.model,
 		"--permission-mode",
 		"acceptEdits",
 		"--tools",
@@ -26033,8 +26088,10 @@ function agentArguments(config) {
 		"Read,Edit,Write,Glob,Grep",
 		"--no-session-persistence"
 	];
+	if (config.model !== void 0) args.push("--model", config.model);
+	return args;
 }
-async function runAgent(config, worktree, prompt, signal, timeoutMs = 900 * 1e3) {
+async function runAgent(config, worktree, prompt, signal, timeoutMs = 900 * 1e3, output) {
 	if (signal.aborted) throw new Error("Cleanup cancelled.");
 	await new Promise((resolve, reject) => {
 		const child = spawn(config.agentPath, agentArguments(config), {
@@ -26046,8 +26103,8 @@ async function runAgent(config, worktree, prompt, signal, timeoutMs = 900 * 1e3)
 			},
 			stdio: [
 				"pipe",
-				"ignore",
-				"ignore"
+				"pipe",
+				"pipe"
 			]
 		});
 		let failure;
@@ -26067,6 +26124,39 @@ async function runAgent(config, worktree, prompt, signal, timeoutMs = 900 * 1e3)
 			for (const pid of descendants.reverse()) kill(pid, "SIGTERM");
 			child.kill("SIGTERM");
 		};
+		const promptLines = new Set(prompt.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean));
+		const flushers = [];
+		for (const source of ["stdout", "stderr"]) {
+			const decoder = new StringDecoder("utf8");
+			let pending = "";
+			let oversized = false;
+			const emit = (text) => {
+				try {
+					output?.(source, promptLines.has(text.trim()) ? "[Prompt line suppressed]" : text);
+				} catch {
+					stop("Unable to store cleanup logs; worktree preserved.");
+				}
+			};
+			const consume = (text) => {
+				for (const part of text.split(/(?<=\n)/u)) {
+					if (!oversized) pending += part;
+					if (pending.length > 16384) {
+						pending = "";
+						oversized = true;
+					}
+					if (part.endsWith("\n")) {
+						emit(oversized ? "[Oversized output line suppressed]" : pending.slice(0, -1));
+						pending = "";
+						oversized = false;
+					}
+				}
+			};
+			child[source].on("data", (chunk) => consume(decoder.write(chunk)));
+			flushers.push(() => {
+				consume(decoder.end());
+				if (oversized || pending) emit(oversized ? "[Oversized output line suppressed]" : pending);
+			});
+		}
 		const abort = () => stop("Cleanup cancelled.");
 		const timer = setTimeout(() => stop("Cleanup agent exceeded its 15-minute timeout."), timeoutMs);
 		signal.addEventListener("abort", abort, { once: true });
@@ -26076,6 +26166,7 @@ async function runAgent(config, worktree, prompt, signal, timeoutMs = 900 * 1e3)
 			failure = "Unable to launch cleanup agent.";
 		});
 		child.on("close", async (code) => {
+			for (const flush of flushers) flush();
 			clearTimeout(timer);
 			signal.removeEventListener("abort", abort);
 			await termination;
@@ -26161,6 +26252,128 @@ function activity(id) {
 	const parsed = number().finite().safeParse(readState(statePath(id, "activity")));
 	return parsed.success ? parsed.data : null;
 }
+function directory(treeId) {
+	if (!/^[a-f0-9]{64}$/u.test(treeId)) throw new Error("Invalid cleanup tree ID.");
+	return privateDirectory(join(cleanupRoot(), "logs", treeId));
+}
+function runDirectory(root, runId) {
+	string$2().uuid().parse(runId);
+	const path = join(root, runId);
+	if (!lstatSync(path, { throwIfNoEntry: false })) throw new Error("Unknown cleanup run ID.");
+	return privateDirectory(path);
+}
+function summaries(root) {
+	return readdirSync(root).flatMap((id) => {
+		const state = readState(join(runDirectory(root, id), "metadata"));
+		if (state === void 0) return [];
+		const metadata = cleanupRunMetadataSchema.parse(state);
+		if (metadata.runId !== id) throw new Error("Cleanup log identity is corrupt.");
+		return metadata;
+	}).sort((a, b) => b.startedAt - a.startedAt || b.runId.localeCompare(a.runId));
+}
+function readEvents(path) {
+	const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+	try {
+		const stat = fstatSync(fd);
+		if (!stat.isFile() || stat.size > 5242880) throw new Error("Unsafe cleanup events file.");
+		const lines = readFileSync(fd, "utf8").split("\n");
+		lines.pop();
+		return lines.map((line) => cleanupLogEventSchema.parse(JSON.parse(line)));
+	} finally {
+		closeSync(fd);
+	}
+}
+function readCleanupHistory(treeId, options = {}) {
+	if (options.list && options.run !== void 0) throw new Error("--list and --run are mutually exclusive.");
+	if (options.run !== void 0) string$2().uuid().parse(options.run);
+	const root = directory(treeId);
+	const runs = summaries(root);
+	const selected = options.list ? void 0 : options.run ?? runs[0]?.runId;
+	if (options.run && !runs.some((run) => run.runId === options.run)) throw new Error("Unknown cleanup run ID.");
+	return cleanupLogsResultSchema.parse({
+		schemaVersion: 1,
+		runs,
+		selectedRunId: selected ?? null,
+		events: selected ? readEvents(join(runDirectory(root, selected), "events.jsonl")) : []
+	});
+}
+function sanitizeLogText(text) {
+	return sanitizeCommandOutput(stripVTControlCharacters(text).replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/gu, "")).replace(/\b(?:https?|ssh):\/\/[^\s]+/giu, "<redacted URL>").replace(/\b[A-Z_][A-Z0-9_]*=[^\s]+/gu, "<redacted assignment>");
+}
+var CleanupHistory = class {
+	runId;
+	path;
+	metadata;
+	bytes = 0;
+	failed = false;
+	constructor(config) {
+		const root = directory(config.id);
+		const previous = summaries(root);
+		let count = previous.length;
+		for (const run of [...previous].reverse()) {
+			if (count < 50) break;
+			if (!run.terminal) continue;
+			rmSync(runDirectory(root, run.runId), { recursive: true });
+			count--;
+		}
+		this.runId = randomUUID();
+		this.path = privateDirectory(join(root, this.runId));
+		this.metadata = {
+			runId: this.runId,
+			startedAt: Date.now(),
+			agent: config.agent,
+			...config.model === void 0 ? {} : { model: sanitizeLogText(config.model) },
+			truncated: false
+		};
+		closeSync(openSync(join(this.path, "events.jsonl"), constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW, 384));
+		atomicState(join(this.path, "metadata"), this.metadata);
+	}
+	event(source, text) {
+		this.assertHealthy();
+		try {
+			if (this.metadata.truncated) return;
+			const line = `${JSON.stringify(cleanupLogEventSchema.parse({
+				at: Date.now(),
+				source,
+				text: sanitizeLogText(text)
+			}))}\n`;
+			const size = Buffer.byteLength(line);
+			if (this.bytes + size > 5242880) {
+				this.metadata.truncated = true;
+				this.save();
+				return;
+			}
+			privateDirectory(this.path);
+			const fd = openSync(join(this.path, "events.jsonl"), constants.O_APPEND | constants.O_WRONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+			try {
+				if (!fstatSync(fd).isFile()) throw new Error("Unsafe cleanup events file.");
+				const buffer = Buffer.from(line);
+				let written = 0;
+				while (written < buffer.length) written += writeSync(fd, buffer, written, buffer.length - written);
+			} finally {
+				closeSync(fd);
+			}
+			this.bytes += size;
+		} catch {
+			this.failed = true;
+			throw new Error("Unable to store cleanup logs; worktree preserved.");
+		}
+	}
+	assertHealthy() {
+		if (this.failed) throw new Error("Unable to store cleanup logs; worktree preserved.");
+	}
+	finish(outcome) {
+		this.metadata.terminal = {
+			...outcome,
+			...outcome.message === void 0 ? {} : { message: sanitizeLogText(outcome.message) }
+		};
+		this.save();
+	}
+	save() {
+		privateDirectory(this.path);
+		atomicState(join(this.path, "metadata"), this.metadata);
+	}
+};
 //#endregion
 //#region src/core/cleanup/scheduler.ts
 function xml(value) {
@@ -26248,7 +26461,11 @@ function nativeScheduler(platform = process.platform, home = homedir(), runner =
 		remove(config) {
 			const name = label(config);
 			if (platform === "darwin") {
-				command(["bootout", `${domain}/${name}`], true);
+				try {
+					command(["bootout", `${domain}/${name}`], true);
+				} catch (error) {
+					if (status(config).registered) throw error;
+				}
 				const launcherDir = launcherDirectory(config);
 				const launcher = join(launcherDir, "context-tree-cleanup");
 				const entry = lstatSync(launcher, { throwIfNoEntry: false });
@@ -26271,6 +26488,11 @@ function nativeScheduler(platform = process.platform, home = homedir(), runner =
 }
 //#endregion
 //#region src/core/cleanup/index.ts
+/** Low-cost editorial default for agents that need an explicit model; `--model` overrides it. */
+const DEFAULT_CLEANUP_MODEL = {
+	claude: "claude-haiku-4-5",
+	codex: "gpt-5.6-luna"
+};
 function parseCleanupInterval(value = "1h") {
 	const match = /^(\d+)(m|h|d)$/u.exec(value);
 	const minutes = Number(match?.[1]) * (match?.[2] === "d" ? 1440 : match?.[2] === "h" ? 60 : 1);
@@ -26296,6 +26518,12 @@ function findSchedule(project) {
 	const connection = findConnectionRecord(canonical);
 	return connection ? schedules().find((config) => config.id === identityId(treeIdentity(connection.tree))) : void 0;
 }
+function cleanupLogs(project, options = {}) {
+	const connection = findConnectionRecord(canonicalProjectRoot(project));
+	const id = connection ? identityId(treeIdentity(connection.tree)) : findSchedule(project)?.id;
+	if (!id) throw new Error("No Context Tree connection or cleanup schedule exists for this project.");
+	return readCleanupHistory(id, options);
+}
 function cleanupStatus(project, scheduler = nativeScheduler()) {
 	const config = findSchedule(project);
 	if (!config) return {
@@ -26349,7 +26577,7 @@ function scheduleCleanupUnlocked(options, scheduler = nativeScheduler()) {
 		projectPath: connection.projectPath,
 		identity,
 		agent,
-		model: options.model ?? (agent === "codex" ? "gpt-5.6-luna" : "claude-haiku-4-5"),
+		model: options.model ?? DEFAULT_CLEANUP_MODEL[agent],
 		everyMinutes: parseCleanupInterval(options.every),
 		nodePath: realpathSync(process.execPath),
 		cliPath: resolvePackagedResource("dist", "cli", "index.mjs"),
@@ -26466,14 +26694,30 @@ async function runCleanup(project, savedId, dependencies = {}) {
 	process.on("SIGINT", cancel);
 	let worktreePath;
 	let publishing = false;
+	let history;
 	const record = (outcome, extra = {}) => {
 		const value = cleanupOutcomeSchema.parse({
 			at: Date.now(),
+			runId: history?.runId,
 			outcome,
 			...worktreePath ? { worktreePath } : {},
 			...extra
 		});
 		atomicState(statePath(config.id, "latest"), value);
+		if (outcome !== "running") try {
+			try {
+				history?.event("runner", `${outcome}${value.message ? `: ${value.message}` : ""}`);
+			} finally {
+				history?.finish(value);
+			}
+		} catch {
+			if (![
+				"failed",
+				"cancelled",
+				"publication-uncertain"
+			].includes(outcome)) throw new Error("Unable to store cleanup logs; worktree preserved.");
+		}
+		else history?.event("runner", value.message ?? "Agent execution started.");
 		return value;
 	};
 	const check = () => {
@@ -26487,13 +26731,17 @@ async function runCleanup(project, savedId, dependencies = {}) {
 		return tree;
 	};
 	try {
+		history = new CleanupHistory(config);
+		history.event("runner", "Preparing cleanup.");
 		check();
 		const lastActivity = activity(config.id);
 		if (lastActivity === null || Date.now() - lastActivity > 864e5) return record("inactive");
 		identityCheck();
+		record("running", { message: "Synchronizing Context Tree." });
 		const synced = (dependencies.sync ?? syncProject)(config.projectPath);
 		check();
 		if (readState(statePath(config.id, "success")) === synced.sha) return record("unchanged", { sha: synced.sha });
+		record("running", { message: "Preparing cleanup worktree." });
 		worktreePath = (dependencies.prepare ?? prepareContextWrite)(config.projectPath).worktreePath;
 		check();
 		const head = git(worktreePath, ["rev-parse", "HEAD"]);
@@ -26508,10 +26756,12 @@ async function runCleanup(project, savedId, dependencies = {}) {
 			}
 		}, 250);
 		try {
-			await (dependencies.agent ?? runAgent)(config, worktreePath, `${editorial}\n\nYou are the editorial worker in an already prepared isolated worktree. Read all normal and member Markdown content directly using file tools. Edit and check references only. Do not invoke Context Tree lifecycle commands, stage, commit, change Git configuration, or publish. Do not follow other skills that request those operations. Report unresolved issues outside tree files.`, controller.signal);
+			await (dependencies.agent ?? runAgent)(config, worktreePath, `${editorial}\n\nYou are the editorial worker in an already prepared isolated worktree. Read all normal and member Markdown content directly using file tools. Edit and check references only. Do not invoke Context Tree lifecycle commands, stage, commit, change Git configuration, or publish. Do not follow other skills that request those operations. Report unresolved issues outside tree files.`, controller.signal, void 0, (source, text) => history?.event(source, text));
 		} finally {
 			clearInterval(monitor);
 		}
+		history.assertHealthy();
+		history.event("runner", "Verifying cleanup edits.");
 		check();
 		if (git(worktreePath, ["rev-parse", "HEAD"]) !== head) throw new Error("Cleanup agent committed changes.");
 		const changed = inspectEdits(worktreePath, before);
@@ -26529,7 +26779,6 @@ async function runCleanup(project, savedId, dependencies = {}) {
 			worktreePath,
 			message: "Clean up Context Tree content"
 		});
-		publishing = false;
 		atomicState(statePath(config.id, "success"), finished.sha);
 		return record("published", { sha: finished.sha });
 	} catch (error) {
@@ -26718,12 +26967,22 @@ function createProject(projectPath, runner) {
 }
 //#endregion
 //#region src/core/install.ts
-/** Per-host configuration directory, relative to the home directory or to a project root. */
-const HOST_CONFIG_DIRECTORY = {
-	claude: ".claude",
-	codex: ".codex"
+/** Home configuration paths detect hosts independently of their skills destinations. */
+const HOST_DIRECTORIES = {
+	claude: {
+		config: [".claude"],
+		skills: ".claude"
+	},
+	codex: {
+		config: [".codex"],
+		skills: ".agents"
+	},
+	pi: {
+		config: [".pi", "agent"],
+		skills: ".agents"
+	}
 };
-/** Every supported host keeps user skills in the same subdirectory of its configuration directory. */
+/** Subdirectory below each skills destination. */
 const SKILLS_DIRECTORY = "skills";
 /** Only directories carrying this prefix are ever replaced or removed. */
 const OWNED_SKILL_PREFIX = "context-tree-";
@@ -26770,18 +27029,21 @@ function packagedSkillNames(skillsRoot) {
 }
 /** Resolve one host's destination, or the reason it was skipped. */
 function hostDestination(host, root, isProjectInstall) {
-	const configDirectory = HOST_CONFIG_DIRECTORY[host];
+	const directories = HOST_DIRECTORIES[host];
 	if (!isProjectInstall) {
-		const hostRoot = join(root, configDirectory);
-		const entry = lstatSync(hostRoot, { throwIfNoEntry: false });
-		if (entry === void 0) return { reason: `${hostRoot} does not exist; install ${host} first, then run context-tree install.` };
-		if (entry.isSymbolicLink() || !entry.isDirectory()) return { reason: `${hostRoot} is not a real directory.` };
+		let hostRoot = root;
+		for (const segment of directories.config) {
+			hostRoot = join(hostRoot, segment);
+			const entry = lstatSync(hostRoot, { throwIfNoEntry: false });
+			if (entry === void 0) return { reason: `${hostRoot} does not exist; install ${host} first, then run context-tree install.` };
+			if (entry.isSymbolicLink() || !entry.isDirectory()) return { reason: `${hostRoot} is not a real directory.` };
+		}
 	}
-	return { destination: ensureRealDirectory(root, [configDirectory, SKILLS_DIRECTORY]) };
+	return { destination: ensureRealDirectory(root, [directories.skills, SKILLS_DIRECTORY]) };
 }
 /** Resolve one host's existing skills root without creating or following anything. */
 function hostSkillsRoot(host, root) {
-	const hostRoot = join(root, HOST_CONFIG_DIRECTORY[host]);
+	const hostRoot = join(root, HOST_DIRECTORIES[host].skills);
 	const hostEntry = lstatSync(hostRoot, { throwIfNoEntry: false });
 	if (hostEntry === void 0) return { reason: `${hostRoot} does not exist; nothing to remove.` };
 	if (hostEntry.isSymbolicLink() || !hostEntry.isDirectory()) return { reason: `${hostRoot} is not a real directory.` };
@@ -26807,6 +27069,7 @@ function installSkills(options = {}) {
 	const root = projectRoot ?? realHome();
 	const installed = [];
 	const skipped = [];
+	const written = /* @__PURE__ */ new Set();
 	for (const host of hosts) {
 		const resolved = hostDestination(host, root, projectRoot !== void 0);
 		if ("reason" in resolved) {
@@ -26816,13 +27079,16 @@ function installSkills(options = {}) {
 			});
 			continue;
 		}
-		for (const skill of skills) {
-			const target = join(resolved.destination, skill);
-			if (lstatSync(target, { throwIfNoEntry: false }) !== void 0) rmSync(target, {
-				force: true,
-				recursive: true
-			});
-			copyRealTree(join(skillsRoot, skill), target);
+		if (!written.has(resolved.destination)) {
+			for (const skill of skills) {
+				const target = join(resolved.destination, skill);
+				if (lstatSync(target, { throwIfNoEntry: false }) !== void 0) rmSync(target, {
+					force: true,
+					recursive: true
+				});
+				copyRealTree(join(skillsRoot, skill), target);
+			}
+			written.add(resolved.destination);
 		}
 		installed.push({
 			host,
@@ -26843,6 +27109,7 @@ function uninstallSkills(options = {}) {
 	const root = options.projectPath === void 0 ? realHome() : resolve(options.projectPath);
 	const removed = [];
 	const skipped = [];
+	const removedByDestination = /* @__PURE__ */ new Map();
 	for (const host of hosts) {
 		const resolved = hostSkillsRoot(host, root);
 		if ("reason" in resolved) {
@@ -26852,29 +27119,34 @@ function uninstallSkills(options = {}) {
 			});
 			continue;
 		}
-		const skills = [];
-		for (const entry of readdirSync(resolved.destination, { withFileTypes: true })) {
-			if (!entry.name.startsWith(OWNED_SKILL_PREFIX)) continue;
-			const target = join(resolved.destination, entry.name);
-			const targetEntry = lstatSync(target, { throwIfNoEntry: false });
-			if (targetEntry === void 0) continue;
-			if (targetEntry.isSymbolicLink() || !targetEntry.isDirectory()) {
-				skipped.push({
-					host,
-					reason: `${target} is not a real directory.`
+		let skills = removedByDestination.get(resolved.destination);
+		if (skills === void 0) {
+			skills = [];
+			for (const entry of readdirSync(resolved.destination, { withFileTypes: true })) {
+				if (!entry.name.startsWith(OWNED_SKILL_PREFIX)) continue;
+				const target = join(resolved.destination, entry.name);
+				const targetEntry = lstatSync(target, { throwIfNoEntry: false });
+				if (targetEntry === void 0) continue;
+				if (targetEntry.isSymbolicLink() || !targetEntry.isDirectory()) {
+					skipped.push({
+						host,
+						reason: `${target} is not a real directory.`
+					});
+					continue;
+				}
+				rmSync(target, {
+					force: true,
+					recursive: true
 				});
-				continue;
+				skills.push(entry.name);
 			}
-			rmSync(target, {
-				force: true,
-				recursive: true
-			});
-			skills.push(entry.name);
+			skills.sort();
+			removedByDestination.set(resolved.destination, skills);
 		}
 		removed.push({
 			host,
 			path: resolved.destination,
-			skills: skills.sort()
+			skills
 		});
 	}
 	return {
@@ -27197,13 +27469,13 @@ function createContextTreeCli(io = defaultIo) {
 		emit(io, options.json, result, formatVerify);
 		if (!result.ok) process.exitCode = 1;
 	});
-	program.command("install").description("Install the packaged Context Tree skills into each agent's skill directory.").option("--host <host>", "restrict to one host: claude, codex, or all", "all").option("--project <path>", "install below this project root instead of the home directory").action((options) => {
+	program.command("install").description("Install the packaged Context Tree skills into each agent's skill directory.").option("--host <host>", "restrict to one host: claude, codex, pi, or all", "all").option("--project <path>", "install below this project root instead of the home directory").action((options) => {
 		const request = {};
 		if (options.host !== "all") request.hosts = [skillHostSchema.parse(options.host)];
 		if (options.project !== void 0) request.projectPath = resolve(io.cwd(), options.project);
 		line(io, JSON.stringify(installSkills(request)));
 	});
-	program.command("uninstall").description("Remove packaged Context Tree skills from each agent's skill directory.").option("--host <host>", "restrict to one host: claude, codex, or all", "all").option("--project <path>", "remove below this project root instead of the home directory").action((options) => {
+	program.command("uninstall").description("Remove packaged Context Tree skills from each agent's skill directory.").option("--host <host>", "restrict to one host: claude, codex, pi, or all", "all").option("--project <path>", "remove below this project root instead of the home directory").action((options) => {
 		const request = {};
 		if (options.host !== "all") request.hosts = [skillHostSchema.parse(options.host)];
 		if (options.project !== void 0) request.projectPath = resolve(io.cwd(), options.project);
@@ -27214,13 +27486,24 @@ function createContextTreeCli(io = defaultIo) {
 		"schedule",
 		"status",
 		"remove",
-		"run"
+		"run",
+		"logs"
 	]) {
 		const command = cleanup.command(operation).option("--project-path <path>", "project directory", ".").option(...jsonOption);
-		if (operation === "schedule") command.requiredOption("--agent <agent>", "codex or claude").option("--model <model>", "explicit model override").option("--every <duration>", "positive whole-minute interval, e.g. 30m or 1h", "1h");
+		if (operation === "schedule") command.requiredOption("--agent <agent>", "codex, claude, or pi").option("--model <model>", "explicit model override").option("--every <duration>", "positive whole-minute interval, e.g. 30m or 1h", "1h");
+		if (operation === "logs") command.option("--list", "list recorded runs").option("--run <run-id>", "select a recorded run");
 		if (operation === "run") command.addOption(new Option("--schedule-id <id>").hideHelp());
 		command.action(async (options) => {
 			const projectPath = resolve(io.cwd(), options.projectPath);
+			if (operation === "logs") {
+				const result = cleanupLogs(projectPath, options);
+				emit(io, options.json, result, (value) => {
+					if (!value.runs.length) return `No cleanup logs recorded for project ${projectPath}.\nUse --project-path <path> to query another project's Context Tree.`;
+					if (options.list) return value.runs.map((run) => `${run.runId}  ${new Date(run.startedAt).toISOString()}  ${run.agent}/${run.model ?? "agent default"}  ${run.terminal?.outcome ?? "incomplete"}${run.truncated ? "  truncated" : ""}`).join("\n");
+					return value.events.map((event) => `[${new Date(event.at).toISOString()}] [${event.source}] ${event.text}`).join("\n");
+				});
+				return;
+			}
 			if (operation === "run") {
 				const result = await runCleanup(projectPath, options.scheduleId);
 				const wireResult = cleanupRunResultSchema.parse({
@@ -27248,7 +27531,7 @@ function createContextTreeCli(io = defaultIo) {
 					`  Registered: ${value.registered}; running: ${value.running}`,
 					`  Project: ${config.projectPath}`,
 					`  Every: ${config.everyMinutes} minutes`,
-					`  Agent: ${config.agent}; model: ${config.model}`,
+					`  Agent: ${config.agent}; model: ${config.model ?? "agent default"}`,
 					`  Last activity: ${value.lastActivity === null ? "missing" : new Date(value.lastActivity).toISOString()}`,
 					`  Inactivity: ${value.inactive ? "cleanup prevented (no activity within 24 hours)" : "cleanup permitted"}`,
 					`  Latest: ${value.latest?.outcome ?? "none"}${value.latest?.message ? ` — ${value.latest.message}` : ""}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@first-tree-ai/context-tree",
-  "version": "0.1.12",
+  "version": "0.1.14-alpha.202609140819",
   "description": "Durable, structured project context for coding agents: a CLI plus framework-neutral skills.",
   "type": "module",
   "license": "Apache-2.0",

package/scripts/postinstall.mjs

@@ -50,7 +50,7 @@ const skipped = Array.isArray(payload?.skipped) ? payload.skipped : [];
 
 if (installed.length === 0) {
   process.stdout.write(
-    "Context Tree: no agent directory found. Install Claude Code or Codex, then run `context-tree install`.\n",
+    "Context Tree: no agent directory found. Install Claude Code, Codex, or Pi, then run `context-tree install`.\n",
   );
   process.exit(0);
 }

package/skills/context-tree-schedule-cleanup/SKILL.md

@@ -19,11 +19,11 @@ runs cleanup immediately. Use the installed CLI on PATH; if missing, report
    desktop task using its existing controls before creating the CLI schedule.
    The CLI cannot discover or cancel old desktop tasks. Do not create a duplicate
    while cancellation is unconfirmed.
-2. Select the requested installed agent, or the current host's CLI: `codex` or
-   `claude`. Use the requested model if supplied; otherwise keep CLI defaults.
-   Use a positive whole-minute cadence such as `30m`, `1h`, or `1d`; default to
-   every hour. Do not silently approximate unsupported schedules.
-3. Run `context-tree cleanup schedule --project-path "<absolute-project-path>" --agent <codex-or-claude> --every <duration> --json`.
+2. Select the requested installed agent, or the current host's CLI: `codex`,
+   `claude`, or `pi`. Use the requested model if supplied; otherwise keep CLI
+   defaults. Use a positive whole-minute cadence such as `30m`, `1h`, or `1d`;
+   default to every hour. Do not silently approximate unsupported schedules.
+3. Run `context-tree cleanup schedule --project-path "<absolute-project-path>" --agent <codex-claude-or-pi> --every <duration> --json`.
    Add `--model <model>` only for an explicit override. Quote real arguments
    safely. Connection or scheduler errors stop without setup or repair.
 4. Read back `context-tree cleanup status --project-path "<absolute-project-path>" --json`.
@@ -43,8 +43,10 @@ activity, unchanged commits, and overlap. Do not run it merely when scheduling.
 macOS uses user LaunchAgents; Linux uses systemd user timers/services. No desktop
 app, daemon, root installation, or Linux lingering is required. The machine must
 be awake and the user scheduler available; timing follows the native scheduler.
-Defaults are `gpt-5.6-luna` with low reasoning effort or `claude-haiku-4-5`, using
-existing CLI authentication. Do not change credentials, bypass permissions,
+Defaults are `gpt-5.6-luna` with low reasoning effort for Codex and
+`claude-haiku-4-5` for Claude, using existing CLI authentication. Pi uses its
+configured default model. Pi runs ephemeral with extensions disabled; `--model`
+may also name a `provider/model`. Do not change credentials, bypass permissions,
 silently switch models, or retry publication.
 
 Initial scheduling starts a 24-hour activity window. Successful ordinary create,
@@ -54,3 +56,19 @@ activity skips before network or model work; unchanged successfully cleaned
 commits skip the model. Failures preserve worktrees and success checkpoints.
 The runner owns preparation, verification, and publication; the fresh agent
 only edits using the cleanup skill's shared required editorial resource.
+
+Inspect runner history with `context-tree cleanup logs --project-path <project> --json`.
+Use `--list` for newest-first summaries or `--run <run-id>` for a particular run;
+these selectors are mutually exclusive. The versioned result includes summaries
+and the selected run's labeled runner/stdout/stderr events. Reads are snapshots,
+do not refresh activity, and do not query the scheduler. Agent output varies by
+CLI. Missing terminal outcomes mean incomplete runs. Outcomes include `runId`
+when history was recorded.
+
+History is local, shared across connected projects, and survives schedule removal.
+Retention is 50 runs (oldest completed runs are pruned; incomplete entries are
+protected), with 5 MiB of serialized output per run and an explicit truncation
+flag. Final outcome metadata survives output truncation. Credentials and terminal
+controls are sanitized; oversized lines are suppressed. Only runner attempts are
+recorded, including inactivity and unchanged skips. Old transcripts and cleanup
+performed directly through a host skill are unavailable.