@keystrokehq/cli 0.1.2 → 0.1.4

package/dist/dist-CwR72_PS.mjs

@@ -0,0 +1,1887 @@
+#!/usr/bin/env node
+import { $t as normalizeCredentialList, an as custom, cn as object, dn as toJSONSchema, ht as PromptResponseSchema, in as array, ln as string, nn as ZodType, on as discriminatedUnion, rn as _function, sn as literal, un as union, vt as ROUTE_MANIFEST_REL_PATH } from "./dist-C47GdlWY.mjs";
+import "./chunk-BZUGFHVS-CPWRFwK8.mjs";
+import "./chunk-DLL7UR66-BUYgzxnR.mjs";
+import "./chunk-TN7HHBQW-CSB_R-XD.mjs";
+import "./chunk-L64BMZUV-CyR7RKok.mjs";
+import "./chunk-4RUAZWKT-D60fyWAB.mjs";
+import "./chunk-NRSASXYY-CuWyREpD.mjs";
+import "./chunk-SAI2SPQQ-CVRoDNs9.mjs";
+import "./chunk-STHBFACM-lyj-j2a-.mjs";
+import "./chunk-W5DWRFSU-lCyWk0ph.mjs";
+import "./chunk-WNH3HOQA-BCZUOjCJ.mjs";
+import "./chunk-HBVMHTO5-CJyD-QZX.mjs";
+import "./chunk-FOCWZZDE-BIntqBh2.mjs";
+import "./chunk-L2UW7DWF-B3tEHhPF.mjs";
+import "./chunk-XRFHFXFP-BGxzVZgK.mjs";
+import { createRequire } from "node:module";
+import "node:os";
+import { basename, dirname, join, relative, sep } from "node:path";
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { readdir, stat } from "node:fs/promises";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region ../../node_modules/.pnpm/just-bash@3.0.1/node_modules/just-bash/dist/bundle/chunks/chunk-G5EVRAOO.js
+createRequire(import.meta.url);
+var p;
+(function(e) {
+	e.EOF = "EOF", e.NEWLINE = "NEWLINE", e.SEMICOLON = "SEMICOLON", e.AMP = "AMP", e.PIPE = "PIPE", e.PIPE_AMP = "PIPE_AMP", e.AND_AND = "AND_AND", e.OR_OR = "OR_OR", e.BANG = "BANG", e.LESS = "LESS", e.GREAT = "GREAT", e.DLESS = "DLESS", e.DGREAT = "DGREAT", e.LESSAND = "LESSAND", e.GREATAND = "GREATAND", e.LESSGREAT = "LESSGREAT", e.DLESSDASH = "DLESSDASH", e.CLOBBER = "CLOBBER", e.TLESS = "TLESS", e.AND_GREAT = "AND_GREAT", e.AND_DGREAT = "AND_DGREAT", e.LPAREN = "LPAREN", e.RPAREN = "RPAREN", e.LBRACE = "LBRACE", e.RBRACE = "RBRACE", e.DSEMI = "DSEMI", e.SEMI_AND = "SEMI_AND", e.SEMI_SEMI_AND = "SEMI_SEMI_AND", e.DBRACK_START = "DBRACK_START", e.DBRACK_END = "DBRACK_END", e.DPAREN_START = "DPAREN_START", e.DPAREN_END = "DPAREN_END", e.IF = "IF", e.THEN = "THEN", e.ELSE = "ELSE", e.ELIF = "ELIF", e.FI = "FI", e.FOR = "FOR", e.WHILE = "WHILE", e.UNTIL = "UNTIL", e.DO = "DO", e.DONE = "DONE", e.CASE = "CASE", e.ESAC = "ESAC", e.IN = "IN", e.FUNCTION = "FUNCTION", e.SELECT = "SELECT", e.TIME = "TIME", e.COPROC = "COPROC", e.WORD = "WORD", e.NAME = "NAME", e.NUMBER = "NUMBER", e.ASSIGNMENT_WORD = "ASSIGNMENT_WORD", e.FD_VARIABLE = "FD_VARIABLE", e.COMMENT = "COMMENT", e.HEREDOC_CONTENT = "HEREDOC_CONTENT";
+})(p || (p = {}));
+new Map([
+	["if", p.IF],
+	["then", p.THEN],
+	["else", p.ELSE],
+	["elif", p.ELIF],
+	["fi", p.FI],
+	["for", p.FOR],
+	["while", p.WHILE],
+	["until", p.UNTIL],
+	["do", p.DO],
+	["done", p.DONE],
+	["case", p.CASE],
+	["esac", p.ESAC],
+	["in", p.IN],
+	["function", p.FUNCTION],
+	["select", p.SELECT],
+	["time", p.TIME],
+	["coproc", p.COPROC]
+]);
+p.SEMI_SEMI_AND, p.TLESS, p.AND_DGREAT;
+p.DBRACK_START, p.DBRACK_END, p.DPAREN_START, p.DPAREN_END, p.AND_AND, p.OR_OR, p.DSEMI, p.SEMI_AND, p.PIPE_AMP, p.DGREAT, p.LESSAND, p.GREATAND, p.LESSGREAT, p.CLOBBER, p.AND_GREAT;
+new Map([
+	["|", p.PIPE],
+	["&", p.AMP],
+	[";", p.SEMICOLON],
+	["(", p.LPAREN],
+	[")", p.RPAREN],
+	["<", p.LESS],
+	[">", p.GREAT]
+]);
+new Set([
+	p.LESS,
+	p.GREAT,
+	p.DLESS,
+	p.DGREAT,
+	p.LESSAND,
+	p.GREATAND,
+	p.LESSGREAT,
+	p.DLESSDASH,
+	p.CLOBBER,
+	p.TLESS,
+	p.AND_GREAT,
+	p.AND_DGREAT
+]);
+new Set([
+	p.LESS,
+	p.GREAT,
+	p.DLESS,
+	p.DGREAT,
+	p.LESSAND,
+	p.GREATAND,
+	p.LESSGREAT,
+	p.DLESSDASH,
+	p.CLOBBER,
+	p.TLESS
+]);
+new Set([
+	p.LESS,
+	p.GREAT,
+	p.DLESS,
+	p.DGREAT,
+	p.LESSAND,
+	p.GREATAND,
+	p.LESSGREAT,
+	p.DLESSDASH,
+	p.CLOBBER,
+	p.TLESS,
+	p.AND_GREAT,
+	p.AND_DGREAT
+]);
+new Set([
+	p.AMP,
+	p.PIPE,
+	p.PIPE_AMP,
+	p.SEMICOLON,
+	p.AND_AND,
+	p.OR_OR,
+	p.DSEMI,
+	p.SEMI_AND,
+	p.SEMI_SEMI_AND
+]);
+//#endregion
+//#region ../../packages/manifest/dist/discovery-CWjr_liZ.mjs
+const SOURCE_EXT = /\.(ts|mts|mjs|js)$/;
+const DECLARATION_FILE$1 = /\.d\.(ts|mts|cts)$/;
+function entryIdFromFile(rootDir, filePath, options) {
+	if (DECLARATION_FILE$1.test(filePath)) return null;
+	const baseName = filePath.split(sep).at(-1) ?? "";
+	if (/\.(int\.)?test\.(ts|mts)$/.test(baseName)) return null;
+	const segments = relative(rootDir, filePath).replace(SOURCE_EXT, "").split(sep).filter((segment) => segment.length > 0);
+	if (segments.length === 1) return segments[0] ?? null;
+	const last = segments.at(-1);
+	const entryNames = new Set([options.nestedEntry]);
+	if (options.allowIndex !== false) entryNames.add("index");
+	if (!last || !entryNames.has(last)) return null;
+	const id = segments.slice(0, -1).join("/");
+	return id.length > 0 ? id : null;
+}
+const SOURCE_FILE = /\.(ts|mts|mjs|js)$/;
+const TEST_FILE = /\.(int\.)?test\.(ts|mts)$/;
+const DECLARATION_FILE = /\.d\.(ts|mts|cts)$/;
+const JUNK_FILE = /^\._|\.DS_Store$/;
+async function walkTypeScriptFiles(dir) {
+	let names;
+	try {
+		names = await readdir(dir);
+	} catch (error) {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	}
+	const files = [];
+	for (const name of names) {
+		const path = join(dir, name);
+		if ((await stat(path)).isDirectory()) files.push(...await walkTypeScriptFiles(path));
+		else if (!JUNK_FILE.test(name) && SOURCE_FILE.test(name) && !DECLARATION_FILE.test(name) && !TEST_FILE.test(name)) files.push(path);
+	}
+	return files;
+}
+async function discoverEntries(rootDir, options) {
+	const files = await walkTypeScriptFiles(rootDir);
+	const byKey = /* @__PURE__ */ new Map();
+	for (const filePath of files) {
+		const id = entryIdFromFile(rootDir, filePath, options);
+		if (!id) continue;
+		const key = options.formatKey(id);
+		const moduleFile = relative(rootDir, filePath);
+		const existing = byKey.get(key);
+		if (existing) throw new Error(`Duplicate ${options.duplicateLabel} ${key}: ${existing.filePath} and ${filePath}`);
+		byKey.set(key, {
+			key,
+			filePath,
+			moduleFile
+		});
+	}
+	return [...byKey.values()];
+}
+async function discoverModuleFileEntries(rootDir, options) {
+	return (await discoverEntries(rootDir, {
+		nestedEntry: options.nestedEntry,
+		formatKey: (id) => id,
+		duplicateLabel: options.duplicateLabel
+	})).filter((entry) => options.shouldDiscoverFile?.(entry.filePath) ?? true).map(({ filePath, moduleFile }) => ({
+		filePath,
+		moduleFile
+	}));
+}
+const HEADER_BYTES = 2048;
+const DIRECTIVE_RE = /@keystroke\s+ignore(?::([a-z]+))?/;
+/** Parse `@keystroke ignore` directives from a file header snippet. */
+function parseKeystrokeIgnoreDirective(header) {
+	for (const line of header.slice(0, HEADER_BYTES).split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed.length === 0) continue;
+		if (!isCommentLine(trimmed)) break;
+		const match = DIRECTIVE_RE.exec(trimmed);
+		if (!match) continue;
+		const scope = match[1];
+		if (!scope) return "ignore";
+		if (scope === "deploy") return "ignore:deploy";
+		throw new Error(`Unknown @keystroke ignore target "${scope}" in directive "@keystroke ignore:${scope}"`);
+	}
+	return null;
+}
+/** Read `@keystroke ignore` directives from the top of a module file. */
+function readKeystrokeIgnoreDirective(filePath) {
+	return parseKeystrokeIgnoreDirective(readFileSync(filePath, "utf8").slice(0, HEADER_BYTES));
+}
+/** Whether a discovered module file should be skipped for the given build phase. */
+function shouldSkipKeystrokeModuleFile(directive, phase) {
+	if (!directive) return false;
+	if (directive === "ignore") return true;
+	return phase === "deploy";
+}
+function isCommentLine(line) {
+	return line.startsWith("//") || line.startsWith("/*") || line.startsWith("*");
+}
+//#endregion
+//#region ../../packages/sandbox/dist/files-XxiqkzS0.mjs
+const SandboxFileContentSchema = object({
+	path: string(),
+	file: string()
+});
+/** Destination path under `/workspace`. For `dir`, used as a prefix. */
+const SandboxFileSchema = object({
+	path: string(),
+	/** Single file body — typically from a build-time import (`import doc from "./doc.md"`). */
+	file: string().optional(),
+	/** Directory contents — each path is relative to `path`. */
+	dir: array(SandboxFileContentSchema).optional()
+});
+object({
+	key: string().optional(),
+	files: array(SandboxFileSchema).optional()
+});
+const SKIP_DIRS$1 = new Set([".git", "node_modules"]);
+/** Recursively read a host file or directory into sandbox-relative `{ path, file }` entries. */
+function packDirFromDisk(rootPath) {
+	const stat = statSync(rootPath);
+	if (stat.isFile()) return [{
+		path: basename(rootPath),
+		file: readFileSync(rootPath, "utf8")
+	}];
+	if (!stat.isDirectory()) throw new Error(`Expected a file or directory at ${rootPath}`);
+	const files = [];
+	walkDir(rootPath, rootPath, files);
+	return files;
+}
+function walkDir(rootPath, currentPath, files) {
+	for (const name of readdirSync(currentPath)) {
+		if (SKIP_DIRS$1.has(name)) continue;
+		const entryPath = join(currentPath, name);
+		const stat = statSync(entryPath);
+		if (stat.isDirectory()) {
+			walkDir(rootPath, entryPath, files);
+			continue;
+		}
+		if (!stat.isFile()) continue;
+		files.push({
+			path: relative(rootPath, entryPath),
+			file: readFileSync(entryPath, "utf8")
+		});
+	}
+}
+const SKIP_DIRS$2 = new Set([".git", "node_modules"]);
+/** Pack every subdir under `src/skills/` and `src/files/` into an asset manifest. */
+function packAssetDirs(appRoot, srcDir = "src") {
+	return {
+		skills: packAssetRoot(join(appRoot, srcDir, "skills")),
+		files: packAssetRoot(join(appRoot, srcDir, "files"))
+	};
+}
+function packAssetRoot(rootPath) {
+	if (!statSync(rootPath, { throwIfNoEntry: false })?.isDirectory()) return {};
+	const manifest = {};
+	for (const name of readdirSync(rootPath)) {
+		if (SKIP_DIRS$2.has(name)) continue;
+		const entryPath = join(rootPath, name);
+		if (!statSync(entryPath).isDirectory()) continue;
+		manifest[name] = packDirFromDisk(entryPath);
+	}
+	return manifest;
+}
+const appRootStorage = new AsyncLocalStorage();
+/** Run with an explicit user-app root (parallel-safe alternative to mutating `KEYSTROKE_ROOT`). */
+function runWithAppRoot(appRoot, fn) {
+	return appRootStorage.run(appRoot, fn);
+}
+/** Walk upward from a module file to find the user app root (`src/agents`, `src/skills`, etc.). */
+function resolveAppRoot(fromPath) {
+	let dir = statSync(fromPath).isDirectory() ? fromPath : dirname(fromPath);
+	while (dir !== dirname(dir)) {
+		if (hasAppLayout(dir)) return dir;
+		dir = dirname(dir);
+	}
+	return process.env.KEYSTROKE_ROOT ?? process.cwd();
+}
+function hasAppLayout(dir) {
+	const src = join(dir, "src");
+	const dist = join(dir, "dist");
+	return existsSync(join(src, "agents")) || existsSync(join(src, "skills")) || existsSync(join(src, "files")) || existsSync(join(dist, "agents")) || existsSync(join(dist, ".keystroke", "assets.mjs"));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/system/memory/metrics.mjs
+/** TypeBox instantiation metrics */
+const Metrics = {
+	assign: 0,
+	create: 0,
+	clone: 0,
+	discard: 0,
+	update: 0
+};
+//#endregion
+//#region ../../node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/guard/guard.mjs
+/** Returns true if this value is an array */
+function IsArray(value) {
+	return Array.isArray(value);
+}
+/** Returns true if this value is null */
+function IsNull(value) {
+	return IsEqual(value, null);
+}
+/** Returns true if this value is an object */
+function IsObject(value) {
+	return IsEqual(typeof value, "object") && !IsNull(value);
+}
+function IsEqual(left, right) {
+	return left === right;
+}
+/** Returns true if the PropertyKey is Unsafe (ref: prototype-pollution). */
+function IsUnsafePropertyKey(key) {
+	return IsEqual(key, "__proto__") || IsEqual(key, "constructor") || IsEqual(key, "prototype");
+}
+/** Returns true if this value has this property key */
+function HasPropertyKey(value, key) {
+	return IsUnsafePropertyKey(key) ? Object.prototype.hasOwnProperty.call(value, key) : key in value;
+}
+/** Returns property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
+function Keys(value) {
+	return Object.getOwnPropertyNames(value);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/system/memory/clone.mjs
+function IsGuard(value) {
+	return IsObject(value) && HasPropertyKey(value, "~guard");
+}
+function FromGuard(value) {
+	return value;
+}
+function FromArray(value) {
+	return value.map((value) => FromValue(value));
+}
+function FromObject(value) {
+	const result = {};
+	const descriptors = Object.getOwnPropertyDescriptors(value);
+	for (const key of Object.keys(descriptors)) {
+		const descriptor = descriptors[key];
+		if (HasPropertyKey(descriptor, "value")) Object.defineProperty(result, key, {
+			...descriptor,
+			value: FromValue(descriptor.value)
+		});
+	}
+	return result;
+}
+function FromRegExp(value) {
+	return new RegExp(value.source, value.flags);
+}
+function FromUnknown(value) {
+	return value;
+}
+function FromValue(value) {
+	return value instanceof RegExp ? FromRegExp(value) : IsGuard(value) ? FromGuard(value) : IsArray(value) ? FromArray(value) : IsObject(value) ? FromObject(value) : FromUnknown(value);
+}
+/**
+* Clones a value using the TypeBox type cloning strategy. This function preserves non-enumerable
+* properties from the source value. This is to ensure cloned types retain discriminable
+* hidden properties.
+*/
+function Clone(value) {
+	Metrics.clone += 1;
+	return FromValue(value);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/system/settings/settings.mjs
+const settings = {
+	immutableTypes: false,
+	maxErrors: 8,
+	useAcceleration: true,
+	exactOptionalPropertyTypes: false,
+	enumerableKind: false,
+	correctiveParse: false
+};
+/** Gets current system settings */
+function Get() {
+	return settings;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/system/memory/create.mjs
+function MergeHidden(left, right) {
+	for (const key of Object.keys(right)) Object.defineProperty(left, key, {
+		configurable: true,
+		writable: true,
+		enumerable: false,
+		value: right[key]
+	});
+	return left;
+}
+function Merge(left, right) {
+	return {
+		...left,
+		...right
+	};
+}
+/**
+* Creates an object with hidden, enumerable, and optional property sets. This function
+* ensures types are instantiated according to configuration rules for enumerable and
+* non-enumerable properties.
+*/
+function Create(hidden, enumerable, options = {}) {
+	Metrics.create += 1;
+	const settings = Get();
+	const withOptions = Merge(enumerable, options);
+	const withHidden = settings.enumerableKind ? Merge(withOptions, hidden) : MergeHidden(withOptions, hidden);
+	return settings.immutableTypes ? Object.freeze(withHidden) : withHidden;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/system/memory/update.mjs
+/**
+* Updates a value with new properties while preserving property enumerability. Use this function to modify
+* existing types without altering their configuration.
+*/
+function Update(current, hidden, enumerable) {
+	Metrics.update += 1;
+	const settings = Get();
+	const result = Clone(current);
+	for (const key of Object.keys(hidden)) Object.defineProperty(result, key, {
+		configurable: true,
+		writable: true,
+		enumerable: settings.enumerableKind,
+		value: hidden[key]
+	});
+	for (const key of Object.keys(enumerable)) Object.defineProperty(result, key, {
+		configurable: true,
+		enumerable: true,
+		writable: true,
+		value: enumerable[key]
+	});
+	return result;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/types/schema.mjs
+function IsSchema(value) {
+	return IsObject(value);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/types/_optional.mjs
+/** Adds Optional to the given type. */
+function OptionalAdd(type) {
+	return Update(type, { "~optional": true }, {});
+}
+/** Applies an Optional modifier to the given type. */
+function Optional(type) {
+	return OptionalAdd(type);
+}
+/** Returns true if the given value is TOptional */
+function IsOptional(value) {
+	return IsSchema(value) && HasPropertyKey(value, "~optional");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/types/array.mjs
+/** Creates an Array type. */
+function _Array_(items, options) {
+	return Create({ "~kind": "Array" }, {
+		type: "array",
+		items
+	}, options);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/types/properties.mjs
+/** Creates a RequiredArray derived from the given TProperties value. */
+function RequiredArray(properties) {
+	return Keys(properties).filter((key) => !IsOptional(properties[key]));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/types/object.mjs
+/** Creates an Object type. */
+function _Object_(properties, options = {}) {
+	const requiredKeys = RequiredArray(properties);
+	return Create({ "~kind": "Object" }, {
+		type: "object",
+		...requiredKeys.length > 0 ? { required: requiredKeys } : {},
+		properties
+	}, options);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/system/hashing/hash.mjs
+var ByteMarker;
+(function(ByteMarker) {
+	ByteMarker[ByteMarker["Array"] = 0] = "Array";
+	ByteMarker[ByteMarker["BigInt"] = 1] = "BigInt";
+	ByteMarker[ByteMarker["Boolean"] = 2] = "Boolean";
+	ByteMarker[ByteMarker["Date"] = 3] = "Date";
+	ByteMarker[ByteMarker["Constructor"] = 4] = "Constructor";
+	ByteMarker[ByteMarker["Function"] = 5] = "Function";
+	ByteMarker[ByteMarker["Null"] = 6] = "Null";
+	ByteMarker[ByteMarker["Number"] = 7] = "Number";
+	ByteMarker[ByteMarker["Object"] = 8] = "Object";
+	ByteMarker[ByteMarker["RegExp"] = 9] = "RegExp";
+	ByteMarker[ByteMarker["String"] = 10] = "String";
+	ByteMarker[ByteMarker["Symbol"] = 11] = "Symbol";
+	ByteMarker[ByteMarker["TypeArray"] = 12] = "TypeArray";
+	ByteMarker[ByteMarker["Undefined"] = 13] = "Undefined";
+})(ByteMarker || (ByteMarker = {}));
+Array.from({ length: 256 }).map((_, i) => BigInt(i));
+const F64 = new Float64Array(1);
+new DataView(F64.buffer);
+new Uint8Array(F64.buffer);
+new TextEncoder();
+//#endregion
+//#region ../../node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/types/integer.mjs
+const IntegerPattern = "-?(?:0|[1-9][0-9]*)";
+/** Creates a Number type. */
+function Number$1(options) {
+	return Create({ "~kind": "Number" }, { type: "number" }, options);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/types/string.mjs
+/** Creates a String type. */
+function String$1(options) {
+	return Create({ "~kind": "String" }, { type: "string" }, options);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/types/record.mjs
+const IntegerKey = `^${IntegerPattern}$`;
+//#endregion
+//#region ../../node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/script/token/internal/char.mjs
+function Range(start, end) {
+	return Array.from({ length: end - start + 1 }, (_, i) => String.fromCharCode(start + i));
+}
+const Alpha = [...Range(97, 122), ...Range(65, 90)];
+const Digit = ["0", ...Range(49, 57)];
+[...Digit];
+[...[
+	...Alpha,
+	"_",
+	"$"
+], ...Digit];
+[...Digit];
+new RegExp(IntegerKey);
+//#endregion
+//#region ../../packages/sandbox/dist/create-coding-tools-5--zCsRF.mjs
+const replaceEditSchema = _Object_({
+	oldText: String$1({ description: "Exact text to replace. Must be unique in the file and must not overlap other edits in this call." }),
+	newText: String$1({ description: "Replacement text" })
+}, { additionalProperties: false });
+_Object_({
+	path: String$1({ description: "Path to the file to edit (under /workspace)" }),
+	edits: _Array_(replaceEditSchema, { description: "Replacements applied against the original file (not chained). Each oldText must be unique and non-overlapping." })
+}, { additionalProperties: false });
+_Object_({
+	path: String$1({ description: "Path to the file to read (under /workspace)" }),
+	offset: Optional(Number$1({ description: "Line number to start reading from (1-indexed)" })),
+	limit: Optional(Number$1({ description: "Maximum number of lines to read" }))
+});
+_Object_({
+	path: String$1({ description: "Path to the file to write (under /workspace)" }),
+	content: String$1({ description: "Content to write to the file" })
+});
+//#endregion
+//#region ../../node_modules/.pnpm/just-bash@3.0.1/node_modules/just-bash/dist/bundle/index.js
+createRequire(import.meta.url);
+var tt = [
+	{
+		name: "echo",
+		load: async () => (await import("./echo-NDWZZHPO-CCp_-MxA.mjs")).echoCommand
+	},
+	{
+		name: "cat",
+		load: async () => (await import("./cat-TSFMZVYS-Dz3-oHsV.mjs")).catCommand
+	},
+	{
+		name: "printf",
+		load: async () => (await import("./printf-TWGXF445-B7cTysaa.mjs")).printfCommand
+	},
+	{
+		name: "ls",
+		load: async () => (await import("./ls-ZJGQER7M-DLDSfI4x.mjs")).lsCommand
+	},
+	{
+		name: "mkdir",
+		load: async () => (await import("./mkdir-MEPGZOB6-BjUKzhdL.mjs")).mkdirCommand
+	},
+	{
+		name: "rmdir",
+		load: async () => (await import("./rmdir-OC4ZLPYA-D3QCHlIB.mjs")).rmdirCommand
+	},
+	{
+		name: "touch",
+		load: async () => (await import("./touch-UA33VN3N-oW1SBT1r.mjs")).touchCommand
+	},
+	{
+		name: "rm",
+		load: async () => (await import("./rm-SSGETQVQ-Ch53Rmrr.mjs")).rmCommand
+	},
+	{
+		name: "cp",
+		load: async () => (await import("./cp-BISAAS7A-CMWayU4n.mjs")).cpCommand
+	},
+	{
+		name: "mv",
+		load: async () => (await import("./mv-W5BIQ646-CdSIyY-U.mjs")).mvCommand
+	},
+	{
+		name: "ln",
+		load: async () => (await import("./ln-4LGSXXGD-Dg0R9i5G.mjs")).lnCommand
+	},
+	{
+		name: "chmod",
+		load: async () => (await import("./chmod-TFEPA42X-YF02QJUv.mjs")).chmodCommand
+	},
+	{
+		name: "pwd",
+		load: async () => (await import("./pwd-WE6EN5AV-CO8o2WQS.mjs")).pwdCommand
+	},
+	{
+		name: "readlink",
+		load: async () => (await import("./readlink-OPJF4DL5-Rc1Mz_Xx.mjs")).readlinkCommand
+	},
+	{
+		name: "head",
+		load: async () => (await import("./head-442HYESI-D96RMdki.mjs")).headCommand
+	},
+	{
+		name: "tail",
+		load: async () => (await import("./tail-R4PCA2C4-CUfroNeu.mjs")).tailCommand
+	},
+	{
+		name: "wc",
+		load: async () => (await import("./wc-LF7NU4LA-BFPabrwD.mjs")).wcCommand
+	},
+	{
+		name: "stat",
+		load: async () => (await import("./stat-CD34IZ4P-B5ZOJh4J.mjs")).statCommand
+	},
+	{
+		name: "grep",
+		load: async () => (await import("./grep-V3LQVMRQ-D99Bq7Kj.mjs")).grepCommand
+	},
+	{
+		name: "fgrep",
+		load: async () => (await import("./grep-V3LQVMRQ-D99Bq7Kj.mjs")).fgrepCommand
+	},
+	{
+		name: "egrep",
+		load: async () => (await import("./grep-V3LQVMRQ-D99Bq7Kj.mjs")).egrepCommand
+	},
+	{
+		name: "rg",
+		load: async () => (await import("./rg-S4FXYXWB-BbXVo6JX.mjs")).rgCommand
+	},
+	{
+		name: "sed",
+		load: async () => (await import("./sed-S5UIK574-DE1KeTk3.mjs")).sedCommand
+	},
+	{
+		name: "awk",
+		load: async () => (await import("./awk2-LA3USKJP-BbsfXVlR.mjs")).awkCommand2
+	},
+	{
+		name: "sort",
+		load: async () => (await import("./sort-SW2YEO5B-B7j1zw8k.mjs")).sortCommand
+	},
+	{
+		name: "uniq",
+		load: async () => (await import("./uniq-XSIZR6PB-D5lt-IXF.mjs")).uniqCommand
+	},
+	{
+		name: "comm",
+		load: async () => (await import("./comm-VV2LDX2J-ppxDJFkY.mjs")).commCommand
+	},
+	{
+		name: "cut",
+		load: async () => (await import("./cut-OKARJCCV-Bt8b58eI.mjs")).cutCommand
+	},
+	{
+		name: "paste",
+		load: async () => (await import("./paste-7JC6S4DX-CtmM5Qy8.mjs")).pasteCommand
+	},
+	{
+		name: "tr",
+		load: async () => (await import("./tr-36LHWFRQ-CTq3z6wq.mjs")).trCommand
+	},
+	{
+		name: "rev",
+		load: async () => (await import("./rev-5EHFX4EJ-3dd9vwHW.mjs")).rev
+	},
+	{
+		name: "nl",
+		load: async () => (await import("./nl-WSDW7I4O-DmtCnyKU.mjs")).nl
+	},
+	{
+		name: "fold",
+		load: async () => (await import("./fold-4TQNYMSW-C54bHzLd.mjs")).fold
+	},
+	{
+		name: "expand",
+		load: async () => (await import("./expand-JSPG6VOP-B-YUvYpu.mjs")).expand
+	},
+	{
+		name: "unexpand",
+		load: async () => (await import("./unexpand-CADSA4VO-Cq9DTcUg.mjs")).unexpand
+	},
+	{
+		name: "strings",
+		load: async () => (await import("./strings-6WDHLGMX-DdiEdoL-.mjs")).strings
+	},
+	{
+		name: "split",
+		load: async () => (await import("./split-4KKZZXXE-h8GD4HP4.mjs")).split
+	},
+	{
+		name: "column",
+		load: async () => (await import("./column-XT6UFXNQ-DHENV9D2.mjs")).column
+	},
+	{
+		name: "join",
+		load: async () => (await import("./join-TBRGI3LQ-B8I9tkJ5.mjs")).join
+	},
+	{
+		name: "tee",
+		load: async () => (await import("./tee-YUZ2FKCJ-po_dfyc_.mjs")).teeCommand
+	},
+	{
+		name: "find",
+		load: async () => (await import("./find-INTH3OLC-6p47KeeT.mjs")).findCommand
+	},
+	{
+		name: "basename",
+		load: async () => (await import("./basename-UB3CIYNI-BgNN3bGm.mjs")).basenameCommand
+	},
+	{
+		name: "dirname",
+		load: async () => (await import("./dirname-MPHRFUTI-Dkb3S4OX.mjs")).dirnameCommand
+	},
+	{
+		name: "tree",
+		load: async () => (await import("./tree-YLD52CNT-CIozNsLQ.mjs")).treeCommand
+	},
+	{
+		name: "du",
+		load: async () => (await import("./du-572XNP42-ClP4jXB1.mjs")).duCommand
+	},
+	{
+		name: "env",
+		load: async () => (await import("./env-36M5BO7M-CsP_aiWr.mjs")).envCommand
+	},
+	{
+		name: "printenv",
+		load: async () => (await import("./env-36M5BO7M-CsP_aiWr.mjs")).printenvCommand
+	},
+	{
+		name: "alias",
+		load: async () => (await import("./alias-RTYYYW3D-CLFgrowj.mjs")).aliasCommand
+	},
+	{
+		name: "unalias",
+		load: async () => (await import("./alias-RTYYYW3D-CLFgrowj.mjs")).unaliasCommand
+	},
+	{
+		name: "history",
+		load: async () => (await import("./history-WYYKSLSZ-ACNQVupn.mjs")).historyCommand
+	},
+	{
+		name: "xargs",
+		load: async () => (await import("./xargs-MGZPH7AX-D2bIgrdg.mjs")).xargsCommand
+	},
+	{
+		name: "true",
+		load: async () => (await import("./true-FHQXJXBE-DsJOznSp.mjs")).trueCommand
+	},
+	{
+		name: "false",
+		load: async () => (await import("./true-FHQXJXBE-DsJOznSp.mjs")).falseCommand
+	},
+	{
+		name: "clear",
+		load: async () => (await import("./clear-HKGFEOF6-CekN2x-O.mjs")).clearCommand
+	},
+	{
+		name: "bash",
+		load: async () => (await import("./bash-YZ33HQZQ-N6YyKtUH.mjs")).bashCommand
+	},
+	{
+		name: "sh",
+		load: async () => (await import("./bash-YZ33HQZQ-N6YyKtUH.mjs")).shCommand
+	},
+	{
+		name: "jq",
+		load: async () => (await import("./jq-4XLYLOS5-wFZYfsfJ.mjs")).jqCommand
+	},
+	{
+		name: "base64",
+		load: async () => (await import("./base64-C2AIWVNC-C0WIgu5V.mjs")).base64Command
+	},
+	{
+		name: "diff",
+		load: async () => (await import("./diff-MWJFIG7X-DhnPc_5r.mjs")).diffCommand
+	},
+	{
+		name: "date",
+		load: async () => (await import("./date-UUUPW43J-B7T5OTZZ.mjs")).dateCommand
+	},
+	{
+		name: "sleep",
+		load: async () => (await import("./sleep-X22JJINO-Do5hEQQW.mjs")).sleepCommand
+	},
+	{
+		name: "timeout",
+		load: async () => (await import("./timeout-YDCRSLPQ-B_yntmXU.mjs")).timeoutCommand
+	},
+	{
+		name: "time",
+		load: async () => (await import("./time-D4LNBSWX-DVWhAldK.mjs")).timeCommand
+	},
+	{
+		name: "seq",
+		load: async () => (await import("./seq-M5EC7Q57-BHfGjQvK.mjs")).seqCommand
+	},
+	{
+		name: "expr",
+		load: async () => (await import("./expr-5JAACS4X-1TBq84gG.mjs")).exprCommand
+	},
+	{
+		name: "md5sum",
+		load: async () => (await import("./md5sum-SPU24VSG-DQc8sqXO.mjs")).md5sumCommand
+	},
+	{
+		name: "sha1sum",
+		load: async () => (await import("./sha1sum-2PTOAFR6-DNjSNcYK.mjs")).sha1sumCommand
+	},
+	{
+		name: "sha256sum",
+		load: async () => (await import("./sha256sum-NS7D3IXX-BMaCKkT5.mjs")).sha256sumCommand
+	},
+	{
+		name: "file",
+		load: async () => (await import("./file-IPZJC3FQ-DcZNOWyY.mjs")).fileCommand
+	},
+	{
+		name: "html-to-markdown",
+		load: async () => (await import("./html-to-markdown-JW4MSQZO-DQOxFIvF.mjs")).htmlToMarkdownCommand
+	},
+	{
+		name: "help",
+		load: async () => (await import("./help-HZ6M2CKN--DK8mY2L.mjs")).helpCommand
+	},
+	{
+		name: "which",
+		load: async () => (await import("./which-XEM24D5D-2LvlkpUo.mjs")).whichCommand
+	},
+	{
+		name: "tac",
+		load: async () => (await import("./tac-2STMMJYW-DPyeWM9R.mjs")).tac
+	},
+	{
+		name: "hostname",
+		load: async () => (await import("./hostname-C4HQXXUP-CXVVFkUK.mjs")).hostname
+	},
+	{
+		name: "whoami",
+		load: async () => (await import("./whoami-XMTX52VE-24Kwqrk6.mjs")).whoami
+	},
+	{
+		name: "od",
+		load: async () => (await import("./od-WOKFDJTP-DZ2nxQNJ.mjs")).od
+	},
+	{
+		name: "gzip",
+		load: async () => (await import("./gzip-O5ASJAFY-CZDRROqP.mjs")).gzipCommand
+	},
+	{
+		name: "gunzip",
+		load: async () => (await import("./gzip-O5ASJAFY-CZDRROqP.mjs")).gunzipCommand
+	},
+	{
+		name: "zcat",
+		load: async () => (await import("./gzip-O5ASJAFY-CZDRROqP.mjs")).zcatCommand
+	}
+];
+(typeof __BROWSER__ > "u" || !__BROWSER__) && (tt.push({
+	name: "tar",
+	load: async () => (await import("./tar-STHHZTZ6-DRf60e-G.mjs")).tarCommand
+}), tt.push({
+	name: "yq",
+	load: async () => (await import("./yq-4QJW3EQG-XhB3aACo.mjs")).yqCommand
+}), tt.push({
+	name: "xan",
+	load: async () => (await import("./xan-Y6WF3IRG-DjKO96Pj.mjs")).xanCommand
+}), tt.push({
+	name: "sqlite3",
+	load: async () => (await import("./sqlite3-CGOEFJAO-DvzzghDg.mjs")).sqlite3Command
+}));
+var Yt = [];
+(typeof __BROWSER__ > "u" || !__BROWSER__) && (Yt.push({
+	name: "python3",
+	load: async () => (await import("./python3-POMOR4OA-CKy80mpF.mjs")).python3Command
+}), Yt.push({
+	name: "python",
+	load: async () => (await import("./python3-POMOR4OA-CKy80mpF.mjs")).pythonCommand
+}));
+var Qt = [];
+(typeof __BROWSER__ > "u" || !__BROWSER__) && (Qt.push({
+	name: "js-exec",
+	load: async () => (await import("./js-exec-N5KEZBH7-CgtG-I6s.mjs")).jsExecCommand
+}), Qt.push({
+	name: "node",
+	load: async () => (await import("./js-exec-N5KEZBH7-CgtG-I6s.mjs")).nodeStubCommand
+}));
+new TextEncoder();
+Object.freeze({
+	stdout: "",
+	stderr: "",
+	exitCode: 0
+});
+[...new Map([
+	[":", [": [arguments]", `Null command.
+    No effect; the command does nothing.
+    Exit Status:
+    Always succeeds.`]],
+	[".", [". filename [arguments]", `Execute commands from a file in the current shell.
+    Read and execute commands from FILENAME in the current shell.
+    The entries in $PATH are used to find the directory containing FILENAME.
+    Exit Status:
+    Returns the status of the last command executed in FILENAME.`]],
+	["[", ["[ arg... ]", `Evaluate conditional expression.
+    This is a synonym for the "test" builtin, but the last argument must
+    be a literal \`]', to match the opening \`['.`]],
+	["alias", ["alias [-p] [name[=value] ... ]", `Define or display aliases.
+    Without arguments, \`alias' prints the list of aliases in the reusable
+    form \`alias NAME=VALUE' on standard output.
+    Exit Status:
+    alias returns true unless a NAME is supplied for which no alias has been
+    defined.`]],
+	["bg", ["bg [job_spec ...]", `Move jobs to the background.
+    Place the jobs identified by each JOB_SPEC in the background, as if they
+    had been started with \`&'.`]],
+	["break", ["break [n]", `Exit for, while, or until loops.
+    Exit a FOR, WHILE or UNTIL loop.  If N is specified, break N enclosing
+    loops.
+    Exit Status:
+    The exit status is 0 unless N is not greater than or equal to 1.`]],
+	["builtin", ["builtin [shell-builtin [arg ...]]", `Execute shell builtins.
+    Execute SHELL-BUILTIN with arguments ARGs without performing command
+    lookup.  This is useful when you wish to reimplement a shell builtin
+    as a shell function, but need to execute the builtin within the function.
+    Exit Status:
+    Returns the exit status of SHELL-BUILTIN, or false if SHELL-BUILTIN is
+    not a shell builtin.`]],
+	["caller", ["caller [expr]", `Return the context of the current subroutine call.
+    Without EXPR, returns "$line $filename".  With EXPR, returns
+    "$line $subroutine $filename"; this extra information can be used to
+    provide a stack trace.
+    Exit Status:
+    Returns 0 unless the shell is not executing a subroutine call or
+    EXPR is invalid.`]],
+	["cd", ["cd [-L|-P] [dir]", `Change the shell working directory.
+    Change the current directory to DIR.  The default DIR is the value of the
+    HOME shell variable.
+
+    The variable CDPATH defines the search path for the directory containing
+    DIR.  Alternative directory names in CDPATH are separated by a colon (:).
+    A null directory name is the same as the current directory.  If DIR begins
+    with a slash (/), then CDPATH is not used.
+
+    If the directory is not found, and the shell option \`cdable_vars' is set,
+    the word is assumed to be a variable name.  If that variable has a value,
+    its value is used for DIR.
+
+    Options:
+      -L	force symbolic links to be followed
+      -P	use the physical directory structure without following symbolic
+    	links
+
+    The default is to follow symbolic links, as if \`-L' were specified.
+
+    Exit Status:
+    Returns 0 if the directory is changed; non-zero otherwise.`]],
+	["command", ["command [-pVv] command [arg ...]", `Execute a simple command or display information about commands.
+    Runs COMMAND with ARGS suppressing shell function lookup, or display
+    information about the specified COMMANDs.
+
+    Options:
+      -p	use a default value for PATH that is guaranteed to find all of
+    	the standard utilities
+      -v	print a description of COMMAND similar to the \`type' builtin
+      -V	print a more verbose description of each COMMAND
+
+    Exit Status:
+    Returns exit status of COMMAND, or failure if COMMAND is not found.`]],
+	["compgen", ["compgen [-abcdefgjksuv] [-o option] [-A action] [-G globpat] [-W wordlist]  [-F function] [-C command] [-X filterpat] [-P prefix] [-S suffix] [word]", `Display possible completions depending on the options.
+    Intended to be used from within a shell function generating possible
+    completions.  If the optional WORD argument is supplied, matches against
+    WORD are generated.
+    Exit Status:
+    Returns success unless an invalid option is supplied or an error occurs.`]],
+	["complete", ["complete [-abcdefgjksuv] [-pr] [-DEI] [-o option] [-A action] [-G globpat] [-W wordlist]  [-F function] [-C command] [-X filterpat] [-P prefix] [-S suffix] [name ...]", `Specify how arguments are to be completed.
+    For each NAME, specify how arguments are to be completed.
+    Exit Status:
+    Returns success unless an invalid option is supplied or an error occurs.`]],
+	["continue", ["continue [n]", `Resume for, while, or until loops.
+    Resumes the next iteration of the enclosing FOR, WHILE or UNTIL loop.
+    If N is specified, resumes the Nth enclosing loop.
+    Exit Status:
+    The exit status is 0 unless N is not greater than or equal to 1.`]],
+	["declare", ["declare [-aAfFgilnrtux] [-p] [name[=value] ...]", `Set variable values and attributes.
+    Declare variables and give them attributes.  If no NAMEs are given,
+    display the attributes and values of all variables.
+
+    Options:
+      -a	to make NAMEs indexed arrays (if supported)
+      -A	to make NAMEs associative arrays (if supported)
+      -i	to make NAMEs have the \`integer' attribute
+      -l	to convert the value of each NAME to lower case on assignment
+      -n	make NAME a reference to the variable named by its value
+      -r	to make NAMEs readonly
+      -t	to make NAMEs have the \`trace' attribute
+      -u	to convert the value of each NAME to upper case on assignment
+      -x	to make NAMEs export
+
+    Exit Status:
+    Returns success unless an invalid option is supplied or a variable
+    assignment error occurs.`]],
+	["dirs", ["dirs [-clpv] [+N] [-N]", `Display directory stack.
+    Display the list of currently remembered directories.  Directories
+    find their way onto the list with the \`pushd' command; you can get
+    back up through the list with the \`popd' command.
+    Exit Status:
+    Returns success unless an invalid option is supplied or an error occurs.`]],
+	["disown", ["disown [-h] [-ar] [jobspec ...]", `Remove jobs from current shell.
+    Without any JOBSPECs, remove the current job.`]],
+	["echo", ["echo [-neE] [arg ...]", `Write arguments to the standard output.
+    Display the ARGs, separated by a single space character and followed by a
+    newline, on the standard output.
+
+    Options:
+      -n	do not append a newline
+      -e	enable interpretation of the following backslash escapes
+      -E	explicitly suppress interpretation of backslash escapes
+
+    Exit Status:
+    Returns success unless a write error occurs.`]],
+	["enable", ["enable [-a] [-dnps] [-f filename] [name ...]", `Enable and disable shell builtins.
+    Enables and disables builtin shell commands.
+    Exit Status:
+    Returns success unless NAME is not a shell builtin or an error occurs.`]],
+	["eval", ["eval [arg ...]", `Execute arguments as a shell command.
+    Combine ARGs into a single string, use the result as input to the shell,
+    and execute the resulting commands.
+    Exit Status:
+    Returns exit status of command or success if command is null.`]],
+	["exec", ["exec [-cl] [-a name] [command [arguments ...]] [redirection ...]", `Replace the shell with the given command.
+    Execute COMMAND, replacing this shell with the specified program.
+    ARGUMENTS become the arguments to COMMAND.  If COMMAND is not specified,
+    any redirections take effect in the current shell.
+    Exit Status:
+    Returns success unless COMMAND is not found or a redirection error occurs.`]],
+	["exit", ["exit [n]", `Exit the shell.
+    Exits the shell with a status of N.  If N is omitted, the exit status
+    is that of the last command executed.`]],
+	["export", ["export [-fn] [name[=value] ...] or export -p", `Set export attribute for shell variables.
+    Marks each NAME for automatic export to the environment of subsequently
+    executed commands.  If VALUE is supplied, assign VALUE before exporting.
+
+    Options:
+      -f	refer to shell functions
+      -n	remove the export property from each NAME
+      -p	display a list of all exported variables and functions
+
+    Exit Status:
+    Returns success unless an invalid option is given or NAME is invalid.`]],
+	["false", ["false", `Return an unsuccessful result.
+    Exit Status:
+    Always fails.`]],
+	["fc", ["fc [-e ename] [-lnr] [first] [last] or fc -s [pat=rep] [command]", `Display or execute commands from the history list.
+    Exit Status:
+    Returns success or status of executed command.`]],
+	["fg", ["fg [job_spec]", `Move job to the foreground.
+    Place the job identified by JOB_SPEC in the foreground, making it the
+    current job.`]],
+	["getopts", ["getopts optstring name [arg]", `Parse option arguments.
+    Getopts is used by shell procedures to parse positional parameters
+    as options.
+
+    OPTSTRING contains the option letters to be recognized; if a letter
+    is followed by a colon, the option is expected to have an argument,
+    which should be separated from it by white space.
+    Exit Status:
+    Returns success if an option is found; fails if the end of options is
+    encountered or an error occurs.`]],
+	["hash", ["hash [-lr] [-p pathname] [-dt] [name ...]", `Remember or display program locations.
+    Determine and remember the full pathname of each command NAME.
+    Exit Status:
+    Returns success unless NAME is not found or an invalid option is given.`]],
+	["help", ["help [-s] [pattern ...]", `Display information about builtin commands.
+    Displays brief summaries of builtin commands.  If PATTERN is
+    specified, gives detailed help on all commands matching PATTERN,
+    otherwise the list of help topics is printed.
+
+    Options:
+      -s	output only a short usage synopsis for each topic matching
+    	PATTERN
+
+    Exit Status:
+    Returns success unless PATTERN is not found.`]],
+	["history", ["history [-c] [-d offset] [n] or history -anrw [filename] or history -ps arg [arg...]", `Display or manipulate the history list.
+    Display the history list with line numbers, prefixing each modified
+    entry with a \`*'.
+    Exit Status:
+    Returns success unless an invalid option is given or an error occurs.`]],
+	["jobs", ["jobs [-lnprs] [jobspec ...] or jobs -x command [args]", `Display status of jobs.
+    Lists the active jobs.
+    Exit Status:
+    Returns success unless an invalid option is given or an error occurs.`]],
+	["kill", ["kill [-s sigspec | -n signum | -sigspec] pid | jobspec ... or kill -l [sigspec]", `Send a signal to a job.
+    Send the processes identified by PID or JOBSPEC the signal named by
+    SIGSPEC or SIGNUM.
+    Exit Status:
+    Returns success unless an invalid option is given or an error occurs.`]],
+	["let", ["let arg [arg ...]", `Evaluate arithmetic expressions.
+    Evaluate each ARG as an arithmetic expression.  Evaluation is done in
+    fixed-width integers with no check for overflow, though division by 0
+    is trapped and flagged as an error.
+    Exit Status:
+    If the last ARG evaluates to 0, let returns 1; 0 is returned otherwise.`]],
+	["local", ["local [option] name[=value] ...", `Define local variables.
+    Create a local variable called NAME, and give it VALUE.  OPTION can
+    be any option accepted by \`declare'.
+
+    Local can only be used within a function; it makes the variable NAME
+    have a visible scope restricted to that function and its children.
+    Exit Status:
+    Returns success unless an invalid option is supplied, a variable
+    assignment error occurs, or the shell is not executing a function.`]],
+	["logout", ["logout [n]", `Exit a login shell.
+    Exits a login shell with exit status N.  Returns an error if not executed
+    in a login shell.`]],
+	["mapfile", ["mapfile [-d delim] [-n count] [-O origin] [-s count] [-t] [-u fd] [-C callback] [-c quantum] [array]", `Read lines from the standard input into an indexed array variable.
+    Read lines from the standard input into the indexed array variable ARRAY,
+    or from file descriptor FD if the -u option is supplied.
+
+    Options:
+      -d delim	Use DELIM to terminate lines, instead of newline
+      -n count	Copy at most COUNT lines
+      -O origin	Begin assigning to ARRAY at index ORIGIN
+      -s count	Discard the first COUNT lines read
+      -t	Remove a trailing DELIM from each line read (default newline)
+      -u fd	Read lines from file descriptor FD instead of standard input
+
+    Exit Status:
+    Returns success unless an invalid option is given or ARRAY is readonly.`]],
+	["popd", ["popd [-n] [+N | -N]", `Remove directories from stack.
+    Removes entries from the directory stack.
+    Exit Status:
+    Returns success unless an invalid argument is supplied or the directory
+    change fails.`]],
+	["printf", ["printf [-v var] format [arguments]", `Formats and prints ARGUMENTS under control of the FORMAT.
+
+    Options:
+      -v var	assign the output to shell variable VAR rather than
+    		display it on the standard output
+
+    FORMAT is a character string which contains three types of objects: plain
+    characters, which are simply copied to standard output; character escape
+    sequences, which are converted and copied to the standard output; and
+    format specifications, each of which causes printing of the next successive
+    argument.
+    Exit Status:
+    Returns success unless an invalid option is given or a write or assignment
+    error occurs.`]],
+	["pushd", ["pushd [-n] [+N | -N | dir]", `Add directories to stack.
+    Adds a directory to the top of the directory stack, or rotates
+    the stack, making the new top of the stack the current working
+    directory.
+    Exit Status:
+    Returns success unless an invalid argument is supplied or the directory
+    change fails.`]],
+	["pwd", ["pwd [-LP]", `Print the name of the current working directory.
+
+    Options:
+      -L	print the value of $PWD if it names the current working
+    	directory
+      -P	print the physical directory, without any symbolic links
+
+    By default, \`pwd' behaves as if \`-L' were specified.
+    Exit Status:
+    Returns 0 unless an invalid option is given or the current directory
+    cannot be read.`]],
+	["read", ["read [-ers] [-a array] [-d delim] [-i text] [-n nchars] [-N nchars] [-p prompt] [-t timeout] [-u fd] [name ...]", `Read a line from the standard input and split it into fields.
+    Reads a single line from the standard input, or from file descriptor FD
+    if the -u option is supplied.  The line is split into fields as with word
+    splitting, and the first word is assigned to the first NAME, the second
+    word to the second NAME, and so on, with any leftover words assigned to
+    the last NAME.
+    Exit Status:
+    The return code is zero, unless end-of-file is encountered, read times out,
+    or an invalid file descriptor is supplied as the argument to -u.`]],
+	["readarray", ["readarray [-d delim] [-n count] [-O origin] [-s count] [-t] [-u fd] [-C callback] [-c quantum] [array]", "Read lines from a file into an array variable.\n    A synonym for `mapfile'."]],
+	["readonly", ["readonly [-aAf] [name[=value] ...] or readonly -p", `Mark shell variables as unchangeable.
+    Mark each NAME as read-only; the values of these NAMEs may not be
+    changed by subsequent assignment.
+    Exit Status:
+    Returns success unless an invalid option is given or NAME is invalid.`]],
+	["return", ["return [n]", `Return from a shell function.
+    Causes a function or sourced script to exit with the return value
+    specified by N.  If N is omitted, the return status is that of the
+    last command executed within the function or script.
+    Exit Status:
+    Returns N, or failure if the shell is not executing a function or script.`]],
+	["set", ["set [-abefhkmnptuvxBCHP] [-o option-name] [--] [arg ...]", `Set or unset values of shell options and positional parameters.
+    Change the value of shell attributes and positional parameters, or
+    display the names and values of shell variables.
+
+    Options:
+      -e  Exit immediately if a command exits with a non-zero status.
+      -u  Treat unset variables as an error when substituting.
+      -x  Print commands and their arguments as they are executed.
+      -o option-name
+          Set the variable corresponding to option-name
+
+    Exit Status:
+    Returns success unless an invalid option is given.`]],
+	["shift", ["shift [n]", `Shift positional parameters.
+    Rename the positional parameters $N+1,$N+2 ... to $1,$2 ...  If N is
+    not given, it is assumed to be 1.
+    Exit Status:
+    Returns success unless N is negative or greater than $#.`]],
+	["shopt", ["shopt [-pqsu] [-o] [optname ...]", `Set and unset shell options.
+    Change the setting of each shell option OPTNAME.  Without any option
+    arguments, list each supplied OPTNAME, or all shell options if no
+    OPTNAMEs are given, with an indication of whether or not each is set.
+
+    Options:
+      -o	restrict OPTNAMEs to those defined for use with \`set -o'
+      -p	print each shell option with an indication of its status
+      -q	suppress output
+      -s	enable (set) each OPTNAME
+      -u	disable (unset) each OPTNAME
+
+    Exit Status:
+    Returns success if OPTNAME is enabled; fails if an invalid option is
+    given or OPTNAME is disabled.`]],
+	["source", ["source filename [arguments]", `Execute commands from a file in the current shell.
+    Read and execute commands from FILENAME in the current shell.
+    The entries in $PATH are used to find the directory containing FILENAME.
+    Exit Status:
+    Returns the status of the last command executed in FILENAME.`]],
+	["suspend", ["suspend [-f]", `Suspend shell execution.
+    Suspend the execution of this shell until it receives a SIGCONT signal.`]],
+	["test", ["test [expr]", `Evaluate conditional expression.
+    Exits with a status of 0 (true) or 1 (false) depending on
+    the evaluation of EXPR.  Expressions may be unary or binary.
+    Exit Status:
+    Returns success if EXPR evaluates to true; fails if EXPR evaluates to
+    false or an invalid argument is given.`]],
+	["times", ["times", `Display process times.
+    Prints the accumulated user and system times for the shell and all of its
+    child processes.
+    Exit Status:
+    Always succeeds.`]],
+	["trap", ["trap [-lp] [[arg] signal_spec ...]", `Trap signals and other events.
+    Defines and activates handlers to be run when the shell receives signals
+    or other conditions.
+    Exit Status:
+    Returns success unless a SIGSPEC is invalid or an invalid option is given.`]],
+	["true", ["true", `Return a successful result.
+    Exit Status:
+    Always succeeds.`]],
+	["type", ["type [-afptP] name [name ...]", `Display information about command type.
+    For each NAME, indicate how it would be interpreted if used as a
+    command name.
+
+    Options:
+      -a	display all locations containing an executable named NAME
+      -f	suppress shell function lookup
+      -P	force a PATH search for each NAME, even if it is an alias,
+    	builtin, or function, and returns the name of the disk file
+    	that would be executed
+      -p	returns either the name of the disk file that would be executed,
+    	or nothing if \`type -t NAME' would not return \`file'
+      -t	output a single word which is one of \`alias', \`keyword',
+    	\`function', \`builtin', \`file' or \`', if NAME is an alias,
+    	shell reserved word, shell function, shell builtin, disk file,
+    	or not found, respectively
+
+    Exit Status:
+    Returns success if all of the NAMEs are found; fails if any are not found.`]],
+	["typeset", ["typeset [-aAfFgilnrtux] [-p] name[=value] ...", "Set variable values and attributes.\n    A synonym for `declare'."]],
+	["ulimit", ["ulimit [-SHabcdefiklmnpqrstuvxPT] [limit]", `Modify shell resource limits.
+    Provides control over the resources available to the shell and processes
+    it creates, on systems that allow such control.
+    Exit Status:
+    Returns success unless an invalid option is supplied or an error occurs.`]],
+	["umask", ["umask [-p] [-S] [mode]", `Display or set file mode mask.
+    Sets the user file-creation mask to MODE.  If MODE is omitted, prints
+    the current value of the mask.
+    Exit Status:
+    Returns success unless MODE is invalid or an invalid option is given.`]],
+	["unalias", ["unalias [-a] name [name ...]", `Remove each NAME from the list of defined aliases.
+    Exit Status:
+    Returns success unless a NAME is not an existing alias.`]],
+	["unset", ["unset [-f] [-v] [-n] [name ...]", `Unset values and attributes of shell variables and functions.
+    For each NAME, remove the corresponding variable or function.
+
+    Options:
+      -f	treat each NAME as a shell function
+      -v	treat each NAME as a shell variable
+      -n	treat each NAME as a name reference and unset the variable itself
+    	rather than the variable it references
+
+    Without options, unset first tries to unset a variable, and if that fails,
+    tries to unset a function.
+    Exit Status:
+    Returns success unless an invalid option is given or a NAME is read-only.`]],
+	["wait", ["wait [-fn] [id ...]", `Wait for job completion and return exit status.
+    Waits for each process identified by an ID, which may be a process ID or a
+    job specification, and reports its termination status.
+    Exit Status:
+    Returns the status of the last ID; fails if ID is invalid or an invalid
+    option is given.`]]
+]).keys()].sort();
+new TextDecoder("utf-8", { fatal: !0 });
+//#endregion
+//#region ../../packages/manifest/dist/index.mjs
+function isManifestAgent(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const agent = value;
+	return typeof agent.slug === "string" && agent.slug.trim().length > 0 && typeof agent.buildRuntime === "function" && typeof agent.model === "string" && typeof agent.systemPrompt === "string";
+}
+function validateManifestAgent(value, filePath) {
+	if (!isManifestAgent(value)) throw new Error(`${filePath} must default-export defineAgent(...)`);
+	return value;
+}
+function normalizeWebhookEndpoint(endpoint) {
+	return endpoint.replace(/^\/+|\/+$/g, "").replace(/^triggers\/?/, "");
+}
+function agentRouteFromKey(key) {
+	return `/agents/${key}`;
+}
+function workflowRouteFromKey(key) {
+	return `/workflows/${key}`;
+}
+function webhookRouteFromEndpoint(endpoint) {
+	const normalized = normalizeWebhookEndpoint(endpoint);
+	if (!normalized) throw new Error("Webhook endpoint must not be empty");
+	return `/triggers/${normalized}`;
+}
+async function discoverAgentEntries(agentsDir, options) {
+	const files = await discoverModuleFileEntries(agentsDir, {
+		nestedEntry: "agent",
+		duplicateLabel: "agent module file"
+	});
+	const entries = [];
+	for (const { filePath, moduleFile } of files) {
+		const agent = await importAgentDefinition(filePath, options);
+		entries.push({
+			key: agent.slug,
+			route: agentRouteFromKey(agent.slug),
+			filePath,
+			moduleFile
+		});
+	}
+	return entries;
+}
+async function importAgentDefinition(filePath, options) {
+	const appRoot = resolveAppRoot(filePath);
+	const href = pathToFileURL(filePath).href;
+	return runWithAppRoot(appRoot, async () => {
+		return validateManifestAgent((await (options?.reload ? import(`${href}?keystroke=${Date.now()}`) : import(href))).default, filePath);
+	});
+}
+const ACTION = Symbol.for("keystroke.action");
+function isManifestAction(value) {
+	if (typeof value !== "object" || value === null) return false;
+	return ACTION in value && value[ACTION] === true;
+}
+function getManifestActionCredentialRequirements(action) {
+	return Array.isArray(action.credentials) ? action.credentials : void 0;
+}
+function countAgentCredentials(agent) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const tool of agent.tools ?? []) {
+		const record = tool;
+		const requirements = isManifestAction(tool) ? getManifestActionCredentialRequirements(tool) : "credentials" in record && Array.isArray(record.credentials) ? record.credentials : void 0;
+		if (!requirements?.length) continue;
+		for (const requirement of normalizeCredentialList(requirements)) keys.add(requirement.key);
+	}
+	return keys.size;
+}
+const SKIP_DIRS = new Set([".git", "node_modules"]);
+function toPosix$1(path) {
+	return path.split(sep).join("/");
+}
+function parseSkillFrontmatter(raw) {
+	const match = raw.match(/^---\s*\n([\s\S]*?)\n---/);
+	if (!match) return {};
+	const out = {};
+	for (const line of match[1]?.split("\n") ?? []) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const colon = trimmed.indexOf(":");
+		if (colon < 0) continue;
+		const key = trimmed.slice(0, colon).trim();
+		let value = trimmed.slice(colon + 1).trim();
+		if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+		if (key === "name") out.name = value;
+		else if (key === "description") out.description = value;
+	}
+	return out;
+}
+function walkSkillFiles(root, dir, out) {
+	for (const name of readdirSync(dir).sort()) {
+		const absolute = join(dir, name);
+		const stats = statSync(absolute);
+		if (stats.isDirectory()) {
+			if (SKIP_DIRS.has(name)) continue;
+			walkSkillFiles(root, absolute, out);
+			continue;
+		}
+		if (!stats.isFile() || name !== "SKILL.md") continue;
+		const moduleFile = toPosix$1(relative(root, absolute));
+		const slug = toPosix$1(relative(join(root, "src", "skills"), absolute)).replace(/\/?SKILL\.md$/, "");
+		if (!slug) continue;
+		const frontmatter = parseSkillFrontmatter(readFileSync(absolute, "utf8"));
+		out.push({
+			slug,
+			name: frontmatter.name,
+			description: frontmatter.description,
+			moduleFile
+		});
+	}
+}
+/** Discover skill metadata from src/skills SKILL.md files for the route manifest. */
+function discoverSkillManifestEntries(projectRoot) {
+	const skillsDir = join(projectRoot, "src", "skills");
+	if (!statSync(skillsDir, { throwIfNoEntry: false })?.isDirectory()) return [];
+	const entries = [];
+	walkSkillFiles(projectRoot, skillsDir, entries);
+	return entries;
+}
+function schemaToJson(schema) {
+	return toJSONSchema(schema, { target: "openapi-3.0" });
+}
+function collectIntegrationKeys(integrations) {
+	return integrations.map((integration) => integration.key);
+}
+function serializeRouteManifest(manifest) {
+	const entries = [];
+	for (const entry of manifest) switch (entry.kind) {
+		case "health":
+			entries.push(entry);
+			break;
+		case "agent":
+			entries.push({
+				kind: entry.kind,
+				slug: entry.slug,
+				moduleFile: entry.moduleFile,
+				name: entry.name,
+				description: entry.description,
+				model: entry.model,
+				systemPrompt: entry.systemPrompt,
+				toolCount: entry.toolCount,
+				credentialCount: entry.credentialCount
+			});
+			break;
+		case "workflow":
+			entries.push({
+				kind: entry.kind,
+				slug: entry.slug,
+				name: entry.name,
+				description: entry.description,
+				subscribable: entry.subscribable,
+				moduleFile: entry.moduleFile,
+				requestSchema: schemaToJson(entry.request)
+			});
+			break;
+		case "trigger-webhook":
+			entries.push({
+				kind: entry.kind,
+				endpoint: entry.endpoint,
+				attachmentIds: entry.attachmentIds,
+				moduleFile: entry.moduleFile,
+				attachmentSchemas: Object.fromEntries(Object.entries(entry.attachmentSchemas).map(([attachmentKey, schemas]) => [attachmentKey, {
+					requestSchema: schemaToJson(schemas.request),
+					...schemas.filter ? { filterSchema: schemaToJson(schemas.filter) } : {}
+				}]))
+			});
+			break;
+		case "trigger-poll":
+			entries.push({
+				kind: entry.kind,
+				attachmentId: entry.attachmentId,
+				moduleFile: entry.moduleFile,
+				schedule: entry.schedule
+			});
+			break;
+		case "trigger-poll-group":
+			entries.push({
+				kind: entry.kind,
+				pollId: entry.pollId,
+				attachmentIds: entry.attachmentIds,
+				moduleFile: entry.moduleFile,
+				schedule: entry.schedule
+			});
+			break;
+		case "cron-schedule":
+			entries.push(entry);
+			break;
+		default: break;
+	}
+	return entries;
+}
+function toStoredRouteManifest(manifest, options) {
+	return {
+		version: 2,
+		entries: serializeRouteManifest(manifest),
+		skills: options?.skills ?? [],
+		integrations: options?.integrations
+	};
+}
+function buildStoredRouteManifestFromContext(ctx) {
+	const integrations = ctx.options?.integrations ?? ctx.options?.plugins?.map((plugin) => ({
+		key: plugin.name,
+		mount: plugin.register
+	})) ?? [];
+	return toStoredRouteManifest(ctx.manifest, {
+		integrations: collectIntegrationKeys(integrations),
+		skills: ctx.skills ?? (ctx.projectRoot ? discoverSkillManifestEntries(ctx.projectRoot) : void 0) ?? []
+	});
+}
+function persistStoredRouteManifest(projectRoot, manifest) {
+	const path = join(projectRoot, ROUTE_MANIFEST_REL_PATH);
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, `${JSON.stringify(manifest, null, 2)}\n`);
+}
+const WORKFLOW = Symbol.for("keystroke.workflow");
+function isManifestWorkflow(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if (!(WORKFLOW in value) || value[WORKFLOW] !== true) return false;
+	const workflow = value;
+	return typeof workflow.slug === "string" && workflow.slug.trim().length > 0 && workflow.input instanceof Object && "safeParse" in workflow.input && workflow.output instanceof Object && "safeParse" in workflow.output;
+}
+function validateManifestWorkflow(value, filePath) {
+	if (!isManifestWorkflow(value)) throw new Error(`${filePath} must default-export defineWorkflow(...)`);
+	return value;
+}
+const TRIGGER_ATTACHMENT = Symbol.for("keystroke.triggerAttachment");
+const zodSchema = custom((value) => value instanceof ZodType, "must be a Zod schema");
+const cronScheduleSchema = string().trim().min(1, "cron schedule must be a non-empty string");
+const workflowSchema = custom((value) => isManifestWorkflow(value), "must be defineWorkflow(...)");
+const agentSchema = custom((value) => typeof value === "object" && value !== null && typeof value.slug === "string" && value.slug.trim().length > 0 && typeof value.prompt === "function", "must be defineAgent(...)");
+const promptSchema = union([string(), _function()]);
+const baseSourceShape = {
+	key: string().trim().min(1),
+	attach: _function()
+};
+const triggerSourceSchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("webhook"),
+		...baseSourceShape,
+		endpoint: string().min(1),
+		request: zodSchema,
+		filter: zodSchema.optional(),
+		passes: _function()
+	}),
+	object({
+		kind: literal("cron"),
+		...baseSourceShape,
+		schedule: cronScheduleSchema
+	}),
+	object({
+		kind: literal("poll"),
+		...baseSourceShape,
+		id: string().optional(),
+		schedule: cronScheduleSchema,
+		run: _function(),
+		filters: array(_function()),
+		passes: _function()
+	})
+]);
+const triggerAttachmentCoreSchema = discriminatedUnion("target", [object({
+	key: string().trim().min(1),
+	source: triggerSourceSchema,
+	target: literal("workflow"),
+	workflow: workflowSchema,
+	transform: _function().optional()
+}), object({
+	key: string().trim().min(1),
+	source: triggerSourceSchema,
+	target: literal("agent"),
+	agent: agentSchema,
+	prompt: promptSchema
+})]);
+function isManifestTriggerAttachment(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if (!(TRIGGER_ATTACHMENT in value) || value[TRIGGER_ATTACHMENT] !== true) return false;
+	return triggerAttachmentCoreSchema.safeParse(value).success;
+}
+function validateManifestTriggerAttachment(value, filePath) {
+	if (!isManifestTriggerAttachment(value)) throw new Error(`${filePath} must default-export a trigger attachment from .attach({ workflow }) or .attach({ agent, prompt })`);
+	return value;
+}
+function shouldDiscoverTriggerFile(triggersDir, filePath) {
+	return !relative(triggersDir, filePath).split(sep).includes("sources");
+}
+async function discoverTriggerAttachments(triggersDir, options) {
+	const files = await discoverModuleFileEntries(triggersDir, {
+		nestedEntry: "trigger",
+		duplicateLabel: "trigger module file",
+		shouldDiscoverFile: (filePath) => shouldDiscoverTriggerFile(triggersDir, filePath)
+	});
+	const attachments = [];
+	for (const { filePath, moduleFile } of files) {
+		const attachment = await importTriggerAttachment(filePath, options);
+		attachments.push({
+			key: attachment.key,
+			filePath,
+			moduleFile,
+			attachment
+		});
+	}
+	return attachments;
+}
+function validateImportedTriggerAttachment(def, filePath) {
+	return validateManifestTriggerAttachment(def, filePath);
+}
+async function importTriggerAttachment(filePath, options) {
+	const href = pathToFileURL(filePath).href;
+	return validateImportedTriggerAttachment((await (options?.reload ? import(`${href}?keystroke=${Date.now()}`) : import(href))).default, filePath);
+}
+function pollGroupId(discovered) {
+	const source = discovered.attachment.source;
+	if (source.kind !== "poll") throw new Error(`Attachment "${discovered.key}" is not a poll trigger`);
+	return source.id ?? source.key;
+}
+function buildPollGroups(attachments) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const discovered of attachments) {
+		if (discovered.attachment.source.kind !== "poll") continue;
+		const id = pollGroupId(discovered);
+		const group = byId.get(id) ?? [];
+		group.push(discovered);
+		byId.set(id, group);
+	}
+	return [...byId.entries()].map(([id, groupAttachments]) => ({
+		id,
+		attachments: groupAttachments
+	}));
+}
+function buildWebhookBindingsByRoute(attachments, handlerOptionsFor) {
+	const webhookBindingsByRoute = /* @__PURE__ */ new Map();
+	for (const discovered of attachments) {
+		const source = discovered.attachment.source;
+		if (source.kind !== "webhook") continue;
+		const route = webhookRouteFromEndpoint(source.endpoint);
+		const bindings = webhookBindingsByRoute.get(route) ?? [];
+		bindings.push({
+			discovered,
+			options: handlerOptionsFor(discovered.key)
+		});
+		webhookBindingsByRoute.set(route, bindings);
+	}
+	return webhookBindingsByRoute;
+}
+function webhookSchemaEntriesFromBindings(bindings) {
+	return bindings.flatMap((binding) => {
+		const source = binding.discovered.attachment.source;
+		if (source.kind !== "webhook") return [];
+		return [{
+			attachmentKey: binding.discovered.key,
+			request: source.request,
+			...source.filter ? { filter: source.filter } : {}
+		}];
+	});
+}
+function webhookMatchSchemaForBindings(bindings) {
+	const schemas = bindings.flatMap((binding) => {
+		const source = binding.discovered.attachment.source;
+		return source.kind === "webhook" ? [source.request] : [];
+	});
+	if (schemas.length === 0) throw new Error("Webhook bindings require at least one webhook source");
+	if (schemas.length === 1) return schemas[0];
+	return union(schemas);
+}
+function webhookManifestAttachmentSchemasFromBindings(bindings) {
+	return Object.fromEntries(webhookSchemaEntriesFromBindings(bindings).map((entry) => [entry.attachmentKey, {
+		request: entry.request,
+		...entry.filter ? { filter: entry.filter } : {}
+	}]));
+}
+async function discoverWorkflowEntries(workflowsDir, options) {
+	const files = await discoverModuleFileEntries(workflowsDir, {
+		nestedEntry: "workflow",
+		duplicateLabel: "workflow module file"
+	});
+	const entries = [];
+	for (const { filePath, moduleFile } of files) {
+		const definition = await importWorkflowDefinition(filePath, options);
+		entries.push({
+			key: definition.slug,
+			route: workflowRouteFromKey(definition.slug),
+			filePath,
+			moduleFile
+		});
+	}
+	return entries;
+}
+function validateImportedWorkflowDefinition(def, filePath) {
+	return validateManifestWorkflow(def, filePath);
+}
+async function importWorkflowDefinition(filePath, options) {
+	const href = pathToFileURL(filePath).href;
+	return validateImportedWorkflowDefinition((await (options?.reload ? import(`${href}?keystroke=${Date.now()}`) : import(href))).default, filePath);
+}
+async function discoverWorkflows(workflowsDir, options) {
+	const entries = await discoverWorkflowEntries(workflowsDir, options);
+	const workflows = [];
+	for (const entry of entries) {
+		const definition = await importWorkflowDefinition(entry.filePath, options);
+		workflows.push({
+			key: definition.slug,
+			route: workflowRouteFromKey(definition.slug),
+			filePath: entry.filePath,
+			definition
+		});
+	}
+	return workflows;
+}
+function resolveDistModuleDirs(projectRoot) {
+	const distBase = join(projectRoot, "dist");
+	if (!existsSync(distBase)) throw new Error(`Build output missing at ${distBase}. Run keystroke build before emitting the route manifest.`);
+	return {
+		agentsDir: join(distBase, "agents"),
+		workflowsDir: join(distBase, "workflows"),
+		triggersDir: join(distBase, "triggers")
+	};
+}
+function toPosix(path) {
+	return path.split(sep).join("/");
+}
+/**
+* Resolve manifest moduleFile values to project-root-relative source paths.
+*
+* Discovery runs over compiled `dist/` modules, so the raw moduleFile is a
+* dist-relative `.mjs` path. Dist entries are named by their source entry id
+* (`team/escalation.mjs` ← `src/agents/team/escalation/agent.ts`), so walking
+* the matching source dir by the same id rules recovers the source path. Falls
+* back to the dist-relative value when no source file matches (e.g. building
+* a dist-only artifact with no `src/`).
+*/
+var SourceModuleFileResolver = class {
+	projectRoot;
+	mapsByKind = /* @__PURE__ */ new Map();
+	constructor(projectRoot) {
+		this.projectRoot = projectRoot;
+	}
+	async sourceMapFor(kindDir, nestedEntry) {
+		const existing = this.mapsByKind.get(kindDir);
+		if (existing) return existing;
+		const map = /* @__PURE__ */ new Map();
+		const sourceDir = join(this.projectRoot, "src", kindDir);
+		for (const filePath of await walkTypeScriptFiles(sourceDir)) {
+			const id = entryIdFromFile(sourceDir, filePath, { nestedEntry });
+			if (id) map.set(id, toPosix(relative(this.projectRoot, filePath)));
+		}
+		this.mapsByKind.set(kindDir, map);
+		return map;
+	}
+	async resolve(kindDir, nestedEntry, distDir, distFilePath) {
+		const fallback = toPosix(relative(distDir, distFilePath));
+		const id = entryIdFromFile(distDir, distFilePath, { nestedEntry });
+		if (!id) return fallback;
+		return (await this.sourceMapFor(kindDir, nestedEntry)).get(id) ?? fallback;
+	}
+};
+/** Build a stored route manifest from compiled dist/ modules without starting a server. */
+async function buildStoredRouteManifestForProject(projectRoot, options) {
+	const previousRoot = process.env.KEYSTROKE_ROOT;
+	process.env.KEYSTROKE_ROOT = projectRoot;
+	const reload = options?.reloadModules ? { reload: true } : void 0;
+	try {
+		const dirs = resolveDistModuleDirs(projectRoot);
+		const sourcePaths = new SourceModuleFileResolver(projectRoot);
+		const manifest = [{ kind: "health" }];
+		const agentEntries = await discoverAgentEntries(dirs.agentsDir, reload);
+		for (const entry of agentEntries) {
+			const agent = await importAgentDefinition(entry.filePath, reload);
+			const moduleFile = await sourcePaths.resolve("agents", "agent", dirs.agentsDir, entry.filePath);
+			manifest.push({
+				kind: "agent",
+				slug: agent.slug,
+				moduleFile,
+				name: agent.name,
+				description: agent.description,
+				model: agent.model,
+				systemPrompt: agent.systemPrompt,
+				toolCount: agent.tools?.length ?? 0,
+				credentialCount: countAgentCredentials(agent)
+			});
+		}
+		const workflows = await discoverWorkflows(dirs.workflowsDir, reload);
+		for (const workflow of workflows) {
+			const moduleFile = await sourcePaths.resolve("workflows", "workflow", dirs.workflowsDir, workflow.filePath);
+			manifest.push({
+				kind: "workflow",
+				slug: workflow.definition.slug,
+				name: workflow.definition.name,
+				description: workflow.definition.description,
+				subscribable: workflow.definition.subscription?.mode === "subscribable",
+				moduleFile,
+				request: workflow.definition.input
+			});
+		}
+		const attachments = await discoverTriggerAttachments(dirs.triggersDir, reload);
+		const discoveredByKey = new Map(attachments.map((attachment) => [attachment.key, attachment]));
+		const pollGroups = buildPollGroups(attachments);
+		for (const discovered of discoveredByKey.values()) {
+			const source = discovered.attachment.source;
+			const moduleFile = await sourcePaths.resolve("triggers", "trigger", dirs.triggersDir, discovered.filePath);
+			if (source.kind === "cron") {
+				manifest.push({
+					kind: "cron-schedule",
+					attachmentId: discovered.key,
+					moduleFile,
+					schedule: source.schedule
+				});
+				continue;
+			}
+			if (source.kind === "poll") {
+				manifest.push({
+					kind: "trigger-poll",
+					attachmentId: discovered.key,
+					moduleFile,
+					schedule: source.schedule,
+					response: PromptResponseSchema
+				});
+				continue;
+			}
+			if (source.kind === "webhook") {
+				const route = webhookRouteFromEndpoint(source.endpoint);
+				const bindings = buildWebhookBindingsByRoute(discoveredByKey.values(), () => ({
+					execution: { attachmentKey: discovered.key },
+					attachmentKey: discovered.key
+				})).get(route) ?? [{
+					discovered,
+					options: { attachmentKey: discovered.key }
+				}];
+				manifest.push({
+					kind: "trigger-webhook",
+					endpoint: source.endpoint,
+					attachmentIds: bindings.map(({ discovered: row }) => row.key),
+					moduleFile,
+					request: webhookMatchSchemaForBindings(bindings),
+					attachmentSchemas: webhookManifestAttachmentSchemasFromBindings(bindings),
+					response: PromptResponseSchema
+				});
+			}
+		}
+		for (const group of pollGroups) {
+			if (group.attachments.length <= 1) continue;
+			const first = group.attachments[0];
+			const source = first.attachment.source;
+			manifest.push({
+				kind: "trigger-poll-group",
+				pollId: group.id,
+				attachmentIds: group.attachments.map((attachment) => attachment.key),
+				moduleFile: await sourcePaths.resolve("triggers", "trigger", dirs.triggersDir, first.filePath),
+				schedule: source.kind === "poll" ? source.schedule : "",
+				response: PromptResponseSchema
+			});
+		}
+		return buildStoredRouteManifestFromContext({
+			manifest,
+			options: {},
+			projectRoot,
+			skills: discoverSkillManifestEntries(projectRoot)
+		});
+	} finally {
+		if (previousRoot === void 0) delete process.env.KEYSTROKE_ROOT;
+		else process.env.KEYSTROKE_ROOT = previousRoot;
+	}
+}
+/** Write `dist/.keystroke/route-manifest.json` for the project. */
+async function emitStoredRouteManifestForProject(projectRoot) {
+	persistStoredRouteManifest(projectRoot, await buildStoredRouteManifestForProject(projectRoot));
+}
+//#endregion
+export { entryIdFromFile as A, webhookManifestAttachmentSchemasFromBindings as C, packAssetDirs as D, workflowRouteFromKey as E, shouldSkipKeystrokeModuleFile as M, walkTypeScriptFiles as N, discoverEntries as O, validateImportedWorkflowDefinition as S, webhookRouteFromEndpoint as T, pollGroupId as _, buildWebhookBindingsByRoute as a, toStoredRouteManifest as b, discoverSkillManifestEntries as c, discoverWorkflows as d, emitStoredRouteManifestForProject as f, persistStoredRouteManifest as g, importWorkflowDefinition as h, buildStoredRouteManifestFromContext as i, readKeystrokeIgnoreDirective as j, discoverModuleFileEntries as k, discoverTriggerAttachments as l, importTriggerAttachment as m, buildPollGroups as n, countAgentCredentials as o, importAgentDefinition as p, buildStoredRouteManifestForProject as r, discoverAgentEntries as s, agentRouteFromKey as t, discoverWorkflowEntries as u, schemaToJson as v, webhookMatchSchemaForBindings as w, validateImportedTriggerAttachment as x, serializeRouteManifest as y };
+
+//# sourceMappingURL=dist-CwR72_PS.mjs.map