@gajae-code/coding-agent 0.11.2 → 0.11.4

package/src/tools/ask.ts

@@ -16,6 +16,7 @@
  */
 
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
+import type { RawArgumentValidationResult } from "@gajae-code/ai/types";
 import {
 	type Component,
 	Container,
@@ -109,36 +110,40 @@ const DeepInterviewIntentReview = z
 	.strict();
 
 /** Optional structured deep-interview round metadata; when present the round is recorded automatically. */
-const DeepInterviewMeta = z
-	.object({
-		round_id: z.string().max(128).describe("stable optional round identity").optional(),
-		round: z.number().int().nonnegative().describe("round number"),
-		component: z.string().min(1).max(128).describe("targeted topology component"),
-		dimension: z.string().min(1).max(128).describe("targeted clarity dimension"),
-		ambiguity: z.number().min(0).max(1).describe("ambiguity at ask time (0..1)"),
-		intent_contract: DeepInterviewIntentContract.describe("Round-0 locked intent contract").optional(),
-		intent_review: DeepInterviewIntentReview.describe("Locked-intent reduction review").optional(),
-	})
-	.strict()
-	.superRefine((value, context) => {
-		if (
-			value.intent_contract &&
-			(value.round !== 0 || value.component !== "review-topology" || value.dimension !== "topology")
-		)
-			context.addIssue({
-				code: "custom",
-				message: "intent_contract requires Round 0 review-topology metadata",
-				path: ["intent_contract"],
-			});
-		if (value.intent_review && value.round === 0)
-			context.addIssue({
-				code: "custom",
-				message: "intent_review requires a post-Round-0 answer",
-				path: ["intent_review"],
-			});
-		if (value.intent_contract && value.intent_review)
-			context.addIssue({ code: "custom", message: "intent_contract and intent_review are mutually exclusive" });
-	});
+const DeepInterviewMetadata = z.object({
+	round_id: z.string().max(128).describe("stable optional round identity").optional(),
+	round: z.number().int().nonnegative().describe("round number"),
+	component: z.string().min(1).max(128).describe("targeted topology component"),
+	dimension: z.string().min(1).max(128).describe("targeted clarity dimension"),
+	ambiguity: z.number().min(0).max(1).describe("ambiguity at ask time (0..1)"),
+});
+
+/** Provider-visible branches keep ordinary, contract, and review metadata mutually exclusive. */
+const DeepInterviewMeta = z.union([
+	DeepInterviewMetadata.strict(),
+	DeepInterviewMetadata.extend({
+		round: z.literal(0).describe("round number"),
+		component: z.literal("review-topology").describe("targeted topology component"),
+		dimension: z.literal("topology").describe("targeted clarity dimension"),
+		intent_contract: DeepInterviewIntentContract.describe("Round-0 locked intent contract"),
+	}).strict(),
+	DeepInterviewMetadata.extend({
+		round: z.number().int().positive().describe("round number"),
+		intent_review: DeepInterviewIntentReview.describe("Locked-intent reduction review"),
+	}).strict(),
+]);
+
+type DeepInterviewMeta = z.infer<typeof DeepInterviewMeta>;
+
+function intentContract(
+	metadata: DeepInterviewMeta | undefined,
+): z.infer<typeof DeepInterviewIntentContract> | undefined {
+	return metadata && "intent_contract" in metadata ? metadata.intent_contract : undefined;
+}
+
+function intentReview(metadata: DeepInterviewMeta | undefined): z.infer<typeof DeepInterviewIntentReview> | undefined {
+	return metadata && "intent_review" in metadata ? metadata.intent_review : undefined;
+}
 
 const WorkflowGateMeta = z.object({
 	stage: z.enum(["deep-interview", "ralplan", "ultragoal"]).describe("workflow gate stage"),
@@ -157,23 +162,25 @@ const QuestionItem = z
 	})
 	.superRefine((value, context) => {
 		const labels = new Set(value.options.map(option => option.label));
-		if ((value.deepInterview?.intent_contract || value.deepInterview?.intent_review) && value.multi === true)
+		const contract = intentContract(value.deepInterview);
+		const review = intentReview(value.deepInterview);
+		if ((contract || review) && value.multi === true)
 			context.addIssue({ code: "custom", message: "intent gates must be single-select", path: ["multi"] });
-		const confirmationOptions = value.deepInterview?.intent_contract?.confirmation_options ?? [];
+		const confirmationOptions = contract?.confirmation_options ?? [];
 		if (new Set(confirmationOptions).size !== confirmationOptions.length)
 			context.addIssue({
 				code: "custom",
 				message: "intent confirmation options must be unique",
 				path: ["deepInterview", "intent_contract"],
 			});
-		const approvalOptions = value.deepInterview?.intent_review?.approval_options ?? [];
+		const approvalOptions = review?.approval_options ?? [];
 		if (new Set(approvalOptions).size !== approvalOptions.length)
 			context.addIssue({
 				code: "custom",
 				message: "intent approval options must be unique",
 				path: ["deepInterview", "intent_review"],
 			});
-		for (const label of value.deepInterview?.intent_contract?.confirmation_options ?? []) {
+		for (const label of confirmationOptions) {
 			if (!labels.has(label))
 				context.addIssue({
 					code: "custom",
@@ -181,7 +188,7 @@ const QuestionItem = z
 					path: ["deepInterview", "intent_contract"],
 				});
 		}
-		for (const label of value.deepInterview?.intent_review?.approval_options ?? []) {
+		for (const label of approvalOptions) {
 			if (!labels.has(label))
 				context.addIssue({
 					code: "custom",
@@ -197,6 +204,173 @@ export const askSchema = z.object({
 
 export type AskToolInput = z.infer<typeof askSchema>;
 
+function isPlainRecord(value: unknown): value is Record<string, unknown> {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+
+function isOnlyPlainData(value: unknown): boolean {
+	if (Array.isArray(value)) return value.every(isOnlyPlainData);
+	if (typeof value !== "object" || value === null) return true;
+	return isPlainRecord(value) && Object.values(value).every(isOnlyPlainData);
+}
+
+function hasExactOwnKeys(value: Record<string, unknown>, allowed: readonly string[]): boolean {
+	const keys = Reflect.ownKeys(value);
+	return keys.length === allowed.length && keys.every(key => typeof key === "string" && allowed.includes(key));
+}
+
+function hasOnlyAllowedOwnKeys(value: Record<string, unknown>, allowed: readonly string[]): boolean {
+	return Reflect.ownKeys(value).every(key => typeof key === "string" && allowed.includes(key));
+}
+
+function hasUniqueDisplayedLabels(labels: readonly string[], optionLabels: ReadonlySet<string>): boolean {
+	return new Set(labels).size === labels.length && labels.every(label => optionLabels.has(label));
+}
+
+/** Parse only to recognize a retired recovery shape; parsed values are never eligible for recovery. */
+function parseEncodedContainer(value: unknown): unknown {
+	if (typeof value !== "string") return value;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+}
+
+/** Whether malformed input is close enough to the retired pair shape to require a terminal rejection. */
+function isRoundZeroRecoveryCandidate(value: unknown): boolean {
+	const root = parseEncodedContainer(value);
+	if (typeof root !== "object" || root === null || !Object.hasOwn(root, "questions")) return false;
+	const questionsValue = parseEncodedContainer((root as Record<string, unknown>).questions);
+	if (!Array.isArray(questionsValue)) return questionsValue === null;
+	return questionsValue.some(rawQuestion => {
+		const question = parseEncodedContainer(rawQuestion);
+		if (typeof question !== "object" || question === null || !Object.hasOwn(question, "deepInterview")) return false;
+		const deepInterview = parseEncodedContainer((question as Record<string, unknown>).deepInterview);
+		if (typeof deepInterview !== "object" || deepInterview === null) return deepInterview === null;
+		const metadata = deepInterview as Record<string, unknown>;
+		return Object.hasOwn(metadata, "intent_contract") || Object.hasOwn(metadata, "intent_review");
+	});
+}
+
+/** Remove only strict-provider null placeholders for fields optional in the canonical Ask contract. */
+function normalizeRoundZeroOptionalNulls(arguments_: Record<string, unknown>): Record<string, unknown> {
+	if (!isPlainRecord(arguments_) || !Array.isArray(arguments_.questions) || arguments_.questions.length !== 1)
+		return arguments_;
+	const question = arguments_.questions[0];
+	if (!isPlainRecord(question) || !isPlainRecord(question.deepInterview)) return arguments_;
+	const normalizedQuestion = { ...question };
+	let changed = false;
+	for (const key of ["multi", "recommended", "workflowGate"] as const) {
+		if (Object.hasOwn(normalizedQuestion, key) && normalizedQuestion[key] === null) {
+			delete normalizedQuestion[key];
+			changed = true;
+		}
+	}
+	const normalizedDeepInterview = { ...question.deepInterview };
+	if (Object.hasOwn(normalizedDeepInterview, "round_id") && normalizedDeepInterview.round_id === null) {
+		delete normalizedDeepInterview.round_id;
+		normalizedQuestion.deepInterview = normalizedDeepInterview;
+		changed = true;
+	}
+	return changed ? { ...arguments_, questions: [normalizedQuestion] } : arguments_;
+}
+function recoverRoundZeroIntentContract(arguments_: Record<string, unknown>): RawArgumentValidationResult {
+	if (!isRoundZeroRecoveryCandidate(arguments_)) return { outcome: "passthrough" };
+	const normalizedArguments = normalizeRoundZeroOptionalNulls(arguments_);
+	if (!isOnlyPlainData(normalizedArguments) || !isPlainRecord(normalizedArguments)) return { outcome: "reject" };
+	if (
+		!hasExactOwnKeys(normalizedArguments, ["questions"]) ||
+		!Array.isArray(normalizedArguments.questions) ||
+		normalizedArguments.questions.length !== 1
+	)
+		return { outcome: "reject" };
+
+	const question = normalizedArguments.questions[0];
+	if (!isPlainRecord(question)) return { outcome: "reject" };
+	const questionKeys = ["id", "question", "options", "multi", "recommended", "deepInterview", "workflowGate"];
+	if (!hasOnlyAllowedOwnKeys(question, questionKeys)) return { outcome: "reject" };
+	if (
+		typeof question.id !== "string" ||
+		typeof question.question !== "string" ||
+		!Array.isArray(question.options) ||
+		!Object.hasOwn(question, "deepInterview") ||
+		!isPlainRecord(question.deepInterview) ||
+		(Object.hasOwn(question, "multi") && question.multi !== false) ||
+		(Object.hasOwn(question, "recommended") && typeof question.recommended !== "number")
+	)
+		return { outcome: "reject" };
+	const deepInterview = question.deepInterview;
+	const hasIntentContract = Object.hasOwn(deepInterview, "intent_contract");
+	const hasIntentReview = Object.hasOwn(deepInterview, "intent_review");
+	if (hasIntentContract !== hasIntentReview && askSchema.safeParse(normalizedArguments).success)
+		return { outcome: "passthrough" };
+
+	if (
+		Object.hasOwn(question, "workflowGate") &&
+		(!isPlainRecord(question.workflowGate) ||
+			!hasExactOwnKeys(question.workflowGate, ["stage", "kind"]) ||
+			question.workflowGate.stage !== "deep-interview" ||
+			question.workflowGate.kind !== "question")
+	)
+		return { outcome: "reject" };
+
+	if (
+		!question.options.every(
+			option => isPlainRecord(option) && hasExactOwnKeys(option, ["label"]) && typeof option.label === "string",
+		)
+	)
+		return { outcome: "reject" };
+	const optionLabels = question.options.map(option => (option as { label: string }).label);
+	if (new Set(optionLabels).size !== optionLabels.length) return { outcome: "reject" };
+
+	const deepInterviewKeys = [
+		"round_id",
+		"round",
+		"component",
+		"dimension",
+		"ambiguity",
+		"intent_contract",
+		"intent_review",
+	];
+	if (
+		!hasOnlyAllowedOwnKeys(deepInterview, deepInterviewKeys) ||
+		!Object.hasOwn(deepInterview, "intent_contract") ||
+		!Object.hasOwn(deepInterview, "intent_review") ||
+		deepInterview.round !== 0 ||
+		typeof deepInterview.component !== "string" ||
+		deepInterview.component !== "review-topology" ||
+		typeof deepInterview.dimension !== "string" ||
+		deepInterview.dimension !== "topology" ||
+		typeof deepInterview.ambiguity !== "number" ||
+		(Object.hasOwn(deepInterview, "round_id") && typeof deepInterview.round_id !== "string")
+	)
+		return { outcome: "reject" };
+
+	const contract = DeepInterviewIntentContract.safeParse(deepInterview.intent_contract);
+	const review = DeepInterviewIntentReview.safeParse(deepInterview.intent_review);
+	if (!contract.success || !review.success) return { outcome: "reject" };
+	const displayedLabels = new Set(optionLabels);
+	if (
+		!hasUniqueDisplayedLabels(contract.data.confirmation_options, displayedLabels) ||
+		!hasUniqueDisplayedLabels(review.data.approval_options, displayedLabels)
+	)
+		return { outcome: "reject" };
+
+	const { intent_review: _intentReview, ...recoveredDeepInterview } = deepInterview;
+	const recovered = {
+		questions: [
+			{
+				...question,
+				deepInterview: { ...recoveredDeepInterview, intent_contract: contract.data },
+			},
+		],
+	};
+	return askSchema.safeParse(recovered).success ? { outcome: "accept", arguments: recovered } : { outcome: "reject" };
+}
+
 /** Result for a single question */
 export interface QuestionResult {
 	id: string;
@@ -803,6 +977,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 	readonly summary = "Ask the user a clarifying question";
 	readonly description: string;
 	readonly parameters = askSchema;
+	readonly rawArgumentValidation = recoverRoundZeroIntentContract;
 	readonly strict = true;
 	readonly loadMode = "discoverable";
 
@@ -850,14 +1025,14 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 					ambiguity: meta.ambiguity,
 					selectedOptions,
 					customInput,
-					intent_contract: meta.intent_contract,
-					intent_review: meta.intent_review,
+					intent_contract: intentContract(meta),
+					intent_review: intentReview(meta),
 				},
 				{ sessionId },
 			).then(async () => {
 				await syncDeepInterviewRecorderHud(cwd, statePath, sessionId);
 			}),
-			meta.intent_contract !== undefined || meta.intent_review !== undefined,
+			intentContract(meta) !== undefined || intentReview(meta) !== undefined,
 		);
 	}
 
@@ -1190,7 +1365,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 					navigation: options?.navigation,
 					scrollTitleRows: isDeepInterviewQuestion ? DEEP_INTERVIEW_SELECTOR_SCROLL_TITLE_ROWS : undefined,
 					otherOptionLabel,
-					autoSelectOnTimeout: !q.deepInterview?.intent_contract && !q.deepInterview?.intent_review,
+					autoSelectOnTimeout: !intentContract(q.deepInterview) && !intentReview(q.deepInterview),
 					clarificationOptionLabel,
 					onRemoteState: state => {
 						activeRemoteRequest = {
@@ -1277,7 +1452,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 			}
 			if (
 				clarificationQuestion === undefined &&
-				!(timedOut && (q.deepInterview?.intent_contract || q.deepInterview?.intent_review))
+				!(timedOut && (intentContract(q.deepInterview) || intentReview(q.deepInterview)))
 			) {
 				await this.#recordDeepInterviewRound(q, selectedOptions, customInput);
 			}
@@ -1358,7 +1533,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 
 			if (
 				clarificationQuestion === undefined &&
-				!(timedOut && (q.deepInterview?.intent_contract || q.deepInterview?.intent_review))
+				!(timedOut && (intentContract(q.deepInterview) || intentReview(q.deepInterview)))
 			) {
 				await this.#recordDeepInterviewRound(q, selectedOptions, customInput);
 			}

package/src/tools/bash-allowed-prefixes.ts

@@ -1,3 +1,11 @@
+import {
+	classifyStateArgv,
+	STATE_ACTION_NAMES,
+	type StateAction,
+	type StateArgvClassification,
+} from "../gjc-runtime/state-argv";
+import { CANONICAL_GJC_WORKFLOW_SKILLS } from "../skill-state/canonical-skills";
+
 export interface BashAllowedPrefixesCheck {
 	allowed: boolean;
 	reason?: string;
@@ -11,9 +19,8 @@ export interface BashRestrictionOptions {
 
 const SHELL_CONTROL_CHARS = new Set([";", "|", "&", "<", ">", "(", ")"]);
 const UNSAFE_UNQUOTED_EXPANSION_CHARS = new Set(["$", "*", "?", "[", "]", "{", "}", "~"]);
-const STATE_FLAGS_WITH_VALUES = new Set(["--input", "--mode", "--session-id", "--thread-id", "--turn-id", "--to"]);
-const STATE_ACTIONS = new Set(["read", "write", "clear", "contract", "handoff"]);
 const ALLOWED_STATE_ACTIONS = new Set(["read", "write", "contract"]);
+const CANONICAL_STATE_TARGETS = new Set<string>(CANONICAL_GJC_WORKFLOW_SKILLS);
 const READ_ONLY_COMMANDS = new Set(["grep", "rg", "tree", "ls", "pwd", "wc", "du", "file", "stat"]);
 
 function parseShellWords(command: string): { words: string[]; reason?: string } {
@@ -21,6 +28,7 @@ function parseShellWords(command: string): { words: string[]; reason?: string }
 	let current = "";
 	let quote: "single" | "double" | null = null;
 
+	let wordStarted = false;
 	for (let index = 0; index < command.length; index += 1) {
 		const char = command[index]!;
 		const next = command[index + 1];
@@ -54,10 +62,12 @@ function parseShellWords(command: string): { words: string[]; reason?: string }
 
 		if (char === "'") {
 			quote = "single";
+			wordStarted = true;
 			continue;
 		}
 		if (char === '"') {
 			quote = "double";
+			wordStarted = true;
 			continue;
 		}
 		if (char === "`" || (char === "$" && next === "(")) {
@@ -73,9 +83,10 @@ function parseShellWords(command: string): { words: string[]; reason?: string }
 			return { words, reason: `shell expansion character '${char}' is not allowed in restricted bash commands` };
 		}
 		if (/\s/u.test(char)) {
-			if (current.length > 0) {
+			if (wordStarted) {
 				words.push(current);
 				current = "";
+				wordStarted = false;
 			}
 			continue;
 		}
@@ -83,12 +94,13 @@ function parseShellWords(command: string): { words: string[]; reason?: string }
 			return { words, reason: "backslash escapes are not allowed in restricted bash commands" };
 		}
 		current += char;
+		wordStarted = true;
 	}
 
 	if (quote !== null) {
 		return { words, reason: "unterminated quote in restricted bash command" };
 	}
-	if (current.length > 0) words.push(current);
+	if (wordStarted) words.push(current);
 	return { words };
 }
 
@@ -101,28 +113,62 @@ function wordsStartWith(words: readonly string[], prefix: readonly string[]): bo
 	return prefix.every((word, index) => words[index] === word);
 }
 
-function parseStateAction(words: readonly string[]): string | undefined {
-	const args = words.slice(2);
-	const positional: string[] = [];
-	let skipNext = false;
-	for (const arg of args) {
-		if (skipNext) {
-			skipNext = false;
-			continue;
-		}
-		if (STATE_FLAGS_WITH_VALUES.has(arg)) {
-			skipNext = true;
-			continue;
-		}
-		if (!arg.startsWith("-")) positional.push(arg);
+function malformedStateShape(): StateActionClassification {
+	return { reason: "restricted role-agent bash only allows documented `gjc state` action shapes" };
+}
+
+interface ParsedStateAction {
+	action: string;
+	target: string;
+}
+
+interface StateActionClassification {
+	parsed?: ParsedStateAction;
+	reason?: string;
+}
+
+function hasDocumentedStatePositionals(classification: StateArgvClassification): boolean {
+	const [first, second, third] = classification.positionals;
+	if (third) return false;
+	if (!second) return true;
+	return STATE_ACTION_NAMES.has(first as StateAction) || STATE_ACTION_NAMES.has(second as StateAction);
+}
+
+function classifyStateAction(words: readonly string[]): StateActionClassification {
+	const classification = classifyStateArgv(words.slice(2));
+	if (
+		classification.unknownFlags.length > 0 ||
+		classification.flags.some(flag => flag.malformed) ||
+		!hasDocumentedStatePositionals(classification)
+	) {
+		return malformedStateShape();
+	}
+
+	const modeFlags = classification.flags.filter(flag => flag.name === "--mode");
+	const inputFlags = classification.flags.filter(flag => flag.name === "--input");
+	if (modeFlags.length > 1 || inputFlags.length > 1) {
+		return { reason: "restricted role-agent bash rejects repeated or conflicting `gjc state` target selectors" };
+	}
+	if (classification.inputs.some(input => input.kind === "file")) {
+		return { reason: "restricted role-agent bash does not allow file-backed `gjc state --input` values" };
 	}
+	if (classification.inputs.some(input => input.kind === "invalid")) return malformedStateShape();
 
-	const [first, second, third] = positional;
-	if (!first) return "read";
-	if (STATE_ACTIONS.has(first)) return second ? undefined : first;
-	if (!second) return "read";
-	if (!STATE_ACTIONS.has(second)) return undefined;
-	return third ? undefined : second;
+	const runtimeTarget = classification.runtimeSelectorCandidates.find(candidate => candidate.value)?.value;
+	const suppliedTargets = classification.selectorCandidates
+		.map(candidate => candidate.value)
+		.filter((target): target is string => target !== undefined);
+	const distinctTargets = new Set(suppliedTargets);
+	if (distinctTargets.size > 1 || (runtimeTarget && suppliedTargets.some(target => target !== runtimeTarget))) {
+		return {
+			reason:
+				"restricted role-agent bash rejects conflicting `gjc state` selectors that disagree with runtime precedence",
+		};
+	}
+	if (!runtimeTarget || !CANONICAL_STATE_TARGETS.has(runtimeTarget)) {
+		return { reason: "restricted role-agent bash requires a canonical workflow skill for `gjc state` commands" };
+	}
+	return { parsed: { action: classification.effectiveAction, target: runtimeTarget } };
 }
 
 function optionWords(words: readonly string[]): string[] {
@@ -189,15 +235,19 @@ function validateMatchedGjcCommand(words: readonly string[]): BashAllowedPrefixe
 	}
 
 	if (words[1] === "state") {
-		const action = parseStateAction(words);
-		if (!action) {
+		const classification = classifyStateAction(words);
+		if (!classification.parsed) {
 			return {
 				allowed: false,
-				reason: "restricted role-agent bash only allows documented `gjc state` action shapes",
+				reason:
+					classification.reason ?? "restricted role-agent bash only allows documented `gjc state` action shapes",
 			};
 		}
-		if (!ALLOWED_STATE_ACTIONS.has(action)) {
-			return { allowed: false, reason: `restricted role-agent bash does not allow \`gjc state ${action}\`` };
+		if (!ALLOWED_STATE_ACTIONS.has(classification.parsed.action)) {
+			return {
+				allowed: false,
+				reason: `restricted role-agent bash does not allow \`gjc state ${classification.parsed.action}\``,
+			};
 		}
 		return { allowed: true };
 	}

package/src/tools/browser/launch.ts

@@ -1,7 +1,9 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { $which, getPuppeteerDir, logger } from "@gajae-code/utils";
+import { getPuppeteerDir } from "@gajae-code/utils/dirs";
+import * as logger from "@gajae-code/utils/logger";
+import { $which } from "@gajae-code/utils/which";
 import * as browsers from "@puppeteer/browsers";
 import type { Browser, CDPSession, Page, default as Puppeteer, Target } from "puppeteer-core";
 import { PUPPETEER_REVISIONS } from "puppeteer-core/internal/revisions.js";

package/src/tools/browser/readable.ts

@@ -1,6 +1,6 @@
 import { Readability } from "@mozilla/readability";
 import { parseHtmlLazy } from "../../utils/linkedom";
-import { htmlToBasicMarkdown } from "../../web/scrapers/types";
+import { htmlToBasicMarkdown } from "../../web/scrapers/html-to-markdown";
 
 export type ReadableFormat = "text" | "markdown";
 

package/src/tools/browser/screenshot-format.ts

@@ -0,0 +1,34 @@
+import * as os from "node:os";
+
+import { formatDimensionNote, type ResizedImage } from "../../utils/image-resize";
+
+function shortenPath(filePath: string): string {
+	const home = os.homedir();
+	return home && filePath.startsWith(home) ? `~${filePath.slice(home.length)}` : filePath;
+}
+
+export function formatScreenshot(opts: {
+	saveFullRes: boolean;
+	savedMimeType: string;
+	savedByteLength: number;
+	dest: string;
+	resized: ResizedImage;
+}): string[] {
+	const lines = ["Screenshot captured"];
+	if (opts.saveFullRes) {
+		lines.push(
+			`Saved: ${opts.savedMimeType} (${(opts.savedByteLength / 1024).toFixed(2)} KB) to ${shortenPath(opts.dest)}`,
+		);
+		lines.push(
+			`Model: ${opts.resized.mimeType} (${(opts.resized.buffer.length / 1024).toFixed(2)} KB, ${opts.resized.width}x${opts.resized.height})`,
+		);
+	} else {
+		lines.push(`Format: ${opts.resized.mimeType} (${(opts.resized.buffer.length / 1024).toFixed(2)} KB)`);
+		lines.push(`Dimensions: ${opts.resized.width}x${opts.resized.height}`);
+	}
+	const dimensionNote = formatDimensionNote(opts.resized);
+	if (dimensionNote) {
+		lines.push(dimensionNote);
+	}
+	return lines;
+}

package/src/tools/browser/tab-protocol.ts

@@ -63,6 +63,7 @@ export type WorkerInitPayload =
 export type ToolReply = { ok: true; value: unknown } | { ok: false; error: RunErrorPayload };
 
 export type WorkerInbound =
+	| { type: "bootstrap"; version: 1; mode: "native-free" }
 	| { type: "init"; payload: WorkerInitPayload }
 	| { type: "run"; id: string; name: string; code: string; timeoutMs: number; session: SessionSnapshot }
 	| { type: "abort"; id: string }
@@ -91,6 +92,8 @@ export interface RunErrorPayload {
 }
 
 export type WorkerOutbound =
+	| { type: "bootstrap-ready"; version: 1; mode: "native-free" }
+	| { type: "bootstrap-failed"; error: string }
 	| { type: "ready"; info: ReadyInfo }
 	| { type: "init-failed"; error: RunErrorPayload }
 	| { type: "result"; id: string; ok: true; payload: RunResultOk }