@p4code/cli 0.1.17 → 0.1.18

package/dist/bin.mjs

@@ -233,7 +233,7 @@ const make$75 = () => {
 const layer$71 = Layer.sync(NetService, make$75);
 //#endregion
 //#region package.json
-var version = "0.1.17";
+var version = "0.1.18";
 //#endregion
 //#region src/config.ts
 /**
@@ -4773,6 +4773,7 @@ Schema$1.Literals([
 	"config.warning",
 	"deprecation.notice",
 	"files.persisted",
+	"code.published",
 	"runtime.warning",
 	"runtime.error"
 ]);
@@ -4821,6 +4822,7 @@ const ModelReroutedType = Schema$1.Literal("model.rerouted");
 const ConfigWarningType = Schema$1.Literal("config.warning");
 const DeprecationNoticeType = Schema$1.Literal("deprecation.notice");
 const FilesPersistedType = Schema$1.Literal("files.persisted");
+const CodePublishedType = Schema$1.Literal("code.published");
 const ToolDeniedType = Schema$1.Literal("tool.denied");
 const RuntimeWarningType = Schema$1.Literal("runtime.warning");
 const RuntimeErrorType = Schema$1.Literal("runtime.error");
@@ -5123,6 +5125,12 @@ const FilesPersistedPayload = Schema$1.Struct({
 		error: TrimmedNonEmptyStringSchema$1
 	})))
 });
+const CodePublishedPayload = Schema$1.Struct({
+	hostingProvider: TrimmedNonEmptyStringSchema$1,
+	url: TrimmedNonEmptyStringSchema$1,
+	repo: Schema$1.optional(TrimmedNonEmptyStringSchema$1),
+	identifier: Schema$1.optional(TrimmedNonEmptyStringSchema$1)
+});
 const ToolDeniedPayload = Schema$1.Struct({
 	toolName: TrimmedNonEmptyStringSchema$1,
 	toolUseId: Schema$1.optional(TrimmedNonEmptyStringSchema$1),
@@ -5363,6 +5371,11 @@ const ProviderRuntimeFilesPersistedEvent = Schema$1.Struct({
 	type: FilesPersistedType,
 	payload: FilesPersistedPayload
 });
+const ProviderRuntimeCodePublishedEvent = Schema$1.Struct({
+	...ProviderRuntimeEventBase.fields,
+	type: CodePublishedType,
+	payload: CodePublishedPayload
+});
 const ProviderRuntimeToolDeniedEvent = Schema$1.Struct({
 	...ProviderRuntimeEventBase.fields,
 	type: ToolDeniedType,
@@ -5424,6 +5437,7 @@ Schema$1.Union([
 	ProviderRuntimeConfigWarningEvent,
 	ProviderRuntimeDeprecationNoticeEvent,
 	ProviderRuntimeFilesPersistedEvent,
+	ProviderRuntimeCodePublishedEvent,
 	ProviderRuntimeToolDeniedEvent,
 	ProviderRuntimeWarningEvent,
 	ProviderRuntimeErrorEvent
@@ -5795,6 +5809,20 @@ const ServerSettings = Schema$1.Struct({
 	* back for sessions started by the Claude provider.
 	*/
 	enableToolCallNarration: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
+	/**
+	* Whether the model may spawn subagents without being asked to.
+	*
+	* On by default: a bounded search or review whose result is far smaller than
+	* the reading it takes to produce is exactly the work a subagent is for, and
+	* an agent that has to ask first will simply do it inline instead.
+	*
+	* Stated in the appended prompt whichever way it is set, rather than only
+	* when off. The provider's own preset prompt carries an instruction not to
+	* spawn subagents unless asked, and p4code requests that preset wholesale —
+	* so there is nothing to withhold, and only a later, more specific
+	* instruction can override an earlier general one.
+	*/
+	enableUnpromptedSubagents: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
 	automaticGitFetchInterval: Schema$1.DurationFromMillis.pipe(Schema$1.withDecodingDefault(Effect.succeed(Duration.toMillis(DEFAULT_AUTOMATIC_GIT_FETCH_INTERVAL)))),
 	defaultThreadEnvMode: ThreadEnvMode.pipe(Schema$1.withDecodingDefault(Effect.succeed("local"))),
 	newWorktreesStartFromOrigin: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
@@ -5929,6 +5957,7 @@ const ServerSettingsPatch = Schema$1.Struct({
 	enableAssistantStreaming: Schema$1.optionalKey(Schema$1.Boolean),
 	enableProviderUpdateChecks: Schema$1.optionalKey(Schema$1.Boolean),
 	enableToolCallNarration: Schema$1.optionalKey(Schema$1.Boolean),
+	enableUnpromptedSubagents: Schema$1.optionalKey(Schema$1.Boolean),
 	automaticGitFetchInterval: Schema$1.optionalKey(Schema$1.DurationFromMillis),
 	defaultThreadEnvMode: Schema$1.optionalKey(ThreadEnvMode),
 	newWorktreesStartFromOrigin: Schema$1.optionalKey(Schema$1.Boolean),
@@ -7820,11 +7849,17 @@ const AGENT_ASSET_TOTAL_MAX_BYTES = 4 * 1024 * 1024;
 *   directory rather than the provider's. The definition travels; the bearer
 *   tokens and API keys it references do not, and stay in each machine's own
 *   secret store.
+* - `agent` — a subagent definition, a single markdown file in
+*   `<configDir>/agents`. The name is the filename, as for `memory`. This is the
+*   only artifact that bounds what a subagent is handed and what it hands back,
+*   because p4code observes subagent runs rather than constructing their
+*   prompts — so the I/O contract can only ship as a file the provider reads.
 */
 const AgentAssetKind = Schema$1.Literals([
 	"skill",
 	"memory",
-	"mcp"
+	"mcp",
+	"agent"
 ]);
 /**
 * An asset's name, which for a skill is also its directory name.
@@ -15532,7 +15567,15 @@ function buildSkillOverrides(disabled, discovered) {
 * @module provider/Drivers/ClaudeSkills
 */
 const FRONTMATTER_PATTERN = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
-function parseSkillFrontmatter(contents) {
+/**
+* The `name`/`description` header a skill and a subagent definition both carry.
+*
+* Exported because agent definitions are the same header in a different file,
+* and the sync validates them before publishing one. A second copy of this
+* would be a second answer to "does this load in the provider", which is the
+* one question both callers are asking.
+*/
+function parseMarkdownFrontmatter(contents) {
 	const match = FRONTMATTER_PATTERN.exec(contents);
 	if (!match) return { kind: "missing" };
 	let parsed;
@@ -15583,6 +15626,19 @@ const resolveClaudeUserSkillsDir = Effect.fn("resolveClaudeUserSkillsDir")(funct
 	return path.join(configDirPath, "skills");
 });
 /**
+* The user-scope subagent directory the CLI would read.
+*
+* Same resolution as the skills directory beside it, for the same reason: the
+* sync materializes into exactly the directory the provider loads from, and
+* deriving it a second time is how the two come to disagree about where an
+* agent definition lives.
+*/
+const resolveClaudeUserAgentsDir = Effect.fn("resolveClaudeUserAgentsDir")(function* (config, environment, cwd) {
+	const path = yield* Path.Path;
+	const configDirPath = yield* resolveClaudeConfigDirPath(config, environment ?? process.env, cwd);
+	return path.join(configDirPath, "agents");
+});
+/**
 * Enumerate Claude Code skills from the user config dir and the workspace.
 * Discovery is best-effort: unreadable roots and malformed skill entries are
 * skipped so a broken skill never degrades the provider snapshot. On name
@@ -15607,7 +15663,7 @@ const discoverClaudeSkills = Effect.fn("discoverClaudeSkills")(function* (config
 			const skillPath = path.join(root.directory, entry, "SKILL.md");
 			const contents = yield* fileSystem.readFileString(skillPath).pipe(Effect.orElseSucceed(() => void 0));
 			if (contents === void 0) continue;
-			const frontmatter = parseSkillFrontmatter(contents);
+			const frontmatter = parseMarkdownFrontmatter(contents);
 			if (frontmatter.kind === "malformed") continue;
 			const name = (frontmatter.kind === "parsed" ? frontmatter.name : void 0) ?? entry.trim();
 			if (!name) continue;
@@ -16429,6 +16485,288 @@ const make$62 = Effect.gen(function* () {
 });
 const layer$57 = Layer.effect(McpRegistry, make$62);
 //#endregion
+//#region src/sync/skillDirectory.ts
+/**
+* Reading and writing skill directories on disk.
+*
+* Kept apart from the sync itself so the filesystem shape has its own tests,
+* and so the rules about what is refusable — binaries, oversized files, deep
+* trees — live in one place rather than being rediscovered at each call site.
+*
+* @module sync/skillDirectory
+*/
+/** Bounded so a stray symlink or a vendored `node_modules` cannot walk forever. */
+const MAX_SKILL_DEPTH = 4;
+/**
+* Entries that are never part of a skill, skipped rather than refused.
+*
+* The distinction matters. Refusing an asset because it cannot be represented
+* faithfully is right — a half-materialized skill loads and misbehaves. But a
+* `.DS_Store` is not part of the skill at all, and macOS drops one into any
+* directory that has been opened in Finder, so refusing on its account rejects
+* a perfectly good skill for a reason its author cannot see.
+*
+* These could not sync in any case: `AgentAssetFilePath` rejects a leading dot,
+* so a dotfile has no representable path even if it were text.
+*/
+const IGNORED_ENTRIES = /* @__PURE__ */ new Set([
+	".DS_Store",
+	"Thumbs.db",
+	".git",
+	".svn",
+	".hg",
+	"node_modules",
+	"__pycache__",
+	".venv",
+	".pytest_cache",
+	".ruff_cache",
+	".mypy_cache"
+]);
+/**
+* Anything else with a leading dot is skipped too — an editor's `.idea`, a
+* `.gitignore` that belongs to the checkout rather than the skill. The rule is
+* the same one the path schema already enforces, applied earlier so it reads as
+* "not part of the skill" instead of "this skill is broken".
+*/
+const isIgnoredEntry = (entry) => IGNORED_ENTRIES.has(entry) || entry.startsWith(".");
+/**
+* A file is binary if decoding it yields a NUL.
+*
+* Cheap, and right for what is being asked: the question is not "is this valid
+* UTF-8" but "can this round-trip through a JSON text column", and a NUL is
+* what actually breaks that on the way back out of SQLite.
+*
+* Exported so the single-file kinds ask it the same way this one does, rather
+* than each keeping a copy that could drift into a different answer.
+*/
+const looksBinary$1 = (content) => content.includes("\0");
+/**
+* Read one directory as an asset's files, or say why it cannot be one.
+*
+* Exported because memory's `global-memory/` is the same shape by a different
+* name: a directory whose whole contents are the asset. Sharing this keeps the
+* refusal rules — depth, file count, binaries, size — identical for both,
+* rather than letting a second copy drift into accepting what the first
+* rejects.
+*/
+const readSkillFiles = Effect.fn("skillDirectory.readSkillFiles")(function* (root) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const files = [];
+	const walk = Effect.fn("skillDirectory.walk")(function* (directory, prefix, depth) {
+		if (depth > MAX_SKILL_DEPTH) return "too-deep";
+		const entries = yield* fileSystem.readDirectory(directory).pipe(Effect.orElseSucceed(() => []));
+		for (const entry of [...entries].sort()) {
+			if (isIgnoredEntry(entry)) continue;
+			const absolute = path.join(directory, entry);
+			const relative = prefix === "" ? entry : `${prefix}/${entry}`;
+			const info = yield* fileSystem.stat(absolute).pipe(Effect.orElseSucceed(() => void 0));
+			if (info === void 0) return "unreadable";
+			if (info.type === "Directory") {
+				const nested = yield* walk(absolute, relative, depth + 1);
+				if (nested !== null) return nested;
+				continue;
+			}
+			if (info.type !== "File") continue;
+			if (files.length >= 512) return "too-many-files";
+			const content = yield* fileSystem.readFileString(absolute).pipe(Effect.orElseSucceed(() => void 0));
+			if (content === void 0) return "unreadable";
+			if (looksBinary$1(content)) return "binary-file";
+			if (content.length > 524288) return "file-too-large";
+			files.push({
+				path: relative,
+				content
+			});
+		}
+		return null;
+	});
+	const refusal = yield* walk(root, "", 1);
+	if (refusal !== null) return { refusal };
+	if (agentAssetTotalBytes(files) > 4194304) return { refusal: "asset-too-large" };
+	return { files };
+});
+/**
+* Read every skill directory under a user-scope `skills/` root.
+*
+* A directory with no `SKILL.md` is not a skill and is skipped silently —
+* Claude Code would ignore it too, so reporting it would be noise about
+* something that was never a skill in the first place.
+*/
+const readSkillDirectory = Effect.fn("skillDirectory.readSkillDirectory")(function* (skillsRoot) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const entries = yield* fileSystem.readDirectory(skillsRoot).pipe(Effect.orElseSucceed(() => []));
+	const skills = [];
+	const refused = [];
+	for (const entry of [...entries].sort()) {
+		if (isIgnoredEntry(entry)) continue;
+		const directory = path.join(skillsRoot, entry);
+		if ((yield* fileSystem.stat(directory).pipe(Effect.orElseSucceed(() => void 0)))?.type !== "Directory") continue;
+		if (!(yield* fileSystem.exists(path.join(directory, "SKILL.md")).pipe(Effect.orElseSucceed(() => false)))) continue;
+		const read = yield* readSkillFiles(directory);
+		if ("refusal" in read) {
+			refused.push({
+				name: entry,
+				reason: read.refusal
+			});
+			continue;
+		}
+		skills.push({
+			name: entry,
+			files: read.files
+		});
+	}
+	return {
+		skills,
+		refused
+	};
+});
+/**
+* Replace a skill directory with exactly the asset's files.
+*
+* Written to a sibling and then swapped, so a crash mid-write leaves the old
+* skill intact rather than half of the new one. A skill is loaded as a unit and
+* a partially written one is instructions with the middle missing, which an
+* agent will happily follow.
+*/
+const writeSkillDirectory = Effect.fn("skillDirectory.writeSkillDirectory")(function* (input) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const target = path.join(input.skillsRoot, input.name);
+	const staging = path.join(input.skillsRoot, `.${input.name}.p4code-staging`);
+	yield* fileSystem.makeDirectory(input.skillsRoot, { recursive: true });
+	yield* fileSystem.remove(staging, {
+		recursive: true,
+		force: true
+	});
+	yield* fileSystem.makeDirectory(staging, { recursive: true });
+	for (const file of input.files) {
+		const destination = path.join(staging, file.path);
+		yield* fileSystem.makeDirectory(path.dirname(destination), { recursive: true });
+		yield* fileSystem.writeFileString(destination, file.content);
+	}
+	yield* fileSystem.remove(target, {
+		recursive: true,
+		force: true
+	});
+	yield* fileSystem.rename(staging, target);
+});
+const removeSkillDirectory = Effect.fn("skillDirectory.removeSkillDirectory")(function* (input) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	yield* fileSystem.remove(path.join(input.skillsRoot, input.name), {
+		recursive: true,
+		force: true
+	});
+});
+/**
+* Whether this text is a definition the provider would actually load.
+*
+* Both fields, not just the header. `name` is how a subagent is addressed and
+* `description` is how the orchestrator decides to address it, so a definition
+* missing either is present on disk and unreachable in practice.
+*/
+const isLoadableAgentDefinition = (content) => {
+	const frontmatter = parseMarkdownFrontmatter(content);
+	return frontmatter.kind === "parsed" && frontmatter.name !== void 0 && frontmatter.description !== void 0;
+};
+/**
+* Every definition in the directory, as syncable assets.
+*
+* A file that will not load is refused rather than skipped, unlike a stray
+* `.DS_Store`: a `.md` in this directory is meant to be an agent, so a broken
+* header is a fault worth reporting instead of noise to ignore.
+*/
+const readAgentDefinitions = Effect.fn("agentDefinitionFiles.read")(function* (agentsRoot) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const entries = yield* fileSystem.readDirectory(agentsRoot).pipe(Effect.orElseSucceed(() => []));
+	const skills = [];
+	const refused = [];
+	for (const entry of [...entries].sort()) {
+		if (!entry.endsWith(".md") || entry.startsWith(".")) continue;
+		const absolute = path.join(agentsRoot, entry);
+		if ((yield* fileSystem.stat(absolute).pipe(Effect.orElseSucceed(() => void 0)))?.type !== "File") continue;
+		const content = yield* fileSystem.readFileString(absolute).pipe(Effect.orElseSucceed(() => void 0));
+		if (content === void 0) {
+			refused.push({
+				name: entry,
+				reason: "unreadable"
+			});
+			continue;
+		}
+		if (looksBinary$1(content)) {
+			refused.push({
+				name: entry,
+				reason: "binary-file"
+			});
+			continue;
+		}
+		if (content.length > 524288) {
+			refused.push({
+				name: entry,
+				reason: "file-too-large"
+			});
+			continue;
+		}
+		if (!isLoadableAgentDefinition(content)) {
+			refused.push({
+				name: entry,
+				reason: "unreadable"
+			});
+			continue;
+		}
+		const files = [{
+			path: entry,
+			content
+		}];
+		if (agentAssetTotalBytes(files) > 4194304) {
+			refused.push({
+				name: entry,
+				reason: "asset-too-large"
+			});
+			continue;
+		}
+		skills.push({
+			name: entry,
+			files
+		});
+	}
+	return {
+		skills,
+		refused
+	};
+});
+/**
+* Write a definition that arrived from the hub.
+*
+* Refused unless it is exactly one markdown file whose path is the asset's own
+* name and whose frontmatter would load. The last check is the one that matters
+* across machines: it is what stops a hub row edited by hand from installing a
+* file the provider quietly ignores on every machine that syncs it.
+*
+* Written atomically because a definition is read whole when a subagent starts,
+* and half of one is instructions with the contract missing.
+*/
+const writeAgentDefinition = Effect.fn("agentDefinitionFiles.write")(function* (input) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const file = input.files[0];
+	if (!input.name.endsWith(".md") || input.files.length !== 1 || file === void 0 || file.path !== input.name) return "refused";
+	if (!isLoadableAgentDefinition(file.content)) return "refused";
+	yield* fileSystem.makeDirectory(input.agentsRoot, { recursive: true }).pipe(Effect.ignore);
+	return yield* writeFileStringAtomically({
+		filePath: path.join(input.agentsRoot, input.name),
+		contents: file.content
+	}).pipe(Effect.as("written"), Effect.orElseSucceed(() => "failed"));
+});
+const removeAgentDefinition = Effect.fn("agentDefinitionFiles.remove")(function* (input) {
+	if (!input.name.endsWith(".md")) return;
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	yield* fileSystem.remove(path.join(input.agentsRoot, input.name), { force: true });
+});
+//#endregion
 //#region src/sync/HubLink.ts
 /**
 * Where this server's hub is, what it authenticates with, and whether it syncs
@@ -16802,178 +17140,6 @@ const removeMcpRegistration = Effect.fn("mcpRegistrationFiles.remove")(function*
 	yield* fileSystem.remove(path.join(input.registrationsRoot, input.name), { force: true });
 });
 //#endregion
-//#region src/sync/skillDirectory.ts
-/**
-* Reading and writing skill directories on disk.
-*
-* Kept apart from the sync itself so the filesystem shape has its own tests,
-* and so the rules about what is refusable — binaries, oversized files, deep
-* trees — live in one place rather than being rediscovered at each call site.
-*
-* @module sync/skillDirectory
-*/
-/** Bounded so a stray symlink or a vendored `node_modules` cannot walk forever. */
-const MAX_SKILL_DEPTH = 4;
-/**
-* Entries that are never part of a skill, skipped rather than refused.
-*
-* The distinction matters. Refusing an asset because it cannot be represented
-* faithfully is right — a half-materialized skill loads and misbehaves. But a
-* `.DS_Store` is not part of the skill at all, and macOS drops one into any
-* directory that has been opened in Finder, so refusing on its account rejects
-* a perfectly good skill for a reason its author cannot see.
-*
-* These could not sync in any case: `AgentAssetFilePath` rejects a leading dot,
-* so a dotfile has no representable path even if it were text.
-*/
-const IGNORED_ENTRIES = /* @__PURE__ */ new Set([
-	".DS_Store",
-	"Thumbs.db",
-	".git",
-	".svn",
-	".hg",
-	"node_modules",
-	"__pycache__",
-	".venv",
-	".pytest_cache",
-	".ruff_cache",
-	".mypy_cache"
-]);
-/**
-* Anything else with a leading dot is skipped too — an editor's `.idea`, a
-* `.gitignore` that belongs to the checkout rather than the skill. The rule is
-* the same one the path schema already enforces, applied earlier so it reads as
-* "not part of the skill" instead of "this skill is broken".
-*/
-const isIgnoredEntry = (entry) => IGNORED_ENTRIES.has(entry) || entry.startsWith(".");
-/**
-* A file is binary if decoding it yields a NUL.
-*
-* Cheap, and right for what is being asked: the question is not "is this valid
-* UTF-8" but "can this round-trip through a JSON text column", and a NUL is
-* what actually breaks that on the way back out of SQLite.
-*/
-const looksBinary$1 = (content) => content.includes("\0");
-/**
-* Read one directory as an asset's files, or say why it cannot be one.
-*
-* Exported because memory's `global-memory/` is the same shape by a different
-* name: a directory whose whole contents are the asset. Sharing this keeps the
-* refusal rules — depth, file count, binaries, size — identical for both,
-* rather than letting a second copy drift into accepting what the first
-* rejects.
-*/
-const readSkillFiles = Effect.fn("skillDirectory.readSkillFiles")(function* (root) {
-	const fileSystem = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const files = [];
-	const walk = Effect.fn("skillDirectory.walk")(function* (directory, prefix, depth) {
-		if (depth > MAX_SKILL_DEPTH) return "too-deep";
-		const entries = yield* fileSystem.readDirectory(directory).pipe(Effect.orElseSucceed(() => []));
-		for (const entry of [...entries].sort()) {
-			if (isIgnoredEntry(entry)) continue;
-			const absolute = path.join(directory, entry);
-			const relative = prefix === "" ? entry : `${prefix}/${entry}`;
-			const info = yield* fileSystem.stat(absolute).pipe(Effect.orElseSucceed(() => void 0));
-			if (info === void 0) return "unreadable";
-			if (info.type === "Directory") {
-				const nested = yield* walk(absolute, relative, depth + 1);
-				if (nested !== null) return nested;
-				continue;
-			}
-			if (info.type !== "File") continue;
-			if (files.length >= 512) return "too-many-files";
-			const content = yield* fileSystem.readFileString(absolute).pipe(Effect.orElseSucceed(() => void 0));
-			if (content === void 0) return "unreadable";
-			if (looksBinary$1(content)) return "binary-file";
-			if (content.length > 524288) return "file-too-large";
-			files.push({
-				path: relative,
-				content
-			});
-		}
-		return null;
-	});
-	const refusal = yield* walk(root, "", 1);
-	if (refusal !== null) return { refusal };
-	if (agentAssetTotalBytes(files) > 4194304) return { refusal: "asset-too-large" };
-	return { files };
-});
-/**
-* Read every skill directory under a user-scope `skills/` root.
-*
-* A directory with no `SKILL.md` is not a skill and is skipped silently —
-* Claude Code would ignore it too, so reporting it would be noise about
-* something that was never a skill in the first place.
-*/
-const readSkillDirectory = Effect.fn("skillDirectory.readSkillDirectory")(function* (skillsRoot) {
-	const fileSystem = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const entries = yield* fileSystem.readDirectory(skillsRoot).pipe(Effect.orElseSucceed(() => []));
-	const skills = [];
-	const refused = [];
-	for (const entry of [...entries].sort()) {
-		if (isIgnoredEntry(entry)) continue;
-		const directory = path.join(skillsRoot, entry);
-		if ((yield* fileSystem.stat(directory).pipe(Effect.orElseSucceed(() => void 0)))?.type !== "Directory") continue;
-		if (!(yield* fileSystem.exists(path.join(directory, "SKILL.md")).pipe(Effect.orElseSucceed(() => false)))) continue;
-		const read = yield* readSkillFiles(directory);
-		if ("refusal" in read) {
-			refused.push({
-				name: entry,
-				reason: read.refusal
-			});
-			continue;
-		}
-		skills.push({
-			name: entry,
-			files: read.files
-		});
-	}
-	return {
-		skills,
-		refused
-	};
-});
-/**
-* Replace a skill directory with exactly the asset's files.
-*
-* Written to a sibling and then swapped, so a crash mid-write leaves the old
-* skill intact rather than half of the new one. A skill is loaded as a unit and
-* a partially written one is instructions with the middle missing, which an
-* agent will happily follow.
-*/
-const writeSkillDirectory = Effect.fn("skillDirectory.writeSkillDirectory")(function* (input) {
-	const fileSystem = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const target = path.join(input.skillsRoot, input.name);
-	const staging = path.join(input.skillsRoot, `.${input.name}.p4code-staging`);
-	yield* fileSystem.makeDirectory(input.skillsRoot, { recursive: true });
-	yield* fileSystem.remove(staging, {
-		recursive: true,
-		force: true
-	});
-	yield* fileSystem.makeDirectory(staging, { recursive: true });
-	for (const file of input.files) {
-		const destination = path.join(staging, file.path);
-		yield* fileSystem.makeDirectory(path.dirname(destination), { recursive: true });
-		yield* fileSystem.writeFileString(destination, file.content);
-	}
-	yield* fileSystem.remove(target, {
-		recursive: true,
-		force: true
-	});
-	yield* fileSystem.rename(staging, target);
-});
-const removeSkillDirectory = Effect.fn("skillDirectory.removeSkillDirectory")(function* (input) {
-	const fileSystem = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	yield* fileSystem.remove(path.join(input.skillsRoot, input.name), {
-		recursive: true,
-		force: true
-	});
-});
-//#endregion
 //#region src/sync/memoryFile.ts
 /**
 * Reading and writing user-scope memory files.
@@ -17254,12 +17420,20 @@ const PROCEED = { _tag: "proceed" };
 * - A skill without `SKILL.md` would be invisible to discovery: the picker
 *   skips directories without one, so the create would look like it silently
 *   failed. Refused with the reason instead.
+* - An agent definition is one markdown file whose name is the asset's own, and
+*   anything else is invisible in the same way — the provider reads `.md` in
+*   that directory and nothing else. The frontmatter check is the writer's,
+*   because it needs a YAML parse this module deliberately does without.
 * - An existing local name is never overwritten. Create means create; editing
 *   is a different operation with a different surface.
 */
 function decideCreateLocal(input) {
 	if (input.asset.kind === "mcp") return refuse("refused", "MCP registrations are created through mcp.save, not as files.");
 	if (input.asset.kind === "skill" && !input.asset.files.some((file) => file.path === "SKILL.md")) return refuse("refused", "A skill needs a SKILL.md at its root; without one, discovery skips the directory.");
+	if (input.asset.kind === "agent") {
+		const [file, ...rest] = input.asset.files;
+		if (!input.asset.name.endsWith(".md") || rest.length > 0 || file?.path !== input.asset.name) return refuse("refused", "An agent definition is a single markdown file named after the asset, for example 'reviewer.md' holding 'reviewer.md'.");
+	}
 	if (input.localNames.has(input.asset.name)) return refuse("exists", `An asset named '${input.asset.name}' already exists locally.`);
 	return PROCEED;
 }
@@ -17502,6 +17676,22 @@ const make$59 = Effect.gen(function* () {
 				name
 			}).pipe(Effect.ignore)
 		},
+		{
+			kind: "agent",
+			resolveRoot: Effect.gen(function* () {
+				return yield* resolveClaudeUserAgentsDir(yield* claudeHome());
+			}),
+			read: (root) => readAgentDefinitions(root),
+			write: ({ root, name, files }) => writeAgentDefinition({
+				agentsRoot: root,
+				name,
+				files
+			}),
+			remove: ({ root, name }) => removeAgentDefinition({
+				agentsRoot: root,
+				name
+			}).pipe(Effect.ignore)
+		},
 		{
 			kind: "mcp",
 			resolveRoot: Effect.succeed(path.join(config.stateDir, "mcp")),
@@ -18143,6 +18333,262 @@ const make$59 = Effect.gen(function* () {
 });
 const layer$54 = Layer.effect(AssetSync, make$59);
 //#endregion
+//#region src/provider/CompressPrompts.ts
+/**
+* Caveman-style response compression rulesets, adapted from the caveman
+* plugin's SKILL.md. Pre-baked per level so injection is a lookup, not a
+* runtime template. Applies to assistant prose only: code blocks, commits,
+* PRs, error strings, and safety-critical text stay uncompressed.
+*/
+const COMPRESS_SHARED_RULES = `Respond terse. All technical substance stays. Only fluff dies.
+
+## Persistence
+
+Active every response. No revert after many turns. No filler drift. Still active if unsure.
+
+## Rules
+
+Drop filler (just/really/basically/actually/simply), pleasantries (sure/certainly/of course/happy to), hedging. Short synonyms (big not extensive, fix not "implement a solution for"). No decorative tables/emoji, no dumping long raw error logs unless asked - quote shortest decisive line. Standard well-known tech acronyms OK (DB/API/HTTP); never invent new abbreviations (cfg/impl/req/res/fn) - tokenizers split them same as the full word: zero tokens saved, reader still decodes. No causal arrows (->) in prose. Technical terms exact. Code blocks unchanged. Errors quoted exact.
+
+Never drop not/never/no/only/except: flipping the meaning costs more than any token saved. Numbers and units exact.
+
+Tool calls: fire direct. No plan, no progress note between calls, never announce the next call. If the harness asks for a short lead-in before tool calls, write that one line and nothing more. Otherwise text before a call only to clarify, warn about a security or irreversible action, or resolve ambiguity.
+
+Preserve the user's dominant language: reply in the language the user writes, whatever language the examples or the surrounding context use. Compress the style, not the language. Every emitted line in that language, lead-in lines included, not just the final reply. Always keep technical terms, code, API names, CLI commands, commit-type keywords (feat/fix/...), and exact error strings verbatim unless the user explicitly asks for translation.
+
+Dropping articles applies to article languages only. Where small markers carry case or role (particles, postpositions), keep them: grammar, not filler. Compress politeness and filler instead.
+
+No self-reference. Never name or announce the style. No compressed answer plus normal recap - compressed output only. Exception: user explicitly asks what the mode is.
+
+## Auto-Clarity
+
+Drop compression and write normally when:
+- Security warnings
+- Irreversible action confirmations
+- Multi-step sequences where fragment order or omitted conjunctions risk misread
+- Compression itself creates technical ambiguity (e.g. "migrate table drop column backup first" - order unclear without articles and conjunctions)
+- User asks to clarify or repeats a question
+
+Resume compression after the clear part is done. The example below shows the format only: write the warning in the session's language, not the example's.
+
+Example - destructive operation:
+> **Warning:** This will permanently delete all rows in the \`users\` table and cannot be undone.
+> \`\`\`sql
+> DROP TABLE users;
+> \`\`\`
+> Compression resumes. Verify a backup exists first.
+
+## Boundaries
+
+Anything persisted outside the chat: write normal, uncompressed prose. Covers code, code comments, commit messages, PR and issue text, docs, memory files, and messages to third parties.`;
+const COMPRESS_RULESETS = {
+	lite: `## Response compression: lite
+
+${COMPRESS_SHARED_RULES}
+
+## Intensity: lite
+
+No filler or hedging. Keep articles and full sentences. Professional but tight.
+
+Example - "Why does my React component re-render?"
+"Your component re-renders because you create a new object reference each render. Wrap it in \`useMemo\`."
+
+Example - "Explain database connection pooling."
+"Connection pooling reuses open connections instead of creating a new one per request. Avoids repeated handshake overhead."`,
+	full: `## Response compression: full
+
+${COMPRESS_SHARED_RULES}
+
+## Intensity: full
+
+Drop articles (a/an/the), fragments OK, short synonyms. Pattern: [thing] [action] [reason]. [next step].
+
+Not: "Sure! I'd be happy to help you with that. The issue you're experiencing is likely caused by..."
+Yes: "Bug in auth middleware. Token expiry check use \`<\` not \`<=\`. Fix:"
+
+Example - "Why does my React component re-render?"
+"New object ref each render. Inline object prop = new ref = re-render. Wrap in \`useMemo\`."
+
+Example - "Explain database connection pooling."
+"Pool reuses open DB connections. No new connection per request. Skips handshake overhead."`,
+	ultra: `## Response compression: ultra
+
+${COMPRESS_SHARED_RULES}
+
+## Intensity: ultra
+
+Drop articles, fragments OK, short synonyms. Also strip conjunctions when cause-then-effect stays unambiguous. One word when one word is enough. State each fact once. Still no invented abbreviations (cfg/impl/req/res/fn/auth) and still no arrows (X -> Y): both measure as zero token saving and cost decode clarity. Code symbols, function names, API names, error strings: never touch.
+
+Example - "Why does my React component re-render?"
+"Inline object prop, new ref, re-render. \`useMemo\`."
+
+Example - "Explain database connection pooling."
+"Pool reuses open DB connections. No per-request handshake."`
+};
+const COMPRESS_TURN_REMINDERS = {
+	lite: "[response style: compressed lite - no filler/hedging, full sentences; keep negations and numbers exact; code/commits/security text normal]",
+	full: "[response style: compressed full - terse fragments, drop articles/filler; keep negations and numbers exact; code/commits/security text normal]",
+	ultra: "[response style: compressed ultra - maximum terseness, one word when enough; keep negations and numbers exact; code/commits/security text normal]"
+};
+function compressRulesetFor(mode) {
+	return mode === "off" ? void 0 : COMPRESS_RULESETS[mode];
+}
+function compressTurnReminderFor(mode) {
+	return mode === "off" ? void 0 : COMPRESS_TURN_REMINDERS[mode];
+}
+//#endregion
+//#region src/sync/agentPresets.ts
+/**
+* The row ceiling both presets impose.
+*
+* A cap rather than "be brief": an uncapped list is how a subagent turns a
+* bounded answer back into a page, and a number is the only form of that
+* instruction a model cannot negotiate with.
+*/
+const PRESET_MAX_RESULT_ROWS = 20;
+/**
+* Named `p4-*` on purpose.
+*
+* The directory is shared with whatever the user has written by hand, and
+* installing a preset must never quietly replace their own `reviewer`. The
+* prefix also makes provenance obvious in the settings list, where every kind
+* of agent definition appears in one column.
+*/
+const PRESET_NAME_PREFIX = "p4-";
+/**
+* What every preset says about what it is handed.
+*
+* Shared because it is the same contract whatever the subagent does: no
+* inherited history, exact paths, and a refusal instead of a guess. The last
+* clause is the one that earns its place — a subagent that invents the missing
+* half of an under-specified prompt returns something confident and wrong,
+* which costs more than the turn that asked for it.
+*/
+const INPUT_CONTRACT = `## What you are given
+
+You inherit no session history. The prompt is the whole of what you know: one
+request, plus whatever exact paths the orchestrator has already established.
+Treat those paths as authoritative and start from them rather than searching for
+them again.
+
+What the prompt does not say, you do not assume. If it names no request, or
+names a path that is not there, answer with the BLOCKED line below. Guessing at
+the missing half of a request produces an answer that reads as confident and is
+not checkable, which is worse than no answer.`;
+/**
+* What every preset says about the answer.
+*
+* The two sentinels matter as much as the table. Without `NONE` a clean run
+* comes back as a paragraph explaining that everything looked fine; without
+* `BLOCKED` an under-specified request comes back as an apology. Both are the
+* narrative this contract exists to remove, and both are cheap to name.
+*/
+const outputContract = (row, extra) => [
+	"## What you return",
+	"",
+	"Your final message is the result. It is the table and nothing else: no",
+	"preamble, no restatement of the request, no summary underneath it.",
+	"",
+	`One row per finding, at most ${PRESET_MAX_RESULT_ROWS}, most important first:`,
+	"",
+	`    ${row}`,
+	"",
+	"Nothing to report: the single word NONE.",
+	"Request insufficient: BLOCKED - <what is missing>, on one line.",
+	"",
+	"Paths are repository-relative and carry a line number. A row without one is",
+	"a row you have not verified: open the file and get it.",
+	...extra
+].join("\n");
+/**
+* Assemble one definition.
+*
+* The compression ruleset goes last so the contract above it is read first.
+* Both are instructions to the same model and neither overrides the other:
+* the contract fixes the shape, the ruleset fixes the prose inside it.
+*/
+const buildPreset = (input) => {
+	const name = `${PRESET_NAME_PREFIX}${input.name}`;
+	const content = [
+		"---",
+		`name: ${name}`,
+		`description: ${JSON.stringify(input.description)}`,
+		`tools: ${input.tools}`,
+		"---",
+		"",
+		input.body.trim(),
+		"",
+		compressRulesetFor("full") ?? "",
+		""
+	].join("\n");
+	const fileName = `${name}.md`;
+	return {
+		name: fileName,
+		summary: input.summary,
+		files: [{
+			path: fileName,
+			content
+		}]
+	};
+};
+/** Every preset, in the order `p4c agents presets` lists them. */
+const AGENT_PRESETS = [buildPreset({
+	name: "investigator",
+	description: "Find where something lives in the codebase. Use when the answer is a set of locations rather than a change. Returns a fixed table of path:line rows and nothing else.",
+	tools: "Read, Grep, Glob, Bash",
+	summary: "Locates code and answers with a path:line table.",
+	body: `You locate code. You do not change it, and you say no more about any location
+than the one clause that explains why it is in the list.
+
+${INPUT_CONTRACT}
+
+${outputContract("path:line - symbol - one clause on why it matters", [
+		"",
+		"Symbol is the function, type or constant the line belongs to, not a paraphrase",
+		"of the line. Where there is genuinely no symbol, name the block: a route table,",
+		"a config literal."
+	])}`
+}), buildPreset({
+	name: "reviewer",
+	description: "Review named files or a diff for defects. Use when the answer is a list of findings rather than a change. Returns a fixed table of path:line findings and nothing else.",
+	tools: "Read, Grep, Glob, Bash",
+	summary: "Reviews named files and answers with a severity-tagged finding table.",
+	body: `You review code you did not write. You do not change it, and you do not report
+what it does well - the orchestrator asked what is wrong, and a list padded with
+approval is a list that has to be re-read to find the three rows that matter.
+
+${INPUT_CONTRACT}
+
+${outputContract("path:line - severity - what is wrong, and what it breaks", [
+		"",
+		"Severity is one of three words:",
+		"",
+		"    bug   - wrong behaviour reachable in ordinary use. Name the input that reaches it.",
+		"    risk  - correct today, and depends on something the code does not state.",
+		"    nit   - style or clarity. Include only when the file is otherwise clean.",
+		"",
+		"A finding you cannot reach with a concrete input is a risk, not a bug. Saying",
+		"so is what keeps the bug rows worth reading."
+	])}`
+})];
+/**
+* Look one up by the name someone typed.
+*
+* Both spellings are accepted - `investigator` and `p4-investigator.md` - because
+* the listing shows the filename and the sentence people write is the bare word,
+* and refusing one of the two would be refusing whichever the person happened to
+* read most recently.
+*/
+const findAgentPreset = (requested) => {
+	const wanted = requested.trim().toLowerCase();
+	if (wanted.length === 0) return void 0;
+	return AGENT_PRESETS.find((preset) => {
+		const fileName = preset.name.toLowerCase();
+		const bare = fileName.slice(3, -3);
+		return wanted === fileName || wanted === bare || wanted === `${PRESET_NAME_PREFIX}${bare}`;
+	});
+};
+//#endregion
 //#region src/cli/assets.ts
 const SyncServicesLive = layer$54.pipe(Layer.provideMerge(layer$55), Layer.provideMerge(layer$56), Layer.provideMerge(layer$60.pipe(Layer.provide(layer$67))), Layer.provideMerge(layer$67), Layer.provideMerge(FetchHttpClient.layer));
 const runWithSync = (flags, run) => Effect.gen(function* () {
@@ -18186,6 +18632,14 @@ const MCP_WORDS = {
 	rootLabel: "MCP",
 	nameDescription: "Registration filename, for example linear.json."
 };
+const AGENT_WORDS = {
+	kind: "agent",
+	command: "agents",
+	singular: "agent definition",
+	plural: "agent definitions",
+	rootLabel: "Agents",
+	nameDescription: "Definition filename, for example p4-reviewer.md."
+};
 const rootFor = (status, kind) => status.roots.find((root) => root.kind === kind)?.path ?? null;
 /**
 * Exported for tests. These two are the only place a wrong report becomes a
@@ -18248,7 +18702,8 @@ const formatReport = (report) => {
 const ALL_WORDS = [
 	SKILL_WORDS,
 	MEMORY_WORDS,
-	MCP_WORDS
+	MCP_WORDS,
+	AGENT_WORDS
 ];
 /**
 * The whole picture, in one page.
@@ -18380,6 +18835,67 @@ const makeAssetCommands = (words) => {
 const skillCommands = makeAssetCommands(SKILL_WORDS);
 const memoryCommands = makeAssetCommands(MEMORY_WORDS);
 const mcpCommands = makeAssetCommands(MCP_WORDS);
+const agentCommands = makeAssetCommands(AGENT_WORDS);
+/**
+* What one install attempt did, in a sentence.
+*
+* Exported for tests: `exists` in particular must never read as success. The
+* whole point of refusing to overwrite is that someone who has edited a preset
+* keeps their edits, and a line saying "installed" would tell them the opposite.
+*/
+const formatPresetInstall = (input) => {
+	if (input.outcome === "created") return `Installed ${input.name}${input.path === null ? "" : ` at ${input.path}`}`;
+	if (input.outcome === "exists") return `Skipped ${input.name}: it already exists here, and installing would overwrite your copy.`;
+	return `Could not install ${input.name}: ${input.detail ?? input.outcome}`;
+};
+/**
+* `p4c agents presets` — what is on offer, before anything is written.
+*
+* Its own command rather than a flag on `install`, because reading the list is
+* what people do first and a listing that requires naming an install target is
+* not a listing.
+*/
+const presetsCommand = Command.make("presets", { ...authLocationFlags }).pipe(Command.withDescription("List the agent definitions p4code ships, without installing any."), Command.withHandler(() => Console.log([
+	...AGENT_PRESETS.map((preset) => `  ${preset.name.padEnd(28)} ${preset.summary}`),
+	"",
+	"Install one with:  p4c agents install <name>"
+].join("\n"))));
+/**
+* Install a shipped definition onto this machine, and only this machine.
+*
+* `createLocal` rather than a hub write, so an installed preset starts out
+* exactly like one written by hand: local, unmanaged, and shared only when
+* something explicitly publishes it. It also means this works with no hub
+* configured, which is when a fresh machine most wants it.
+*/
+const presetInstallCommand = Command.make("install", {
+	...authLocationFlags,
+	name: Argument.string("name").pipe(Argument.withDescription("Preset to install, for example investigator."), Argument.optional),
+	all: Flag.boolean("all").pipe(Flag.withDescription("Install every preset p4code ships."))
+}).pipe(Command.withDescription("Install a p4code agent definition into this machine's agents directory."), Command.withHandler((flags) => runWithSync(flags, ({ sync }) => Effect.gen(function* () {
+	const requested = Option.getOrUndefined(flags.name);
+	if (!flags.all && requested === void 0) return yield* Console.error("Name a preset, or pass --all to install every one.\nSee them with:  p4c agents presets");
+	const chosen = flags.all ? AGENT_PRESETS : (() => {
+		const found = findAgentPreset(requested ?? "");
+		return found === void 0 ? [] : [found];
+	})();
+	if (chosen.length === 0) return yield* Console.error(`No preset named ${requested ?? ""}. See them with:  p4c agents presets`);
+	const lines = [];
+	for (const preset of chosen) {
+		const result = yield* sync.createLocal({
+			kind: AGENT_WORDS.kind,
+			name: preset.name,
+			files: preset.files
+		});
+		lines.push(formatPresetInstall({
+			name: preset.name,
+			outcome: result.outcome,
+			path: result.path,
+			detail: result.detail
+		}));
+	}
+	return yield* Console.log(lines.join("\n"));
+}))));
 const shareAllCommand = Command.make("share-all", { ...authLocationFlags }).pipe(Command.withDescription("Share everything, including new items, automatically. The default."), Command.withHandler((flags) => runWithSync(flags, ({ sync, link }) => Effect.gen(function* () {
 	yield* link.setShareMode("all");
 	yield* Console.log(formatStatus(yield* sync.status));
@@ -18432,6 +18948,23 @@ const mcpCommand = Command.make("mcp", {}).pipe(Command.withDescription("Share M
 	mcpCommands.showCommand,
 	mcpCommands.removeCommand
 ]));
+/**
+* `p4c agents` — the subagent definitions this machine runs.
+*
+* The same six subcommands every kind gets, plus the two that are particular to
+* this one: p4code ships definitions, and a definition is the only place a
+* subagent's input and output contract can be stated.
+*/
+const agentsCommand = Command.make("agents", {}).pipe(Command.withDescription("Share subagent definitions across your machines, and install p4code's."), Command.withSubcommands([
+	agentCommands.statusCommand,
+	agentCommands.syncCommand,
+	agentCommands.publishCommand,
+	agentCommands.unpublishCommand,
+	agentCommands.showCommand,
+	agentCommands.removeCommand,
+	presetsCommand,
+	presetInstallCommand
+]));
 /** Exported for the hub command, which owns `connect`/`disconnect`. */
 const hubLinkCommands = [hubConnectCommand, hubDisconnectCommand];
 //#endregion
@@ -49044,88 +49577,6 @@ function formatAskUserQuestionAnswers(answers) {
 	return formatted;
 }
 //#endregion
-//#region src/provider/CompressPrompts.ts
-/**
-* Caveman-style response compression rulesets, adapted from the caveman
-* plugin's SKILL.md. Pre-baked per level so injection is a lookup, not a
-* runtime template. Applies to assistant prose only: code blocks, commits,
-* PRs, error strings, and safety-critical text stay uncompressed.
-*/
-const COMPRESS_SHARED_RULES = `Respond terse. All technical substance stays. Only fluff dies.
-
-## Persistence
-
-Active every response. No revert after many turns. No filler drift. Still active if unsure.
-
-## Rules
-
-Drop filler (just/really/basically/actually/simply), pleasantries (sure/certainly/of course/happy to), hedging. Short synonyms (big not extensive, fix not "implement a solution for"). No tool-call narration, no decorative tables/emoji, no dumping long raw error logs unless asked - quote shortest decisive line. Standard well-known tech acronyms OK (DB/API/HTTP); never invent new abbreviations (cfg/impl/req/res/fn) - tokenizers split them same as the full word: zero tokens saved, reader still decodes. No causal arrows (->) in prose. Technical terms exact. Code blocks unchanged. Errors quoted exact.
-
-Preserve the user's dominant language: compress the style, not the language. Always keep technical terms, code, API names, CLI commands, commit-type keywords (feat/fix/...), and exact error strings verbatim unless the user explicitly asks for translation.
-
-No self-reference. Never name or announce the style. No compressed answer plus normal recap - compressed output only. Exception: user explicitly asks what the mode is.
-
-## Auto-Clarity
-
-Drop compression and write normally when:
-- Security warnings
-- Irreversible action confirmations
-- Multi-step sequences where fragment order or omitted conjunctions risk misread
-- Compression itself creates technical ambiguity
-- User asks to clarify or repeats a question
-
-Resume compression after the clear part is done.
-
-## Boundaries
-
-Code, commit messages, and PR descriptions: write normal, uncompressed.`;
-const COMPRESS_RULESETS = {
-	lite: `## Response compression: lite
-
-${COMPRESS_SHARED_RULES}
-
-## Intensity: lite
-
-No filler or hedging. Keep articles and full sentences. Professional but tight.
-
-Example - "Why does my React component re-render?"
-"Your component re-renders because you create a new object reference each render. Wrap it in \`useMemo\`."`,
-	full: `## Response compression: full
-
-${COMPRESS_SHARED_RULES}
-
-## Intensity: full
-
-Drop articles (a/an/the), fragments OK, short synonyms. Pattern: [thing] [action] [reason]. [next step].
-
-Not: "Sure! I'd be happy to help you with that. The issue you're experiencing is likely caused by..."
-Yes: "Bug in auth middleware. Token expiry check use \`<\` not \`<=\`. Fix:"
-
-Example - "Why does my React component re-render?"
-"New object ref each render. Inline object prop = new ref = re-render. Wrap in \`useMemo\`."`,
-	ultra: `## Response compression: ultra
-
-${COMPRESS_SHARED_RULES}
-
-## Intensity: ultra
-
-Drop articles, fragments OK, short synonyms. Also strip conjunctions when cause-then-effect stays unambiguous. One word when one word is enough. State each fact once. Code symbols, function names, API names, error strings: never touch.
-
-Example - "Why does my React component re-render?"
-"Inline object prop, new ref, re-render. \`useMemo\`."`
-};
-const COMPRESS_TURN_REMINDERS = {
-	lite: "[response style: compressed lite - no filler/hedging, full sentences; code/commits/security text normal]",
-	full: "[response style: compressed full - terse fragments, drop articles/filler; code/commits/security text normal]",
-	ultra: "[response style: compressed ultra - maximum terseness, one word when enough; code/commits/security text normal]"
-};
-function compressRulesetFor(mode) {
-	return mode === "off" ? void 0 : COMPRESS_RULESETS[mode];
-}
-function compressTurnReminderFor(mode) {
-	return mode === "off" ? void 0 : COMPRESS_TURN_REMINDERS[mode];
-}
-//#endregion
 //#region src/provider/Layers/ClaudeAdapter.ts
 /**
 * ClaudeAdapterLive - Scoped live implementation for the Claude Agent provider adapter.
@@ -49687,6 +50138,20 @@ const SUPPORTED_CLAUDE_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
 /** Emitted by the CLI but absent from the SDK's `SDKMessage` union. */
 const UNTYPED_COMMAND_LIFECYCLE_MESSAGE = "command_lifecycle";
 const NARRATE_BEFORE_TOOLS_PROMPT = "Before your first tool call in a turn, write one short sentence saying what you are about to do. Keep it to a single line and skip it when you are answering without tools.";
+/**
+* Said whichever way the setting is set, and said as an override.
+*
+* The preset system prompt this adapter requests already carries an
+* instruction not to spawn subagents unless the user asked — and a preset is
+* taken wholesale, so there is no version of it with that line removed. An
+* append that merely stayed silent when subagents are allowed would therefore
+* leave the restriction standing, which is the one outcome the setting exists
+* to change. Both texts name the earlier instruction they replace, because a
+* later instruction that does not acknowledge the conflict reads as an
+* accident rather than a decision.
+*/
+const SUBAGENTS_ALLOWED_PROMPT = "You may spawn subagents with the Task tool whenever it helps, without asking the user first. This overrides any earlier instruction to use subagents only when they are requested. Prefer one for bounded search or review work whose result is much smaller than the reading it takes to produce; do the work inline when the answer is a single file or a single edit.";
+const SUBAGENTS_ON_REQUEST_PROMPT = "Do not spawn subagents with the Task tool unless the user asks for one. This overrides any earlier instruction permitting them on your own initiative. Do the work inline instead, and say so if it would have been better delegated.";
 const CLAUDE_SETTING_SOURCES = [
 	"user",
 	"project",
@@ -49915,6 +50380,25 @@ function sdkNativeMethod(message) {
 *   would only duplicate a refresh that has already happened.
 */
 const CONSUMED_UNDECLARED_SYSTEM_SUBTYPES = /* @__PURE__ */ new Set(["background_tasks_changed", "vcs_state_changed"]);
+/**
+* Another undeclared-but-real subtype, emitted once the CLI has pushed the
+* turn's changes to a hosting provider:
+* `{provider: "github", url: "https://github.com/org/repo/pull/96",
+*   repo: "org/repo", identifier: "96"}`. Mapped to `code.published` so the
+* work log links the pull request instead of logging an unknown-subtype
+* warning.
+*/
+const CODE_CHANGE_PUBLISHED_SUBTYPE = "code_change_published";
+function codePublishedPayloadFromSdkMessage(message) {
+	const record = message;
+	if (typeof record.url !== "string" || record.url.length === 0) return;
+	return {
+		hostingProvider: typeof record.provider === "string" && record.provider.length > 0 ? record.provider : "unknown",
+		url: record.url,
+		...typeof record.repo === "string" && record.repo.length > 0 ? { repo: record.repo } : {},
+		...typeof record.identifier === "string" && record.identifier.length > 0 ? { identifier: record.identifier } : {}
+	};
+}
 const SDK_MESSAGE_NOISE_KEYS = /* @__PURE__ */ new Set([
 	"type",
 	"subtype",
@@ -50886,6 +51370,17 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			}
 		};
 		if (CONSUMED_UNDECLARED_SYSTEM_SUBTYPES.has(message.subtype)) return;
+		if (message.subtype === CODE_CHANGE_PUBLISHED_SUBTYPE) {
+			const published = codePublishedPayloadFromSdkMessage(message);
+			if (published) {
+				yield* offerRuntimeEvent({
+					...base,
+					type: "code.published",
+					payload: published
+				});
+				return;
+			}
+		}
 		switch (message.subtype) {
 			case "init":
 				yield* offerRuntimeEvent({
@@ -51520,8 +52015,13 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		const mcpSession = readMcpProviderSession(input.threadId);
 		const externalMcpServers = options?.resolveMcpServers === void 0 ? {} : yield* options.resolveMcpServers;
 		const narrateBeforeTools = options?.resolveToolCallNarration === void 0 ? DEFAULT_SERVER_SETTINGS.enableToolCallNarration : yield* options.resolveToolCallNarration;
+		const unpromptedSubagents = options?.resolveUnpromptedSubagents === void 0 ? DEFAULT_SERVER_SETTINGS.enableUnpromptedSubagents : yield* options.resolveUnpromptedSubagents;
 		const compressRuleset = compressRulesetFor(input.compressMode ?? "off");
-		const systemPromptAppend = [...narrateBeforeTools ? [NARRATE_BEFORE_TOOLS_PROMPT] : [], ...compressRuleset !== void 0 ? [compressRuleset] : []].join("\n\n");
+		const systemPromptAppend = [
+			...narrateBeforeTools ? [NARRATE_BEFORE_TOOLS_PROMPT] : [],
+			unpromptedSubagents ? SUBAGENTS_ALLOWED_PROMPT : SUBAGENTS_ON_REQUEST_PROMPT,
+			...compressRuleset !== void 0 ? [compressRuleset] : []
+		].join("\n\n");
 		const queryOptions = {
 			...input.cwd ? { cwd: input.cwd } : {},
 			...apiModelId ? { model: apiModelId } : {},
@@ -51983,12 +52483,14 @@ const ClaudeDriver = {
 		const mcpRegistry = yield* McpRegistry;
 		const resolveDisabledSkills = serverSettings.getSettings.pipe(Effect.map((settings) => settings.disabledSkills), Effect.orElseSucceed(() => []));
 		const resolveToolCallNarration = serverSettings.getSettings.pipe(Effect.map((settings) => settings.enableToolCallNarration), Effect.orElseSucceed(() => DEFAULT_SERVER_SETTINGS.enableToolCallNarration));
+		const resolveUnpromptedSubagents = serverSettings.getSettings.pipe(Effect.map((settings) => settings.enableUnpromptedSubagents), Effect.orElseSucceed(() => DEFAULT_SERVER_SETTINGS.enableUnpromptedSubagents));
 		const adapter = yield* makeClaudeAdapter(effectiveConfig, {
 			instanceId,
 			environment: processEnv,
 			resolveMcpServers: mcpRegistry.resolveForSession,
 			resolveDisabledSkills,
 			resolveToolCallNarration,
+			resolveUnpromptedSubagents,
 			...eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {}
 		});
 		const textGeneration = yield* makeClaudeTextGeneration(effectiveConfig, processEnv);
@@ -85633,6 +86135,24 @@ function runtimeEventToActivities(event, taskTitle) {
 			turnId: toTurnId$1(event.turnId) ?? null,
 			...maybeSequence
 		}];
+		case "code.published": {
+			const label = event.payload.repo ? event.payload.identifier ? `${event.payload.repo}#${event.payload.identifier}` : event.payload.repo : event.payload.url;
+			return [{
+				id: event.eventId,
+				createdAt: event.createdAt,
+				tone: "info",
+				kind: "code.published",
+				summary: `Published ${label}`,
+				payload: {
+					hostingProvider: event.payload.hostingProvider,
+					url: event.payload.url,
+					...event.payload.repo ? { repo: event.payload.repo } : {},
+					...event.payload.identifier ? { identifier: event.payload.identifier } : {}
+				},
+				turnId: toTurnId$1(event.turnId) ?? null,
+				...maybeSequence
+			}];
+		}
 		case "turn.plan.updated": return [{
 			id: event.eventId,
 			createdAt: event.createdAt,
@@ -88764,6 +89284,7 @@ const reportUpdateAvailable = Effect.gen(function* () {
 const makeCli = () => Command.make("p4c", { ...sharedServerCommandFlags }).pipe(Command.withDescription("Run the P4Code server."), Command.withHandler((flags) => runServerCommand(flags)), Command.withSubcommands([
 	startCommand,
 	serveCommand,
+	agentsCommand,
 	authCommand,
 	hubCommand,
 	mcpCommand,