@p4code/cli 0.1.23 → 0.1.25

package/dist/bin.mjs

@@ -236,7 +236,7 @@ const make$76 = () => {
 const layer$72 = Layer.sync(NetService, make$76);
 //#endregion
 //#region package.json
-var version = "0.1.23";
+var version = "0.1.25";
 //#endregion
 //#region src/config.ts
 /**
@@ -5035,6 +5035,13 @@ const ThreadTokenUsageSnapshot = Schema$1.Struct({
 	toolUses: Schema$1.optional(NonNegativeInt),
 	durationMs: Schema$1.optional(NonNegativeInt),
 	compactsAutomatically: Schema$1.optional(Schema$1.Boolean),
+	/**
+	* The compress mode the turn these deltas belong to actually ran under, not
+	* the thread's mode now. Without it the per-turn output figures cannot be
+	* attributed, and the whole question of what compression costs stays a guess.
+	* Optional because snapshots recorded before it existed have no answer.
+	*/
+	compressMode: Schema$1.optional(CompressMode),
 	breakdown: Schema$1.optional(ContextWindowBreakdown)
 });
 const ThreadTokenUsageUpdatedPayload = Schema$1.Struct({ usage: ThreadTokenUsageSnapshot });
@@ -16151,6 +16158,36 @@ function buildSkillOverrides(disabled, discovered) {
 * @module provider/Drivers/ClaudeSkills
 */
 const FRONTMATTER_PATTERN$1 = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
+/** The `true` spellings the CLI accepts for a boolean frontmatter field. */
+const TRUTHY_FRONTMATTER_VALUES = /* @__PURE__ */ new Set([
+	"true",
+	"yes",
+	"on",
+	"1"
+]);
+/**
+* A frontmatter boolean, spelled any of the ways the CLI allows.
+*
+* YAML already decodes an unquoted `true` to a boolean, but a quoted `"yes"`
+* arrives as a string, and the CLI accepts both. Reading only the boolean would
+* make a skill that works there silently model-invocable here.
+*/
+function readFrontmatterBoolean(value) {
+	if (typeof value === "boolean") return value;
+	if (typeof value === "number") return value === 1;
+	if (typeof value === "string") return TRUTHY_FRONTMATTER_VALUES.has(value.trim().toLowerCase());
+}
+/**
+* The document with its frontmatter block removed.
+*
+* The body is what a skill actually instructs; the header is metadata about
+* how it is selected. Exported for the expansion that inlines a skill into a
+* turn, which must send the instructions without the routing header.
+*/
+function stripMarkdownFrontmatter(contents) {
+	const match = FRONTMATTER_PATTERN$1.exec(contents);
+	return (match ? contents.slice(match[0].length) : contents).trim();
+}
 /**
 * The `name`/`description` header a skill and a subagent definition both carry.
 *
@@ -16172,10 +16209,12 @@ function parseMarkdownFrontmatter(contents) {
 	const record = parsed;
 	const name = typeof record.name === "string" ? record.name.trim() : "";
 	const description = typeof record.description === "string" ? record.description.trim() : "";
+	const disableModelInvocation = readFrontmatterBoolean(record["disable-model-invocation"]);
 	return {
 		kind: "parsed",
 		...name ? { name } : {},
-		...description ? { description } : {}
+		...description ? { description } : {},
+		...disableModelInvocation === void 0 ? {} : { disableModelInvocation }
 	};
 }
 /**
@@ -18928,7 +18967,7 @@ const COMPRESS_SHARED_RULES = `Respond terse. All technical substance stays. Onl
 
 ## Persistence
 
-Active every response. No revert after many turns. No filler drift. Still active if unsure.
+Active every response. No filler drift, no drifting back to verbose prose on your own. A later instruction that switches the response style off or changes its intensity replaces this block: obey the most recent one, not this one.
 
 ## Rules
 
@@ -19016,12 +19055,35 @@ const COMPRESS_TURN_REMINDERS = {
 	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]"
 };
+/**
+* Sent when compression is switched off on a session that is still carrying a
+* ruleset it cannot un-send. Silence is not enough: the ruleset states its own
+* persistence, so the absence of a reminder reads to the model as "nothing
+* changed" rather than "stop".
+*/
+const COMPRESS_REVERT_REMINDER = "[response style: compression off - any earlier response-compression instruction in this session no longer applies; write normal, complete prose from here on]";
 function compressRulesetFor(mode) {
 	return mode === "off" ? void 0 : COMPRESS_RULESETS[mode];
 }
 function compressTurnReminderFor(mode) {
 	return mode === "off" ? void 0 : COMPRESS_TURN_REMINDERS[mode];
 }
+/**
+* What to prepend to a turn's message so the running session ends up in the
+* requested compress mode.
+*
+* `staleRulesetMode` is the mode whose ruleset the session is still carrying in
+* a channel that cannot be rebuilt for this turn - Claude's system prompt is
+* frozen at session start, and a first-turn message prefix lives in the
+* conversation history forever. Codex rebuilds its developer instructions every
+* turn, so callers pass `undefined` for it and no revert line is spent.
+*/
+function compressTurnPrefixFor(input) {
+	if (input.injectRuleset) return compressRulesetFor(input.mode);
+	const reminder = compressTurnReminderFor(input.mode);
+	if (reminder !== void 0) return reminder;
+	return input.staleRulesetMode !== void 0 && input.staleRulesetMode !== "off" ? COMPRESS_REVERT_REMINDER : void 0;
+}
 //#endregion
 //#region src/sync/agentPresets.ts
 /**
@@ -88365,6 +88427,8 @@ const BUFFERED_PROPOSED_PLAN_BY_ID_CACHE_CAPACITY = 1e4;
 const BUFFERED_PROPOSED_PLAN_BY_ID_TTL = Duration.minutes(120);
 const TASK_DESCRIPTION_BY_TASK_CACHE_CAPACITY = 1e4;
 const TASK_DESCRIPTION_BY_TASK_TTL = Duration.minutes(120);
+const COMPRESS_MODE_BY_THREAD_CACHE_CAPACITY = 1e4;
+const COMPRESS_MODE_BY_THREAD_TTL = Duration.minutes(120);
 const MAX_BUFFERED_ASSISTANT_CHARS = 24e3;
 const STRICT_PROVIDER_LIFECYCLE_GUARD = process.env.P4CODE_STRICT_PROVIDER_LIFECYCLE_GUARD !== "0";
 function toTurnId$1(value) {
@@ -88437,9 +88501,12 @@ function assistantSegmentBaseKeyFromEvent(event) {
 function assistantSegmentMessageId(baseKey, segmentIndex) {
 	return MessageId.make(segmentIndex === 0 ? `assistant:${baseKey}` : `assistant:${baseKey}:segment:${segmentIndex}`);
 }
-function buildContextWindowActivityPayload(event) {
+function buildContextWindowActivityPayload(event, compressMode) {
 	if (event.type !== "thread.token-usage.updated" || event.payload.usage.usedTokens <= 0) return;
-	return event.payload.usage;
+	return compressMode === void 0 ? event.payload.usage : {
+		...event.payload.usage,
+		compressMode
+	};
 }
 function normalizeRuntimeTurnState(value) {
 	switch (value) {
@@ -88474,7 +88541,7 @@ function requestKindFromCanonicalRequestType(requestType) {
 		default: return;
 	}
 }
-function runtimeEventToActivities(event, taskTitle) {
+function runtimeEventToActivities(event, taskTitle, compressMode) {
 	const maybeSequence = (() => {
 		const eventWithSequence = event;
 		return eventWithSequence.sessionSequence !== void 0 ? { sequence: eventWithSequence.sessionSequence } : {};
@@ -88684,7 +88751,7 @@ function runtimeEventToActivities(event, taskTitle) {
 				...maybeSequence
 			}];
 		case "thread.token-usage.updated": {
-			const payload = buildContextWindowActivityPayload(event);
+			const payload = buildContextWindowActivityPayload(event, compressMode);
 			if (!payload) return [];
 			return [{
 				id: event.eventId,
@@ -88785,6 +88852,11 @@ const make$3 = Effect.gen(function* () {
 		timeToLive: TASK_DESCRIPTION_BY_TASK_TTL,
 		lookup: () => Effect.succeed("")
 	});
+	const compressModeByThreadId = yield* Cache.make({
+		capacity: COMPRESS_MODE_BY_THREAD_CACHE_CAPACITY,
+		timeToLive: COMPRESS_MODE_BY_THREAD_TTL,
+		lookup: () => Effect.die(/* @__PURE__ */ new Error("compress mode should be read through getOption"))
+	});
 	const rememberTaskDescription = (threadId, taskId, description) => Cache.set(taskDescriptionByTaskKey, providerTaskKey(threadId, taskId), description);
 	const lookupTaskDescription = (threadId, taskId) => Cache.getOption(taskDescriptionByTaskKey, providerTaskKey(threadId, taskId)).pipe(Effect.map((description) => Option.filter(description, (value) => value.length > 0).pipe(Option.getOrUndefined)));
 	const resolveThreadDetail = Effect.fn("resolveThreadDetail")(function* (threadId) {
@@ -89291,7 +89363,9 @@ const make$3 = Effect.gen(function* () {
 			taskTitle = yield* lookupTaskDescription(thread.id, event.payload.taskId);
 			if (!taskTitle) taskTitle = findTaskTitleInActivities((yield* getLoadedThreadDetail())?.activities, event.payload.taskId);
 		}
-		const activities = runtimeEventToActivities(event, taskTitle);
+		if (event.type === "turn.started") yield* Cache.set(compressModeByThreadId, thread.id, thread.compressMode);
+		const turnCompressMode = event.type === "thread.token-usage.updated" ? (yield* Cache.getOption(compressModeByThreadId, thread.id).pipe(Effect.map(Option.getOrUndefined))) ?? thread.compressMode : void 0;
+		const activities = runtimeEventToActivities(event, taskTitle, turnCompressMode);
 		yield* Effect.forEach(activities, (activity) => providerCommandId(event, "thread-activity-append").pipe(Effect.flatMap((commandId) => orchestrationEngine.dispatch({
 			type: "thread.activity.append",
 			commandId,
@@ -89332,6 +89406,126 @@ const make$3 = Effect.gen(function* () {
 });
 const ProviderRuntimeIngestionLive = Layer.effect(ProviderRuntimeIngestionService, make$3).pipe(Layer.provide(ProjectionTurnRepositoryLive));
 //#endregion
+//#region src/provider/userInvokedSkills.ts
+/**
+* Running a skill the model is not allowed to reach.
+*
+* A skill carrying `disable-model-invocation: true` is withheld from the model
+* entirely — description included — so only a person typing `/name` can start
+* it. That works in the interactive CLI, which expands the slash command before
+* the model ever sees it. It does not work here: p4code drives the Agent SDK,
+* whose non-interactive path forwards the typed text verbatim, and p4code's own
+* fallback is to ask the model to call the `Skill` tool — which is the one door
+* this flag locks. The result is a skill that is unreachable from both sides,
+* with nothing in the transcript to say why.
+*
+* So the expansion happens here, server-side, before the turn leaves: the
+* skill's own instructions are inlined into the message the provider receives.
+* The transcript keeps what the person typed, the same split compression
+* already uses.
+*
+* **Only skills the model may not invoke are expanded.** Everything else is
+* left alone deliberately — those already work through the `Skill` tool, and
+* inlining them too would mean two mechanisms racing to run the same skill.
+*
+* @module provider/userInvokedSkills
+*/
+/**
+* A leading `/name`, with whatever followed it.
+*
+* Anchored at the start: a slash somewhere inside a sentence is a path, a date
+* or an "and/or", and treating those as commands would rewrite ordinary
+* messages. The name pattern matches what a skill directory can be called,
+* including the `plugin:skill` form.
+*/
+const SLASH_INVOCATION = /^\/([A-Za-z0-9][A-Za-z0-9_:-]*)[ \t]*([\s\S]*)$/;
+/** `SKILL.md` is the only file a skill is required to have. */
+const SKILL_FILENAME = "SKILL.md";
+const parseSlashInvocation = (text) => {
+	const match = SLASH_INVOCATION.exec(text.trim());
+	const name = match?.[1];
+	if (name === void 0) return void 0;
+	return {
+		name,
+		args: (match?.[2] ?? "").trim()
+	};
+};
+/**
+* The message the provider receives in place of `/name args`.
+*
+* Tagged rather than pasted bare so the instructions cannot be mistaken for the
+* person's own words, and attributed to its file so an agent that needs the
+* skill's siblings — a reference, a template — knows where to look.
+*/
+const buildUserInvokedSkillInput = (input) => [
+	`<skill name="${input.name}" path="${input.path}">`,
+	input.body,
+	"</skill>",
+	"",
+	`The user invoked the ${input.name} skill${input.args ? ` with: ${input.args}` : ""}. Follow the instructions above.`
+].join("\n");
+/**
+* The `SKILL.md` a typed name refers to, searched across the given roots.
+*
+* Both names a skill answers to are matched — the frontmatter `name` and the
+* directory it lives in — because either is what a person sees depending on the
+* surface they read it from, and matching one only would leave a skill whose
+* two names disagree quietly unreachable. Later roots win, which is how the
+* CLI resolves a project skill over a user one.
+*/
+const findSkillFile = Effect.fnUntraced(function* (input) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	let found;
+	for (const root of input.roots) {
+		const entries = yield* fileSystem.readDirectory(root).pipe(Effect.orElseSucceed(() => []));
+		for (const entry of [...entries].sort()) {
+			const skillPath = path.join(root, entry, SKILL_FILENAME);
+			const contents = yield* fileSystem.readFileString(skillPath).pipe(Effect.orElseSucceed(() => void 0));
+			if (contents === void 0) continue;
+			const frontmatter = parseMarkdownFrontmatter(contents);
+			const frontmatterName = frontmatter.kind === "parsed" ? frontmatter.name : void 0;
+			if (entry !== input.name && frontmatterName !== input.name) continue;
+			found = {
+				path: skillPath,
+				contents
+			};
+		}
+	}
+	return found;
+});
+/**
+* The turn's text, with a user-invoked skill inlined when there is one.
+*
+* `undefined` means "nothing to do", which covers every ordinary message: no
+* leading slash, a name no skill answers to, a skill the model can invoke for
+* itself, or a body that is empty once the frontmatter comes off. Reading the
+* filesystem is best-effort throughout — an unreadable root or file leaves the
+* message exactly as it was typed, because failing a turn over a skill lookup
+* would be a worse answer than sending the text.
+*
+* @param roots - Skill directories, least specific first.
+*/
+const expandUserInvokedSkill = Effect.fnUntraced(function* (input) {
+	const invocation = parseSlashInvocation(input.text);
+	if (invocation === void 0) return void 0;
+	const skill = yield* findSkillFile({
+		name: invocation.name,
+		roots: input.roots
+	});
+	if (skill === void 0) return void 0;
+	const frontmatter = parseMarkdownFrontmatter(skill.contents);
+	if (frontmatter.kind !== "parsed" || frontmatter.disableModelInvocation !== true) return;
+	const body = stripMarkdownFrontmatter(skill.contents);
+	if (body.length === 0) return void 0;
+	return buildUserInvokedSkillInput({
+		name: invocation.name,
+		path: skill.path,
+		body,
+		args: invocation.args
+	});
+});
+//#endregion
 //#region src/orchestration/Layers/ProviderCommandReactor.ts
 const isProviderAdapterRequestError = Schema$1.is(ProviderAdapterRequestError);
 const isProviderDriverKind = Schema$1.is(ProviderDriverKind);
@@ -89415,6 +89609,15 @@ const make$2 = Effect.gen(function* () {
 	});
 	const hasHandledTurnStartRecently = (key) => Cache.getOption(handledTurnStartKeys, key).pipe(Effect.flatMap((cached) => Cache.set(handledTurnStartKeys, key, true).pipe(Effect.as(Option.isSome(cached)))));
 	const threadModelSelections = /* @__PURE__ */ new Map();
+	/**
+	* The compress mode whose ruleset the thread's live session was handed at
+	* start, kept because two of the three delivery channels cannot be rebuilt
+	* afterwards: Claude bakes the ruleset into the system prompt of a
+	* long-lived process, and the prefix providers put it in the first turn's
+	* message. Toggling compression off has to send a counter-instruction, and
+	* this is how the reactor knows there is something to counter.
+	*/
+	const threadSessionRulesetModes = /* @__PURE__ */ new Map();
 	const appendProviderFailureActivity = (input) => Effect.all({
 		commandId: serverCommandId("provider-failure-activity"),
 		eventId: serverEventId()
@@ -89519,6 +89722,25 @@ const make$2 = Effect.gen(function* () {
 	const resolveProject = Effect.fnUntraced(function* (projectId) {
 		return yield* projectionSnapshotQuery.getProjectShellById(projectId).pipe(Effect.map(Option.getOrUndefined));
 	});
+	/**
+	* Where a typed `/name` is looked up: the user's skills, then the
+	* workspace's.
+	*
+	* Project last so it wins, matching the CLI's most-specific-wins resolution.
+	* The user root is resolved with an empty `homePath` on purpose — this runs
+	* before a provider instance is chosen, and the config-dir override that a
+	* single Claude instance may carry is not a fact about the person's skills.
+	*/
+	const resolveUserInvokedSkillRoots = Effect.fnUntraced(function* (thread) {
+		const path = yield* Path.Path;
+		const userSkillsDir = yield* resolveClaudeUserSkillsDir({ homePath: "" });
+		const project = yield* resolveProject(thread.projectId);
+		const cwd = resolveThreadWorkspaceCwd({
+			thread,
+			projects: project ? [project] : []
+		});
+		return [userSkillsDir, ...cwd ? [path.join(cwd, ".claude", "skills")] : []];
+	});
 	const resolveThread = Effect.fnUntraced(function* (threadId) {
 		return yield* projectionSnapshotQuery.getThreadDetailById(threadId).pipe(Effect.map(Option.getOrUndefined));
 	});
@@ -89613,17 +89835,20 @@ const make$2 = Effect.gen(function* () {
 			thread,
 			projects: project ? [project] : []
 		});
-		const startProviderSession = (input) => providerService.startSession(threadId, {
-			threadId,
-			...preferredProvider ? { provider: preferredProvider } : {},
-			providerInstanceId: desiredInstanceId,
-			...effectiveCwd ? { cwd: effectiveCwd } : {},
-			modelSelection: desiredModelSelection,
-			...input?.resumeCursor !== void 0 ? { resumeCursor: input.resumeCursor } : {},
-			runtimeMode: desiredRuntimeMode,
-			compressMode: thread.compressMode,
-			unpromptedSubagents: thread.unpromptedSubagents
-		});
+		const startProviderSession = (input) => {
+			threadSessionRulesetModes.set(threadId, thread.compressMode);
+			return providerService.startSession(threadId, {
+				threadId,
+				...preferredProvider ? { provider: preferredProvider } : {},
+				providerInstanceId: desiredInstanceId,
+				...effectiveCwd ? { cwd: effectiveCwd } : {},
+				modelSelection: desiredModelSelection,
+				...input?.resumeCursor !== void 0 ? { resumeCursor: input.resumeCursor } : {},
+				runtimeMode: desiredRuntimeMode,
+				compressMode: thread.compressMode,
+				unpromptedSubagents: thread.unpromptedSubagents
+			});
+		};
 		const bindSessionToThread = (session) => Effect.gen(function* () {
 			if (session.providerInstanceId === void 0) return yield* new ProviderAdapterRequestError({
 				provider: providerErrorLabel(session.provider),
@@ -89702,6 +89927,10 @@ const make$2 = Effect.gen(function* () {
 		});
 		if (input.modelSelection !== void 0) threadModelSelections.set(input.threadId, input.modelSelection);
 		const normalizedInput = toNonEmptyProviderInput(input.messageText);
+		const expandedInput = normalizedInput === void 0 ? void 0 : (yield* expandUserInvokedSkill({
+			text: normalizedInput,
+			roots: yield* resolveUserInvokedSkillRoots(thread)
+		})) ?? normalizedInput;
 		const normalizedAttachments = input.attachments ?? [];
 		const activeSession = yield* providerService.listSessions().pipe(Effect.map((sessions) => sessions.find((session) => session.threadId === input.threadId)));
 		const sessionModelSwitch = activeSession === void 0 ? "in-session" : activeSession.providerInstanceId === void 0 ? yield* new ProviderAdapterRequestError({
@@ -89716,8 +89945,13 @@ const make$2 = Effect.gen(function* () {
 		} : requestedModelSelection : input.modelSelection;
 		const compressMode = thread.compressMode;
 		const hasSessionLevelRuleset = activeSession?.provider === "claudeAgent" || activeSession?.provider === "codex";
-		const compressPrefix = !hadActiveSession && !hasSessionLevelRuleset ? compressRulesetFor(compressMode) : compressTurnReminderFor(compressMode);
-		const inputWithCompressPrefix = normalizedInput !== void 0 && compressPrefix !== void 0 ? `${compressPrefix}\n\n${normalizedInput}` : normalizedInput;
+		const rebuildsRulesetEachTurn = activeSession?.provider === "codex";
+		const compressPrefix = compressTurnPrefixFor({
+			mode: compressMode,
+			injectRuleset: !hadActiveSession && !hasSessionLevelRuleset,
+			staleRulesetMode: hadActiveSession && !rebuildsRulesetEachTurn ? threadSessionRulesetModes.get(input.threadId) : void 0
+		});
+		const inputWithCompressPrefix = expandedInput !== void 0 && compressPrefix !== void 0 ? `${compressPrefix}\n\n${expandedInput}` : expandedInput;
 		return {
 			threadId: input.threadId,
 			...inputWithCompressPrefix ? { input: inputWithCompressPrefix } : {},
@@ -89940,6 +90174,7 @@ const make$2 = Effect.gen(function* () {
 		if (!thread) return;
 		const now = event.payload.createdAt;
 		if (thread.session && thread.session.status !== "stopped") yield* providerService.stopSession({ threadId: thread.id });
+		threadSessionRulesetModes.delete(thread.id);
 		yield* setThreadSession({
 			threadId: thread.id,
 			session: {