@p4code/cli 0.3.11 → 0.3.12

package/dist/bin.mjs

@@ -238,7 +238,7 @@ const make$91 = () => {
 const layer$82 = Layer.sync(NetService, make$91);
 //#endregion
 //#region package.json
-var version = "0.3.11";
+var version = "0.3.12";
 //#endregion
 //#region src/config.ts
 /**
@@ -15731,6 +15731,27 @@ var _051_ThreadPairActivationTurn_default = Effect.gen(function* () {
   `;
 });
 //#endregion
+//#region src/persistence/Migrations/052_CompactHistoricalToolActivities.ts
+var _052_CompactHistoricalToolActivities_default = Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	yield* sql`
+    CREATE TABLE historical_activity_compaction_progress (
+      job_name TEXT PRIMARY KEY,
+      cursor_sequence INTEGER NOT NULL DEFAULT 0 CHECK (cursor_sequence >= 0),
+      completed_at TEXT
+    ) STRICT
+  `;
+	yield* sql`
+    CREATE TABLE historical_activity_compaction_skips (
+      sequence INTEGER PRIMARY KEY,
+      event_id TEXT NOT NULL,
+      reason TEXT NOT NULL,
+      payload_bytes INTEGER NOT NULL,
+      recorded_at TEXT NOT NULL DEFAULT (datetime('now'))
+    ) STRICT
+  `;
+});
+//#endregion
 //#region src/persistence/Migrations.ts
 /**
 * MigrationsLive - Migration runner with inline loader
@@ -16006,6 +16027,11 @@ const migrationEntries = [
 		51,
 		"ThreadPairActivationTurn",
 		_051_ThreadPairActivationTurn_default
+	],
+	[
+		52,
+		"CompactHistoricalToolActivities",
+		_052_CompactHistoricalToolActivities_default
 	]
 ];
 const makeMigrationLoader = (throughId) => Migrator.fromRecord(Object.fromEntries(migrationEntries.filter(([id]) => throughId === void 0 || id <= throughId).map(([id, name, migration]) => [`${id}_${name}`, migration])));
@@ -16085,6 +16111,665 @@ const runGuardedMigrations = Effect.fn("runGuardedMigrations")(function* (input)
 const discardSnapshotQuietly = (dbPath) => discardDatabaseSnapshot(dbPath).pipe(Effect.tapError((cause) => Effect.logWarning("Could not discard the database snapshot").pipe(Effect.annotateLogs({ cause }))), Effect.ignore);
 Layer.effectDiscard(runMigrations());
 //#endregion
+//#region ../../packages/shared/src/toolCategory.ts
+const TOOL_CATEGORY_TITLES = {
+	file_read: "File read",
+	file_search: "File search",
+	file_change: "File change",
+	command: "Command run",
+	version_control: "Version control",
+	build_test: "Build or test",
+	mcp_tool: "MCP tool call",
+	subagent: "Subagent task",
+	web_search: "Web search",
+	web_fetch: "Web fetch",
+	task_plan: "Task or plan",
+	image_view: "Image view",
+	tool: "Tool call"
+};
+new Set(Object.keys(TOOL_CATEGORY_TITLES));
+/** Exact tool names, lowercased, matched before the substring heuristics below. */
+const FILE_READ_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"read",
+	"readfile",
+	"read_file",
+	"view",
+	"viewfile",
+	"view_file",
+	"notebookread",
+	"notebook_read",
+	"openfile",
+	"open_file"
+]);
+const FILE_SEARCH_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"grep",
+	"glob",
+	"search",
+	"filesearch",
+	"file_search",
+	"codebasesearch",
+	"codebase_search",
+	"listdir",
+	"list_dir",
+	"list_directory",
+	"ls"
+]);
+const FILE_CHANGE_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"edit",
+	"write",
+	"multiedit",
+	"multi_edit",
+	"notebookedit",
+	"notebook_edit",
+	"applypatch",
+	"apply_patch",
+	"patch",
+	"createfile",
+	"create_file",
+	"strreplace",
+	"str_replace",
+	"deletefile",
+	"delete_file"
+]);
+const COMMAND_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"bash",
+	"shell",
+	"terminal",
+	"exec",
+	"execute",
+	"execcommand",
+	"exec_command",
+	"runcommand",
+	"run_command",
+	"local_shell"
+]);
+const SUBAGENT_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"task",
+	"agent",
+	"subagent",
+	"sub_agent"
+]);
+const WEB_FETCH_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"webfetch",
+	"web_fetch",
+	"fetch",
+	"fetchurl",
+	"fetch_url",
+	"browse",
+	"openurl",
+	"open_url"
+]);
+/**
+* Matched before the subagent rules, so `task_create` is a board write while the
+* bare `Task` tool stays a subagent.
+*/
+const TASK_PLAN_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"todowrite",
+	"todo_write",
+	"todoread",
+	"todo_read",
+	"exitplanmode",
+	"exit_plan_mode",
+	"updateplan",
+	"update_plan",
+	"task_create",
+	"task_update",
+	"task_list",
+	"task_get",
+	"task_current",
+	"task_propose",
+	"ticket_resolve",
+	"taskcreate",
+	"taskupdate",
+	"tasklist",
+	"taskget"
+]);
+/** Shell builtins that say nothing about what the command as a whole does. */
+const NEUTRAL_SHELL_COMMANDS = /* @__PURE__ */ new Set([
+	"cd",
+	"echo",
+	"printf",
+	"pwd",
+	"true",
+	"false",
+	"time"
+]);
+/** `sed`/`awk` are stream editors (`sed -i` rewrites files), so they stay commands. */
+const FILE_READ_SHELL_COMMANDS = /* @__PURE__ */ new Set([
+	"cat",
+	"head",
+	"tail",
+	"less",
+	"more",
+	"bat",
+	"nl",
+	"jq",
+	"wc"
+]);
+const FILE_SEARCH_SHELL_COMMANDS = /* @__PURE__ */ new Set([
+	"grep",
+	"egrep",
+	"fgrep",
+	"rg",
+	"ag",
+	"ack",
+	"find",
+	"fd",
+	"ls",
+	"tree",
+	"which"
+]);
+/** `git status` and `git diff` sort here too: the verb is what a reader scans for. */
+const VERSION_CONTROL_SHELL_COMMANDS = /* @__PURE__ */ new Set([
+	"git",
+	"gh",
+	"jj",
+	"hg",
+	"svn",
+	"glab"
+]);
+/**
+* Builds, tests, type checks, lint and install share one category: a test run is
+* what a person scans for when a turn goes long, and the rest is the same noise.
+*/
+const BUILD_TEST_SHELL_COMMANDS = /* @__PURE__ */ new Set([
+	"pnpm",
+	"npm",
+	"npx",
+	"yarn",
+	"bun",
+	"bunx",
+	"vitest",
+	"jest",
+	"vp",
+	"tsc",
+	"tsgo",
+	"eslint",
+	"oxlint",
+	"biome",
+	"prettier",
+	"ruff",
+	"pytest",
+	"make",
+	"cargo",
+	"gradle",
+	"mvn",
+	"xcodebuild",
+	"swift",
+	"pip",
+	"uv",
+	"poetry"
+]);
+const WEB_FETCH_SHELL_COMMANDS = /* @__PURE__ */ new Set([
+	"curl",
+	"wget",
+	"http",
+	"httpie"
+]);
+const SHELL_SEGMENT_SEPARATOR = /\|\||&&|;|\||\n/u;
+const LEADING_ENV_ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=\S*\s+/u;
+const REDIRECT_TARGET = /\d?>>?\s*(?<target>[^\s|;&]+)/gu;
+/** Redirect targets that discard output instead of writing a file. */
+const DISCARDED_REDIRECT_TARGETS = /* @__PURE__ */ new Set([
+	"/dev/null",
+	"&1",
+	"&2"
+]);
+function toolCategoryTitle(category) {
+	return TOOL_CATEGORY_TITLES[category];
+}
+function readCommandInput(toolInput) {
+	const raw = toolInput?.command ?? toolInput?.cmd;
+	if (typeof raw !== "string") return;
+	const trimmed = raw.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+/** `cat x > y` reads and writes; only the write matters for the row heading. */
+function redirectsToFile(segment) {
+	for (const match of segment.matchAll(REDIRECT_TARGET)) {
+		const target = match.groups?.target;
+		if (target && !DISCARDED_REDIRECT_TARGETS.has(target)) return true;
+	}
+	return false;
+}
+function classifyShellSegment(segment) {
+	if (redirectsToFile(segment)) return "command";
+	const head = segment.trim().replace(LEADING_ENV_ASSIGNMENT, "").split(/\s+/u)[0]?.replace(/^.*\//u, "").toLowerCase();
+	if (!head || NEUTRAL_SHELL_COMMANDS.has(head)) return;
+	if (FILE_READ_SHELL_COMMANDS.has(head)) return "file_read";
+	if (FILE_SEARCH_SHELL_COMMANDS.has(head)) return "file_search";
+	if (VERSION_CONTROL_SHELL_COMMANDS.has(head)) return "version_control";
+	if (BUILD_TEST_SHELL_COMMANDS.has(head)) return "build_test";
+	if (WEB_FETCH_SHELL_COMMANDS.has(head)) return "web_fetch";
+	return "command";
+}
+/**
+* A shell call only counts as anything narrower than a command when every
+* non-neutral segment agrees; anything unrecognized (or write-ish) keeps the
+* whole call a command, and so does a pipeline that mixes two categories — the
+* one exception being a read piped into a search, which is still a search.
+* Quoted separators split segments too, which can only downgrade to "command".
+*/
+function classifyShellCommand(command) {
+	const categories = new Set(command.split(SHELL_SEGMENT_SEPARATOR).map(classifyShellSegment).filter((category) => category !== void 0));
+	if (categories.size === 0 || categories.has("command")) return "command";
+	const [only] = categories;
+	if (categories.size === 1 && only) return only;
+	return [...categories].every((category) => category === "file_read" || category === "file_search") ? "file_search" : "command";
+}
+function classifyToolCategory(input) {
+	const normalized = input.toolName.trim().toLowerCase();
+	if (normalized.startsWith("mcp__") || normalized.includes("mcp")) return "mcp_tool";
+	if (TASK_PLAN_TOOL_NAMES.has(normalized)) return "task_plan";
+	if (WEB_FETCH_TOOL_NAMES.has(normalized)) return "web_fetch";
+	if (SUBAGENT_TOOL_NAMES.has(normalized) || normalized.includes("agent")) return "subagent";
+	if (FILE_READ_TOOL_NAMES.has(normalized)) return "file_read";
+	if (FILE_SEARCH_TOOL_NAMES.has(normalized)) return "file_search";
+	if (FILE_CHANGE_TOOL_NAMES.has(normalized)) return "file_change";
+	if (COMMAND_TOOL_NAMES.has(normalized) || normalized.includes("bash") || normalized.includes("shell") || normalized.includes("terminal") || normalized.includes("command")) {
+		const command = readCommandInput(input.toolInput);
+		return command ? classifyShellCommand(command) : "command";
+	}
+	if (normalized.includes("websearch") || normalized.includes("web_search")) return "web_search";
+	if (normalized.includes("webfetch") || normalized.includes("web_fetch")) return "web_fetch";
+	if (normalized.includes("todo") || normalized.includes("plan")) return "task_plan";
+	if (normalized.includes("edit") || normalized.includes("write") || normalized.includes("patch") || normalized.includes("replace") || normalized.includes("create") || normalized.includes("delete")) return "file_change";
+	if (normalized.includes("read") || normalized.includes("view")) return "file_read";
+	if (normalized.includes("grep") || normalized.includes("glob")) return "file_search";
+	if (normalized.includes("image")) return "image_view";
+	return "tool";
+}
+function asRecord$7(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+/** Classify from a runtime item payload's `data` (`{ toolName, input }`). */
+function classifyToolCategoryFromToolData(data) {
+	const record = asRecord$7(data);
+	const toolName = record?.toolName;
+	if (typeof toolName !== "string" || toolName.trim().length === 0) return;
+	return classifyToolCategory({
+		toolName,
+		toolInput: asRecord$7(record?.input)
+	});
+}
+//#endregion
+//#region src/orchestration/ActivityPayloadProjection.ts
+function asRecord$6(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function asTrimmedString$1(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+function pushChangedFile(target, seen, value) {
+	const normalized = asTrimmedString$1(value);
+	if (!normalized || seen.has(normalized)) return;
+	seen.add(normalized);
+	target.push(normalized);
+}
+function collectChangedFiles(value, target, seen, depth) {
+	if (depth > 4 || target.length >= 12) return;
+	if (Array.isArray(value)) {
+		for (const entry of value) {
+			collectChangedFiles(entry, target, seen, depth + 1);
+			if (target.length >= 12) return;
+		}
+		return;
+	}
+	const record = asRecord$6(value);
+	if (!record) return;
+	pushChangedFile(target, seen, record.path);
+	pushChangedFile(target, seen, record.filePath);
+	pushChangedFile(target, seen, record.relativePath);
+	pushChangedFile(target, seen, record.filename);
+	pushChangedFile(target, seen, record.newPath);
+	pushChangedFile(target, seen, record.oldPath);
+	for (const nestedKey of [
+		"item",
+		"result",
+		"input",
+		"data",
+		"changes",
+		"files",
+		"edits",
+		"patch",
+		"patches",
+		"operations"
+	]) {
+		if (!(nestedKey in record)) continue;
+		collectChangedFiles(record[nestedKey], target, seen, depth + 1);
+		if (target.length >= 12) return;
+	}
+}
+function projectCommandData(data) {
+	const item = asRecord$6(data.item);
+	if (!item) return;
+	const projectedItem = {};
+	if ("command" in item) projectedItem.command = item.command;
+	const input = asRecord$6(item.input);
+	if (input && "command" in input) projectedItem.input = { command: input.command };
+	const result = asRecord$6(item.result);
+	if (result && "command" in result) projectedItem.result = { command: result.command };
+	return Object.keys(projectedItem).length > 0 ? projectedItem : void 0;
+}
+function summarizeToolTextOutput(value) {
+	const lines = [];
+	for (const rawLine of value.split(/\r?\n/u)) {
+		const line = rawLine.replace(/\s+/g, " ").trim();
+		if (line.length > 0) lines.push(line);
+	}
+	const firstLine = lines.find((line) => line !== "```");
+	if (firstLine) return firstLine.length <= 84 ? firstLine : `${firstLine.slice(0, 83).trimEnd()}…`;
+	if (lines.length > 1) return `${lines.length.toLocaleString()} lines`;
+	return null;
+}
+function projectRawOutput(value) {
+	const rawOutput = asRecord$6(value);
+	if (!rawOutput) return;
+	if (typeof rawOutput.totalFiles === "number" && Number.isFinite(rawOutput.totalFiles)) return {
+		totalFiles: rawOutput.totalFiles,
+		...rawOutput.truncated === true ? { truncated: true } : {}
+	};
+	const content = asTrimmedString$1(rawOutput.content);
+	if (content) {
+		const summary = summarizeToolTextOutput(content);
+		return summary ? { content: summary } : void 0;
+	}
+	const stdout = asTrimmedString$1(rawOutput.stdout);
+	if (stdout) {
+		const summary = summarizeToolTextOutput(stdout);
+		return summary ? { content: summary } : void 0;
+	}
+}
+/**
+* Removes activity payload fields that no current client or projector reads.
+* The same compact shape is used for persistence and transport so eligible
+* tool outputs do not accumulate twice in the event store and activity projection.
+*/
+function projectActivityPayload(activity) {
+	const payload = asRecord$6(activity.payload);
+	const data = asRecord$6(payload?.data);
+	if (!payload || !data || payload.itemType === "mcp_tool_call") return activity;
+	const projectedData = {};
+	const item = projectCommandData(data);
+	if (item) projectedData.item = item;
+	if ("command" in data) projectedData.command = data.command;
+	const input = asRecord$6(data.input);
+	if (input && "command" in input) projectedData.input = { command: input.command };
+	const changedFiles = [];
+	collectChangedFiles(data, changedFiles, /* @__PURE__ */ new Set(), 0);
+	if (changedFiles.length > 0) projectedData.files = changedFiles.map((path) => ({ path }));
+	if (asTrimmedString$1(data.patch)) projectedData.patch = data.patch;
+	const toolCategory = classifyToolCategoryFromToolData(data);
+	if (toolCategory) projectedData.toolCategory = toolCategory;
+	if ("toolCallId" in data) projectedData.toolCallId = data.toolCallId;
+	if ("kind" in data) projectedData.kind = data.kind;
+	const rawOutput = projectRawOutput(data.rawOutput);
+	if (rawOutput) projectedData.rawOutput = rawOutput;
+	return {
+		...activity,
+		payload: {
+			...payload,
+			data: projectedData
+		}
+	};
+}
+/**
+* Matches the validity rule in the web client's
+* `deriveLatestContextWindowSnapshot`: rows without a finite, non-negative
+* `usedTokens` are skipped during its backward walk, so they must not shadow
+* an earlier resolvable row here.
+*/
+function isResolvableContextWindowActivity(activity) {
+	if (activity.kind !== "context-window.updated") return false;
+	const usedTokens = asRecord$6(activity.payload)?.usedTokens;
+	return typeof usedTokens === "number" && Number.isFinite(usedTokens) && usedTokens >= 0;
+}
+/**
+* Drops all but the last resolvable context-window activity per turn from a
+* snapshot. Clients only ever read the latest usage value (walking the array
+* backwards), so shipping the full history — often thousands of rows on long
+* threads — buys nothing. Retention is per turn rather than per thread because
+* a live `thread.reverted` makes the client discard whole turns; keeping each
+* turn's latest row means the meter can still resolve a value from the turns
+* that survive. Malformed rows pass through untouched rather than shadowing a
+* valid earlier row. Live `thread.activity-appended` events are untouched:
+* newer updates still stream through and supersede the retained rows on the
+* client.
+*/
+function withoutContextWindowBreakdown$1(activity) {
+	const payload = asRecord$6(activity.payload);
+	if (!payload || payload.breakdown === void 0) return activity;
+	const { breakdown: _breakdown, ...rest } = payload;
+	return {
+		...activity,
+		payload: rest
+	};
+}
+function dropStaleContextWindowActivities(activities) {
+	const latestIndexByTurn = /* @__PURE__ */ new Map();
+	for (let index = 0; index < activities.length; index += 1) if (isResolvableContextWindowActivity(activities[index])) latestIndexByTurn.set(activities[index].turnId, index);
+	if (latestIndexByTurn.size === 0) return activities;
+	const retainedIndexes = new Set(latestIndexByTurn.values());
+	let breakdownIndex = null;
+	for (const index of retainedIndexes) {
+		if (asRecord$6(activities[index].payload)?.breakdown === void 0) continue;
+		if (breakdownIndex === null || index > breakdownIndex) breakdownIndex = index;
+	}
+	return activities.flatMap((activity, index) => {
+		if (!isResolvableContextWindowActivity(activity)) return [activity];
+		if (latestIndexByTurn.get(activity.turnId) !== index) return [];
+		return [index === breakdownIndex ? activity : withoutContextWindowBreakdown$1(activity)];
+	});
+}
+function projectThreadDetailSnapshot(snapshot) {
+	return {
+		...snapshot,
+		thread: {
+			...snapshot.thread,
+			activities: dropStaleContextWindowActivities(snapshot.thread.activities).map(projectActivityPayload)
+		}
+	};
+}
+function projectActivityEvent(event) {
+	if (event.type !== "thread.activity-appended") return event;
+	return {
+		...event,
+		payload: {
+			...event.payload,
+			activity: projectActivityPayload(event.payload.activity)
+		}
+	};
+}
+const HISTORICAL_ACTIVITY_COMPACTION_BATCH_BYTE_LIMIT = 8 * 1024 * 1024;
+const JOB_NAME = "tool-activity-payload-v1";
+const SCHEMA_TRANSFORM_FAILURE_REASON = "schema-transform-failed";
+const decodeActivityEventPayload = Schema$1.decodeUnknownEffect(Schema$1.fromJsonString(ThreadActivityAppendedPayload$1));
+const encodeActivityEventPayload = Schema$1.encodeEffect(Schema$1.fromJsonString(ThreadActivityAppendedPayload$1));
+const encodeUnknownJson = Schema$1.encodeEffect(Schema$1.fromJsonString(Schema$1.Unknown));
+const runHistoricalActivityCompaction = Effect.fn("runHistoricalActivityCompaction")(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	const progress = (yield* sql`
+    SELECT
+      cursor_sequence AS "cursorSequence",
+      completed_at AS "completedAt"
+    FROM historical_activity_compaction_progress
+    WHERE job_name = ${JOB_NAME}
+  `)[0];
+	if (progress?.completedAt !== null && progress?.completedAt !== void 0) return {
+		batches: 0,
+		processedEvents: 0,
+		skippedEvents: 0
+	};
+	let cursor = progress?.cursorSequence ?? 0;
+	let batches = 0;
+	let processedEvents = 0;
+	let skippedEvents = 0;
+	yield* sql`DROP TABLE IF EXISTS temp_historical_activity_compaction`;
+	yield* sql`
+    CREATE TEMP TABLE temp_historical_activity_compaction (
+      sequence INTEGER PRIMARY KEY,
+      activity_id TEXT NOT NULL,
+      event_payload_json TEXT NOT NULL,
+      activity_payload_json TEXT NOT NULL
+    ) WITHOUT ROWID
+  `;
+	yield* sql`
+    CREATE UNIQUE INDEX temp_historical_activity_compaction_activity_id
+    ON temp_historical_activity_compaction(activity_id)
+  `;
+	while (true) {
+		const rows = yield* sql`
+      WITH candidate_rows AS (
+        SELECT
+          sequence,
+          event_id,
+          payload_json,
+          length(CAST(payload_json AS BLOB)) AS payload_bytes
+        FROM orchestration_events
+        WHERE sequence > ${cursor}
+          AND event_type = 'thread.activity-appended'
+          AND CASE
+            WHEN json_valid(payload_json) = 0 THEN 1
+            WHEN json_type(payload_json, '$.activity.payload.data') = 'object'
+              AND COALESCE(
+                json_extract(payload_json, '$.activity.payload.itemType'),
+                ''
+              ) <> 'mcp_tool_call'
+            THEN 1
+            ELSE 0
+          END = 1
+        ORDER BY sequence ASC
+        LIMIT ${256}
+      ), bounded_rows AS (
+        SELECT
+          sequence,
+          event_id,
+          payload_json,
+          payload_bytes,
+          sum(payload_bytes) OVER (
+            ORDER BY sequence ASC ROWS UNBOUNDED PRECEDING
+          ) AS cumulative_bytes
+        FROM candidate_rows
+      )
+      SELECT
+        sequence,
+        event_id AS "eventId",
+        payload_json AS "payloadJson",
+        payload_bytes AS "payloadBytes"
+      FROM bounded_rows
+      WHERE cumulative_bytes <= ${HISTORICAL_ACTIVITY_COMPACTION_BATCH_BYTE_LIMIT}
+        OR sequence = (SELECT min(sequence) FROM bounded_rows)
+      ORDER BY sequence ASC
+    `;
+		if (rows.length === 0) {
+			yield* sql`
+        INSERT INTO historical_activity_compaction_progress (
+          job_name,
+          cursor_sequence,
+          completed_at
+        ) VALUES (${JOB_NAME}, ${cursor}, datetime('now'))
+        ON CONFLICT(job_name) DO UPDATE SET
+          cursor_sequence = excluded.cursor_sequence,
+          completed_at = excluded.completed_at
+      `;
+			break;
+		}
+		const projectedRows = yield* Effect.forEach(rows, (row) => Effect.gen(function* () {
+			const payload = yield* decodeActivityEventPayload(row.payloadJson);
+			const activity = projectActivityPayload(payload.activity);
+			return {
+				sequence: row.sequence,
+				activity_id: activity.id,
+				event_payload_json: yield* encodeActivityEventPayload({
+					...payload,
+					activity
+				}),
+				activity_payload_json: yield* encodeUnknownJson(activity.payload)
+			};
+		}).pipe(Effect.match({
+			onFailure: () => ({
+				_tag: "Skipped",
+				row: {
+					sequence: row.sequence,
+					event_id: row.eventId,
+					reason: SCHEMA_TRANSFORM_FAILURE_REASON,
+					payload_bytes: row.payloadBytes
+				}
+			}),
+			onSuccess: (compactedRow) => ({
+				_tag: "Compacted",
+				row: compactedRow
+			})
+		})));
+		const compactedRows = projectedRows.flatMap((result) => result._tag === "Compacted" ? [result.row] : []);
+		const skippedRows = projectedRows.flatMap((result) => result._tag === "Skipped" ? [result.row] : []);
+		const nextCursor = rows[rows.length - 1].sequence;
+		yield* sql.withTransaction(Effect.gen(function* () {
+			if (compactedRows.length > 0) {
+				yield* sql`
+              INSERT INTO temp_historical_activity_compaction ${sql.insert(compactedRows)}
+            `;
+				yield* sql`
+          UPDATE orchestration_events
+          SET payload_json = (
+            SELECT compact.event_payload_json
+            FROM temp_historical_activity_compaction AS compact
+            WHERE compact.sequence = orchestration_events.sequence
+          )
+          WHERE sequence IN (
+            SELECT sequence FROM temp_historical_activity_compaction
+          )
+            `;
+				yield* sql`
+          UPDATE projection_thread_activities
+          SET payload_json = (
+            SELECT compact.activity_payload_json
+            FROM temp_historical_activity_compaction AS compact
+            WHERE compact.activity_id = projection_thread_activities.activity_id
+          )
+          WHERE activity_id IN (
+            SELECT activity_id FROM temp_historical_activity_compaction
+          )
+            `;
+			}
+			if (skippedRows.length > 0) yield* sql`
+              INSERT INTO historical_activity_compaction_skips ${sql.insert(skippedRows)}
+              ON CONFLICT(sequence) DO NOTHING
+            `;
+			yield* sql`
+          INSERT INTO historical_activity_compaction_progress (
+            job_name,
+            cursor_sequence,
+            completed_at
+          ) VALUES (${JOB_NAME}, ${nextCursor}, NULL)
+          ON CONFLICT(job_name) DO UPDATE SET
+            cursor_sequence = excluded.cursor_sequence,
+            completed_at = NULL
+        `;
+			yield* sql`DELETE FROM temp_historical_activity_compaction`;
+		}));
+		if (skippedRows.length > 0) yield* Effect.logWarning("Skipped malformed historical tool activities").pipe(Effect.annotateLogs({
+			skippedCount: skippedRows.length,
+			firstSkippedSequence: skippedRows[0].sequence,
+			lastSkippedSequence: skippedRows[skippedRows.length - 1].sequence
+		}));
+		yield* sql`PRAGMA wal_checkpoint(TRUNCATE)`;
+		cursor = nextCursor;
+		batches += 1;
+		processedEvents += rows.length;
+		skippedEvents += skippedRows.length;
+	}
+	yield* sql`DROP TABLE temp_historical_activity_compaction`;
+	yield* sql`PRAGMA wal_checkpoint(TRUNCATE)`;
+	return {
+		batches,
+		processedEvents,
+		skippedEvents
+	};
+});
+//#endregion
 //#region src/persistence/Layers/Sqlite.ts
 const defaultSqliteClientLoaders = {
 	bun: () => import("@effect/sql-sqlite-bun/SqliteClient"),
@@ -16100,7 +16785,7 @@ const applyPragmas = Effect.gen(function* () {
 	yield* sql`PRAGMA journal_mode = WAL;`;
 	yield* sql`PRAGMA foreign_keys = ON;`;
 });
-const setupFile = (dbPath) => Layer.effectDiscard(applyPragmas.pipe(Effect.andThen(runGuardedMigrations({ dbPath }))));
+const setupFile = (dbPath) => Layer.effectDiscard(applyPragmas.pipe(Effect.andThen(runGuardedMigrations({ dbPath })), Effect.andThen(runHistoricalActivityCompaction())));
 /**
 * The in-memory database used by tests has no file to snapshot and nothing that
 * survives the process to restore.
@@ -16109,7 +16794,7 @@ const setupFile = (dbPath) => Layer.effectDiscard(applyPragmas.pipe(Effect.andTh
 * needing nothing but `SqlClient`: sharing one function would put the file
 * path's `FileSystem | Path` requirement into every test layer built on it.
 */
-const setupMemory = Layer.effectDiscard(applyPragmas.pipe(Effect.andThen(runMigrations())));
+const setupMemory = Layer.effectDiscard(applyPragmas.pipe(Effect.andThen(runMigrations()), Effect.andThen(runHistoricalActivityCompaction())));
 const makeSqlitePersistenceLive = Effect.fn("makeSqlitePersistenceLive")(function* (dbPath) {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
@@ -22016,14 +22701,12 @@ const MEMORY_FILE_NAMES = ["CLAUDE.md", "AGENTS.md"];
 */
 const isMemoryFileName = (name) => MEMORY_FILE_NAMES.includes(name);
 /**
-* The directories in the config directory this sync will carry whole.
+* Directory asset this sync carries whole. `agent-memory` maps to the
+* provider-independent `~/.agent-memory` directory.
 *
-* A memory file is rarely the whole of the memory. `CLAUDE.md` is written to be
-* an index — a dozen `@~/.claude/global-memory/...` lines and little else — so
-* syncing the file alone hands the other machine a list of pointers to files
-* that are not there, and an agent reading it behaves as if the rules it names
-* do not exist. That failure is silent: the includes resolve to nothing rather
-* than to an error.
+* A memory file is rarely the whole of the memory. Shared manual memories now
+* live under `~/.agent-memory`. Syncing only the entry-point file would leave
+* its referenced files missing on another machine.
 *
 * So this is an allowlist too, and for the same reason the file one exists. The
 * escape it prevents is different, though, and weaker: `AgentAssetFilePath`
@@ -22033,7 +22716,7 @@ const isMemoryFileName = (name) => MEMORY_FILE_NAMES.includes(name);
 * asset is not permitted to claim `.claude/projects` or any other directory
 * that already means something to the provider.
 */
-const MEMORY_DIRECTORY_NAMES = ["global-memory"];
+const MEMORY_DIRECTORY_NAMES = ["agent-memory"];
 /** Whether this name is one of the memory directories. Exact match, as above. */
 const isMemoryDirectoryName = (name) => MEMORY_DIRECTORY_NAMES.includes(name);
 /**
@@ -22053,7 +22736,7 @@ const looksBinary$1 = (content) => content.includes("\0");
 * most machines have a `CLAUDE.md` and no `AGENTS.md`, and reporting the second
 * as a problem would be reporting the normal case.
 */
-const readMemoryFiles = Effect.fn("memoryFile.readMemoryFiles")(function* (memoryRoot) {
+const readMemoryFiles = Effect.fn("memoryFile.readMemoryFiles")(function* (memoryRoot, sharedMemoryRoot) {
 	const fileSystem = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const skills = [];
@@ -22100,7 +22783,8 @@ const readMemoryFiles = Effect.fn("memoryFile.readMemoryFiles")(function* (memor
 		});
 	}
 	for (const name of MEMORY_DIRECTORY_NAMES) {
-		const absolute = path.join(memoryRoot, name);
+		if (name === "agent-memory" && !sharedMemoryRoot) continue;
+		const absolute = name === "agent-memory" && sharedMemoryRoot ? sharedMemoryRoot : path.join(memoryRoot, name);
 		if ((yield* fileSystem.stat(absolute).pipe(Effect.orElseSucceed(() => void 0)))?.type !== "Directory") continue;
 		const read = yield* readSkillFiles(absolute);
 		if ("refusal" in read) {
@@ -22143,12 +22827,18 @@ const isWritableMemoryAsset = (input) => {
 * missing, which an agent will follow without noticing.
 */
 const writeMemoryFile = Effect.fn("memoryFile.writeMemoryFile")(function* (input) {
+	if (input.name === "agent-memory" && !input.sharedMemoryRoot) return "refused";
 	if (!isWritableMemoryAsset(input)) return "refused";
 	const fileSystem = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	if (isMemoryDirectoryName(input.name)) return yield* writeSkillDirectory({
-		skillsRoot: input.memoryRoot,
-		name: input.name,
+		...input.name === "agent-memory" && input.sharedMemoryRoot ? {
+			skillsRoot: path.dirname(input.sharedMemoryRoot),
+			name: path.basename(input.sharedMemoryRoot)
+		} : {
+			skillsRoot: input.memoryRoot,
+			name: input.name
+		},
 		files: input.files
 	}).pipe(Effect.as("written"), Effect.orElseSucceed(() => "failed"));
 	const contents = input.files[0]?.content ?? "";
@@ -22160,8 +22850,13 @@ const writeMemoryFile = Effect.fn("memoryFile.writeMemoryFile")(function* (input
 });
 const removeMemoryFile = Effect.fn("memoryFile.removeMemoryFile")(function* (input) {
 	if (!isMemoryAssetName(input.name)) return;
+	if (input.name === "agent-memory" && !input.sharedMemoryRoot) return;
 	if (isMemoryDirectoryName(input.name)) {
-		yield* removeSkillDirectory({
+		const path = yield* Path.Path;
+		yield* removeSkillDirectory(input.name === "agent-memory" && input.sharedMemoryRoot ? {
+			skillsRoot: path.dirname(input.sharedMemoryRoot),
+			name: path.basename(input.sharedMemoryRoot)
+		} : {
 			skillsRoot: input.memoryRoot,
 			name: input.name
 		});
@@ -22434,6 +23129,27 @@ function planSkillSync(input) {
 }
 //#endregion
 //#region src/sync/AssetSync.ts
+/**
+* Syncing user-scope agent assets between this machine and the hub.
+*
+* Bidirectional between servers, one-way onto the filesystem: an edit made on
+* either machine propagates through the hub, and the hub is the only thing that
+* writes a managed asset. There is deliberately **no filesystem watcher**. The
+* sync reads only what its manifest names, and the reason is concrete rather
+* than stylistic — the provider's config directory is where the CLI keeps
+* `.credentials.json`, and anything that mirrored the tree upward would carry a
+* provider credential to the hub. Provider credentials never sync. See
+* `docs/architecture/hub.md`.
+*
+* **Kinds are drivers, not branches.** Each kind answers four questions — where
+* do I live, what is here, write this, remove this — and everything above that
+* is shared. Skills are a directory per asset; memory is a single allowlisted
+* file in the config directory itself. Writing the second kind as a parallel
+* service would have doubled the state table, which is the one part of this that
+* is genuinely hard to get right.
+*
+* @module sync/AssetSync
+*/
 const EMPTY_REPORT = {
 	ran: false,
 	roots: [],
@@ -22452,6 +23168,7 @@ const make$75 = Effect.gen(function* () {
 	const settingsStore = yield* ServerSettingsService;
 	const config = yield* ServerConfig$1;
 	const path = yield* Path.Path;
+	const sharedMemoryRoot = path.join(NodeOS.homedir(), ".agent-memory");
 	/**
 	* Captured here rather than left in each method's requirements, so the
 	* service's own type says what it really is: an effect that needs nothing and
@@ -22489,14 +23206,16 @@ const make$75 = Effect.gen(function* () {
 		{
 			kind: "memory",
 			resolveRoot: claudeHome().pipe(Effect.flatMap((config) => resolveClaudeConfigDirPath(config, process.env))),
-			read: (root) => readMemoryFiles(root),
+			read: (root) => readMemoryFiles(root, sharedMemoryRoot),
 			write: ({ root, name, files }) => writeMemoryFile({
 				memoryRoot: root,
+				sharedMemoryRoot,
 				name,
 				files
 			}).pipe(Effect.map((outcome) => outcome)),
 			remove: ({ root, name }) => removeMemoryFile({
 				memoryRoot: root,
+				sharedMemoryRoot,
 				name
 			}).pipe(Effect.ignore)
 		},
@@ -24215,6 +24934,9 @@ const ReadFromSequenceOfTypesRequestSchema = Schema$1.Struct({
 const ReadByCommandIdRequestSchema = Schema$1.Struct({ commandId: CommandId });
 const DEFAULT_READ_FROM_SEQUENCE_LIMIT = 1e3;
 const READ_PAGE_SIZE = 500;
+function isThreadActivityAppendedEvent(event) {
+	return event.type === "thread.activity-appended";
+}
 function inferActorKind(event) {
 	if (event.commandId !== null && event.commandId.startsWith("provider:")) return "provider";
 	if (event.commandId !== null && event.commandId.startsWith("server:")) return "server";
@@ -24349,19 +25071,28 @@ const makeEventStore = Effect.gen(function* () {
         ORDER BY sequence ASC
       `
 	});
-	const append = (event) => appendEventRow({
-		eventId: event.eventId,
-		aggregateKind: event.aggregateKind,
-		streamId: event.aggregateId,
-		type: event.type,
-		causationEventId: event.causationEventId,
-		correlationId: event.correlationId,
-		actorKind: inferActorKind(event),
-		occurredAt: event.occurredAt,
-		commandId: event.commandId,
-		payloadJson: event.payload,
-		metadataJson: event.metadata
-	}).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$4("OrchestrationEventStore.append:insert", "OrchestrationEventStore.append:decodeRow")), Effect.flatMap((row) => decodeEvent(row).pipe(Effect.mapError(toPersistenceDecodeError("OrchestrationEventStore.append:rowToEvent")))));
+	const append = (event) => {
+		const payload = isThreadActivityAppendedEvent(event) ? {
+			...event.payload,
+			activity: projectActivityPayload(event.payload.activity)
+		} : event.payload;
+		return appendEventRow({
+			eventId: event.eventId,
+			aggregateKind: event.aggregateKind,
+			streamId: event.aggregateId,
+			type: event.type,
+			causationEventId: event.causationEventId,
+			correlationId: event.correlationId,
+			actorKind: inferActorKind(event),
+			occurredAt: event.occurredAt,
+			commandId: event.commandId,
+			payloadJson: payload,
+			metadataJson: event.metadata
+		}).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$4("OrchestrationEventStore.append:insert", "OrchestrationEventStore.append:decodeRow")), Effect.flatMap((row) => decodeEvent({
+			...event,
+			sequence: row.sequence
+		}).pipe(Effect.mapError(toPersistenceDecodeError("OrchestrationEventStore.append:returnedEvent")))));
+	};
 	const readFromSequence = (sequenceExclusive, limit = DEFAULT_READ_FROM_SEQUENCE_LIMIT, options) => {
 		const normalizedLimit = Math.max(0, Math.floor(limit));
 		if (normalizedLimit === 0) return Stream.empty;
@@ -28848,16 +29579,17 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 	const applyThreadActivitiesProjection = Effect.fn("applyThreadActivitiesProjection")(function* (event, _attachmentSideEffects) {
 		switch (event.type) {
 			case "thread.activity-appended":
+				const activity = projectActivityPayload(event.payload.activity);
 				yield* projectionThreadActivityRepository.upsert({
-					activityId: event.payload.activity.id,
+					activityId: activity.id,
 					threadId: event.payload.threadId,
-					turnId: event.payload.activity.turnId,
-					tone: event.payload.activity.tone,
-					kind: event.payload.activity.kind,
-					summary: event.payload.activity.summary,
-					payload: event.payload.activity.payload,
-					...event.payload.activity.sequence !== void 0 ? { sequence: event.payload.activity.sequence } : {},
-					createdAt: event.payload.activity.createdAt
+					turnId: activity.turnId,
+					tone: activity.tone,
+					kind: activity.kind,
+					summary: activity.summary,
+					payload: activity.payload,
+					...activity.sequence !== void 0 ? { sequence: activity.sequence } : {},
+					createdAt: activity.createdAt
 				});
 				return;
 			case "thread.reverted": {
@@ -37324,7 +38056,7 @@ const NESTED_PAYLOAD_KEYS = [
 	"operations"
 ];
 const MAX_COLLECT_DEPTH = 4;
-function asRecord$7(value) {
+function asRecord$5(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
 }
 function pushChangedFilePath(target, value) {
@@ -37339,7 +38071,7 @@ function collectChangedFilePaths(value, target, depth) {
 		for (const entry of value) collectChangedFilePaths(entry, target, depth + 1);
 		return;
 	}
-	const record = asRecord$7(value);
+	const record = asRecord$5(value);
 	if (!record) return;
 	for (const field of CHANGED_FILE_FIELDS) pushChangedFilePath(target, record[field]);
 	for (const nestedKey of NESTED_PAYLOAD_KEYS) if (nestedKey in record) collectChangedFilePaths(record[nestedKey], target, depth + 1);
@@ -37350,7 +38082,7 @@ function collectChangedFilePaths(value, target, depth) {
 */
 function collectActivityChangedFilePaths(payload) {
 	const target = /* @__PURE__ */ new Set();
-	collectChangedFilePaths(asRecord$7(asRecord$7(payload)?.data), target, 0);
+	collectChangedFilePaths(asRecord$5(asRecord$5(payload)?.data), target, 0);
 	return target;
 }
 /**
@@ -40186,477 +40918,6 @@ const make$54 = Effect.gen(function* () {
 });
 const layer$44 = Layer.effect(CheckpointDiffQuery, make$54);
 //#endregion
-//#region ../../packages/shared/src/toolCategory.ts
-const TOOL_CATEGORY_TITLES = {
-	file_read: "File read",
-	file_search: "File search",
-	file_change: "File change",
-	command: "Command run",
-	version_control: "Version control",
-	build_test: "Build or test",
-	mcp_tool: "MCP tool call",
-	subagent: "Subagent task",
-	web_search: "Web search",
-	web_fetch: "Web fetch",
-	task_plan: "Task or plan",
-	image_view: "Image view",
-	tool: "Tool call"
-};
-new Set(Object.keys(TOOL_CATEGORY_TITLES));
-/** Exact tool names, lowercased, matched before the substring heuristics below. */
-const FILE_READ_TOOL_NAMES = /* @__PURE__ */ new Set([
-	"read",
-	"readfile",
-	"read_file",
-	"view",
-	"viewfile",
-	"view_file",
-	"notebookread",
-	"notebook_read",
-	"openfile",
-	"open_file"
-]);
-const FILE_SEARCH_TOOL_NAMES = /* @__PURE__ */ new Set([
-	"grep",
-	"glob",
-	"search",
-	"filesearch",
-	"file_search",
-	"codebasesearch",
-	"codebase_search",
-	"listdir",
-	"list_dir",
-	"list_directory",
-	"ls"
-]);
-const FILE_CHANGE_TOOL_NAMES = /* @__PURE__ */ new Set([
-	"edit",
-	"write",
-	"multiedit",
-	"multi_edit",
-	"notebookedit",
-	"notebook_edit",
-	"applypatch",
-	"apply_patch",
-	"patch",
-	"createfile",
-	"create_file",
-	"strreplace",
-	"str_replace",
-	"deletefile",
-	"delete_file"
-]);
-const COMMAND_TOOL_NAMES = /* @__PURE__ */ new Set([
-	"bash",
-	"shell",
-	"terminal",
-	"exec",
-	"execute",
-	"execcommand",
-	"exec_command",
-	"runcommand",
-	"run_command",
-	"local_shell"
-]);
-const SUBAGENT_TOOL_NAMES = /* @__PURE__ */ new Set([
-	"task",
-	"agent",
-	"subagent",
-	"sub_agent"
-]);
-const WEB_FETCH_TOOL_NAMES = /* @__PURE__ */ new Set([
-	"webfetch",
-	"web_fetch",
-	"fetch",
-	"fetchurl",
-	"fetch_url",
-	"browse",
-	"openurl",
-	"open_url"
-]);
-/**
-* Matched before the subagent rules, so `task_create` is a board write while the
-* bare `Task` tool stays a subagent.
-*/
-const TASK_PLAN_TOOL_NAMES = /* @__PURE__ */ new Set([
-	"todowrite",
-	"todo_write",
-	"todoread",
-	"todo_read",
-	"exitplanmode",
-	"exit_plan_mode",
-	"updateplan",
-	"update_plan",
-	"task_create",
-	"task_update",
-	"task_list",
-	"task_get",
-	"task_current",
-	"task_propose",
-	"ticket_resolve",
-	"taskcreate",
-	"taskupdate",
-	"tasklist",
-	"taskget"
-]);
-/** Shell builtins that say nothing about what the command as a whole does. */
-const NEUTRAL_SHELL_COMMANDS = /* @__PURE__ */ new Set([
-	"cd",
-	"echo",
-	"printf",
-	"pwd",
-	"true",
-	"false",
-	"time"
-]);
-/** `sed`/`awk` are stream editors (`sed -i` rewrites files), so they stay commands. */
-const FILE_READ_SHELL_COMMANDS = /* @__PURE__ */ new Set([
-	"cat",
-	"head",
-	"tail",
-	"less",
-	"more",
-	"bat",
-	"nl",
-	"jq",
-	"wc"
-]);
-const FILE_SEARCH_SHELL_COMMANDS = /* @__PURE__ */ new Set([
-	"grep",
-	"egrep",
-	"fgrep",
-	"rg",
-	"ag",
-	"ack",
-	"find",
-	"fd",
-	"ls",
-	"tree",
-	"which"
-]);
-/** `git status` and `git diff` sort here too: the verb is what a reader scans for. */
-const VERSION_CONTROL_SHELL_COMMANDS = /* @__PURE__ */ new Set([
-	"git",
-	"gh",
-	"jj",
-	"hg",
-	"svn",
-	"glab"
-]);
-/**
-* Builds, tests, type checks, lint and install share one category: a test run is
-* what a person scans for when a turn goes long, and the rest is the same noise.
-*/
-const BUILD_TEST_SHELL_COMMANDS = /* @__PURE__ */ new Set([
-	"pnpm",
-	"npm",
-	"npx",
-	"yarn",
-	"bun",
-	"bunx",
-	"vitest",
-	"jest",
-	"vp",
-	"tsc",
-	"tsgo",
-	"eslint",
-	"oxlint",
-	"biome",
-	"prettier",
-	"ruff",
-	"pytest",
-	"make",
-	"cargo",
-	"gradle",
-	"mvn",
-	"xcodebuild",
-	"swift",
-	"pip",
-	"uv",
-	"poetry"
-]);
-const WEB_FETCH_SHELL_COMMANDS = /* @__PURE__ */ new Set([
-	"curl",
-	"wget",
-	"http",
-	"httpie"
-]);
-const SHELL_SEGMENT_SEPARATOR = /\|\||&&|;|\||\n/u;
-const LEADING_ENV_ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=\S*\s+/u;
-const REDIRECT_TARGET = /\d?>>?\s*(?<target>[^\s|;&]+)/gu;
-/** Redirect targets that discard output instead of writing a file. */
-const DISCARDED_REDIRECT_TARGETS = /* @__PURE__ */ new Set([
-	"/dev/null",
-	"&1",
-	"&2"
-]);
-function toolCategoryTitle(category) {
-	return TOOL_CATEGORY_TITLES[category];
-}
-function readCommandInput(toolInput) {
-	const raw = toolInput?.command ?? toolInput?.cmd;
-	if (typeof raw !== "string") return;
-	const trimmed = raw.trim();
-	return trimmed.length > 0 ? trimmed : void 0;
-}
-/** `cat x > y` reads and writes; only the write matters for the row heading. */
-function redirectsToFile(segment) {
-	for (const match of segment.matchAll(REDIRECT_TARGET)) {
-		const target = match.groups?.target;
-		if (target && !DISCARDED_REDIRECT_TARGETS.has(target)) return true;
-	}
-	return false;
-}
-function classifyShellSegment(segment) {
-	if (redirectsToFile(segment)) return "command";
-	const head = segment.trim().replace(LEADING_ENV_ASSIGNMENT, "").split(/\s+/u)[0]?.replace(/^.*\//u, "").toLowerCase();
-	if (!head || NEUTRAL_SHELL_COMMANDS.has(head)) return;
-	if (FILE_READ_SHELL_COMMANDS.has(head)) return "file_read";
-	if (FILE_SEARCH_SHELL_COMMANDS.has(head)) return "file_search";
-	if (VERSION_CONTROL_SHELL_COMMANDS.has(head)) return "version_control";
-	if (BUILD_TEST_SHELL_COMMANDS.has(head)) return "build_test";
-	if (WEB_FETCH_SHELL_COMMANDS.has(head)) return "web_fetch";
-	return "command";
-}
-/**
-* A shell call only counts as anything narrower than a command when every
-* non-neutral segment agrees; anything unrecognized (or write-ish) keeps the
-* whole call a command, and so does a pipeline that mixes two categories — the
-* one exception being a read piped into a search, which is still a search.
-* Quoted separators split segments too, which can only downgrade to "command".
-*/
-function classifyShellCommand(command) {
-	const categories = new Set(command.split(SHELL_SEGMENT_SEPARATOR).map(classifyShellSegment).filter((category) => category !== void 0));
-	if (categories.size === 0 || categories.has("command")) return "command";
-	const [only] = categories;
-	if (categories.size === 1 && only) return only;
-	return [...categories].every((category) => category === "file_read" || category === "file_search") ? "file_search" : "command";
-}
-function classifyToolCategory(input) {
-	const normalized = input.toolName.trim().toLowerCase();
-	if (normalized.startsWith("mcp__") || normalized.includes("mcp")) return "mcp_tool";
-	if (TASK_PLAN_TOOL_NAMES.has(normalized)) return "task_plan";
-	if (WEB_FETCH_TOOL_NAMES.has(normalized)) return "web_fetch";
-	if (SUBAGENT_TOOL_NAMES.has(normalized) || normalized.includes("agent")) return "subagent";
-	if (FILE_READ_TOOL_NAMES.has(normalized)) return "file_read";
-	if (FILE_SEARCH_TOOL_NAMES.has(normalized)) return "file_search";
-	if (FILE_CHANGE_TOOL_NAMES.has(normalized)) return "file_change";
-	if (COMMAND_TOOL_NAMES.has(normalized) || normalized.includes("bash") || normalized.includes("shell") || normalized.includes("terminal") || normalized.includes("command")) {
-		const command = readCommandInput(input.toolInput);
-		return command ? classifyShellCommand(command) : "command";
-	}
-	if (normalized.includes("websearch") || normalized.includes("web_search")) return "web_search";
-	if (normalized.includes("webfetch") || normalized.includes("web_fetch")) return "web_fetch";
-	if (normalized.includes("todo") || normalized.includes("plan")) return "task_plan";
-	if (normalized.includes("edit") || normalized.includes("write") || normalized.includes("patch") || normalized.includes("replace") || normalized.includes("create") || normalized.includes("delete")) return "file_change";
-	if (normalized.includes("read") || normalized.includes("view")) return "file_read";
-	if (normalized.includes("grep") || normalized.includes("glob")) return "file_search";
-	if (normalized.includes("image")) return "image_view";
-	return "tool";
-}
-function asRecord$6(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-}
-/** Classify from a runtime item payload's `data` (`{ toolName, input }`). */
-function classifyToolCategoryFromToolData(data) {
-	const record = asRecord$6(data);
-	const toolName = record?.toolName;
-	if (typeof toolName !== "string" || toolName.trim().length === 0) return;
-	return classifyToolCategory({
-		toolName,
-		toolInput: asRecord$6(record?.input)
-	});
-}
-//#endregion
-//#region src/orchestration/ActivityPayloadProjection.ts
-function asRecord$5(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
-}
-function asTrimmedString$1(value) {
-	if (typeof value !== "string") return null;
-	const trimmed = value.trim();
-	return trimmed.length > 0 ? trimmed : null;
-}
-function pushChangedFile(target, seen, value) {
-	const normalized = asTrimmedString$1(value);
-	if (!normalized || seen.has(normalized)) return;
-	seen.add(normalized);
-	target.push(normalized);
-}
-function collectChangedFiles(value, target, seen, depth) {
-	if (depth > 4 || target.length >= 12) return;
-	if (Array.isArray(value)) {
-		for (const entry of value) {
-			collectChangedFiles(entry, target, seen, depth + 1);
-			if (target.length >= 12) return;
-		}
-		return;
-	}
-	const record = asRecord$5(value);
-	if (!record) return;
-	pushChangedFile(target, seen, record.path);
-	pushChangedFile(target, seen, record.filePath);
-	pushChangedFile(target, seen, record.relativePath);
-	pushChangedFile(target, seen, record.filename);
-	pushChangedFile(target, seen, record.newPath);
-	pushChangedFile(target, seen, record.oldPath);
-	for (const nestedKey of [
-		"item",
-		"result",
-		"input",
-		"data",
-		"changes",
-		"files",
-		"edits",
-		"patch",
-		"patches",
-		"operations"
-	]) {
-		if (!(nestedKey in record)) continue;
-		collectChangedFiles(record[nestedKey], target, seen, depth + 1);
-		if (target.length >= 12) return;
-	}
-}
-function projectCommandData(data) {
-	const item = asRecord$5(data.item);
-	if (!item) return;
-	const projectedItem = {};
-	if ("command" in item) projectedItem.command = item.command;
-	const input = asRecord$5(item.input);
-	if (input && "command" in input) projectedItem.input = { command: input.command };
-	const result = asRecord$5(item.result);
-	if (result && "command" in result) projectedItem.result = { command: result.command };
-	return Object.keys(projectedItem).length > 0 ? projectedItem : void 0;
-}
-function summarizeToolTextOutput(value) {
-	const lines = [];
-	for (const rawLine of value.split(/\r?\n/u)) {
-		const line = rawLine.replace(/\s+/g, " ").trim();
-		if (line.length > 0) lines.push(line);
-	}
-	const firstLine = lines.find((line) => line !== "```");
-	if (firstLine) return firstLine.length <= 84 ? firstLine : `${firstLine.slice(0, 83).trimEnd()}…`;
-	if (lines.length > 1) return `${lines.length.toLocaleString()} lines`;
-	return null;
-}
-function projectRawOutput(value) {
-	const rawOutput = asRecord$5(value);
-	if (!rawOutput) return;
-	if (typeof rawOutput.totalFiles === "number" && Number.isFinite(rawOutput.totalFiles)) return {
-		totalFiles: rawOutput.totalFiles,
-		...rawOutput.truncated === true ? { truncated: true } : {}
-	};
-	const content = asTrimmedString$1(rawOutput.content);
-	if (content) {
-		const summary = summarizeToolTextOutput(content);
-		return summary ? { content: summary } : void 0;
-	}
-	const stdout = asTrimmedString$1(rawOutput.stdout);
-	if (stdout) {
-		const summary = summarizeToolTextOutput(stdout);
-		return summary ? { content: summary } : void 0;
-	}
-}
-/**
-* Removes activity payload fields that no current client reads while retaining
-* the full payload in persistence and the event store.
-*/
-function projectActivityPayload(activity) {
-	const payload = asRecord$5(activity.payload);
-	const data = asRecord$5(payload?.data);
-	if (!payload || !data || payload.itemType === "mcp_tool_call") return activity;
-	const projectedData = {};
-	const item = projectCommandData(data);
-	if (item) projectedData.item = item;
-	if ("command" in data) projectedData.command = data.command;
-	const input = asRecord$5(data.input);
-	if (input && "command" in input) projectedData.input = { command: input.command };
-	const changedFiles = [];
-	collectChangedFiles(data, changedFiles, /* @__PURE__ */ new Set(), 0);
-	if (changedFiles.length > 0) projectedData.files = changedFiles.map((path) => ({ path }));
-	if (asTrimmedString$1(data.patch)) projectedData.patch = data.patch;
-	const toolCategory = classifyToolCategoryFromToolData(data);
-	if (toolCategory) projectedData.toolCategory = toolCategory;
-	if ("toolCallId" in data) projectedData.toolCallId = data.toolCallId;
-	if ("kind" in data) projectedData.kind = data.kind;
-	const rawOutput = projectRawOutput(data.rawOutput);
-	if (rawOutput) projectedData.rawOutput = rawOutput;
-	return {
-		...activity,
-		payload: {
-			...payload,
-			data: projectedData
-		}
-	};
-}
-/**
-* Matches the validity rule in the web client's
-* `deriveLatestContextWindowSnapshot`: rows without a finite, non-negative
-* `usedTokens` are skipped during its backward walk, so they must not shadow
-* an earlier resolvable row here.
-*/
-function isResolvableContextWindowActivity(activity) {
-	if (activity.kind !== "context-window.updated") return false;
-	const usedTokens = asRecord$5(activity.payload)?.usedTokens;
-	return typeof usedTokens === "number" && Number.isFinite(usedTokens) && usedTokens >= 0;
-}
-/**
-* Drops all but the last resolvable context-window activity per turn from a
-* snapshot. Clients only ever read the latest usage value (walking the array
-* backwards), so shipping the full history — often thousands of rows on long
-* threads — buys nothing. Retention is per turn rather than per thread because
-* a live `thread.reverted` makes the client discard whole turns; keeping each
-* turn's latest row means the meter can still resolve a value from the turns
-* that survive. Malformed rows pass through untouched rather than shadowing a
-* valid earlier row. Live `thread.activity-appended` events are untouched:
-* newer updates still stream through and supersede the retained rows on the
-* client.
-*/
-function withoutContextWindowBreakdown$1(activity) {
-	const payload = asRecord$5(activity.payload);
-	if (!payload || payload.breakdown === void 0) return activity;
-	const { breakdown: _breakdown, ...rest } = payload;
-	return {
-		...activity,
-		payload: rest
-	};
-}
-function dropStaleContextWindowActivities(activities) {
-	const latestIndexByTurn = /* @__PURE__ */ new Map();
-	for (let index = 0; index < activities.length; index += 1) if (isResolvableContextWindowActivity(activities[index])) latestIndexByTurn.set(activities[index].turnId, index);
-	if (latestIndexByTurn.size === 0) return activities;
-	const retainedIndexes = new Set(latestIndexByTurn.values());
-	let breakdownIndex = null;
-	for (const index of retainedIndexes) {
-		if (asRecord$5(activities[index].payload)?.breakdown === void 0) continue;
-		if (breakdownIndex === null || index > breakdownIndex) breakdownIndex = index;
-	}
-	return activities.flatMap((activity, index) => {
-		if (!isResolvableContextWindowActivity(activity)) return [activity];
-		if (latestIndexByTurn.get(activity.turnId) !== index) return [];
-		return [index === breakdownIndex ? activity : withoutContextWindowBreakdown$1(activity)];
-	});
-}
-function projectThreadDetailSnapshot(snapshot) {
-	return {
-		...snapshot,
-		thread: {
-			...snapshot.thread,
-			activities: dropStaleContextWindowActivities(snapshot.thread.activities).map(projectActivityPayload)
-		}
-	};
-}
-function projectActivityEvent(event) {
-	if (event.type !== "thread.activity-appended") return event;
-	return {
-		...event,
-		payload: {
-			...event.payload,
-			activity: projectActivityPayload(event.payload.activity)
-		}
-	};
-}
-//#endregion
 //#region src/orchestration/Normalizer.ts
 const canonicalizeClientCommandTimestamps = (command, receivedAt) => {
 	const canonicalCommand = "createdAt" in command ? {
@@ -90075,6 +90336,32 @@ const makeCodexSessionRuntime = (options) => Effect.gen(function* () {
 			return providerConversationId ? collabReceiverTurns.get(providerConversationId) : void 0;
 		})();
 		rememberCollabReceiverTurns(collabReceiverTurns, notification, route.turnId);
+		if (childParentTurnId && notification.method === "turn/completed" && notification.params.turn.status !== "inProgress") {
+			const childThreadId = notification.params.threadId;
+			const childStatus = notification.params.turn.status === "failed" ? "errored" : notification.params.turn.status === "interrupted" ? "interrupted" : "completed";
+			yield* emitEvent({
+				kind: "notification",
+				threadId: options.threadId,
+				method: "item/completed",
+				turnId: childParentTurnId,
+				itemId: ProviderItemId.make(`subagent-${notification.params.turn.id}`),
+				payload: {
+					completedAtMs: DateTime.toEpochMillis(yield* DateTime.now),
+					threadId: childThreadId,
+					turnId: childParentTurnId,
+					item: {
+						type: "collabAgentToolCall",
+						id: `subagent-${notification.params.turn.id}`,
+						tool: "wait",
+						status: childStatus === "errored" ? "failed" : "completed",
+						senderThreadId: childThreadId,
+						receiverThreadIds: [childThreadId],
+						agentsStates: { [childThreadId]: { status: childStatus } }
+					}
+				}
+			});
+			collabReceiverTurns.delete(childThreadId);
+		}
 		if (childParentTurnId && shouldSuppressChildConversationNotification(notification.method)) {
 			yield* Ref.set(collabReceiverTurnsRef, collabReceiverTurns);
 			return;
@@ -90616,16 +90903,26 @@ function collabTaskEvents(event, canonicalThreadId, item) {
 	const prompt = trimText$1(item.prompt);
 	const model = trimText$1(item.model);
 	const reasoningEffort = trimText$1(item.reasoningEffort);
-	if (item.tool === "spawnAgent") for (const receiverThreadId of item.receiverThreadIds) events.push({
-		...base,
-		type: "task.started",
-		payload: {
-			taskId: RuntimeTaskId.make(receiverThreadId),
-			...prompt ? { description: prompt } : {},
-			...model ? { model } : {},
-			...reasoningEffort ? { reasoningEffort } : {}
-		}
-	});
+	if (item.tool === "spawnAgent") for (const receiverThreadId of item.receiverThreadIds) {
+		events.push({
+			...base,
+			type: "task.started",
+			payload: {
+				taskId: RuntimeTaskId.make(receiverThreadId),
+				...prompt ? { description: prompt } : {},
+				...model ? { model } : {},
+				...reasoningEffort ? { reasoningEffort } : {}
+			}
+		});
+		if (!(receiverThreadId in item.agentsStates)) events.push({
+			...base,
+			type: "task.progress",
+			payload: {
+				taskId: RuntimeTaskId.make(receiverThreadId),
+				description: prompt ?? "Agent started"
+			}
+		});
+	}
 	for (const [agentThreadId, state] of Object.entries(item.agentsStates)) {
 		const taskId = RuntimeTaskId.make(agentThreadId);
 		const message = trimText$1(state.message);
@@ -109281,6 +109578,73 @@ const ObservabilityLive = Layer.unwrap(Effect.gen(function* () {
 	return Layer.mergeAll(ServerLoggerLive, traceReferencesLayer, tracerLayer, metricsLayer);
 }));
 //#endregion
+//#region src/serverInstanceLock.ts
+const SERVER_LOCK_DATABASE_FILE_NAME = "server.lock.sqlite";
+const SQLITE_BUSY = 5;
+const SqliteError = Schema$1.Struct({
+	code: Schema$1.optional(Schema$1.String),
+	errno: Schema$1.optional(Schema$1.Int),
+	errcode: Schema$1.optional(Schema$1.Int),
+	message: Schema$1.optional(Schema$1.String)
+});
+const isSqliteError = Schema$1.is(SqliteError);
+var ServerInstanceAlreadyRunningError = class extends Schema$1.TaggedErrorClass()("ServerInstanceAlreadyRunningError", { stateDir: Schema$1.String }) {
+	get message() {
+		return `A P4Code server is already using ${this.stateDir}. Stop it before starting another server with the same P4 home.`;
+	}
+};
+var ServerInstanceLockError = class extends Schema$1.TaggedErrorClass()("ServerInstanceLockError", {
+	operation: Schema$1.String,
+	lockPath: Schema$1.String,
+	cause: Schema$1.Defect()
+}) {
+	get message() {
+		return `Failed to ${this.operation} P4Code server lock at ${this.lockPath}.`;
+	}
+};
+const isSqliteBusy = (cause) => {
+	if (!isSqliteError(cause)) return false;
+	return cause.errno === SQLITE_BUSY || cause.errcode === SQLITE_BUSY || cause.code === "SQLITE_BUSY" || cause.code === "SQLITE_LOCKED" || cause.message?.includes("database is locked") === true;
+};
+const openLockDatabase = Effect.fn("serverInstanceLock.openDatabase")(function* (stateDir, lockPath) {
+	yield* (yield* FileSystem.FileSystem).makeDirectory(stateDir, { recursive: true }).pipe(Effect.mapError((cause) => new ServerInstanceLockError({
+		operation: "create lock directory",
+		lockPath,
+		cause
+	})));
+	return yield* Effect.tryPromise({
+		try: async () => {
+			const database = process.versions.bun ? new (await (import("bun:sqlite"))).Database(lockPath) : new (await (import("node:sqlite"))).DatabaseSync(lockPath);
+			try {
+				database.exec("PRAGMA busy_timeout = 0; BEGIN EXCLUSIVE;");
+				return database;
+			} catch (cause) {
+				database.close();
+				throw cause;
+			}
+		},
+		catch: (cause) => isSqliteBusy(cause) ? new ServerInstanceAlreadyRunningError({ stateDir }) : new ServerInstanceLockError({
+			operation: "acquire",
+			lockPath,
+			cause
+		})
+	});
+});
+const acquireServerInstanceLock = Effect.fn("serverInstanceLock.acquire")(function* (stateDir) {
+	const lockPath = (yield* Path.Path).join(stateDir, SERVER_LOCK_DATABASE_FILE_NAME);
+	return yield* Effect.acquireRelease(openLockDatabase(stateDir, lockPath), (database) => Effect.try({
+		try: () => database.close(),
+		catch: (cause) => new ServerInstanceLockError({
+			operation: "release",
+			lockPath,
+			cause
+		})
+	}).pipe(Effect.catch((error) => Effect.logWarning(error.message, {
+		lockPath,
+		error
+	}))));
+});
+//#endregion
 //#region src/orchestration/http.ts
 const orchestrationHttpApiLayer = HttpApiBuilder.group(EnvironmentHttpApi, "orchestration", Effect.fnUntraced(function* (handlers) {
 	const projectionSnapshotQuery = yield* ProjectionSnapshotQuery;
@@ -109640,7 +110004,11 @@ const makeServerLayer = Layer.unwrap(Effect.gen(function* () {
 		cause,
 		servePort: configured.servePort
 	}))) : Effect.void)) : Layer.empty;
-	return Layer.mergeAll(HttpRouter.serve(makeRoutesLayer, { disableLogger: !config.logWebSocketEvents }), httpListeningLayer, runtimeStateLayer, tailscaleServeLayer).pipe(Layer.provideMerge(RuntimeServicesLive), Layer.provideMerge(HttpResponseCompressionLive), Layer.provideMerge(HttpServerLive), Layer.provide(ObservabilityLive), Layer.provideMerge(FetchHttpClient.layer), Layer.provideMerge(layer$49), Layer.provideMerge(PlatformServicesLive));
+	const fullyProvisionedServerLayer = Layer.mergeAll(HttpRouter.serve(makeRoutesLayer, { disableLogger: !config.logWebSocketEvents }), httpListeningLayer, runtimeStateLayer, tailscaleServeLayer).pipe(Layer.provideMerge(RuntimeServicesLive), Layer.provideMerge(HttpResponseCompressionLive), Layer.provideMerge(HttpServerLive), Layer.provide(ObservabilityLive), Layer.provideMerge(FetchHttpClient.layer), Layer.provideMerge(layer$49));
+	return Layer.unwrap(Effect.gen(function* () {
+		yield* acquireServerInstanceLock(config.stateDir);
+		return fullyProvisionedServerLayer;
+	})).pipe(Layer.provide(PlatformServicesLive));
 }));
 const runServer = Layer.launch(makeServerLayer);
 //#endregion