one-code-extension 0.5.0 → 0.6.0

package/extensions/skill/invoke.ts

@@ -143,10 +143,6 @@ export function missingArgumentsNote(argumentHint: string): { before: string; af
 	};
 }
 
-/** Fast pre-check before the regex walk; also the marker `redactOffSkillText` scans for. */
-const SKILL_BLOCK_START = '<skill name="';
-const SKILL_BLOCK_RE = /<skill name="([^"]+)"[^>]*>[\s\S]*?<\/skill>/g;
-
 /**
  * The hidden message a `/skill:` command is delivered as. `details.input` is
  * the text the user typed, so an extension that saw that text at `input` (the
@@ -160,69 +156,6 @@ export interface SkillInvocationDetails {
 	input?: string;
 }
 
-export const offSkillNotice = (name: string): string =>
-	`[Skill "${name}" is turned off — its instructions were removed. The user can re-enable it from /skills or /plugins.]`;
-
-/**
- * Replace every `<skill>` block belonging to a turned-off skill with a short
- * refusal notice. Returns the rewritten text, or undefined when nothing
- * needed redacting (so callers keep the original object untouched).
- *
- * This is the fail-closed backstop behind the `input`-hook interception:
- * pi's `steer()`/`followUp()` expand `/skill:<name>` natively WITHOUT firing
- * the `input` event (queued interactive messages after the first, RPC
- * steer/followUp), so an off skill's instructions can land in the session
- * history. Redacting on the `context` hook strips them from every outgoing
- * request — the session file keeps the original bytes, and the rewrite is
- * deterministic for a fixed override state, so the request prefix stays
- * byte-stable across turns (prompt-cache friendly).
- */
-export function redactOffSkillText(text: string, isOff: (name: string) => boolean): string | undefined {
-	if (!text.includes(SKILL_BLOCK_START)) return undefined;
-	let changed = false;
-	const redacted = text.replace(SKILL_BLOCK_RE, (block, name: string) => {
-		if (!isOff(name)) return block;
-		changed = true;
-		return offSkillNotice(name);
-	});
-	return changed ? redacted : undefined;
-}
-
-/**
- * Apply redactOffSkillText across a request's messages (user and custom roles,
- * string or text-block content). Returns a rewritten copy, or undefined when
- * no message needed redacting — callers must then keep the original array so
- * untouched requests stay byte-identical.
- */
-export function redactOffSkillMessages<M extends { role: string; content?: unknown }>(
-	messages: readonly M[],
-	isOff: (name: string) => boolean,
-): M[] | undefined {
-	let changed = false;
-	const out = messages.map((message) => {
-		if (message.role !== "user" && message.role !== "custom") return message;
-		if (typeof message.content === "string") {
-			const redacted = redactOffSkillText(message.content, isOff);
-			if (redacted === undefined) return message;
-			changed = true;
-			return { ...message, content: redacted };
-		}
-		if (!Array.isArray(message.content)) return message;
-		let blockChanged = false;
-		const blocks = message.content.map((block: { type?: string; text?: string }) => {
-			if (block?.type !== "text" || typeof block.text !== "string") return block;
-			const redacted = redactOffSkillText(block.text, isOff);
-			if (redacted === undefined) return block;
-			blockChanged = true;
-			return { ...block, text: redacted };
-		});
-		if (!blockChanged) return message;
-		changed = true;
-		return { ...message, content: blocks };
-	});
-	return changed ? out : undefined;
-}
-
 // ---------------------------------------------------------------------------
 // Bare `/<skill>` commands (Claude Code's invocation shape)
 

package/extensions/subagents/agents.ts

@@ -14,7 +14,7 @@
  * Subdirectories are searched recursively.
  */
 
-import { readdirSync, readFileSync, statSync } from "node:fs";
+import { readdirSync, readFileSync, type Stats, statSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseFrontmatterLoosely } from "../lib/frontmatter.ts";
@@ -42,32 +42,54 @@ export interface AgentDefinition {
 	source: string;
 }
 
-function collectMarkdownFiles(dir: string, out: string[] = []): string[] {
+/** Visit every `.md` file under `dir`, at any depth, with its stats. */
+function walkMarkdownFiles(dir: string, visit: (path: string, stats: Stats) => void): void {
 	let entries: string[];
 	try {
 		entries = readdirSync(dir);
 	} catch {
-		return out; // missing or unreadable directory: nothing to discover
+		return; // missing or unreadable directory: nothing to discover
 	}
 	for (const entry of entries) {
 		const full = join(dir, entry);
 		// A dangling symlink or an unreadable entry must not take the whole
 		// catalog (and every Agent call) down with it — skip it (review L1).
-		let isDirectory: boolean;
+		let stats: Stats;
 		try {
-			isDirectory = statSync(full).isDirectory();
+			stats = statSync(full);
 		} catch {
 			continue;
 		}
-		if (isDirectory) {
-			collectMarkdownFiles(full, out);
+		if (stats.isDirectory()) {
+			walkMarkdownFiles(full, visit);
 		} else if (entry.endsWith(".md")) {
-			out.push(full);
+			visit(full, stats);
 		}
 	}
+}
+
+function collectMarkdownFiles(dir: string): string[] {
+	const out: string[] = [];
+	walkMarkdownFiles(dir, (path) => out.push(path));
 	return out;
 }
 
+/**
+ * A stamp of the agent files `discoverAgents` would read from these sources:
+ * each source, then each file's path, times and size. It changes when a file
+ * is added, removed, renamed or written, so a catalog built from the sources
+ * can be reused while the stamp holds, without reading or parsing any file.
+ */
+export function agentSourcesStamp(sources: Array<string | AgentSource>): string {
+	const parts: string[] = [];
+	for (const source of sources) {
+		const { dir, namespace } = typeof source === "string" ? { dir: source, namespace: undefined } : source;
+		parts.push(`${namespace ?? ""}@${dir}`);
+		walkMarkdownFiles(dir, (path, stats) => parts.push(`${path}:${stats.mtimeMs}:${stats.ctimeMs}:${stats.size}`));
+	}
+	return parts.join("\n");
+}
+
 /**
  * Split one frontmatter tool string the way Claude Code does: on commas and
  * spaces, except inside a rule's parentheses, so `Bash(git push:*), Write` is

package/extensions/subagents/fork-cache.ts

@@ -26,10 +26,13 @@
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { DEFER_CHANNEL } from "../lib/deferred.ts";
-import { type AffinityModel, affinityHeaders, captureMatches, forkOutputRoom, forkRequestPayload, MIN_REPLAY_OUTPUT_TOKENS, type RequestCapture, toolNames, uncoveredMessages } from "../lib/request-replay.ts";
+import { type AffinityModel, affinityHeaders, captureMatches, forkOutputRoom, forkRequestPayload, forkBaselineNames, MIN_REPLAY_OUTPUT_TOKENS, type RequestCapture, uncoveredMessages } from "../lib/request-replay.ts";
 
 type ModelRef = { api?: string; provider?: string; id?: string };
 
+/** The APIs whose fork splice (`forkRequestPayload`) handles the body's shape. */
+const SPLICED_FORK_APIS: ReadonlySet<string> = new Set(["anthropic-messages", "openai-completions", "openai-responses", "azure-openai-responses", "openai-codex-responses"]);
+
 export function forkCacheExtension(capture: RequestCapture) {
 	return (pi: ExtensionAPI) => {
 		// The fork advertises the parent's tools, where SendMessage is deferred
@@ -46,7 +49,10 @@ export function forkCacheExtension(capture: RequestCapture) {
 		pi.on("context_with_system", (event, ctx) => {
 			shaped = false;
 			const covers = capture.covers;
-			if (!covers || !captureMatches(capture, ctx.model as ModelRef | undefined)) return undefined;
+			// Bedrock and Google nest their tools and need joined turns and the
+			// fork's own abort signal, which the fork splice does not handle: their
+			// forks go out whole instead.
+			if (!covers || !SPLICED_FORK_APIS.has(capture.api) || !captureMatches(capture, ctx.model as ModelRef | undefined)) return undefined;
 			const tail = uncoveredMessages(event.messages as { role: string; timestamp?: number }[], covers);
 			if (!tail) return undefined;
 			// Too little output room left after the prefix: send the fork whole
@@ -69,7 +75,7 @@ export function forkCacheExtension(capture: RequestCapture) {
 			if (!shaped || !captureMatches(capture, ctx.model as ModelRef | undefined)) return undefined;
 			shaped = false;
 			const payload = event.payload as Record<string, unknown>;
-			baseline ??= new Set(toolNames(payload.tools));
+			baseline ??= forkBaselineNames(payload, capture.api);
 			return forkRequestPayload(capture, payload, baseline);
 		});
 	};