@unbrained/pm-cli 2026.7.6 → 2026.7.7

package/dist/cli-bundle/chunks/{chunk-EOKXK3R3.js → chunk-XZWL7VNE.js}

@@ -1,17 +1,34 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="c63a3843-4fe5-59f1-a28c-51139dae3ccd")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="143ba130-1e4a-555a-ad5a-281c82c7f363")}catch(e){}}();
 import {
-  locateItem,
-  readLocatedItem
-} from "./chunk-ENGQOEUY.js";
+  ACTIVITY_COMMANDER_STRING_OPTION_CONTRACTS,
+  CONTEXT_COMMANDER_STRING_OPTION_CONTRACTS,
+  CREATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS,
+  CREATE_COMMANDER_STRING_OPTION_CONTRACTS,
+  LIST_COMMANDER_STRING_OPTION_CONTRACTS,
+  NEXT_COMMANDER_STRING_OPTION_CONTRACTS,
+  SEARCH_COMMANDER_STRING_OPTION_CONTRACTS,
+  UPDATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS,
+  UPDATE_COMMANDER_STRING_OPTION_CONTRACTS,
+  readFirstStringFromCommanderOptions,
+  readFirstValueFromCommanderOptions,
+  readStringArrayFromCommanderOptions
+} from "./chunk-2APXX4TZ.js";
 import {
-  nowIso
-} from "./chunk-3GCS5SKL.js";
+  printError,
+  writeStdout
+} from "./chunk-EOUVR7JN.js";
 import {
+  PmCliError,
   getActiveExtensionRegistrations,
-  readSettings
-} from "./chunk-E3SZTQ4K.js";
+  locateItem,
+  nowIso,
+  readLocatedItem,
+  readSettings,
+  setActiveCommandResult
+} from "./chunk-GH73UOSJ.js";
 import {
+  EXIT_CODE,
   coercePositiveInteger,
   getSettingsPath,
   isFiniteNumberArray,
@@ -20,11 +37,18 @@ import {
   removeFileIfExists,
   resolveItemTypeRegistry,
   resolvePmPackageRootFromModule,
+  resolvePmRoot,
   toErrorMessage,
   toNonEmptyString,
   trimTrailingSlashes,
   writeFileAtomic
-} from "./chunk-57NWPFF2.js";
+} from "./chunk-UO7XAZK6.js";
+
+// dist/cli/registration-helpers.js
+import { Option } from "commander";
+
+// dist/core/search/cache.js
+import path2 from "node:path";
 
 // dist/core/search/http-client.js
 var DEFAULT_SEARCH_HTTP_TIMEOUT_MS = 3e4;
@@ -511,12 +535,157 @@ function buildSemanticCorpusInput(document, options = {}) {
   return `${serialized.slice(0, keepLength)}${SEMANTIC_CORPUS_TRUNCATION_SUFFIX}`;
 }
 
+// dist/core/search/embedding-batches.js
+function resolveBatchRuntime(settings, maxInputCharacters) {
+  const batchSizeCandidate = settings.search.embedding_batch_size;
+  const timeoutMsCandidate = settings.search.embedding_timeout_ms;
+  const maxRetriesCandidate = settings.search.scanner_max_batch_retries;
+  const batchSize = Number.isFinite(batchSizeCandidate) && batchSizeCandidate > 0 ? Math.floor(batchSizeCandidate) : 1;
+  const timeoutMs = Number.isFinite(timeoutMsCandidate) && timeoutMsCandidate > 0 ? Math.floor(timeoutMsCandidate) : 3e4;
+  const maxRetries = Number.isFinite(maxRetriesCandidate) && maxRetriesCandidate >= 0 ? Math.floor(maxRetriesCandidate) : 0;
+  return {
+    batchSize,
+    timeoutMs,
+    maxRetries,
+    maxBatchInputCharacters: Number.POSITIVE_INFINITY,
+    maxInputCharacters
+  };
+}
+function createBatches(inputs, batchSize, maxBatchInputCharacters) {
+  const batches = [];
+  let currentBatch = [];
+  let currentCharacters = 0;
+  for (const input of inputs) {
+    const wouldExceedCount = currentBatch.length >= batchSize;
+    const wouldExceedCharacters = currentBatch.length > 0 && Number.isFinite(maxBatchInputCharacters) && currentCharacters + input.length > maxBatchInputCharacters;
+    if (wouldExceedCount || wouldExceedCharacters) {
+      batches.push(currentBatch);
+      currentBatch = [];
+      currentCharacters = 0;
+    }
+    currentBatch.push(input);
+    currentCharacters += input.length;
+  }
+  batches.push(currentBatch);
+  return batches;
+}
+function resolveProviderBatchRuntime(provider, runtime) {
+  if (provider.name !== "ollama") {
+    return runtime;
+  }
+  return {
+    ...runtime,
+    maxBatchInputCharacters: OLLAMA_SEMANTIC_CORPUS_INPUT_MAX_CHARACTERS
+  };
+}
+function truncateInputForRuntime(input, maxInputCharacters) {
+  if (!Number.isFinite(maxInputCharacters) || maxInputCharacters <= 0 || input.length <= maxInputCharacters) {
+    return input;
+  }
+  const keepLength = Math.max(0, maxInputCharacters - SEMANTIC_CORPUS_TRUNCATION_SUFFIX.length);
+  return `${input.slice(0, keepLength)}${SEMANTIC_CORPUS_TRUNCATION_SUFFIX}`.slice(0, maxInputCharacters);
+}
+function isEmbeddingTimeoutError(error) {
+  const message = toErrorMessage(error).toLowerCase();
+  return message.includes("timed out") || message.includes("timeout");
+}
+function buildEmbeddingFailureMessage(provider, batchLabel, batchSize, timeoutMs, attempts, error) {
+  const base = `Embedding batch ${batchLabel} failed after ${attempts} attempt(s): ${toErrorMessage(error)}`;
+  const details = `provider=${provider.name} model=${provider.model} batch_size=${batchSize} timeout_ms=${timeoutMs}`;
+  if (!isEmbeddingTimeoutError(error)) {
+    return `${base} (${details})`;
+  }
+  return `${base} (${details}; guidance=check provider availability or lower search.embedding_batch_size, raise search.embedding_timeout_ms, or run keyword search while semantic indexing catches up)`;
+}
+async function executeBatchWithAdaptiveSplit(provider, batch, batchLabel, timeoutMs, maxRetries, warnings) {
+  let lastError = null;
+  for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+    try {
+      const batchVectors = await executeEmbeddingRequest(provider, batch, { timeout_ms: timeoutMs });
+      if (attempt > 0) {
+        warnings.push(`search_embedding_batch_retry_succeeded:batch=${batchLabel}:attempt=${attempt + 1}:size=${batch.length}`);
+      }
+      return batchVectors;
+    } catch (error) {
+      lastError = error;
+      if (isEmbeddingTimeoutError(error) && batch.length > 1) {
+        const midpoint = Math.ceil(batch.length / 2);
+        const left = batch.slice(0, midpoint);
+        const right = batch.slice(midpoint);
+        warnings.push(`search_embedding_batch_split_after_timeout:batch=${batchLabel}:size=${batch.length}:parts=${left.length}|${right.length}`);
+        return [
+          ...await executeBatchWithAdaptiveSplit(provider, left, `${batchLabel}.1`, timeoutMs, maxRetries, warnings),
+          ...await executeBatchWithAdaptiveSplit(provider, right, `${batchLabel}.2`, timeoutMs, maxRetries, warnings)
+        ];
+      }
+      if (attempt < maxRetries) {
+        const delayMs = Math.min(1e3 * 2 ** attempt, 8e3);
+        await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+      }
+    }
+  }
+  throw new Error(buildEmbeddingFailureMessage(provider, batchLabel, batch.length, timeoutMs, maxRetries + 1, lastError));
+}
+async function executeEmbeddingBatchesWithRetry(provider, settings, inputs, options = {}) {
+  if (inputs.length === 0) {
+    return {
+      vectors: [],
+      warnings: []
+    };
+  }
+  const warnings = [];
+  const corpusLimitResolution = resolveSemanticCorpusCharacterLimit(provider.name, settings.search.embedding_corpus_max_characters);
+  if (corpusLimitResolution.warning) {
+    warnings.push(corpusLimitResolution.warning);
+  }
+  const runtime = resolveProviderBatchRuntime(provider, resolveBatchRuntime(settings, corpusLimitResolution.maxCharacters));
+  let truncatedInputCount = 0;
+  const normalizedInputs = inputs.map((input) => {
+    const normalized = truncateInputForRuntime(input, runtime.maxInputCharacters);
+    if (normalized.length < input.length) {
+      truncatedInputCount += 1;
+    }
+    return normalized;
+  });
+  if (truncatedInputCount > 0) {
+    warnings.push(`search_embedding_input_truncated:count=${truncatedInputCount}:max_characters=${runtime.maxInputCharacters}`);
+  }
+  const batches = createBatches(normalizedInputs, runtime.batchSize, runtime.maxBatchInputCharacters);
+  const vectors = [];
+  let completedInputs = 0;
+  for (let batchIndex = 0; batchIndex < batches.length; batchIndex += 1) {
+    const batch = batches[batchIndex];
+    options.onProgress?.({
+      batch_index: batchIndex + 1,
+      batch_total: batches.length,
+      batch_size: batch.length,
+      completed_inputs: completedInputs,
+      total_inputs: normalizedInputs.length,
+      phase: "start"
+    });
+    vectors.push(...await executeBatchWithAdaptiveSplit(provider, batch, String(batchIndex + 1), runtime.timeoutMs, runtime.maxRetries, warnings));
+    completedInputs += batch.length;
+    options.onProgress?.({
+      batch_index: batchIndex + 1,
+      batch_total: batches.length,
+      batch_size: batch.length,
+      completed_inputs: completedInputs,
+      total_inputs: normalizedInputs.length,
+      phase: "complete"
+    });
+  }
+  return {
+    vectors,
+    warnings
+  };
+}
+
 // dist/core/search/semantic-defaults.js
 import { spawnSync } from "node:child_process";
 var DISABLE_AUTO_DEFAULTS_ENV = "PM_DISABLE_OLLAMA_AUTO_DEFAULTS";
 var OLLAMA_MODEL_ENV = "PM_OLLAMA_MODEL";
 var DEFAULT_OLLAMA_BASE_URL = "http://localhost:11434";
-var DEFAULT_OLLAMA_MODEL = "qwen3-embedding:0.6b";
+var RECOMMENDED_OLLAMA_EMBEDDING_MODEL = "qwen3-embedding:0.6b";
 var DEFAULT_LANCEDB_PATH = ".agents/pm/search/lancedb/";
 var OLLAMA_VERSION_TIMEOUT_MS = 1500;
 var OLLAMA_LIST_TIMEOUT_MS = 2500;
@@ -606,7 +775,7 @@ function resolveAutoOllamaModel(settings) {
       return listedModel;
     }
   }
-  return DEFAULT_OLLAMA_MODEL;
+  return null;
 }
 function resolveSemanticDefaultNeeds(settings) {
   return {
@@ -667,6 +836,13 @@ function resolveSettingsWithSemanticRuntimeDefaults(settings) {
   }
   const nextSettings = structuredClone(settings);
   const resolvedModel = resolveAutoOllamaModel(nextSettings);
+  if (!resolvedModel) {
+    return {
+      ...unchanged,
+      auto_ollama_defaults_skipped_reason: "no_installed_embedding_model",
+      auto_ollama_defaults_remediation: `Run ollama pull ${RECOMMENDED_OLLAMA_EMBEDDING_MODEL} or configure providers.ollama.model explicitly (and search.embedding_model if you need an override).`
+    };
+  }
   applyOllamaProviderDefaults(nextSettings, needs, resolvedModel);
   applyVectorStoreDefaults(nextSettings, needs);
   applySearchEmbeddingDefaults(nextSettings, needs, resolvedModel);
@@ -676,90 +852,226 @@ function resolveSettingsWithSemanticRuntimeDefaults(settings) {
   };
 }
 
-// dist/core/search/vector-stores.js
-import { mkdir, readFile, stat, unlink } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-var DEFAULT_COLLECTION = "pm_items";
-var COLLECTION_SANITIZE_PATTERN = /[^a-zA-Z0-9_-]/g;
-var MAX_COLLECTION_NAME_LENGTH = 128;
-var LANCE_DB_LOCAL_SNAPSHOT_DIR = ".pm-cli-local-vectors";
-var LANCE_DB_LOCAL_SNAPSHOT_VERSION = 1;
-var lanceDbLocalTables = /* @__PURE__ */ new Map();
-function resolveStoreCollectionName(store) {
-  const candidate = toNonEmptyString(store.collection_name) ?? DEFAULT_COLLECTION;
-  return candidate.replaceAll(COLLECTION_SANITIZE_PATTERN, "_").slice(0, MAX_COLLECTION_NAME_LENGTH);
-}
-function normalizeVector(value) {
-  if (!isFiniteNumberArray(value) || value.length === 0) {
-    throw new Error("Vector values must be a non-empty numeric array");
+// dist/core/search/background-refresh.js
+import { spawn } from "node:child_process";
+import { mkdirSync, rmSync, statSync } from "node:fs";
+import path from "node:path";
+var REINDEX_LOCK_ID = "reindex";
+var PENDING_QUEUE_REL_PATH = "search/pending-refresh.json";
+var PENDING_QUEUE_GATE_REL_PATH = "search/pending-refresh.gate.lock";
+var PENDING_QUEUE_GATE_STALE_MS = 3e4;
+var SEARCH_REFRESH_INLINE_ENV = "PM_SEARCH_REFRESH_INLINE";
+var SEARCH_REFRESH_CHILD_ENV = "PM_SEARCH_REFRESH_CHILD";
+function parseBooleanTrueLike(value) {
+  if (typeof value !== "string") {
+    return false;
   }
-  return [...value];
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
 }
-function normalizeLimit(value) {
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new Error("Vector query limit must be a positive number");
+function shouldRunSearchRefreshInForeground() {
+  if (parseBooleanTrueLike(process.env[SEARCH_REFRESH_INLINE_ENV])) {
+    return true;
   }
-  return Math.floor(value);
-}
-function normalizeQdrantQueryResponse(payload) {
-  const result = payload.result;
-  if (!Array.isArray(result)) {
-    throw new TypeError("Qdrant query response must include a result array");
+  if (parseBooleanTrueLike(process.env[SEARCH_REFRESH_CHILD_ENV])) {
+    return true;
   }
-  const hits = result.map((entry, index) => {
-    const idValue = entry.id;
-    const idCandidate = typeof idValue === "number" ? String(idValue) : idValue;
-    const id = toNonEmptyString(idCandidate);
-    if (!id) {
-      throw new Error(`Qdrant query response entry at index ${index} is missing a non-empty id`);
-    }
-    const score = entry.score;
-    if (typeof score !== "number" || !Number.isFinite(score)) {
-      throw new TypeError(`Qdrant query response entry at index ${index} is missing a finite numeric score`);
-    }
-    const payloadValue = entry.payload;
-    if (payloadValue !== void 0 && (typeof payloadValue !== "object" || payloadValue === null || Array.isArray(payloadValue))) {
-      throw new Error(`Qdrant query response entry at index ${index} must provide payload as an object when set`);
-    }
-    return {
-      id,
-      score,
-      ...payloadValue ? { payload: payloadValue } : {}
-    };
-  });
-  hits.sort((left, right) => {
-    if (left.score !== right.score) {
-      return right.score - left.score;
-    }
-    return left.id.localeCompare(right.id);
-  });
-  return hits;
+  const nodeEnv = (process.env.NODE_ENV ?? "").trim().toLowerCase();
+  return typeof process.env.VITEST === "string" || typeof process.env.VITEST_WORKER_ID === "string" || nodeEnv === "test";
 }
-function normalizeQdrantUpsertResponse(payload) {
-  const nestedStatus = toNonEmptyString(payload.result?.status);
-  if (nestedStatus) {
-    return { status: nestedStatus };
-  }
-  const topLevelStatus = toNonEmptyString(payload.status);
-  if (topLevelStatus) {
-    return { status: topLevelStatus };
-  }
-  throw new Error("Qdrant upsert response must include status metadata");
+function pendingQueuePath(pmRoot) {
+  return path.join(pmRoot, PENDING_QUEUE_REL_PATH);
 }
-async function executeRemoteVectorPlan(endpoint, plan, timeoutMs, fetcher, requestKind) {
-  return await executeSearchJsonRequest({
-    endpoint,
-    method: plan.method,
-    headers: plan.headers,
-    body: plan.body,
-    timeoutMs,
-    fetcher,
-    requestLabel: `Vector ${requestKind} request`,
-    responseLabel: `Vector ${requestKind} response`
-  });
+function pendingQueueGatePath(pmRoot) {
+  return path.join(pmRoot, PENDING_QUEUE_GATE_REL_PATH);
 }
-function resolveQdrantStore(settings) {
-  const url = toNonEmptyString(settings.vector_store?.qdrant?.url);
+function acquireQueueGate(pmRoot) {
+  const gatePath = pendingQueueGatePath(pmRoot);
+  try {
+    if (Date.now() - statSync(gatePath).mtimeMs < PENDING_QUEUE_GATE_STALE_MS) {
+      return false;
+    }
+    rmSync(gatePath, { recursive: true, force: true });
+  } catch {
+  }
+  try {
+    mkdirSync(path.dirname(gatePath), { recursive: true });
+    mkdirSync(gatePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function releaseQueueGate(pmRoot) {
+  try {
+    rmSync(pendingQueueGatePath(pmRoot), { recursive: true, force: true });
+  } catch {
+  }
+}
+async function withQueueGate(pmRoot, fn, fallback) {
+  for (let attempt = 0; attempt < 50; attempt += 1) {
+    if (acquireQueueGate(pmRoot)) {
+      try {
+        return await fn();
+      } finally {
+        releaseQueueGate(pmRoot);
+      }
+    }
+    await delay(20);
+  }
+  return fallback;
+}
+function delay(ms) {
+  return new Promise((resolve2) => {
+    setTimeout(resolve2, ms);
+  });
+}
+async function readPendingQueueIds(pmRoot) {
+  const raw = await readFileIfExists(pendingQueuePath(pmRoot));
+  if (!raw || raw.trim().length === 0) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.ids)) {
+      return [];
+    }
+    return parsed.ids.filter((id) => typeof id === "string" && id.length > 0);
+  } catch {
+    return [];
+  }
+}
+async function writePendingQueueIds(pmRoot, ids) {
+  await writeFileAtomic(pendingQueuePath(pmRoot), `${JSON.stringify({ ids })}
+`);
+}
+async function enqueuePendingRefreshIds(pmRoot, itemIds) {
+  const incoming = itemIds.filter((id) => typeof id === "string" && id.trim().length > 0);
+  if (incoming.length === 0) {
+    return;
+  }
+  const mergeIncoming = async () => {
+    const existing = await readPendingQueueIds(pmRoot);
+    const merged = [.../* @__PURE__ */ new Set([...existing, ...incoming])].sort((left, right) => left.localeCompare(right));
+    await writePendingQueueIds(pmRoot, merged);
+  };
+  const gated = await withQueueGate(pmRoot, async () => {
+    await mergeIncoming();
+    return true;
+  }, false);
+  if (!gated) {
+    await mergeIncoming();
+  }
+}
+function searchRefreshRunnerPath() {
+  return path.join(resolvePmPackageRootFromModule(import.meta.url, ["../../.."]), "dist", "cli", "search-refresh.js");
+}
+function dispatchRefreshChild(pmRoot) {
+  try {
+    const child = spawn(process.execPath, [searchRefreshRunnerPath()], {
+      detached: true,
+      stdio: "ignore",
+      env: {
+        ...process.env,
+        PM_PATH: pmRoot,
+        [SEARCH_REFRESH_CHILD_ENV]: "1"
+      }
+    });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+async function scheduleBackgroundSemanticRefresh(pmRoot, itemIds) {
+  await enqueuePendingRefreshIds(pmRoot, itemIds);
+  dispatchRefreshChild(pmRoot);
+}
+
+// dist/core/search/vector-stores.js
+import { mkdir, readFile, stat, unlink } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+var DEFAULT_COLLECTION = "pm_items";
+var COLLECTION_SANITIZE_PATTERN = /[^a-zA-Z0-9_-]/g;
+var MAX_COLLECTION_NAME_LENGTH = 128;
+var LANCE_DB_LOCAL_SNAPSHOT_DIR = ".pm-cli-local-vectors";
+var LANCE_DB_LOCAL_SNAPSHOT_VERSION = 1;
+var lanceDbLocalTables = /* @__PURE__ */ new Map();
+function resolveStoreCollectionName(store) {
+  const candidate = toNonEmptyString(store.collection_name) ?? DEFAULT_COLLECTION;
+  return candidate.replaceAll(COLLECTION_SANITIZE_PATTERN, "_").slice(0, MAX_COLLECTION_NAME_LENGTH);
+}
+function normalizeVector(value) {
+  if (!isFiniteNumberArray(value) || value.length === 0) {
+    throw new Error("Vector values must be a non-empty numeric array");
+  }
+  return [...value];
+}
+function normalizeLimit(value) {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error("Vector query limit must be a positive number");
+  }
+  return Math.floor(value);
+}
+function normalizeQdrantQueryResponse(payload) {
+  const result = payload.result;
+  if (!Array.isArray(result)) {
+    throw new TypeError("Qdrant query response must include a result array");
+  }
+  const hits = result.map((entry, index) => {
+    const idValue = entry.id;
+    const idCandidate = typeof idValue === "number" ? String(idValue) : idValue;
+    const id = toNonEmptyString(idCandidate);
+    if (!id) {
+      throw new Error(`Qdrant query response entry at index ${index} is missing a non-empty id`);
+    }
+    const score = entry.score;
+    if (typeof score !== "number" || !Number.isFinite(score)) {
+      throw new TypeError(`Qdrant query response entry at index ${index} is missing a finite numeric score`);
+    }
+    const payloadValue = entry.payload;
+    if (payloadValue !== void 0 && (typeof payloadValue !== "object" || payloadValue === null || Array.isArray(payloadValue))) {
+      throw new Error(`Qdrant query response entry at index ${index} must provide payload as an object when set`);
+    }
+    return {
+      id,
+      score,
+      ...payloadValue ? { payload: payloadValue } : {}
+    };
+  });
+  hits.sort((left, right) => {
+    if (left.score !== right.score) {
+      return right.score - left.score;
+    }
+    return left.id.localeCompare(right.id);
+  });
+  return hits;
+}
+function normalizeQdrantUpsertResponse(payload) {
+  const nestedStatus = toNonEmptyString(payload.result?.status);
+  if (nestedStatus) {
+    return { status: nestedStatus };
+  }
+  const topLevelStatus = toNonEmptyString(payload.status);
+  if (topLevelStatus) {
+    return { status: topLevelStatus };
+  }
+  throw new Error("Qdrant upsert response must include status metadata");
+}
+async function executeRemoteVectorPlan(endpoint, plan, timeoutMs, fetcher, requestKind) {
+  return await executeSearchJsonRequest({
+    endpoint,
+    method: plan.method,
+    headers: plan.headers,
+    body: plan.body,
+    timeoutMs,
+    fetcher,
+    requestLabel: `Vector ${requestKind} request`,
+    responseLabel: `Vector ${requestKind} response`
+  });
+}
+function resolveQdrantStore(settings) {
+  const url = toNonEmptyString(settings.vector_store?.qdrant?.url);
   if (!url) {
     return null;
   }
@@ -772,7 +1084,21 @@ function resolveQdrantStore(settings) {
     ...apiKey ? { api_key: apiKey } : {}
   };
 }
-function resolveLanceDbStore(settings) {
+function resolveWorkspaceRootFromPmRoot(pmRoot) {
+  const resolved = resolve(pmRoot);
+  const parent = dirname(resolved);
+  if (basename(resolved) === "pm" && basename(parent) === ".agents") {
+    return dirname(parent);
+  }
+  return resolved;
+}
+function anchorLanceDbStorePath(storePath, pmRoot) {
+  if (!pmRoot || isAbsolute(storePath)) {
+    return storePath;
+  }
+  return resolve(resolveWorkspaceRootFromPmRoot(pmRoot), storePath);
+}
+function resolveLanceDbStore(settings, pmRoot) {
   const lancedbPath = toNonEmptyString(settings.vector_store?.lancedb?.path);
   if (!lancedbPath) {
     return null;
@@ -780,7 +1106,7 @@ function resolveLanceDbStore(settings) {
   const collectionName = toNonEmptyString(settings.vector_store?.collection_name);
   return {
     name: "lancedb",
-    path: lancedbPath,
+    path: anchorLanceDbStorePath(lancedbPath, pmRoot),
     ...collectionName && collectionName !== DEFAULT_COLLECTION ? { collection_name: collectionName } : {}
   };
 }
@@ -1015,9 +1341,9 @@ function cosineSimilarity(left, right) {
   }
   return dotProd / (leftNorm * rightNorm);
 }
-function resolveVectorStores(settings) {
+function resolveVectorStores(settings, pmRoot) {
   const qdrant = resolveQdrantStore(settings);
-  const lancedb = resolveLanceDbStore(settings);
+  const lancedb = resolveLanceDbStore(settings, pmRoot);
   const available = [qdrant, lancedb].filter((entry) => entry !== null);
   const preferredName = toNonEmptyString(settings.vector_store?.adapter);
   const preferredKey = preferredName ? preferredName.toLowerCase() : null;
@@ -1335,311 +1661,27 @@ function inferConsistentVectorDimension(vectors, context) {
 }
 
 // dist/core/search/cache.js
-import path2 from "node:path";
-
-// dist/core/search/embedding-batches.js
-function resolveBatchRuntime(settings, maxInputCharacters) {
-  const batchSizeCandidate = settings.search.embedding_batch_size;
-  const timeoutMsCandidate = settings.search.embedding_timeout_ms;
-  const maxRetriesCandidate = settings.search.scanner_max_batch_retries;
-  const batchSize = Number.isFinite(batchSizeCandidate) && batchSizeCandidate > 0 ? Math.floor(batchSizeCandidate) : 1;
-  const timeoutMs = Number.isFinite(timeoutMsCandidate) && timeoutMsCandidate > 0 ? Math.floor(timeoutMsCandidate) : 3e4;
-  const maxRetries = Number.isFinite(maxRetriesCandidate) && maxRetriesCandidate >= 0 ? Math.floor(maxRetriesCandidate) : 0;
-  return {
-    batchSize,
-    timeoutMs,
-    maxRetries,
-    maxBatchInputCharacters: Number.POSITIVE_INFINITY,
-    maxInputCharacters
-  };
+var SEARCH_CACHE_ARTIFACT_PATHS = ["index/manifest.json", "search/embeddings.jsonl"];
+var VECTORIZATION_STATUS_LEDGER_PATH = "search/vectorization-status.json";
+function formatInvalidationWarning(relativePath, error) {
+  return `search_cache_invalidation_failed:${relativePath}:${String(error)}`;
 }
-function createBatches(inputs, batchSize, maxBatchInputCharacters) {
-  const batches = [];
-  let currentBatch = [];
-  let currentCharacters = 0;
-  for (const input of inputs) {
-    const wouldExceedCount = currentBatch.length >= batchSize;
-    const wouldExceedCharacters = currentBatch.length > 0 && Number.isFinite(maxBatchInputCharacters) && currentCharacters + input.length > maxBatchInputCharacters;
-    if (wouldExceedCount || wouldExceedCharacters) {
-      batches.push(currentBatch);
-      currentBatch = [];
-      currentCharacters = 0;
-    }
-    currentBatch.push(input);
-    currentCharacters += input.length;
-  }
-  batches.push(currentBatch);
-  return batches;
+function toUniqueSorted(values) {
+  return [...new Set([...values].map((value) => value.trim()).filter((value) => value.length > 0))].sort((left, right) => left.localeCompare(right));
 }
-function resolveProviderBatchRuntime(provider, runtime) {
-  if (provider.name !== "ollama") {
-    return runtime;
-  }
-  return {
-    ...runtime,
-    maxBatchInputCharacters: OLLAMA_SEMANTIC_CORPUS_INPUT_MAX_CHARACTERS
-  };
+function isValidUpdatedAt(value) {
+  return typeof value === "string" && value.trim().length > 0 && Number.isFinite(Date.parse(value));
 }
-function truncateInputForRuntime(input, maxInputCharacters) {
-  if (!Number.isFinite(maxInputCharacters) || maxInputCharacters <= 0 || input.length <= maxInputCharacters) {
-    return input;
+function normalizeVectorizationLedgerEntries(entries) {
+  const normalized = /* @__PURE__ */ new Map();
+  for (const [rawId, rawUpdatedAt] of Object.entries(entries)) {
+    const id = rawId.trim();
+    if (id.length === 0 || !isValidUpdatedAt(rawUpdatedAt)) {
+      continue;
+    }
+    normalized.set(id, rawUpdatedAt);
   }
-  const keepLength = Math.max(0, maxInputCharacters - SEMANTIC_CORPUS_TRUNCATION_SUFFIX.length);
-  return `${input.slice(0, keepLength)}${SEMANTIC_CORPUS_TRUNCATION_SUFFIX}`.slice(0, maxInputCharacters);
-}
-function isEmbeddingTimeoutError(error) {
-  const message = toErrorMessage(error).toLowerCase();
-  return message.includes("timed out") || message.includes("timeout");
-}
-function buildEmbeddingFailureMessage(provider, batchLabel, batchSize, timeoutMs, attempts, error) {
-  const base = `Embedding batch ${batchLabel} failed after ${attempts} attempt(s): ${toErrorMessage(error)}`;
-  const details = `provider=${provider.name} model=${provider.model} batch_size=${batchSize} timeout_ms=${timeoutMs}`;
-  if (!isEmbeddingTimeoutError(error)) {
-    return `${base} (${details})`;
-  }
-  return `${base} (${details}; guidance=check provider availability or lower search.embedding_batch_size, raise search.embedding_timeout_ms, or run keyword search while semantic indexing catches up)`;
-}
-async function executeBatchWithAdaptiveSplit(provider, batch, batchLabel, timeoutMs, maxRetries, warnings) {
-  let lastError = null;
-  for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
-    try {
-      const batchVectors = await executeEmbeddingRequest(provider, batch, { timeout_ms: timeoutMs });
-      if (attempt > 0) {
-        warnings.push(`search_embedding_batch_retry_succeeded:batch=${batchLabel}:attempt=${attempt + 1}:size=${batch.length}`);
-      }
-      return batchVectors;
-    } catch (error) {
-      lastError = error;
-      if (isEmbeddingTimeoutError(error) && batch.length > 1) {
-        const midpoint = Math.ceil(batch.length / 2);
-        const left = batch.slice(0, midpoint);
-        const right = batch.slice(midpoint);
-        warnings.push(`search_embedding_batch_split_after_timeout:batch=${batchLabel}:size=${batch.length}:parts=${left.length}|${right.length}`);
-        return [
-          ...await executeBatchWithAdaptiveSplit(provider, left, `${batchLabel}.1`, timeoutMs, maxRetries, warnings),
-          ...await executeBatchWithAdaptiveSplit(provider, right, `${batchLabel}.2`, timeoutMs, maxRetries, warnings)
-        ];
-      }
-      if (attempt < maxRetries) {
-        const delayMs = Math.min(1e3 * 2 ** attempt, 8e3);
-        await new Promise((resolve2) => setTimeout(resolve2, delayMs));
-      }
-    }
-  }
-  throw new Error(buildEmbeddingFailureMessage(provider, batchLabel, batch.length, timeoutMs, maxRetries + 1, lastError));
-}
-async function executeEmbeddingBatchesWithRetry(provider, settings, inputs, options = {}) {
-  if (inputs.length === 0) {
-    return {
-      vectors: [],
-      warnings: []
-    };
-  }
-  const warnings = [];
-  const corpusLimitResolution = resolveSemanticCorpusCharacterLimit(provider.name, settings.search.embedding_corpus_max_characters);
-  if (corpusLimitResolution.warning) {
-    warnings.push(corpusLimitResolution.warning);
-  }
-  const runtime = resolveProviderBatchRuntime(provider, resolveBatchRuntime(settings, corpusLimitResolution.maxCharacters));
-  let truncatedInputCount = 0;
-  const normalizedInputs = inputs.map((input) => {
-    const normalized = truncateInputForRuntime(input, runtime.maxInputCharacters);
-    if (normalized.length < input.length) {
-      truncatedInputCount += 1;
-    }
-    return normalized;
-  });
-  if (truncatedInputCount > 0) {
-    warnings.push(`search_embedding_input_truncated:count=${truncatedInputCount}:max_characters=${runtime.maxInputCharacters}`);
-  }
-  const batches = createBatches(normalizedInputs, runtime.batchSize, runtime.maxBatchInputCharacters);
-  const vectors = [];
-  let completedInputs = 0;
-  for (let batchIndex = 0; batchIndex < batches.length; batchIndex += 1) {
-    const batch = batches[batchIndex];
-    options.onProgress?.({
-      batch_index: batchIndex + 1,
-      batch_total: batches.length,
-      batch_size: batch.length,
-      completed_inputs: completedInputs,
-      total_inputs: normalizedInputs.length,
-      phase: "start"
-    });
-    vectors.push(...await executeBatchWithAdaptiveSplit(provider, batch, String(batchIndex + 1), runtime.timeoutMs, runtime.maxRetries, warnings));
-    completedInputs += batch.length;
-    options.onProgress?.({
-      batch_index: batchIndex + 1,
-      batch_total: batches.length,
-      batch_size: batch.length,
-      completed_inputs: completedInputs,
-      total_inputs: normalizedInputs.length,
-      phase: "complete"
-    });
-  }
-  return {
-    vectors,
-    warnings
-  };
-}
-
-// dist/core/search/background-refresh.js
-import { spawn } from "node:child_process";
-import { mkdirSync, rmSync, statSync } from "node:fs";
-import path from "node:path";
-var REINDEX_LOCK_ID = "reindex";
-var PENDING_QUEUE_REL_PATH = "search/pending-refresh.json";
-var PENDING_QUEUE_GATE_REL_PATH = "search/pending-refresh.gate.lock";
-var PENDING_QUEUE_GATE_STALE_MS = 3e4;
-var SEARCH_REFRESH_INLINE_ENV = "PM_SEARCH_REFRESH_INLINE";
-var SEARCH_REFRESH_CHILD_ENV = "PM_SEARCH_REFRESH_CHILD";
-function parseBooleanTrueLike(value) {
-  if (typeof value !== "string") {
-    return false;
-  }
-  const normalized = value.trim().toLowerCase();
-  return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
-}
-function shouldRunSearchRefreshInForeground() {
-  if (parseBooleanTrueLike(process.env[SEARCH_REFRESH_INLINE_ENV])) {
-    return true;
-  }
-  if (parseBooleanTrueLike(process.env[SEARCH_REFRESH_CHILD_ENV])) {
-    return true;
-  }
-  const nodeEnv = (process.env.NODE_ENV ?? "").trim().toLowerCase();
-  return typeof process.env.VITEST === "string" || typeof process.env.VITEST_WORKER_ID === "string" || nodeEnv === "test";
-}
-function pendingQueuePath(pmRoot) {
-  return path.join(pmRoot, PENDING_QUEUE_REL_PATH);
-}
-function pendingQueueGatePath(pmRoot) {
-  return path.join(pmRoot, PENDING_QUEUE_GATE_REL_PATH);
-}
-function acquireQueueGate(pmRoot) {
-  const gatePath = pendingQueueGatePath(pmRoot);
-  try {
-    if (Date.now() - statSync(gatePath).mtimeMs < PENDING_QUEUE_GATE_STALE_MS) {
-      return false;
-    }
-    rmSync(gatePath, { recursive: true, force: true });
-  } catch {
-  }
-  try {
-    mkdirSync(path.dirname(gatePath), { recursive: true });
-    mkdirSync(gatePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function releaseQueueGate(pmRoot) {
-  try {
-    rmSync(pendingQueueGatePath(pmRoot), { recursive: true, force: true });
-  } catch {
-  }
-}
-async function withQueueGate(pmRoot, fn, fallback) {
-  for (let attempt = 0; attempt < 50; attempt += 1) {
-    if (acquireQueueGate(pmRoot)) {
-      try {
-        return await fn();
-      } finally {
-        releaseQueueGate(pmRoot);
-      }
-    }
-    await delay(20);
-  }
-  return fallback;
-}
-function delay(ms) {
-  return new Promise((resolve2) => {
-    setTimeout(resolve2, ms);
-  });
-}
-async function readPendingQueueIds(pmRoot) {
-  const raw = await readFileIfExists(pendingQueuePath(pmRoot));
-  if (!raw || raw.trim().length === 0) {
-    return [];
-  }
-  try {
-    const parsed = JSON.parse(raw);
-    if (!Array.isArray(parsed.ids)) {
-      return [];
-    }
-    return parsed.ids.filter((id) => typeof id === "string" && id.length > 0);
-  } catch {
-    return [];
-  }
-}
-async function writePendingQueueIds(pmRoot, ids) {
-  await writeFileAtomic(pendingQueuePath(pmRoot), `${JSON.stringify({ ids })}
-`);
-}
-async function enqueuePendingRefreshIds(pmRoot, itemIds) {
-  const incoming = itemIds.filter((id) => typeof id === "string" && id.trim().length > 0);
-  if (incoming.length === 0) {
-    return;
-  }
-  const mergeIncoming = async () => {
-    const existing = await readPendingQueueIds(pmRoot);
-    const merged = [.../* @__PURE__ */ new Set([...existing, ...incoming])].sort((left, right) => left.localeCompare(right));
-    await writePendingQueueIds(pmRoot, merged);
-  };
-  const gated = await withQueueGate(pmRoot, async () => {
-    await mergeIncoming();
-    return true;
-  }, false);
-  if (!gated) {
-    await mergeIncoming();
-  }
-}
-function searchRefreshRunnerPath() {
-  return path.join(resolvePmPackageRootFromModule(import.meta.url, ["../../.."]), "dist", "cli", "search-refresh.js");
-}
-function dispatchRefreshChild(pmRoot) {
-  try {
-    const child = spawn(process.execPath, [searchRefreshRunnerPath()], {
-      detached: true,
-      stdio: "ignore",
-      env: {
-        ...process.env,
-        PM_PATH: pmRoot,
-        [SEARCH_REFRESH_CHILD_ENV]: "1"
-      }
-    });
-    child.on("error", () => {
-    });
-    child.unref();
-  } catch {
-  }
-}
-async function scheduleBackgroundSemanticRefresh(pmRoot, itemIds) {
-  await enqueuePendingRefreshIds(pmRoot, itemIds);
-  dispatchRefreshChild(pmRoot);
-}
-
-// dist/core/search/cache.js
-var SEARCH_CACHE_ARTIFACT_PATHS = ["index/manifest.json", "search/embeddings.jsonl"];
-var VECTORIZATION_STATUS_LEDGER_PATH = "search/vectorization-status.json";
-function formatInvalidationWarning(relativePath, error) {
-  return `search_cache_invalidation_failed:${relativePath}:${String(error)}`;
-}
-function toUniqueSorted(values) {
-  return [...new Set([...values].map((value) => value.trim()).filter((value) => value.length > 0))].sort((left, right) => left.localeCompare(right));
-}
-function isValidUpdatedAt(value) {
-  return typeof value === "string" && value.trim().length > 0 && Number.isFinite(Date.parse(value));
-}
-function normalizeVectorizationLedgerEntries(entries) {
-  const normalized = /* @__PURE__ */ new Map();
-  for (const [rawId, rawUpdatedAt] of Object.entries(entries)) {
-    const id = rawId.trim();
-    if (id.length === 0 || !isValidUpdatedAt(rawUpdatedAt)) {
-      continue;
-    }
-    normalized.set(id, rawUpdatedAt);
-  }
-  return Object.fromEntries([...normalized.entries()].sort((left, right) => left[0].localeCompare(right[0])));
+  return Object.fromEntries([...normalized.entries()].sort((left, right) => left[0].localeCompare(right[0])));
 }
 async function readVectorizationStatusLedger(pmRoot) {
   const ledgerPath = path2.join(pmRoot, VECTORIZATION_STATUS_LEDGER_PATH);
@@ -1757,7 +1799,7 @@ async function resolveSemanticRefreshRuntimeContext(pmRoot, normalizedItemIds, o
   if (!provider) {
     return buildSkippedSemanticRefreshResult(normalizedItemIds, "search_semantic_refresh_skipped:provider_unconfigured");
   }
-  const vectorStore = resolveVectorStores(effectiveSettings).active;
+  const vectorStore = resolveVectorStores(effectiveSettings, pmRoot).active;
   if (!vectorStore) {
     return buildSkippedSemanticRefreshResult(normalizedItemIds, "search_semantic_refresh_skipped:vector_store_unconfigured");
   }
@@ -2011,6 +2053,763 @@ async function refreshSearchArtifactsForMutation(pmRoot, itemIds, options = {})
   };
 }
 
+// dist/cli/registration-helpers.js
+var RESOLVED_GLOBAL_OPTIONS = /* @__PURE__ */ Symbol("pm.resolvedGlobalOptions");
+function commandOptionsReader(command) {
+  return typeof command === "object" && command !== null ? command : {};
+}
+function resolveCommanderContract(contracts, target) {
+  const contract = contracts.find((entry) => entry.target === target);
+  return contract ?? { target, keys: [target] };
+}
+function setResolvedGlobalOptions(command, globalOptions) {
+  command[RESOLVED_GLOBAL_OPTIONS] = { ...globalOptions };
+}
+function clearResolvedGlobalOptions(command) {
+  delete command[RESOLVED_GLOBAL_OPTIONS];
+}
+function getGlobalOptions(command) {
+  const resolved = command[RESOLVED_GLOBAL_OPTIONS];
+  if (resolved) {
+    return { ...resolved };
+  }
+  const reader = commandOptionsReader(command);
+  const opts = typeof reader.optsWithGlobals === "function" ? reader.optsWithGlobals() : typeof reader.opts === "function" ? reader.opts() : {};
+  return {
+    json: opts.json === true ? true : void 0,
+    quiet: Boolean(opts.quiet),
+    noChangedFields: opts.changedFields === false,
+    idOnly: opts.idOnly === true,
+    path: typeof opts.pmPath === "string" ? opts.pmPath : typeof opts.path === "string" ? opts.path : void 0,
+    noExtensions: opts.extensions === false,
+    noPager: Boolean(opts.noPager),
+    profile: Boolean(opts.profile)
+  };
+}
+function getCommandPath(command) {
+  const parts = [];
+  let current = command;
+  while (current?.parent) {
+    parts.unshift(current.name());
+    current = current.parent;
+  }
+  return parts.join(" ");
+}
+async function applyDefaultOutputFormat(globalOptions) {
+  if (globalOptions.json === true) {
+    return globalOptions;
+  }
+  const pmRoot = resolvePmRoot(process.cwd(), globalOptions.path);
+  if (!await pathExists(getSettingsPath(pmRoot))) {
+    return globalOptions;
+  }
+  const settings = await readSettings(pmRoot);
+  return {
+    ...globalOptions,
+    defaultOutputFormat: settings.output.default_format
+  };
+}
+function collect(value, previous) {
+  const next = previous ?? [];
+  next.push(value);
+  return next;
+}
+function pushOptionalValueFlag(args, flag, value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return;
+  }
+  args.push(flag, trimmed);
+}
+function pushOptionalBooleanFlag(args, flag, value) {
+  if (value === true) {
+    args.push(flag);
+  }
+}
+function pushRepeatableValueFlag(args, flag, values) {
+  if (!Array.isArray(values)) {
+    return;
+  }
+  for (const value of values) {
+    if (typeof value !== "string") {
+      continue;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+      continue;
+    }
+    args.push(flag, trimmed);
+  }
+}
+function optionTrue(options, key) {
+  return options[key] === true ? true : void 0;
+}
+function optionFalse(options, key) {
+  return options[key] === false ? true : void 0;
+}
+function readOptionString(options, key) {
+  return typeof options[key] === "string" ? options[key] : void 0;
+}
+function addHiddenOption(command, flags, description) {
+  command.addOption(new Option(flags, description).hideHelp());
+}
+function anyOptionTrue(options, keys) {
+  return keys.some((key) => options[key] === true) ? true : void 0;
+}
+function copyUnknownOptions(target, source) {
+  for (const [key, value] of Object.entries(source)) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+      continue;
+    }
+    if (Object.hasOwn(target, key)) {
+      continue;
+    }
+    target[key] = value;
+  }
+}
+function buildBackgroundTestCommandArgs(id, options) {
+  const args = ["test", id, "--run", "--json", "--progress"];
+  pushRepeatableValueFlag(args, "--add", options.add);
+  pushRepeatableValueFlag(args, "--add-json", options.addJson);
+  pushRepeatableValueFlag(args, "--remove", options.remove);
+  pushOptionalValueFlag(args, "--match", options.match);
+  pushOptionalValueFlag(args, "--only-index", options.onlyIndex);
+  pushOptionalBooleanFlag(args, "--only-last", options.onlyLast);
+  pushOptionalValueFlag(args, "--timeout", options.timeout);
+  pushRepeatableValueFlag(args, "--env-set", options.envSet);
+  pushRepeatableValueFlag(args, "--env-clear", options.envClear);
+  pushOptionalBooleanFlag(args, "--shared-host-safe", options.sharedHostSafe);
+  pushOptionalValueFlag(args, "--pm-context", options.pmContext);
+  pushOptionalBooleanFlag(args, "--override-linked-pm-context", options.overrideLinkedPmContext);
+  pushOptionalBooleanFlag(args, "--fail-on-context-mismatch", options.failOnContextMismatch);
+  pushOptionalBooleanFlag(args, "--fail-on-skipped", options.failOnSkipped);
+  pushOptionalBooleanFlag(args, "--fail-on-empty-test-run", options.failOnEmptyTestRun);
+  pushOptionalBooleanFlag(args, "--require-assertions-for-pm", options.requireAssertionsForPm);
+  pushOptionalBooleanFlag(args, "--check-context", options.checkContext);
+  pushOptionalBooleanFlag(args, "--auto-pm-context", options.autoPmContext);
+  pushOptionalValueFlag(args, "--author", options.author);
+  pushOptionalValueFlag(args, "--message", options.message);
+  pushOptionalBooleanFlag(args, "--force", options.force);
+  return args;
+}
+function buildBackgroundTestAllCommandArgs(options) {
+  const args = ["test-all", "--json", "--progress"];
+  pushOptionalValueFlag(args, "--status", options.status);
+  pushOptionalValueFlag(args, "--limit", options.limit);
+  pushOptionalValueFlag(args, "--offset", options.offset);
+  pushOptionalValueFlag(args, "--timeout", options.timeout);
+  pushRepeatableValueFlag(args, "--env-set", options.envSet);
+  pushRepeatableValueFlag(args, "--env-clear", options.envClear);
+  pushOptionalBooleanFlag(args, "--shared-host-safe", options.sharedHostSafe);
+  pushOptionalValueFlag(args, "--pm-context", options.pmContext);
+  pushOptionalBooleanFlag(args, "--override-linked-pm-context", options.overrideLinkedPmContext);
+  pushOptionalBooleanFlag(args, "--fail-on-context-mismatch", options.failOnContextMismatch);
+  pushOptionalBooleanFlag(args, "--fail-on-skipped", options.failOnSkipped);
+  pushOptionalBooleanFlag(args, "--fail-on-empty-test-run", options.failOnEmptyTestRun);
+  pushOptionalBooleanFlag(args, "--require-assertions-for-pm", options.requireAssertionsForPm);
+  pushOptionalBooleanFlag(args, "--check-context", options.checkContext);
+  pushOptionalBooleanFlag(args, "--auto-pm-context", options.autoPmContext);
+  return args;
+}
+function formatHookWarnings(warnings) {
+  return warnings.join(",");
+}
+function normalizeCreateOptions(commandOptions, options = {}) {
+  const readCreateString = (target) => readFirstStringFromCommanderOptions(commandOptions, resolveCommanderContract(CREATE_COMMANDER_STRING_OPTION_CONTRACTS, target));
+  const readCreateList = (target) => readStringArrayFromCommanderOptions(commandOptions, resolveCommanderContract(CREATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS, target));
+  const type = readCreateString("type");
+  if (options.requireType !== false && type === void 0) {
+    throw new PmCliError("Missing required option --type <value>. Why required: create resolves runtime schema fields/workflow from item type. Retry: add --type <built-in or configured custom type> (example: --type Task).", EXIT_CODE.USAGE);
+  }
+  const normalized = {
+    title: readCreateString("title"),
+    description: readCreateString("description"),
+    type,
+    template: readCreateString("template"),
+    createMode: readCreateString("createMode"),
+    schedulePreset: readCreateString("schedulePreset"),
+    status: readCreateString("status"),
+    priority: readCreateString("priority"),
+    tags: readCreateString("tags"),
+    addTags: readCreateList("addTags"),
+    body: readCreateString("body"),
+    deadline: readCreateString("deadline"),
+    estimatedMinutes: readCreateString("estimatedMinutes"),
+    acceptanceCriteria: readCreateString("acceptanceCriteria"),
+    definitionOfReady: readCreateString("definitionOfReady"),
+    order: readCreateString("order"),
+    rank: readCreateString("rank"),
+    goal: readCreateString("goal"),
+    objective: readCreateString("objective"),
+    value: readCreateString("value"),
+    impact: readCreateString("impact"),
+    outcome: readCreateString("outcome"),
+    whyNow: readCreateString("whyNow"),
+    author: readCreateString("author"),
+    message: readCreateString("message"),
+    assignee: readCreateString("assignee"),
+    parent: readCreateString("parent"),
+    allowMissingParent: optionTrue(commandOptions, "allowMissingParent") === true,
+    reviewer: readCreateString("reviewer"),
+    risk: readCreateString("risk"),
+    confidence: readCreateString("confidence"),
+    sprint: readCreateString("sprint"),
+    release: readCreateString("release"),
+    blockedBy: readCreateString("blockedBy"),
+    blockedReason: readCreateString("blockedReason"),
+    unblockNote: readCreateString("unblockNote"),
+    reporter: readCreateString("reporter"),
+    severity: readCreateString("severity"),
+    environment: readCreateString("environment"),
+    reproSteps: readCreateString("reproSteps"),
+    resolution: readCreateString("resolution"),
+    expectedResult: readCreateString("expectedResult"),
+    actualResult: readCreateString("actualResult"),
+    affectedVersion: readCreateString("affectedVersion"),
+    fixedVersion: readCreateString("fixedVersion"),
+    component: readCreateString("component"),
+    regression: readCreateString("regression"),
+    customerImpact: readCreateString("customerImpact"),
+    dep: readCreateList("dep"),
+    comment: readCreateList("comment"),
+    note: readCreateList("note"),
+    learning: readCreateList("learning"),
+    file: readCreateList("file"),
+    test: readCreateList("test"),
+    doc: readCreateList("doc"),
+    reminder: readCreateList("reminder"),
+    event: readCreateList("event"),
+    typeOption: readCreateList("typeOption"),
+    field: readCreateList("field"),
+    unset: readCreateList("unset"),
+    clearDeps: optionTrue(commandOptions, "clearDeps"),
+    clearComments: optionTrue(commandOptions, "clearComments"),
+    clearNotes: optionTrue(commandOptions, "clearNotes"),
+    clearLearnings: optionTrue(commandOptions, "clearLearnings"),
+    clearFiles: optionTrue(commandOptions, "clearFiles"),
+    clearTests: optionTrue(commandOptions, "clearTests"),
+    clearDocs: optionTrue(commandOptions, "clearDocs"),
+    clearReminders: optionTrue(commandOptions, "clearReminders"),
+    clearEvents: optionTrue(commandOptions, "clearEvents"),
+    clearTypeOptions: optionTrue(commandOptions, "clearTypeOptions")
+  };
+  copyUnknownOptions(normalized, commandOptions);
+  return normalized;
+}
+function normalizeUpdateOptions(commandOptions) {
+  const readUpdateString = (target) => readFirstStringFromCommanderOptions(commandOptions, resolveCommanderContract(UPDATE_COMMANDER_STRING_OPTION_CONTRACTS, target));
+  const readUpdateList = (target) => readStringArrayFromCommanderOptions(commandOptions, resolveCommanderContract(UPDATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS, target));
+  const normalized = {
+    title: readUpdateString("title"),
+    description: readUpdateString("description"),
+    body: readUpdateString("body"),
+    status: readUpdateString("status"),
+    closeReason: readUpdateString("closeReason"),
+    priority: readUpdateString("priority"),
+    type: readUpdateString("type"),
+    tags: readUpdateString("tags"),
+    addTags: readUpdateList("addTags"),
+    removeTags: readUpdateList("removeTags"),
+    deadline: readUpdateString("deadline"),
+    estimatedMinutes: readUpdateString("estimatedMinutes"),
+    acceptanceCriteria: readUpdateString("acceptanceCriteria"),
+    definitionOfReady: readUpdateString("definitionOfReady"),
+    order: readUpdateString("order"),
+    rank: readUpdateString("rank"),
+    goal: readUpdateString("goal"),
+    objective: readUpdateString("objective"),
+    value: readUpdateString("value"),
+    impact: readUpdateString("impact"),
+    outcome: readUpdateString("outcome"),
+    whyNow: readUpdateString("whyNow"),
+    author: readUpdateString("author"),
+    message: readUpdateString("message"),
+    force: Boolean(commandOptions.force),
+    allowAuditUpdate: anyOptionTrue(commandOptions, ["allowAuditUpdate", "allow_audit_update"]),
+    allowAuditDepUpdate: anyOptionTrue(commandOptions, ["allowAuditDepUpdate", "allow_audit_dep_update"]),
+    assignee: readUpdateString("assignee"),
+    parent: readUpdateString("parent"),
+    reviewer: readUpdateString("reviewer"),
+    risk: readUpdateString("risk"),
+    confidence: readUpdateString("confidence"),
+    sprint: readUpdateString("sprint"),
+    release: readUpdateString("release"),
+    blockedBy: readUpdateString("blockedBy"),
+    blockedReason: readUpdateString("blockedReason"),
+    unblockNote: readUpdateString("unblockNote"),
+    reporter: readUpdateString("reporter"),
+    severity: readUpdateString("severity"),
+    environment: readUpdateString("environment"),
+    reproSteps: readUpdateString("reproSteps"),
+    resolution: readUpdateString("resolution"),
+    expectedResult: readUpdateString("expectedResult"),
+    actualResult: readUpdateString("actualResult"),
+    affectedVersion: readUpdateString("affectedVersion"),
+    fixedVersion: readUpdateString("fixedVersion"),
+    component: readUpdateString("component"),
+    regression: readUpdateString("regression"),
+    customerImpact: readUpdateString("customerImpact"),
+    dep: readUpdateList("dep"),
+    depRemove: readUpdateList("depRemove"),
+    replaceDeps: optionTrue(commandOptions, "replaceDeps"),
+    replaceTests: optionTrue(commandOptions, "replaceTests"),
+    comment: readUpdateList("comment"),
+    note: readUpdateList("note"),
+    learning: readUpdateList("learning"),
+    file: readUpdateList("file"),
+    test: readUpdateList("test"),
+    doc: readUpdateList("doc"),
+    reminder: readUpdateList("reminder"),
+    event: readUpdateList("event"),
+    typeOption: readUpdateList("typeOption"),
+    field: readUpdateList("field"),
+    unset: readUpdateList("unset"),
+    clearDeps: optionTrue(commandOptions, "clearDeps"),
+    clearComments: optionTrue(commandOptions, "clearComments"),
+    clearNotes: optionTrue(commandOptions, "clearNotes"),
+    clearLearnings: optionTrue(commandOptions, "clearLearnings"),
+    clearFiles: optionTrue(commandOptions, "clearFiles"),
+    clearTests: optionTrue(commandOptions, "clearTests"),
+    clearDocs: optionTrue(commandOptions, "clearDocs"),
+    clearReminders: optionTrue(commandOptions, "clearReminders"),
+    clearEvents: optionTrue(commandOptions, "clearEvents"),
+    clearTypeOptions: optionTrue(commandOptions, "clearTypeOptions")
+  };
+  copyUnknownOptions(normalized, commandOptions);
+  return normalized;
+}
+var UPDATE_MANY_CONTROL_OPTION_KEYS = /* @__PURE__ */ new Set([
+  "filterStatus",
+  "filterType",
+  "filterTag",
+  "filterPriority",
+  "filterDeadlineBefore",
+  "filterDeadlineAfter",
+  "filterUpdatedAfter",
+  "filterUpdatedBefore",
+  "filterCreatedAfter",
+  "filterCreatedBefore",
+  "filterAssignee",
+  "filterAssigneeFilter",
+  "filterAssignee_filter",
+  "filterParent",
+  "filterSprint",
+  "filterRelease",
+  "filterAcMissing",
+  "filterEstimatesMissing",
+  "filterEstimateMissing",
+  "filterResolutionMissing",
+  "filterMetadataMissing",
+  "filterReviewerMissing",
+  "filterRiskMissing",
+  "filterConfidenceMissing",
+  "filterSprintMissing",
+  "filterReleaseMissing",
+  "filterHasNotes",
+  "filterNoNotes",
+  "filterHasLearnings",
+  "filterNoLearnings",
+  "filterHasFiles",
+  "filterNoFiles",
+  "filterHasDocs",
+  "filterNoDocs",
+  "filterHasTests",
+  "filterNoTests",
+  "filterHasComments",
+  "filterNoComments",
+  "filterHasDeps",
+  "filterNoDeps",
+  "filterHasBody",
+  "filterEmptyBody",
+  "filterHasLinkedCommand",
+  "filterNoLinkedCommand",
+  "ids",
+  "limit",
+  "offset",
+  "dryRun",
+  "rollback",
+  "checkpoint"
+]);
+function extractUpdateManyMutationOptionSource(commandOptions) {
+  const mutationOptions = {};
+  for (const [key, value] of Object.entries(commandOptions)) {
+    if (UPDATE_MANY_CONTROL_OPTION_KEYS.has(key)) {
+      continue;
+    }
+    mutationOptions[key] = value;
+  }
+  return mutationOptions;
+}
+function readListOptionString(options, target) {
+  const contract = resolveCommanderContract(LIST_COMMANDER_STRING_OPTION_CONTRACTS, target);
+  const stringValue = readFirstStringFromCommanderOptions(options, contract);
+  if (stringValue !== void 0) {
+    return stringValue;
+  }
+  for (const key of contract.keys) {
+    const value = options[key];
+    if (target === "ids" && typeof value === "string") {
+      return value;
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return String(value);
+    }
+  }
+  return void 0;
+}
+function readSelectionFilterOptionFields(options) {
+  const filterFilesMissing = optionTrue(options, "filterFilesMissing");
+  const filterDocsMissing = optionTrue(options, "filterDocsMissing");
+  return {
+    filterReviewerMissing: optionTrue(options, "filterReviewerMissing"),
+    filterRiskMissing: optionTrue(options, "filterRiskMissing"),
+    filterConfidenceMissing: optionTrue(options, "filterConfidenceMissing"),
+    filterSprintMissing: optionTrue(options, "filterSprintMissing"),
+    filterReleaseMissing: optionTrue(options, "filterReleaseMissing"),
+    hasNotes: optionTrue(options, "hasNotes"),
+    hasLearnings: optionTrue(options, "hasLearnings"),
+    hasFiles: optionTrue(options, "hasFiles"),
+    hasDocs: optionTrue(options, "hasDocs"),
+    hasTests: optionTrue(options, "hasTests"),
+    hasComments: optionTrue(options, "hasComments"),
+    hasDeps: optionTrue(options, "hasDeps"),
+    hasBody: optionTrue(options, "hasBody"),
+    hasLinkedCommand: optionTrue(options, "hasLinkedCommand"),
+    noNotes: optionFalse(options, "notes"),
+    noLearnings: optionFalse(options, "learnings"),
+    noFiles: optionFalse(options, "files") ?? filterFilesMissing,
+    filterFilesMissing,
+    noDocs: optionFalse(options, "docs") ?? filterDocsMissing,
+    filterDocsMissing,
+    noTests: optionFalse(options, "tests"),
+    noComments: optionFalse(options, "comments"),
+    noDeps: optionFalse(options, "deps"),
+    emptyBody: optionTrue(options, "emptyBody"),
+    noLinkedCommand: optionFalse(options, "linkedCommand")
+  };
+}
+function normalizeListOptions(options) {
+  const normalized = {
+    status: readListOptionString(options, "status"),
+    type: readListOptionString(options, "type"),
+    tag: readListOptionString(options, "tag"),
+    priority: readListOptionString(options, "priority"),
+    deadlineBefore: readListOptionString(options, "deadlineBefore"),
+    deadlineAfter: readListOptionString(options, "deadlineAfter"),
+    updatedAfter: readListOptionString(options, "updatedAfter"),
+    updatedBefore: readListOptionString(options, "updatedBefore"),
+    createdAfter: readListOptionString(options, "createdAfter"),
+    createdBefore: readListOptionString(options, "createdBefore"),
+    ids: readListOptionString(options, "ids"),
+    assignee: readListOptionString(options, "assignee"),
+    assigneeFilter: readListOptionString(options, "assigneeFilter"),
+    parent: readListOptionString(options, "parent"),
+    sprint: readListOptionString(options, "sprint"),
+    release: readListOptionString(options, "release"),
+    limit: readListOptionString(options, "limit"),
+    offset: readListOptionString(options, "offset"),
+    // Commander stores --no-truncate as truncate=false; --all is the positive alias.
+    noTruncate: optionFalse(options, "truncate") ?? optionTrue(options, "all"),
+    includeBody: optionTrue(options, "includeBody"),
+    compact: optionTrue(options, "compact"),
+    brief: optionTrue(options, "brief"),
+    full: optionTrue(options, "full"),
+    fields: readListOptionString(options, "fields"),
+    sort: readListOptionString(options, "sort"),
+    order: readListOptionString(options, "order"),
+    tree: optionTrue(options, "tree"),
+    treeDepth: readListOptionString(options, "treeDepth"),
+    filterAcMissing: optionTrue(options, "filterAcMissing"),
+    filterEstimatesMissing: anyOptionTrue(options, ["filterEstimatesMissing", "filterEstimateMissing"]),
+    filterResolutionMissing: optionTrue(options, "filterResolutionMissing"),
+    filterMetadataMissing: optionTrue(options, "filterMetadataMissing"),
+    // Governance-missing (GH-236) + content presence/absence (GH-242) filters.
+    ...readSelectionFilterOptionFields(options)
+  };
+  copyUnknownOptions(normalized, options);
+  return normalized;
+}
+function normalizeAggregateOptions(options) {
+  return {
+    groupBy: typeof options.groupBy === "string" ? options.groupBy : void 0,
+    count: options.count === true ? true : void 0,
+    completion: options.completion === true ? true : void 0,
+    sum: typeof options.sum === "string" ? options.sum : void 0,
+    avg: typeof options.avg === "string" ? options.avg : void 0,
+    includeUnparented: options.includeUnparented === true || options.include_unparented === true,
+    status: typeof options.status === "string" ? options.status : void 0,
+    type: readListOptionString(options, "type"),
+    tag: readListOptionString(options, "tag"),
+    priority: readListOptionString(options, "priority"),
+    deadlineBefore: readListOptionString(options, "deadlineBefore"),
+    deadlineAfter: readListOptionString(options, "deadlineAfter"),
+    assignee: readListOptionString(options, "assignee"),
+    assigneeFilter: readListOptionString(options, "assigneeFilter"),
+    parent: readListOptionString(options, "parent"),
+    sprint: readListOptionString(options, "sprint"),
+    release: readListOptionString(options, "release")
+  };
+}
+function printListJsonStream(commandName, result, globalOptions) {
+  setActiveCommandResult(result);
+  if (globalOptions.quiet) {
+    return;
+  }
+  const warnings = Array.isArray(result.warnings) ? result.warnings : [];
+  const metaPayload = {
+    type: "meta",
+    command: commandName,
+    count: result.count,
+    now: result.now,
+    filters: result.filters
+  };
+  if (warnings.length > 0) {
+    metaPayload.warnings = warnings;
+  }
+  if (!writeStdout(`${JSON.stringify(metaPayload)}
+`)) {
+    return;
+  }
+  for (const item of result.items) {
+    if (!writeStdout(`${JSON.stringify({ type: "item", command: commandName, item })}
+`)) {
+      return;
+    }
+  }
+  writeStdout(`${JSON.stringify({ type: "end", command: commandName, count: result.count })}
+`);
+}
+function printActivityJsonStream(result, options, globalOptions) {
+  setActiveCommandResult(result);
+  if (globalOptions.quiet) {
+    return;
+  }
+  const metaPayload = {
+    type: "meta",
+    command: "activity",
+    count: result.count,
+    filters: {
+      id: options.id ?? null,
+      op: options.op ?? null,
+      author: options.author ?? null,
+      from: options.from ?? null,
+      to: options.to ?? null,
+      limit: options.limit ?? null
+    }
+  };
+  if (!writeStdout(`${JSON.stringify(metaPayload)}
+`)) {
+    return;
+  }
+  const entries = result.compact && result.compact_activity ? result.compact_activity : result.activity;
+  for (const entry of entries) {
+    if (!writeStdout(`${JSON.stringify({ type: "entry", command: "activity", entry })}
+`)) {
+      return;
+    }
+  }
+  writeStdout(`${JSON.stringify({ type: "end", command: "activity", count: result.count })}
+`);
+}
+function normalizeSearchOptions(options) {
+  const readSearchString = (target) => readFirstStringFromCommanderOptions(options, resolveCommanderContract(SEARCH_COMMANDER_STRING_OPTION_CONTRACTS, target));
+  const readSearchStringOrNumber = (target) => {
+    const candidate = readFirstValueFromCommanderOptions(options, resolveCommanderContract(SEARCH_COMMANDER_STRING_OPTION_CONTRACTS, target));
+    if (typeof candidate === "string") {
+      return candidate;
+    }
+    if (typeof candidate === "number" && Number.isFinite(candidate)) {
+      return candidate;
+    }
+    return void 0;
+  };
+  const fields = readSearchString("fields");
+  const compactRequested = options.compact === true;
+  const fullRequested = options.full === true;
+  const defaultCompact = !compactRequested && !fullRequested && fields === void 0;
+  const mode = options.semantic === true ? "semantic" : options.hybrid === true ? "hybrid" : readSearchString("mode");
+  const normalized = {
+    mode,
+    matchMode: readSearchString("matchMode"),
+    minScore: readSearchStringOrNumber("minScore"),
+    count: optionTrue(options, "count"),
+    semanticWeight: readSearchStringOrNumber("semanticWeight"),
+    includeLinked: optionTrue(options, "includeLinked"),
+    titleExact: optionTrue(options, "titleExact"),
+    phraseExact: optionTrue(options, "phraseExact"),
+    highlight: optionTrue(options, "highlight"),
+    status: readSearchString("status"),
+    type: readSearchString("type"),
+    tag: readSearchString("tag"),
+    priority: readSearchString("priority"),
+    deadlineBefore: readSearchString("deadlineBefore"),
+    deadlineAfter: readSearchString("deadlineAfter"),
+    updatedAfter: readSearchString("updatedAfter"),
+    updatedBefore: readSearchString("updatedBefore"),
+    createdAfter: readSearchString("createdAfter"),
+    createdBefore: readSearchString("createdBefore"),
+    assignee: readSearchString("assignee"),
+    sprint: readSearchString("sprint"),
+    release: readSearchString("release"),
+    parent: readSearchString("parent"),
+    limit: readSearchString("limit"),
+    fields,
+    compact: compactRequested || defaultCompact ? true : void 0,
+    full: optionTrue(options, "full"),
+    // Governance-missing (GH-236) + content presence/absence (GH-242) filters,
+    // mirroring normalizeListOptions via the shared field slice.
+    ...readSelectionFilterOptionFields(options)
+  };
+  copyUnknownOptions(normalized, options);
+  return normalized;
+}
+function normalizeSearchKeywordsInput(keywords) {
+  const query = keywords.map((entry) => entry.trim()).filter((entry) => entry.length > 0).join(" ");
+  if (query.length === 0) {
+    throw new PmCliError("Search query must not be empty", EXIT_CODE.USAGE);
+  }
+  return query;
+}
+function normalizeActivityOptions(options) {
+  const readActivityString = (target) => readFirstStringFromCommanderOptions(options, resolveCommanderContract(ACTIVITY_COMMANDER_STRING_OPTION_CONTRACTS, target));
+  return {
+    id: readActivityString("id"),
+    op: readActivityString("op"),
+    author: readActivityString("author"),
+    from: readActivityString("from"),
+    to: readActivityString("to"),
+    limit: readActivityString("limit"),
+    compact: options.full === true ? false : options.compact === false ? false : true
+  };
+}
+var ACTIVITY_STREAM_ENABLED_VALUES = /* @__PURE__ */ new Set(["", "rows", "ndjson", "jsonl", "true", "1", "yes", "on"]);
+var ACTIVITY_STREAM_DISABLED_VALUES = /* @__PURE__ */ new Set(["false", "off", "none", "0"]);
+function resolveActivityStreamMode(raw) {
+  if (raw === true) {
+    return true;
+  }
+  if (raw === false || raw === void 0 || raw === null) {
+    return false;
+  }
+  if (typeof raw === "string") {
+    const normalized = raw.trim().toLowerCase();
+    if (ACTIVITY_STREAM_ENABLED_VALUES.has(normalized)) {
+      return true;
+    }
+    if (ACTIVITY_STREAM_DISABLED_VALUES.has(normalized)) {
+      return false;
+    }
+  }
+  throw new PmCliError("Activity --stream accepts rows|ndjson|jsonl (or no value)", EXIT_CODE.USAGE);
+}
+function normalizeContextOptions(options) {
+  const readContextString = (target) => readFirstStringFromCommanderOptions(options, resolveCommanderContract(CONTEXT_COMMANDER_STRING_OPTION_CONTRACTS, target));
+  const sectionRaw = options.section;
+  const section = Array.isArray(sectionRaw) ? sectionRaw.filter((v) => typeof v === "string" && v.trim().length > 0) : typeof sectionRaw === "string" && sectionRaw.trim().length > 0 ? [sectionRaw] : void 0;
+  const normalized = {
+    date: readContextString("date"),
+    from: readContextString("from"),
+    to: readContextString("to"),
+    past: options.past === true ? true : void 0,
+    type: readContextString("type"),
+    tag: readContextString("tag"),
+    priority: readContextString("priority"),
+    assignee: readContextString("assignee"),
+    assigneeFilter: readContextString("assigneeFilter"),
+    sprint: readContextString("sprint"),
+    release: readContextString("release"),
+    parent: readContextString("parent"),
+    limit: readContextString("limit"),
+    format: readContextString("format"),
+    depth: readContextString("depth"),
+    fields: readContextString("fields"),
+    section: section && section.length > 0 ? section : void 0,
+    activityLimit: readContextString("activityLimit"),
+    staleThreshold: readContextString("staleThreshold")
+  };
+  for (const [key, value] of Object.entries(options)) {
+    if (Object.hasOwn(normalized, key)) {
+      continue;
+    }
+    normalized[key] = value;
+  }
+  return normalized;
+}
+function normalizeNextOptions(options) {
+  const readNextString = (target) => readFirstStringFromCommanderOptions(options, resolveCommanderContract(NEXT_COMMANDER_STRING_OPTION_CONTRACTS, target));
+  const normalized = {
+    type: readNextString("type"),
+    tag: readNextString("tag"),
+    priority: readNextString("priority"),
+    assignee: readNextString("assignee"),
+    assigneeFilter: readNextString("assigneeFilter"),
+    sprint: readNextString("sprint"),
+    release: readNextString("release"),
+    parent: readNextString("parent"),
+    limit: readNextString("limit"),
+    blockedLimit: readNextString("blockedLimit"),
+    readyOnly: options.readyOnly === true || options.ready_only === true ? true : void 0,
+    format: readNextString("format")
+  };
+  for (const [key, value] of Object.entries(options)) {
+    if (Object.hasOwn(normalized, key)) {
+      continue;
+    }
+    normalized[key] = value;
+  }
+  return normalized;
+}
+function collectMutationItemIds(result) {
+  if (!result || typeof result !== "object") {
+    return [];
+  }
+  const record = result;
+  const ids = /* @__PURE__ */ new Set();
+  const pushId = (value) => {
+    if (typeof value !== "string") {
+      return;
+    }
+    const normalized = value.trim();
+    if (normalized.length === 0) {
+      return;
+    }
+    ids.add(normalized);
+  };
+  pushId(record.id);
+  const item = record.item;
+  if (item && typeof item === "object") {
+    pushId(item.id);
+  }
+  const explicitIds = record.ids;
+  if (Array.isArray(explicitIds)) {
+    for (const candidate of explicitIds) {
+      pushId(candidate);
+    }
+  }
+  const items = record.items;
+  if (Array.isArray(items)) {
+    for (const candidate of items) {
+      if (!candidate || typeof candidate !== "object") {
+        continue;
+      }
+      pushId(candidate.id);
+    }
+  }
+  return [...ids].sort((left, right) => left.localeCompare(right));
+}
+async function invalidateSearchCachesForMutation(globalOptions, result) {
+  const pmRoot = resolvePmRoot(process.cwd(), globalOptions.path);
+  const refreshResult = await refreshSearchArtifactsForMutation(pmRoot, collectMutationItemIds(result), {
+    background: !shouldRunSearchRefreshInForeground()
+  });
+  if (globalOptions.profile && refreshResult.warnings.length > 0) {
+    printError(`profile:search_refresh_warnings=${formatHookWarnings(refreshResult.warnings)}`);
+  }
+}
+
 export {
   resolveProviderConfigSource,
   resolveEmbeddingProviders,
@@ -2025,7 +2824,6 @@ export {
   executeEmbeddingBatchesWithRetry,
   resolveSettingsWithSemanticRuntimeDefaults,
   REINDEX_LOCK_ID,
-  shouldRunSearchRefreshInForeground,
   resolveVectorStores,
   executeVectorQuery,
   executeVectorUpsert,
@@ -2039,8 +2837,32 @@ export {
   readVectorizationStatusLedger,
   writeVectorizationStatusLedger,
   refreshSemanticEmbeddingsForMutatedItems,
-  refreshSearchArtifactsForMutation
+  setResolvedGlobalOptions,
+  clearResolvedGlobalOptions,
+  getGlobalOptions,
+  getCommandPath,
+  applyDefaultOutputFormat,
+  collect,
+  readOptionString,
+  addHiddenOption,
+  buildBackgroundTestCommandArgs,
+  buildBackgroundTestAllCommandArgs,
+  formatHookWarnings,
+  normalizeCreateOptions,
+  normalizeUpdateOptions,
+  extractUpdateManyMutationOptionSource,
+  normalizeListOptions,
+  normalizeAggregateOptions,
+  printListJsonStream,
+  printActivityJsonStream,
+  normalizeSearchOptions,
+  normalizeSearchKeywordsInput,
+  normalizeActivityOptions,
+  resolveActivityStreamMode,
+  normalizeContextOptions,
+  normalizeNextOptions,
+  invalidateSearchCachesForMutation
 };
-//# sourceMappingURL=chunk-EOKXK3R3.js.map
+//# sourceMappingURL=chunk-XZWL7VNE.js.map
 
-//# debugId=c63a3843-4fe5-59f1-a28c-51139dae3ccd
+//# debugId=143ba130-1e4a-555a-ad5a-281c82c7f363