@piagent/platform 1.37.1 → 1.38.1

package/packages/piagent-core/managed/dist/workspace/workspace-search-index.mjs

@@ -0,0 +1,1007 @@
+import { i as contextIndexExcludeDigest, n as resolveLocalStatePath, r as matchesProtectedPath, s as normalizeContextIndexExcludePatterns, t as ensurePrivateStateDirectory } from "./assets/local-state-path-BrmghxEZ.js";
+import path from "node:path";
+import "node:crypto";
+import fs from "node:fs";
+import { execFileSync } from "node:child_process";
+import { parentPort, workerData } from "node:worker_threads";
+//#region ../piagent-core/extensions/workflow-catalog.ts
+var WORKFLOW_IDS = [
+	"task",
+	"scout",
+	"be-to-fe",
+	"discuss",
+	"plan",
+	"review",
+	"commit",
+	"pr",
+	"onboard",
+	"platform-improve"
+];
+var WORKFLOW_ALIASES = Object.freeze(Object.fromEntries([
+	{
+		id: "task",
+		aliases: ["task", "implement"],
+		label: "Task",
+		description: "Implement a bounded task",
+		argumentHint: "<request>",
+		requestRequired: true,
+		contextWorkflow: "task",
+		changeMode: "source-change",
+		modelUse: "required",
+		recommendedFreshSession: true
+	},
+	{
+		id: "scout",
+		aliases: ["scout", "audit"],
+		label: "Scout",
+		description: "Read-only audit or research",
+		argumentHint: "<area/spec/risk>",
+		requestRequired: true,
+		contextWorkflow: "scout",
+		changeMode: "read-only",
+		modelUse: "required",
+		recommendedFreshSession: true
+	},
+	{
+		id: "be-to-fe",
+		aliases: ["be-to-fe", "befe"],
+		label: "BE → FE",
+		description: "Implement frontend from a backend contract",
+		argumentHint: "<BE spec/change + FE outcome>",
+		requestRequired: true,
+		contextWorkflow: "task",
+		changeMode: "source-change",
+		modelUse: "required",
+		recommendedFreshSession: true
+	},
+	{
+		id: "discuss",
+		aliases: ["discuss", "clarify"],
+		label: "Discuss",
+		description: "Clarify before planning or editing",
+		argumentHint: "<rough idea>",
+		requestRequired: true,
+		contextWorkflow: "discuss",
+		changeMode: "clarification",
+		modelUse: "required",
+		recommendedFreshSession: false
+	},
+	{
+		id: "plan",
+		aliases: ["plan"],
+		label: "Plan",
+		description: "Create an implementation plan",
+		argumentHint: "<goal>",
+		requestRequired: true,
+		contextWorkflow: "plan",
+		changeMode: "plan-only",
+		modelUse: "required",
+		recommendedFreshSession: false
+	},
+	{
+		id: "review",
+		aliases: ["review"],
+		label: "Review",
+		description: "Review a diff or source read-only",
+		argumentHint: "<target or diff>",
+		requestRequired: true,
+		contextWorkflow: "review",
+		changeMode: "read-only",
+		modelUse: "required",
+		recommendedFreshSession: false
+	},
+	{
+		id: "commit",
+		aliases: ["commit"],
+		label: "Commit",
+		description: "Run the guarded local commit workflow",
+		argumentHint: "[message]",
+		requestRequired: false,
+		contextWorkflow: "release",
+		changeMode: "git",
+		modelUse: "required",
+		recommendedFreshSession: false
+	},
+	{
+		id: "pr",
+		aliases: ["pr"],
+		label: "PR",
+		description: "Prepare a guarded pull request",
+		argumentHint: "[title]",
+		requestRequired: false,
+		contextWorkflow: "release",
+		changeMode: "git",
+		modelUse: "required",
+		recommendedFreshSession: false
+	},
+	{
+		id: "onboard",
+		aliases: ["onboard", "onboard-project"],
+		label: "Onboard",
+		description: "Run first-read project onboarding",
+		argumentHint: "[focus]",
+		requestRequired: false,
+		contextWorkflow: "onboard",
+		changeMode: "onboarding",
+		modelUse: "required",
+		recommendedFreshSession: true
+	},
+	{
+		id: "platform-improve",
+		aliases: ["platform-improve", "platform"],
+		label: "Platform improve",
+		description: "Improve Pi Agent Platform itself",
+		argumentHint: "<goal + affected area>",
+		requestRequired: true,
+		contextWorkflow: "task",
+		changeMode: "platform",
+		modelUse: "required",
+		recommendedFreshSession: true
+	}
+].flatMap((option) => option.aliases.map((alias) => [alias, option.id]))));
+function workflowCommandNames(options = {}) {
+	return options.aliases === false ? [...WORKFLOW_IDS] : Object.keys(WORKFLOW_ALIASES);
+}
+function escapedPattern(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** A regex fragment derived from the catalog, for command/projection boundaries. */
+function workflowCommandPattern(options = {}) {
+	return workflowCommandNames(options).sort((left, right) => right.length - left.length).map(escapedPattern).join("|");
+}
+new RegExp(`^/(?:piagent-workflow|workflow)\\s+(${workflowCommandPattern()})(?=\\s|$)\\s*`, "i");
+new RegExp(`^/(${workflowCommandPattern({ aliases: false })})(?=\\s|$)\\s*`, "i");
+new Int32Array(new SharedArrayBuffer(4));
+function readTailText(filePath, maxBytes) {
+	try {
+		const descriptor = fs.openSync(filePath, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
+		try {
+			const stat = fs.fstatSync(descriptor);
+			const start = Math.max(0, stat.size - maxBytes);
+			const length = stat.size - start;
+			const buffer = Buffer.allocUnsafe(length);
+			fs.readSync(descriptor, buffer, 0, length, start);
+			let text = buffer.toString("utf8");
+			if (start > 0) text = text.slice(Math.max(0, text.indexOf("\n") + 1));
+			return text;
+		} finally {
+			fs.closeSync(descriptor);
+		}
+	} catch (error) {
+		if (error?.code === "ENOENT") return "";
+		throw error;
+	}
+}
+function readJsonlTail(filePath, options = {}) {
+	const limit = Math.max(1, Number.isInteger(options.limit) ? options.limit : 100);
+	const maxBytes = Math.max(65536, Number.isInteger(options.maxBytes) ? options.maxBytes : 8388608);
+	const safeFilePath = options.projectRoot ? resolveLocalStatePath(options.projectRoot, filePath, { label: "Local JSONL state" }) : filePath;
+	const lines = (options.projectRoot ? [resolveLocalStatePath(options.projectRoot, `${filePath}.1`, { label: "Rotated local JSONL state" }), safeFilePath] : [`${safeFilePath}.1`, safeFilePath]).flatMap((source) => readTailText(source, maxBytes).split(/\r?\n/).filter(Boolean));
+	const records = [];
+	for (const line of lines.slice(-limit)) try {
+		records.push(JSON.parse(line));
+	} catch {}
+	return records;
+}
+//#endregion
+//#region ../piagent-core/extensions/context-efficiency-metrics.js
+function contextMetricPartition(event, taskByTurn = /* @__PURE__ */ new Map()) {
+	const sessionId = typeof event.sessionId === "string" ? event.sessionId : "";
+	const turnId = typeof event.turnId === "string" ? event.turnId : "";
+	const taskRunId = typeof event.taskRunId === "string" ? event.taskRunId : taskByTurn.get(`${sessionId}\0${turnId}`) ?? "";
+	if (!sessionId || !taskRunId) return "";
+	return [
+		sessionId,
+		taskRunId,
+		event.model ?? "unknown",
+		event.thinkingLevel ?? "unknown"
+	].join("\0");
+}
+var BOUND_IMPORT_STRING = `
pi_import_string_(\\d+)`;
+new RegExp(String.raw`(?<![.$\w])(?:import|export)\s+(?:type\s+)?[\w$*{},\s]+?\s+from\s+(${BOUND_IMPORT_STRING})`, "gu"), new RegExp(String.raw`(?<![.$\w])import\s+(${BOUND_IMPORT_STRING})`, "gu"), new RegExp(String.raw`(?<![.$\w])require\s*\(\s*(${BOUND_IMPORT_STRING})\s*\)`, "gu"), new RegExp(String.raw`(?<![.$\w])import\s*\(\s*(${BOUND_IMPORT_STRING})\s*\)`, "gu");
+function directExplicitImportLinks(importRows, explicitRows) {
+	const explicitPaths = new Set(explicitRows.map((row) => row.path));
+	const byPath = /* @__PURE__ */ new Map();
+	const rankingRows = [];
+	const add = (candidatePath, kind, explicitPath) => {
+		const links = byPath.get(candidatePath) ?? [];
+		if (!links.some((link) => link.kind === kind && link.path === explicitPath)) {
+			links.push({
+				kind,
+				path: explicitPath
+			});
+			rankingRows.push({ path: candidatePath });
+		}
+		byPath.set(candidatePath, links);
+	};
+	for (const row of importRows) {
+		if (typeof row.specifier !== "string" || !/^\.{1,2}\//.test(row.specifier)) continue;
+		if (explicitPaths.has(row.file_path)) add(row.target_path, "explicit-imports-candidate", row.file_path);
+		if (explicitPaths.has(row.target_path)) add(row.file_path, "candidate-imports-explicit", row.target_path);
+	}
+	return {
+		byPath,
+		rankingRows
+	};
+}
+//#endregion
+//#region ../piagent-core/extensions/context-query-paths.js
+function normalizeRelative$1(value) {
+	return String(value ?? "").replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+/g, "/");
+}
+function safeProjectRelativeQueryPath(raw) {
+	const candidate = normalizeRelative$1(raw);
+	if (!candidate || candidate.length > 512 || path.posix.isAbsolute(candidate)) return void 0;
+	if (candidate.split("/").some((segment) => !segment || segment === "." || segment === "..")) return void 0;
+	return candidate;
+}
+function safeGlobSegment(segment) {
+	let bracketDepth = 0;
+	let braceDepth = 0;
+	for (const character of segment) if (character === "[") {
+		if (++bracketDepth > 1) return false;
+	} else if (character === "]") {
+		if (--bracketDepth < 0) return false;
+	} else if (character === "{") {
+		if (++braceDepth > 1) return false;
+	} else if (character === "}") {
+		if (--braceDepth < 0) return false;
+	} else if (character === "," && braceDepth === 0 || character === "!" && bracketDepth === 0) return false;
+	return bracketDepth === 0 && braceDepth === 0;
+}
+function safeProjectRelativeGlob(raw) {
+	const candidate = safeProjectRelativeQueryPath(String(raw ?? "").replace(/[.,]+$/u, ""));
+	if (!candidate || !candidate.includes("/") || !/[*?\[\]{}]/u.test(candidate)) return void 0;
+	if (!/^[\p{L}\p{N}_.@*?{}\[\]!,-]+(?:\/[\p{L}\p{N}_.@*?{}\[\]!,-]+)+$/u.test(candidate)) return void 0;
+	return candidate.split("/").every(safeGlobSegment) ? candidate : void 0;
+}
+function queryPathCandidates(query) {
+	const pattern = /(?:^|[\s"'`(])((?:\.{0,2}\/)?[\p{L}\p{N}_.@-]+(?:\/[\p{L}\p{N}_.@-]+)+|[\p{L}\p{N}_.@-]+\.[\p{L}\p{N}]{1,8}|\.[\p{L}\p{N}_@-]{1,32})(?=$|[\s"'`),:])/gu;
+	const globPattern = /(?:^|[\s"'(\x60=,:])((?:\.\/)?[\p{L}\p{N}_.@*?{}\[\]!,-]+(?:\/[\p{L}\p{N}_.@*?{}\[\]!,-]+)+)(?=$|[\s"'\x60),:;])/gu;
+	const explicitRoots = /^(?:\.github|app|apps|backend|bin|config|docs|examples|frontend|lib|logs|packages|pages|public|scripts|services|spec|src|test|tests|vendor|__tests__)\//i;
+	const text = String(query ?? "");
+	const candidates = [...text.matchAll(pattern)].flatMap((match) => {
+		const raw = match[1], candidate = safeProjectRelativeQueryPath(raw);
+		return candidate && (raw.startsWith("./") || explicitRoots.test(candidate) || candidate.split("/").length >= 3 || /(?:^|\/)(?:\.[^/]+|[^/]+\.[\p{L}\p{N}]{1,8})$/u.test(candidate)) ? [{
+			candidate,
+			index: match.index ?? 0
+		}] : [];
+	});
+	for (const match of text.matchAll(globPattern)) {
+		const candidate = safeProjectRelativeGlob(match[1]);
+		if (candidate) candidates.push({
+			candidate,
+			index: match.index ?? 0
+		});
+	}
+	candidates.sort((left, right) => left.index - right.index);
+	return [...new Set(candidates.map((entry) => entry.candidate))];
+}
+//#endregion
+//#region ../piagent-core/extensions/context-engine.js
+var INDEX_SCHEMA_VERSION = 2;
+var RRF_K = 60;
+var MAX_TELEMETRY_EVENTS = 5e4;
+var MAX_TELEMETRY_READ_BYTES = 33554432;
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".c",
+	".cc",
+	".cpp",
+	".cs",
+	".css",
+	".dart",
+	".ex",
+	".exs",
+	".go",
+	".h",
+	".hpp",
+	".html",
+	".java",
+	".js",
+	".jsx",
+	".kt",
+	".kts",
+	".lua",
+	".m",
+	".md",
+	".mdx",
+	".php",
+	".proto",
+	".py",
+	".rb",
+	".rs",
+	".scala",
+	".scss",
+	".sh",
+	".sql",
+	".svelte",
+	".swift",
+	".toml",
+	".ts",
+	".tsx",
+	".vue",
+	".xml",
+	".yaml",
+	".yml"
+]);
+var SOURCE_NAMES = /* @__PURE__ */ new Set([
+	"AGENTS.md",
+	"Dockerfile",
+	"Makefile",
+	"Procfile",
+	"README",
+	"README.md",
+	"go.mod",
+	"package.json",
+	"pyproject.toml",
+	"requirements.txt",
+	"tsconfig.json"
+]);
+var IGNORED_SEGMENTS = /* @__PURE__ */ new Set([
+	".git",
+	".next",
+	".nuxt",
+	".output",
+	".turbo",
+	".venv",
+	"build",
+	"coverage",
+	"dist",
+	"node_modules",
+	"out",
+	"target",
+	"vendor"
+]);
+var SECRET_FILE_PATTERNS = [
+	/(^|\/)\.env(?:\.|$)/i,
+	/(^|\/)auth\.json$/i,
+	/(^|\/)(?:credentials?|secrets?|tokens?)\.json$/i,
+	/(^|\/)\.pi\/settings\.json$/i,
+	/(^|\/)\.pi\/piagent-profile(?:\.lock)?\.json$/i,
+	/(^|\/)\.pi\/piagent-state(?:\/|$)/i
+];
+var STOP_TERMS = /* @__PURE__ */ new Set([
+	"about",
+	"after",
+	"agent",
+	"before",
+	"build",
+	"change",
+	"check",
+	"code",
+	"could",
+	"file",
+	"from",
+	"have",
+	"into",
+	"just",
+	"make",
+	"need",
+	"please",
+	"project",
+	"should",
+	"task",
+	"that",
+	"them",
+	"then",
+	"there",
+	"these",
+	"this",
+	"through",
+	"update",
+	"using",
+	"want",
+	"what",
+	"when",
+	"where",
+	"which",
+	"with",
+	"would",
+	"anh",
+	"cho",
+	"cua",
+	"em",
+	"giup",
+	"lam",
+	"minh",
+	"muon",
+	"nay",
+	"trong",
+	"voi"
+]);
+var sqliteModulePromise;
+var retrievalFeedbackCache = /* @__PURE__ */ new Map();
+function normalizeRelative(value) {
+	return String(value ?? "").replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+/g, "/");
+}
+function clampInteger(value, fallback, min, max) {
+	const number = Number(value);
+	if (!Number.isFinite(number)) return fallback;
+	return Math.max(min, Math.min(max, Math.trunc(number)));
+}
+function ratio(numerator, denominator) {
+	return denominator > 0 ? numerator / denominator : 0;
+}
+function requireExplicitExcludePatterns(options, operation) {
+	if (!Array.isArray(options?.excludePatterns)) throw new TypeError(`${operation} requires an explicit excludePatterns array`);
+	return normalizeContextIndexExcludePatterns(options.excludePatterns);
+}
+function contextEnginePaths(cwd) {
+	const root = path.join(cwd, ".pi", "piagent-state", "context-engine");
+	return {
+		root,
+		database: path.join(root, "context-v2.sqlite"),
+		telemetry: path.join(root, "events.jsonl"),
+		report: path.join(root, "efficiency-report.json")
+	};
+}
+function hardenContextDatabaseArtifacts(cwd) {
+	const database = resolveLocalStatePath(cwd, contextEnginePaths(cwd).database, { label: "Context index database" });
+	for (const artifact of [
+		database,
+		`${database}-wal`,
+		`${database}-shm`
+	]) try {
+		if (!fs.lstatSync(artifact).isFile()) throw new Error(`Context index storage path must be a regular file: ${artifact}`);
+		fs.chmodSync(artifact, 384);
+	} catch (error) {
+		if (error?.code !== "ENOENT") throw error;
+	}
+}
+async function loadSqlite() {
+	if (!sqliteModulePromise) sqliteModulePromise = (async () => {
+		const emitWarning = process.emitWarning;
+		process.emitWarning = function filteredWarning(warning, ...args) {
+			if ((warning instanceof Error ? warning.message : String(warning)).includes("SQLite is an experimental feature")) return;
+			return emitWarning.call(process, warning, ...args);
+		};
+		try {
+			return await import("node:sqlite");
+		} finally {
+			process.emitWarning = emitWarning;
+		}
+	})();
+	return sqliteModulePromise;
+}
+async function openDatabase(cwd, { create = true } = {}) {
+	const paths = contextEnginePaths(cwd);
+	const database = resolveLocalStatePath(cwd, paths.database, { label: "Context index database" });
+	if (!create && !fs.existsSync(database)) return void 0;
+	if (create) ensurePrivateStateDirectory(cwd, paths.root, "Context index storage root");
+	else {
+		const existingRoot = resolveLocalStatePath(cwd, paths.root, {
+			label: "Context index storage root",
+			kind: "directory"
+		});
+		try {
+			fs.chmodSync(existingRoot, 448);
+		} catch {}
+	}
+	hardenContextDatabaseArtifacts(cwd);
+	const descriptor = fs.openSync(database, fs.constants.O_RDWR | (create ? fs.constants.O_CREAT : 0) | (fs.constants.O_NOFOLLOW ?? 0), 384);
+	try {
+		fs.fchmodSync(descriptor, 384);
+	} finally {
+		fs.closeSync(descriptor);
+	}
+	const { DatabaseSync } = await loadSqlite();
+	const db = new DatabaseSync(database);
+	try {
+		db.exec(`
+      PRAGMA journal_mode = WAL;
+      PRAGMA synchronous = NORMAL;
+      PRAGMA foreign_keys = ON;
+      PRAGMA secure_delete = ON;
+      CREATE TABLE IF NOT EXISTS metadata (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS files (
+        path TEXT PRIMARY KEY,
+        hash TEXT NOT NULL,
+        bytes INTEGER NOT NULL,
+        mtime_ms REAL NOT NULL,
+        language TEXT NOT NULL,
+        indexed_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS symbols (
+        id INTEGER PRIMARY KEY,
+        file_path TEXT NOT NULL REFERENCES files(path) ON DELETE CASCADE,
+        name TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        line INTEGER NOT NULL,
+        end_line INTEGER NOT NULL,
+        signature TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS symbols_name_idx ON symbols(name);
+      CREATE INDEX IF NOT EXISTS symbols_file_idx ON symbols(file_path);
+      CREATE TABLE IF NOT EXISTS imports (
+        id INTEGER PRIMARY KEY,
+        file_path TEXT NOT NULL REFERENCES files(path) ON DELETE CASCADE,
+        specifier TEXT NOT NULL,
+        target_path TEXT,
+        line INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS imports_file_idx ON imports(file_path);
+      CREATE INDEX IF NOT EXISTS imports_target_idx ON imports(target_path);
+      CREATE VIRTUAL TABLE IF NOT EXISTS file_fts USING fts5(
+        path UNINDEXED,
+        body,
+        symbol_names,
+        tokenize = 'unicode61 remove_diacritics 2'
+      );
+    `);
+		const ftsSecureDelete = db.prepare(`
+      SELECT v
+      FROM file_fts_config
+      WHERE k = 'secure-delete'
+    `).get();
+		if (Number(ftsSecureDelete?.v) !== 1) db.exec("INSERT INTO file_fts(file_fts, rank) VALUES('secure-delete', 1)");
+		hardenContextDatabaseArtifacts(cwd);
+		return db;
+	} catch (error) {
+		db.close();
+		throw error;
+	}
+}
+function metadataMap(db) {
+	const result = {};
+	for (const row of db.prepare("SELECT key, value FROM metadata").all()) result[row.key] = row.value;
+	return result;
+}
+function shouldIndexPath(relativePath, options = {}) {
+	const rel = normalizeRelative(relativePath);
+	if (!rel || path.isAbsolute(rel) || rel.startsWith("../")) return false;
+	if (rel.split("/").some((segment) => IGNORED_SEGMENTS.has(segment))) return false;
+	if (SECRET_FILE_PATTERNS.some((pattern) => pattern.test(rel))) return false;
+	if (matchesProtectedPath(rel, options.excludePatterns ?? [])) return false;
+	const name = path.posix.basename(rel);
+	return SOURCE_NAMES.has(name) || SOURCE_EXTENSIONS.has(path.posix.extname(name).toLowerCase());
+}
+function projectFileInfo(cwd, relativePath, root = fs.realpathSync.native(cwd), directoryCache = /* @__PURE__ */ new Map()) {
+	const expected = path.resolve(root, relativePath);
+	if (expected !== root && !expected.startsWith(`${root}${path.sep}`)) return void 0;
+	try {
+		const directPath = path.resolve(cwd, relativePath);
+		const directParent = path.dirname(directPath);
+		let canonicalParent = directoryCache.get(directParent);
+		if (canonicalParent === void 0) {
+			canonicalParent = fs.realpathSync.native(directParent);
+			directoryCache.set(directParent, canonicalParent);
+		}
+		if (canonicalParent !== path.dirname(expected)) return void 0;
+		const direct = fs.lstatSync(directPath);
+		if (direct.isSymbolicLink() || !direct.isFile()) return void 0;
+		return {
+			absolute: expected,
+			stat: direct
+		};
+	} catch {
+		return;
+	}
+}
+function gitFileList(cwd) {
+	try {
+		return execFileSync("git", [
+			"-C",
+			cwd,
+			"ls-files",
+			"--cached",
+			"--others",
+			"--exclude-standard",
+			"-z"
+		], {
+			encoding: "utf8",
+			maxBuffer: 33554432,
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).split("\0").filter(Boolean).map(normalizeRelative);
+	} catch {
+		return;
+	}
+}
+function foldSearchSignal(value) {
+	return String(value ?? "").normalize("NFKD").replace(/\p{M}/gu, "").replace(/[đĐ]/g, (character) => character === "Đ" ? "D" : "d").toLowerCase();
+}
+function tokenizeQuery(query) {
+	const terms = String(query ?? "").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replaceAll("_", " ").replaceAll("-", " ").match(/[\p{L}][\p{L}\p{N}]{1,63}/gu) ?? [];
+	return [...new Set(terms.map((term) => term.toLowerCase()).filter((term) => !STOP_TERMS.has(foldSearchSignal(term))))].slice(0, 16);
+}
+function ftsQuery(terms) {
+	return terms.map((term) => `"${term.replaceAll("\"", "\"\"")}"`).join(" OR ");
+}
+function gitChangedFiles(cwd) {
+	try {
+		return execFileSync("git", [
+			"-C",
+			cwd,
+			"diff",
+			"--name-only",
+			"--diff-filter=ACMR",
+			"HEAD"
+		], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).split(/\r?\n/).map(normalizeRelative).filter(Boolean);
+	} catch {
+		return [];
+	}
+}
+async function contextIndexV2Status(cwd, options = {}) {
+	const expectedExcludePatterns = requireExplicitExcludePatterns(options, "contextIndexV2Status");
+	const expectedExcludeDigest = contextIndexExcludeDigest(expectedExcludePatterns);
+	const paths = contextEnginePaths(cwd);
+	const projectRoot = fs.realpathSync.native(cwd);
+	const directoryCache = /* @__PURE__ */ new Map();
+	const database = resolveLocalStatePath(cwd, paths.database, { label: "Context index database" });
+	if (!fs.existsSync(database)) return {
+		schemaVersion: INDEX_SCHEMA_VERSION,
+		exists: false,
+		path: normalizeRelative(path.relative(cwd, paths.database)),
+		stale: false,
+		policyStale: false,
+		expectedExcludeDigest,
+		purgePending: false,
+		warnings: ["index-v2 missing"]
+	};
+	const db = await openDatabase(cwd, { create: false });
+	try {
+		const metadata = metadataMap(db);
+		const fileRows = db.prepare("SELECT path, bytes, mtime_ms FROM files").all();
+		const files = fileRows.length;
+		const symbols = Number(db.prepare("SELECT COUNT(*) count FROM symbols").get().count);
+		const imports = Number(db.prepare("SELECT COUNT(*) count FROM imports").get().count);
+		const indexedPaths = new Set(fileRows.map((row) => row.path));
+		const storedExcludeDigest = metadata.excludeDigest;
+		const purgePending = metadata.purgePending === "1";
+		const excludeDigestStale = typeof storedExcludeDigest !== "string" || storedExcludeDigest !== expectedExcludeDigest;
+		const policyStale = purgePending || excludeDigestStale;
+		const statChanged = [];
+		for (const row of fileRows) {
+			if (!shouldIndexPath(row.path, { excludePatterns: expectedExcludePatterns })) continue;
+			const file = projectFileInfo(cwd, row.path, projectRoot, directoryCache);
+			if (!file || file.stat.size !== Number(row.bytes) || Math.abs(file.stat.mtimeMs - Number(row.mtime_ms)) >= .5) statChanged.push(row.path);
+		}
+		let skippedPaths = /* @__PURE__ */ new Set();
+		try {
+			const parsed = JSON.parse(metadata.skippedPaths ?? "[]");
+			if (Array.isArray(parsed)) skippedPaths = new Set(parsed.filter((value) => typeof value === "string"));
+		} catch {
+			skippedPaths = /* @__PURE__ */ new Set();
+		}
+		const listed = gitFileList(cwd);
+		const newlyVisible = listed ? listed.filter((file) => !indexedPaths.has(file) && !skippedPaths.has(file) && shouldIndexPath(file, { excludePatterns: expectedExcludePatterns })) : [];
+		const stalePaths = [.../* @__PURE__ */ new Set([...statChanged, ...newlyVisible])];
+		const warnings = [];
+		if (purgePending) warnings.push("context index storage purge pending");
+		if (excludeDigestStale) warnings.push("context index exclusion policy changed");
+		if (stalePaths.length > 0) warnings.push(`${stalePaths.length} changed file(s) since the last index build`);
+		return {
+			schemaVersion: Number(metadata.schemaVersion ?? INDEX_SCHEMA_VERSION),
+			exists: true,
+			path: normalizeRelative(path.relative(cwd, paths.database)),
+			builtAt: metadata.builtAt,
+			files,
+			symbols,
+			imports,
+			stale: policyStale || stalePaths.length > 0,
+			policyStale,
+			purgePending,
+			excludePolicyVersion: metadata.excludePolicyVersion,
+			excludeDigest: storedExcludeDigest,
+			expectedExcludeDigest,
+			stalePaths: stalePaths.slice(0, 20),
+			warnings
+		};
+	} finally {
+		db.close();
+	}
+}
+function addRankedList(scores, rows, source, weight = 1) {
+	rows.forEach((row, index) => {
+		const filePath = row.path ?? row.file_path;
+		if (!filePath) return;
+		const current = scores.get(filePath) ?? {
+			path: filePath,
+			score: 0,
+			sources: /* @__PURE__ */ new Set(),
+			rows: []
+		};
+		current.score += weight / (RRF_K + index + 1);
+		current.sources.add(source);
+		current.rows.push({
+			source,
+			...row
+		});
+		scores.set(filePath, current);
+	});
+}
+function personalizedPageRank(importRows, seeds, iterations = 8) {
+	const nodes = /* @__PURE__ */ new Set();
+	const outgoing = /* @__PURE__ */ new Map();
+	for (const row of importRows) {
+		if (!row.target_path) continue;
+		nodes.add(row.file_path);
+		nodes.add(row.target_path);
+		const targets = outgoing.get(row.file_path) ?? /* @__PURE__ */ new Set();
+		targets.add(row.target_path);
+		outgoing.set(row.file_path, targets);
+	}
+	for (const seed of seeds.keys()) nodes.add(seed);
+	if (nodes.size === 0) return [];
+	const seedTotal = [...seeds.values()].reduce((sum, value) => sum + Math.max(value, 0), 0) || 1;
+	const teleport = new Map([...nodes].map((node) => [node, (seeds.get(node) ?? 0) / seedTotal]));
+	let rank = new Map(teleport);
+	const alpha = .85;
+	for (let iteration = 0; iteration < iterations; iteration += 1) {
+		const next = new Map([...nodes].map((node) => [node, .15000000000000002 * (teleport.get(node) ?? 0)]));
+		let dangling = 0;
+		for (const node of nodes) {
+			const targets = outgoing.get(node);
+			if (!targets?.size) {
+				dangling += rank.get(node) ?? 0;
+				continue;
+			}
+			const share = alpha * (rank.get(node) ?? 0) / targets.size;
+			for (const target of targets) next.set(target, (next.get(target) ?? 0) + share);
+		}
+		for (const node of nodes) next.set(node, (next.get(node) ?? 0) + alpha * dangling * (teleport.get(node) ?? 1 / nodes.size));
+		rank = next;
+	}
+	return [...rank.entries()].sort((left, right) => right[1] - left[1]).map(([filePath, score]) => ({
+		path: filePath,
+		graphScore: score
+	}));
+}
+function retrievalFeedback(cwd) {
+	let signature = "missing";
+	try {
+		const target = resolveLocalStatePath(cwd, contextEnginePaths(cwd).telemetry, { label: "Context telemetry" });
+		const stat = fs.statSync(target);
+		signature = `${stat.size}:${stat.mtimeMs}`;
+	} catch {
+		return {
+			rows: [],
+			observedSelected: 0,
+			selected: 0,
+			used: 0,
+			unused: 0,
+			utilizationRate: 0,
+			fallbackRereads: 0,
+			fallbackRereadRate: 0
+		};
+	}
+	const cached = retrievalFeedbackCache.get(cwd);
+	if (cached?.signature === signature) return cached.value;
+	const events = readContextTelemetry(cwd, {
+		limit: 12e3,
+		maxBytes: 12582912
+	});
+	const selectedCounts = /* @__PURE__ */ new Map();
+	const usedCounts = /* @__PURE__ */ new Map();
+	const fallbackReadCounts = /* @__PURE__ */ new Map();
+	const latestPackByPartition = /* @__PURE__ */ new Map();
+	const taskByTurn = new Map(events.filter((event) => event.event === "turn_task_bound" && typeof event.sessionId === "string" && typeof event.turnId === "string" && typeof event.taskRunId === "string").map((event) => [`${event.sessionId}\0${event.turnId}`, event.taskRunId]));
+	let observedSelected = 0, selected = 0, used = 0, fallbackRereads = 0;
+	const eventPaths = (event) => [...new Set([...Array.isArray(event.selectedPaths) ? event.selectedPaths : [], ...Array.isArray(event.selectedItems) ? event.selectedItems.map((item) => item?.path) : []].map(normalizeRelative).filter((filePath) => shouldIndexPath(filePath, {})))];
+	const successfulMutationPaths = (event) => {
+		if (event.event !== "tool_result" || event.isError === true) return [];
+		const explicit = [
+			event.changedPaths,
+			event.mutationPaths,
+			event.targetPaths
+		].find((value) => Array.isArray(value));
+		if (explicit) return [...new Set(explicit.map(normalizeRelative).filter(Boolean))];
+		const toolName = String(event.toolName ?? "").toLowerCase();
+		if (![
+			"write",
+			"edit",
+			"apply_patch",
+			"patch"
+		].includes(toolName)) return [];
+		const targetPath = normalizeRelative(event.targetPath);
+		return targetPath ? [targetPath] : [];
+	};
+	for (const event of events) {
+		const partition = contextMetricPartition(event, taskByTurn);
+		if (event.event === "context_pack_injected") {
+			const selectedPaths = eventPaths(event);
+			observedSelected += selectedPaths.length;
+			if (!partition) continue;
+			const pack = {
+				selectedPaths: new Set(selectedPaths),
+				usedPaths: /* @__PURE__ */ new Set(),
+				fallbackReadPaths: /* @__PURE__ */ new Set()
+			};
+			latestPackByPartition.set(partition, pack);
+			for (const filePath of selectedPaths) {
+				selectedCounts.set(filePath, (selectedCounts.get(filePath) ?? 0) + 1);
+				selected += 1;
+			}
+			continue;
+		}
+		if (!partition) continue;
+		const pack = latestPackByPartition.get(partition);
+		if (!pack) continue;
+		const targetPath = normalizeRelative(event.targetPath);
+		if (event.event === "tool_call" && [
+			"read",
+			"grep",
+			"find",
+			"ls"
+		].includes(event.toolName) && targetPath && pack.selectedPaths.has(targetPath) && !pack.fallbackReadPaths.has(targetPath)) {
+			pack.fallbackReadPaths.add(targetPath);
+			fallbackReadCounts.set(targetPath, (fallbackReadCounts.get(targetPath) ?? 0) + 1);
+			fallbackRereads += 1;
+			continue;
+		}
+		for (const mutationPath of successfulMutationPaths(event)) {
+			if (!pack.selectedPaths.has(mutationPath) || pack.usedPaths.has(mutationPath)) continue;
+			pack.usedPaths.add(mutationPath);
+			usedCounts.set(mutationPath, (usedCounts.get(mutationPath) ?? 0) + 1);
+			used += 1;
+		}
+	}
+	const value = {
+		rows: [...usedCounts.entries()].map(([filePath, usedCount]) => {
+			const selectedCount = selectedCounts.get(filePath) ?? usedCount;
+			const utilization = ratio(usedCount, selectedCount);
+			const evidence = Math.min(1, selectedCount / 3);
+			return {
+				path: filePath,
+				selectedCount,
+				usedCount,
+				fallbackRereadCount: fallbackReadCounts.get(filePath) ?? 0,
+				feedbackScore: utilization * evidence
+			};
+		}).sort((left, right) => right.feedbackScore - left.feedbackScore || right.usedCount - left.usedCount || left.path.localeCompare(right.path)),
+		observedSelected,
+		selected,
+		used,
+		unused: Math.max(0, selected - used),
+		utilizationRate: ratio(used, selected),
+		fallbackRereads,
+		fallbackRereadRate: ratio(fallbackRereads, selected)
+	};
+	retrievalFeedbackCache.set(cwd, {
+		signature,
+		value
+	});
+	return value;
+}
+async function searchContextIndexV2(cwd, query, options = {}) {
+	const excludePatterns = requireExplicitExcludePatterns(options, "searchContextIndexV2");
+	const limit = clampInteger(options.limit, 12, 1, 50);
+	const projectRoot = fs.realpathSync.native(cwd);
+	const directoryCache = /* @__PURE__ */ new Map();
+	const status = await contextIndexV2Status(cwd, { excludePatterns });
+	if (!status.exists) return {
+		query,
+		terms: [],
+		confidence: "none",
+		results: [],
+		status
+	};
+	const terms = tokenizeQuery(query);
+	const explicitPaths = queryPathCandidates(query);
+	if (terms.length === 0 && explicitPaths.length === 0) return {
+		query,
+		terms,
+		confidence: "none",
+		results: [],
+		status
+	};
+	const db = await openDatabase(cwd, { create: false });
+	try {
+		const scores = /* @__PURE__ */ new Map();
+		const pathAllowed = (filePath) => shouldIndexPath(filePath, { excludePatterns });
+		const allFiles = db.prepare("SELECT path, mtime_ms FROM files").all().filter((file) => pathAllowed(file.path));
+		const explicitRows = [];
+		for (const file of allFiles) {
+			const normalizedFile = file.path.toLowerCase();
+			const basename = path.posix.basename(file.path).toLowerCase();
+			if (explicitPaths.some((candidate) => {
+				const normalized = candidate.toLowerCase();
+				return normalizedFile === normalized || !normalized.includes("/") && basename === normalized;
+			})) explicitRows.push({
+				path: file.path,
+				exact: true
+			});
+		}
+		addRankedList(scores, explicitRows, "explicit", 3);
+		let lexicalRows = [];
+		if (terms.length > 0) {
+			lexicalRows = db.prepare(`
+        SELECT path, bm25(file_fts, 0.0, 1.0, 2.2) lexical_score
+        FROM file_fts WHERE file_fts MATCH ? ORDER BY lexical_score LIMIT ?
+      `).all(ftsQuery(terms), Math.max(limit * 4, 30)).filter((row) => pathAllowed(row.path));
+			addRankedList(scores, lexicalRows, "lexical", 1.5);
+		}
+		const symbolRows = [];
+		const symbolStatement = db.prepare(`
+      SELECT file_path, name, kind, line, end_line, signature
+      FROM symbols WHERE lower(name) = ? OR lower(name) LIKE ?
+      ORDER BY CASE WHEN lower(name) = ? THEN 0 ELSE 1 END, length(name) LIMIT ?
+    `);
+		for (const term of terms.slice(0, 8)) symbolRows.push(...symbolStatement.all(term, `%${term}%`, term, Math.max(limit * 2, 20)).filter((row) => pathAllowed(row.file_path)));
+		addRankedList(scores, [...new Map(symbolRows.map((row) => [`${row.file_path}:${row.line}`, row])).values()], "symbol", 2.2);
+		addRankedList(scores, gitChangedFiles(cwd).map((filePath) => ({ path: filePath })).filter((row) => scores.has(row.path)), "git-change", .8);
+		addRankedList(scores, allFiles.filter((file) => /(^|\/)(?:test|tests|__tests__)(\/|$)|(?:\.test|\.spec|_test)\./i.test(file.path)).filter((file) => terms.some((term) => file.path.toLowerCase().includes(term))).map((file) => ({ path: file.path })), "test", 1.1);
+		addRankedList(scores, retrievalFeedback(cwd).rows.filter((row) => scores.has(row.path)), "feedback", .45);
+		const graphSeeds = new Map([...scores.entries()].map(([filePath, value]) => [filePath, value.score]));
+		const importRows = db.prepare("SELECT file_path, specifier, target_path FROM imports WHERE target_path IS NOT NULL").all().filter((row) => pathAllowed(row.file_path) && pathAllowed(row.target_path));
+		const directLinks = directExplicitImportLinks(importRows, explicitRows);
+		addRankedList(scores, directLinks.rankingRows, "import", 1.8);
+		addRankedList(scores, personalizedPageRank(importRows, graphSeeds).slice(0, Math.max(limit * 3, 30)), "graph", 1);
+		const ranked = [...scores.values()].filter((candidate) => shouldIndexPath(candidate.path, { excludePatterns }) && projectFileInfo(cwd, candidate.path, projectRoot, directoryCache)).sort((left, right) => right.score - left.score).slice(0, limit);
+		const symbolLookup = db.prepare("SELECT name, kind, line, end_line, signature FROM symbols WHERE file_path = ? ORDER BY line LIMIT 12");
+		const results = ranked.map((candidate) => {
+			const matchingSymbols = candidate.rows.filter((row) => row.source === "symbol").map((row) => ({
+				name: row.name,
+				kind: row.kind,
+				line: row.line,
+				endLine: row.end_line,
+				signature: row.signature
+			}));
+			const symbols = matchingSymbols.length > 0 ? matchingSymbols : symbolLookup.all(candidate.path).slice(0, 6).map((row) => ({
+				name: row.name,
+				kind: row.kind,
+				line: row.line,
+				endLine: row.end_line,
+				signature: row.signature
+			}));
+			return {
+				path: candidate.path,
+				score: Number(candidate.score.toFixed(6)),
+				sources: [...candidate.sources],
+				links: directLinks.byPath.get(candidate.path) ?? [],
+				symbols
+			};
+		});
+		const top = results[0];
+		const exact = Boolean(top?.sources.includes("explicit")) || Boolean(top?.sources.includes("symbol") && top.sources.length >= 2);
+		return {
+			query,
+			terms,
+			confidence: !top ? "none" : exact ? "high" : top.sources.length >= 2 ? "medium" : "low",
+			results,
+			status
+		};
+	} finally {
+		db.close();
+	}
+}
+function readContextTelemetry(cwd, options = {}) {
+	const target = contextEnginePaths(cwd).telemetry;
+	return readJsonlTail(target, {
+		limit: clampInteger(options.limit, MAX_TELEMETRY_EVENTS, 1, MAX_TELEMETRY_EVENTS),
+		maxBytes: clampInteger(options.maxBytes, MAX_TELEMETRY_READ_BYTES, 65536, 268435456),
+		projectRoot: cwd
+	});
+}
+//#endregion
+//#region ../piagent-core/extensions/workspace-search-index.mjs
+try {
+	const result = await searchContextIndexV2(workerData.root, workerData.query, {
+		excludePatterns: workerData.excludePatterns,
+		limit: 50
+	});
+	parentPort.postMessage({
+		paths: result.results.map((row) => row.path),
+		available: result.status.exists
+	});
+} catch {
+	parentPort.postMessage({
+		paths: [],
+		available: false
+	});
+}
+//#endregion
+export {};