@unbrained/pm-cli 2026.5.30 → 2026.6.5

package/dist/core/schema/status-defs-file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"status-defs-file.js","sources":["core/schema/status-defs-file.ts"],"sourceRoot":"/","sourcesContent":["import { RUNTIME_STATUS_ROLE_VALUES } from \"../../types/index.js\";\nimport type { RuntimeStatusDefinition, RuntimeStatusRole } from \"../../types/index.js\";\nimport { DEFAULT_RUNTIME_STATUS_DEFINITIONS } from \"./runtime-schema.js\";\n\nexport type { RuntimeStatusDefinition, RuntimeStatusRole } from \"../../types/index.js\";\n\n/**\n * Pure logic for the `pm schema add-status` / `pm schema remove-status`\n * commands. The CLI command file (schema.ts) owns IO/governance; everything\n * testable and side-effect-free lives here so it can be coverage-gated to 100%.\n *\n * Statuses persist at `.agents/pm/schema/statuses.json` under the shape\n * `{ statuses: RuntimeStatusDefinition[] }`. When the file is absent the runtime\n * merge layer (src/core/store/settings.ts) still supplies the built-in defaults\n * from DEFAULT_RUNTIME_STATUS_DEFINITIONS, so this module never duplicates them\n * into the persisted file.\n */\n\nconst RUNTIME_STATUS_ROLE_SET = new Set<string>(RUNTIME_STATUS_ROLE_VALUES);\n\n/**\n * The 5 lifecycle status ids that ship as built-in defaults and may never be\n * removed (their normalized ids match DEFAULT_RUNTIME_STATUS_DEFINITIONS:\n * open/in_progress/blocked/closed/canceled). `draft` is also a default but the\n * acceptance criteria enumerate the 5 terminal/active ids explicitly, so the\n * guard derives the full set from the canonical defaults to stay in sync.\n */\nexport const BUILTIN_STATUS_IDS: ReadonlySet<string> = new Set(\n  DEFAULT_RUNTIME_STATUS_DEFINITIONS.map((definition) => normalizeStatusToken(definition.id)).filter(\n    (id) => id.length > 0,\n  ),\n);\n\n/**\n * The shape persisted at `.agents/pm/schema/statuses.json`.\n */\nexport interface StatusDefsFile {\n  statuses: RuntimeStatusDefinition[];\n}\n\nexport interface RawAddStatusInput {\n  id: string | undefined;\n  roles?: string[];\n  aliases?: string[];\n  description?: string;\n  order?: number;\n}\n\nexport interface NormalizedAddStatusInput {\n  id: string;\n  /**\n   * Normalized roles, or `undefined` when the raw input did not supply a roles\n   * field at all. `undefined` means \"leave existing roles untouched\" on upsert;\n   * an explicit empty array means \"clear roles\". This distinction is what keeps\n   * `add-status review --description x` from wiping a previously-set role.\n   */\n  roles?: RuntimeStatusRole[];\n  /** Same omitted-vs-explicit-empty semantics as `roles`. */\n  aliases?: string[];\n  description?: string;\n  order?: number;\n}\n\nexport interface UpsertStatusDefResult {\n  file: StatusDefsFile;\n  /** The definition as stored after the upsert (existing fields preserved). */\n  definition: RuntimeStatusDefinition;\n  /** True when an existing definition with the same (normalized) id was replaced. */\n  replaced: boolean;\n}\n\nexport interface RemoveStatusDefResult {\n  file: StatusDefsFile;\n  /** True when a matching definition existed and was dropped from the file. */\n  removed: boolean;\n  /** The removed definition, when one matched the requested id. */\n  definition?: RuntimeStatusDefinition;\n}\n\n/**\n * Normalizes a status token using the same rules as runtime-schema.ts: lowercase\n * and collapse any run of whitespace/hyphens into a single underscore.\n */\nexport function normalizeStatusToken(value: unknown): string {\n  return typeof value === \"string\" ? value.trim().toLowerCase().replaceAll(/[\\s-]+/g, \"_\") : \"\";\n}\n\nfunction dedupeTokens(values: Iterable<string>): string[] {\n  const seen = new Set<string>();\n  for (const value of values) {\n    const token = normalizeStatusToken(value);\n    if (token.length > 0) {\n      seen.add(token);\n    }\n  }\n  return [...seen].sort((left, right) => left.localeCompare(right));\n}\n\n/**\n * Validates and normalizes raw add-status CLI input. Throws a plain Error with a\n * stable message when the id is missing/empty or a role is not one of\n * RUNTIME_STATUS_ROLE_VALUES; the CLI layer maps these to PmCliError exit codes.\n *\n * Omitted vs explicit-empty is preserved end-to-end: when `raw.roles`/`raw.aliases`\n * is `undefined` (flag not supplied) the normalized field is `undefined` so the\n * upsert leaves the existing value untouched; when supplied (even an empty array)\n * the field is normalized to an array so the upsert can apply an explicit clear.\n */\nexport function normalizeAddStatusInput(raw: RawAddStatusInput): NormalizedAddStatusInput {\n  const id = normalizeStatusToken(raw.id);\n  if (id.length === 0) {\n    throw new Error(\"Status id must not be empty.\");\n  }\n  // Built-in lifecycle statuses are reserved and cannot be overridden: an\n  // add-status override would change reserved metadata yet remove-status refuses\n  // to delete a built-in id, leaving no CLI path to undo it. Reject up front,\n  // symmetric with removeStatusDef.\n  if (BUILTIN_STATUS_IDS.has(id)) {\n    throw new Error(\n      `Cannot add-status the built-in status \"${id}\". Built-in statuses are reserved: ${[...BUILTIN_STATUS_IDS].join(\", \")}.`,\n    );\n  }\n  let roles: RuntimeStatusRole[] | undefined;\n  if (raw.roles !== undefined) {\n    roles = [];\n    const seenRoles = new Set<string>();\n    for (const rawRole of raw.roles) {\n      const role = typeof rawRole === \"string\" ? rawRole.trim().toLowerCase() : \"\";\n      if (role.length === 0) {\n        continue;\n      }\n      if (!RUNTIME_STATUS_ROLE_SET.has(role)) {\n        throw new Error(\n          `Invalid status role \"${rawRole}\". Allowed roles: ${RUNTIME_STATUS_ROLE_VALUES.join(\", \")}.`,\n        );\n      }\n      if (!seenRoles.has(role)) {\n        seenRoles.add(role);\n        roles.push(role as RuntimeStatusRole);\n      }\n    }\n  }\n  const aliases =\n    raw.aliases === undefined ? undefined : dedupeTokens(raw.aliases).filter((alias) => alias !== id);\n  const description = raw.description?.trim();\n  const order =\n    typeof raw.order === \"number\" && Number.isFinite(raw.order) ? Math.trunc(raw.order) : undefined;\n  return {\n    id,\n    roles,\n    aliases,\n    description: description && description.length > 0 ? description : undefined,\n    order,\n  };\n}\n\nfunction selectStatusesArray(parsed: unknown): unknown[] | undefined {\n  if (Array.isArray(parsed)) {\n    return parsed;\n  }\n  if (typeof parsed !== \"object\" || parsed === null) {\n    return undefined;\n  }\n  const record = parsed as Record<string, unknown>;\n  if (Array.isArray(record.statuses)) {\n    return record.statuses;\n  }\n  if (Array.isArray(record.definitions)) {\n    return record.definitions;\n  }\n  return undefined;\n}\n\nfunction extractStatusDefinitions(parsed: unknown): RuntimeStatusDefinition[] {\n  const candidate = selectStatusesArray(parsed);\n  if (!candidate) {\n    return [];\n  }\n  const definitions: RuntimeStatusDefinition[] = [];\n  for (const entry of candidate) {\n    if (typeof entry !== \"object\" || entry === null || Array.isArray(entry)) {\n      continue;\n    }\n    const record = entry as Record<string, unknown>;\n    if (typeof record.id !== \"string\" || record.id.trim().length === 0) {\n      continue;\n    }\n    definitions.push(record as unknown as RuntimeStatusDefinition);\n  }\n  return definitions;\n}\n\n/**\n * Coerces an arbitrary parsed value from statuses.json into a StatusDefsFile.\n * Accepts the canonical `{ statuses: [...] }` shape, a bare array of\n * definitions, or a `{ definitions: [...] }` form, and tolerates a\n * missing/invalid file by returning an empty statuses list.\n */\nexport function parseStatusDefsFile(raw: string | null | undefined): StatusDefsFile {\n  if (raw === null || raw === undefined || raw.trim().length === 0) {\n    return { statuses: [] };\n  }\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(raw) as unknown;\n  } catch {\n    throw new Error(\"schema/statuses.json contains invalid JSON.\");\n  }\n  return { statuses: extractStatusDefinitions(parsed) };\n}\n\n/**\n * Serializes the status definitions file with a trailing newline (matches the\n * rest of the schema scaffold files written by pm).\n */\nexport function serializeStatusDefsFile(file: StatusDefsFile): string {\n  return `${JSON.stringify({ statuses: file.statuses }, null, 2)}\\n`;\n}\n\n/**\n * Idempotent UPSERT of a status definition into the parsed file. Matching is by\n * normalized id. When a definition already exists, fields supplied in `input`\n * override the previous values (roles/aliases replace when a non-empty array is\n * given, clear when an explicit empty array is given, and are left UNTOUCHED\n * when the field is `undefined` — i.e. the add-status flag was omitted);\n * description/order override when provided. Fields not addressed by add-status\n * flags are preserved untouched, so `add-status <id> --description x` keeps any\n * previously-set roles/aliases.\n */\nexport function upsertStatusDef(\n  file: StatusDefsFile,\n  input: NormalizedAddStatusInput,\n  baseDefinition?: RuntimeStatusDefinition,\n): UpsertStatusDefResult {\n  const statuses = file.statuses.slice();\n  const existingIndex = statuses.findIndex(\n    (definition) => normalizeStatusToken(definition.id) === input.id,\n  );\n  // A file-backed definition is the primary seed; when the status is not yet in\n  // statuses.json fall back to `baseDefinition` (the resolved settings-backed\n  // definition) so omitting --role/--alias preserves metadata that lives in\n  // settings.schema.statuses rather than the file.\n  const existing = existingIndex >= 0 ? statuses[existingIndex] : baseDefinition;\n\n  const next: RuntimeStatusDefinition = {\n    ...(existing ?? {}),\n    id: input.id,\n  };\n  if (input.roles !== undefined) {\n    if (input.roles.length > 0) {\n      next.roles = [...input.roles];\n    } else if (next.roles !== undefined) {\n      delete next.roles;\n    }\n  }\n  if (input.aliases !== undefined) {\n    if (input.aliases.length > 0) {\n      next.aliases = [...input.aliases];\n    } else if (next.aliases !== undefined) {\n      delete next.aliases;\n    }\n  }\n  if (input.description !== undefined) {\n    next.description = input.description;\n  }\n  if (input.order !== undefined) {\n    next.order = input.order;\n  }\n\n  if (existingIndex >= 0) {\n    statuses[existingIndex] = next;\n  } else {\n    statuses.push(next);\n  }\n\n  return {\n    file: { statuses },\n    definition: next,\n    // \"replaced\" reflects whether the status already existed effectively (in the\n    // file OR in resolved settings), so the CLI reports \"Updated\" vs \"Registered\"\n    // correctly even when the prior definition lived only in settings.\n    replaced: existing !== undefined,\n  };\n}\n\n/**\n * Removes a status definition from the parsed file by id (normalized). Throws a\n * plain Error when `id` is empty or matches a reserved built-in default status\n * (those are never stored in the file and must never be deletable). Returns\n * `removed: false` when no matching definition exists so the CLI layer can treat\n * the call as an idempotent no-op.\n */\nexport function removeStatusDef(file: StatusDefsFile, id: string | undefined): RemoveStatusDefResult {\n  const normalizedId = normalizeStatusToken(id);\n  if (normalizedId.length === 0) {\n    throw new Error(\"Status id must not be empty.\");\n  }\n  if (BUILTIN_STATUS_IDS.has(normalizedId)) {\n    throw new Error(\n      `Cannot remove built-in status \"${normalizedId}\". Built-in statuses are reserved: ${[...BUILTIN_STATUS_IDS].join(\", \")}.`,\n    );\n  }\n  const statuses = file.statuses.slice();\n  const existingIndex = statuses.findIndex(\n    (definition) => normalizeStatusToken(definition.id) === normalizedId,\n  );\n  if (existingIndex < 0) {\n    return { file: { statuses }, removed: false };\n  }\n  const [definition] = statuses.splice(existingIndex, 1);\n  return { file: { statuses }, removed: true, definition };\n}\n\n/**\n * Throws when the new status id or any explicitly-supplied alias collides with a\n * DIFFERENT existing status's id/alias. `resolvedAliasToId` maps a normalized\n * token to its owning status id (the runtime status registry's alias_to_id map,\n * which stores ids and aliases in one namespace). Re-adding the same status\n * (matching id) is allowed — only cross-status collisions throw. This prevents a\n * custom status from shadowing a built-in lifecycle token (for example\n * `add-status review --alias open`, or a custom id `cancelled` that aliases the\n * built-in `canceled`), which would make `pm update --status open` resolve to the\n * wrong status. The CLI layer maps the thrown Error to a USAGE exit code.\n */\nexport function assertStatusTokensAvailable(\n  input: { id: string; aliases?: string[] },\n  resolvedAliasToId: ReadonlyMap<string, string>,\n): void {\n  const candidates = [input.id, ...(input.aliases ?? [])];\n  for (const candidate of candidates) {\n    const token = normalizeStatusToken(candidate);\n    if (token.length === 0) {\n      continue;\n    }\n    const owner = resolvedAliasToId.get(token);\n    if (owner !== undefined && owner !== input.id) {\n      throw new Error(\n        `Status token \"${token}\" already belongs to status \"${owner}\". Choose a different id/alias to avoid shadowing it.`,\n      );\n    }\n  }\n}\n"],"names":[],"mappings":"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","debugId":"d738db07-1d64-5ab0-9ebd-f9c9f6de5706"}

package/dist/core/schema/type-workflows.d.ts

@@ -0,0 +1,64 @@
+import type { RuntimeSchemaSettings } from "../../types/index.js";
+/**
+ * Per-type allowed-transition support (governance.workflow_enforcement).
+ *
+ * Rule semantics:
+ * - A type with NO matching type_workflows entry is UNRESTRICTED (every
+ *   transition is allowed).
+ * - A type WITH an entry allows only the listed [from, to] pairs. from/to are
+ *   compared as normalized status ids (resolved through the status registry's
+ *   alias_to_id map when available, otherwise via token normalization).
+ * - A same-status no-op (from === to) is ALWAYS allowed.
+ *
+ * This module is intentionally dependency-light and fully unit-testable; the
+ * CLI enforcement point (src/cli/commands/update.ts) is the only consumer.
+ */
+export interface NormalizedTypeWorkflow {
+    /** Lower-cased type name used for case-insensitive matching. */
+    type: string;
+    /** Allowed [from, to] pairs as normalized status ids. */
+    allowed_transitions: [string, string][];
+}
+/** Minimal status-registry surface needed to resolve a status token to its id. */
+export interface StatusTokenResolver {
+    alias_to_id: Map<string, string>;
+}
+export interface EvaluateTransitionInput {
+    typeName: string;
+    fromStatus: string;
+    toStatus: string;
+    typeWorkflows: NormalizedTypeWorkflow[];
+    statusRegistry?: StatusTokenResolver;
+}
+export interface EvaluateTransitionResult {
+    /** Whether the transition is permitted. */
+    allowed: boolean;
+    /** Whether a matching per-type rule constrained the transition. */
+    hasRule: boolean;
+    /**
+     * Allowed [from, to] pairs for the matched type (normalized ids). Empty when
+     * the type is unrestricted.
+     */
+    allowedTransitions: [string, string][];
+}
+/** Normalize a status token the same way runtime-schema statuses are normalized. */
+export declare function normalizeStatusToken(value: unknown): string;
+/**
+ * Normalize the raw type_workflows from a runtime schema into a deduped,
+ * lower-cased-type list with normalized status tokens.
+ *
+ * An entry is kept when it has a valid (non-empty) `type` AND its
+ * `allowed_transitions` is an ARRAY — even when that array is empty. An explicit
+ * empty array is a deliberate DENY-ALL rule (only same-status no-ops are
+ * permitted, see evaluateTransition), so it must NOT collapse into "no rule"
+ * (which would leave the type unrestricted). Entries with a missing/empty type
+ * or a non-array `allowed_transitions` are dropped, as are malformed/short pairs.
+ */
+export declare function resolveTypeWorkflows(schema: Pick<RuntimeSchemaSettings, "type_workflows"> | undefined): NormalizedTypeWorkflow[];
+/**
+ * Evaluate whether a status transition is allowed for the given item type.
+ * Returns hasRule=false (allowed) when the type is unrestricted.
+ */
+export declare function evaluateTransition(input: EvaluateTransitionInput): EvaluateTransitionResult;
+/** Render the allowed transitions for an error/warning hint. */
+export declare function describeAllowedTransitions(allowedTransitions: [string, string][]): string;

package/dist/core/schema/type-workflows.js

@@ -0,0 +1,98 @@
+/** Normalize a status token the same way runtime-schema statuses are normalized. */
+
+!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]="70ab7197-566b-52de-8a82-e432b324ad8d")}catch(e){}}();
+export function normalizeStatusToken(value) {
+    return typeof value === "string" ? value.trim().toLowerCase().replaceAll(/[\s-]+/g, "_") : "";
+}
+function normalizeTypeName(value) {
+    return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+function resolveStatusId(value, statusRegistry) {
+    const token = normalizeStatusToken(value);
+    if (token.length === 0) {
+        return "";
+    }
+    return statusRegistry?.alias_to_id?.get(token) ?? token;
+}
+/**
+ * Normalize the raw type_workflows from a runtime schema into a deduped,
+ * lower-cased-type list with normalized status tokens.
+ *
+ * An entry is kept when it has a valid (non-empty) `type` AND its
+ * `allowed_transitions` is an ARRAY — even when that array is empty. An explicit
+ * empty array is a deliberate DENY-ALL rule (only same-status no-ops are
+ * permitted, see evaluateTransition), so it must NOT collapse into "no rule"
+ * (which would leave the type unrestricted). Entries with a missing/empty type
+ * or a non-array `allowed_transitions` are dropped, as are malformed/short pairs.
+ */
+export function resolveTypeWorkflows(schema) {
+    const rawWorkflows = Array.isArray(schema?.type_workflows) ? schema.type_workflows : [];
+    const byType = new Map();
+    for (const entry of rawWorkflows) {
+        const type = normalizeTypeName(entry?.type);
+        if (type.length === 0) {
+            continue;
+        }
+        if (!Array.isArray(entry?.allowed_transitions)) {
+            continue;
+        }
+        const pairs = entry.allowed_transitions;
+        const record = byType.get(type) ?? { pairs: [], denyAll: false };
+        // Only an explicitly empty array is an intentional deny-all; a nonempty array
+        // whose pairs are all malformed is a typo and must be dropped (not deny-all).
+        if (pairs.length === 0) {
+            record.denyAll = true;
+        }
+        for (const pair of pairs) {
+            if (!Array.isArray(pair) || pair.length !== 2) {
+                continue;
+            }
+            const from = normalizeStatusToken(pair[0]);
+            const to = normalizeStatusToken(pair[1]);
+            if (from.length === 0 || to.length === 0) {
+                continue;
+            }
+            if (record.pairs.some((candidate) => candidate[0] === from && candidate[1] === to)) {
+                continue;
+            }
+            record.pairs.push([from, to]);
+        }
+        byType.set(type, record);
+    }
+    return [...byType.entries()]
+        .filter(([, record]) => record.pairs.length > 0 || record.denyAll)
+        .map(([type, record]) => ({ type, allowed_transitions: record.pairs }))
+        .sort((left, right) => left.type.localeCompare(right.type));
+}
+/**
+ * Evaluate whether a status transition is allowed for the given item type.
+ * Returns hasRule=false (allowed) when the type is unrestricted.
+ */
+export function evaluateTransition(input) {
+    const typeName = normalizeTypeName(input.typeName);
+    const matched = input.typeWorkflows.find((workflow) => workflow.type === typeName);
+    if (!matched) {
+        return { allowed: true, hasRule: false, allowedTransitions: [] };
+    }
+    const from = resolveStatusId(input.fromStatus, input.statusRegistry);
+    const to = resolveStatusId(input.toStatus, input.statusRegistry);
+    // A no-op self-transition is always permitted, even under a restricting rule.
+    if (from.length > 0 && from === to) {
+        return { allowed: true, hasRule: true, allowedTransitions: matched.allowed_transitions };
+    }
+    const allowed = matched.allowed_transitions.some((pair) => {
+        const ruleFrom = resolveStatusId(pair[0], input.statusRegistry);
+        const ruleTo = resolveStatusId(pair[1], input.statusRegistry);
+        return ruleFrom === from && ruleTo === to;
+    });
+    return { allowed, hasRule: true, allowedTransitions: matched.allowed_transitions };
+}
+/** Render the allowed transitions for an error/warning hint. */
+export function describeAllowedTransitions(allowedTransitions) {
+    if (allowedTransitions.length === 0) {
+        return "(no transitions allowed)";
+    }
+    return allowedTransitions.map((pair) => `${pair[0]} -> ${pair[1]}`).join(", ");
+}
+//# sourceMappingURL=type-workflows.js.map
+//# debugId=70ab7197-566b-52de-8a82-e432b324ad8d

package/dist/core/schema/type-workflows.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-workflows.js","sources":["core/schema/type-workflows.ts"],"sourceRoot":"/","sourcesContent":["import type { RuntimeSchemaSettings, TypeWorkflowDefinition } from \"../../types/index.js\";\n\n/**\n * Per-type allowed-transition support (governance.workflow_enforcement).\n *\n * Rule semantics:\n * - A type with NO matching type_workflows entry is UNRESTRICTED (every\n *   transition is allowed).\n * - A type WITH an entry allows only the listed [from, to] pairs. from/to are\n *   compared as normalized status ids (resolved through the status registry's\n *   alias_to_id map when available, otherwise via token normalization).\n * - A same-status no-op (from === to) is ALWAYS allowed.\n *\n * This module is intentionally dependency-light and fully unit-testable; the\n * CLI enforcement point (src/cli/commands/update.ts) is the only consumer.\n */\n\nexport interface NormalizedTypeWorkflow {\n  /** Lower-cased type name used for case-insensitive matching. */\n  type: string;\n  /** Allowed [from, to] pairs as normalized status ids. */\n  allowed_transitions: [string, string][];\n}\n\n/** Minimal status-registry surface needed to resolve a status token to its id. */\nexport interface StatusTokenResolver {\n  alias_to_id: Map<string, string>;\n}\n\nexport interface EvaluateTransitionInput {\n  typeName: string;\n  fromStatus: string;\n  toStatus: string;\n  typeWorkflows: NormalizedTypeWorkflow[];\n  statusRegistry?: StatusTokenResolver;\n}\n\nexport interface EvaluateTransitionResult {\n  /** Whether the transition is permitted. */\n  allowed: boolean;\n  /** Whether a matching per-type rule constrained the transition. */\n  hasRule: boolean;\n  /**\n   * Allowed [from, to] pairs for the matched type (normalized ids). Empty when\n   * the type is unrestricted.\n   */\n  allowedTransitions: [string, string][];\n}\n\n/** Normalize a status token the same way runtime-schema statuses are normalized. */\nexport function normalizeStatusToken(value: unknown): string {\n  return typeof value === \"string\" ? value.trim().toLowerCase().replaceAll(/[\\s-]+/g, \"_\") : \"\";\n}\n\nfunction normalizeTypeName(value: unknown): string {\n  return typeof value === \"string\" ? value.trim().toLowerCase() : \"\";\n}\n\nfunction resolveStatusId(value: string, statusRegistry: StatusTokenResolver | undefined): string {\n  const token = normalizeStatusToken(value);\n  if (token.length === 0) {\n    return \"\";\n  }\n  return statusRegistry?.alias_to_id?.get(token) ?? token;\n}\n\n/**\n * Normalize the raw type_workflows from a runtime schema into a deduped,\n * lower-cased-type list with normalized status tokens.\n *\n * An entry is kept when it has a valid (non-empty) `type` AND its\n * `allowed_transitions` is an ARRAY — even when that array is empty. An explicit\n * empty array is a deliberate DENY-ALL rule (only same-status no-ops are\n * permitted, see evaluateTransition), so it must NOT collapse into \"no rule\"\n * (which would leave the type unrestricted). Entries with a missing/empty type\n * or a non-array `allowed_transitions` are dropped, as are malformed/short pairs.\n */\nexport function resolveTypeWorkflows(\n  schema: Pick<RuntimeSchemaSettings, \"type_workflows\"> | undefined,\n): NormalizedTypeWorkflow[] {\n  const rawWorkflows: TypeWorkflowDefinition[] = Array.isArray(schema?.type_workflows) ? schema!.type_workflows! : [];\n  const byType = new Map<string, { pairs: [string, string][]; denyAll: boolean }>();\n  for (const entry of rawWorkflows) {\n    const type = normalizeTypeName(entry?.type);\n    if (type.length === 0) {\n      continue;\n    }\n    if (!Array.isArray(entry?.allowed_transitions)) {\n      continue;\n    }\n    const pairs = entry.allowed_transitions;\n    const record = byType.get(type) ?? { pairs: [], denyAll: false };\n    // Only an explicitly empty array is an intentional deny-all; a nonempty array\n    // whose pairs are all malformed is a typo and must be dropped (not deny-all).\n    if (pairs.length === 0) {\n      record.denyAll = true;\n    }\n    for (const pair of pairs) {\n      if (!Array.isArray(pair) || pair.length !== 2) {\n        continue;\n      }\n      const from = normalizeStatusToken(pair[0]);\n      const to = normalizeStatusToken(pair[1]);\n      if (from.length === 0 || to.length === 0) {\n        continue;\n      }\n      if (record.pairs.some((candidate) => candidate[0] === from && candidate[1] === to)) {\n        continue;\n      }\n      record.pairs.push([from, to]);\n    }\n    byType.set(type, record);\n  }\n  return [...byType.entries()]\n    .filter(([, record]) => record.pairs.length > 0 || record.denyAll)\n    .map(([type, record]) => ({ type, allowed_transitions: record.pairs }))\n    .sort((left, right) => left.type.localeCompare(right.type));\n}\n\n/**\n * Evaluate whether a status transition is allowed for the given item type.\n * Returns hasRule=false (allowed) when the type is unrestricted.\n */\nexport function evaluateTransition(input: EvaluateTransitionInput): EvaluateTransitionResult {\n  const typeName = normalizeTypeName(input.typeName);\n  const matched = input.typeWorkflows.find((workflow) => workflow.type === typeName);\n  if (!matched) {\n    return { allowed: true, hasRule: false, allowedTransitions: [] };\n  }\n  const from = resolveStatusId(input.fromStatus, input.statusRegistry);\n  const to = resolveStatusId(input.toStatus, input.statusRegistry);\n  // A no-op self-transition is always permitted, even under a restricting rule.\n  if (from.length > 0 && from === to) {\n    return { allowed: true, hasRule: true, allowedTransitions: matched.allowed_transitions };\n  }\n  const allowed = matched.allowed_transitions.some((pair) => {\n    const ruleFrom = resolveStatusId(pair[0], input.statusRegistry);\n    const ruleTo = resolveStatusId(pair[1], input.statusRegistry);\n    return ruleFrom === from && ruleTo === to;\n  });\n  return { allowed, hasRule: true, allowedTransitions: matched.allowed_transitions };\n}\n\n/** Render the allowed transitions for an error/warning hint. */\nexport function describeAllowedTransitions(allowedTransitions: [string, string][]): string {\n  if (allowedTransitions.length === 0) {\n    return \"(no transitions allowed)\";\n  }\n  return allowedTransitions.map((pair) => `${pair[0]} -> ${pair[1]}`).join(\", \");\n}\n"],"names":[],"mappings":"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","debugId":"70ab7197-566b-52de-8a82-e432b324ad8d"}

package/dist/core/search/background-refresh.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Shared lock id for any process that rewrites the local vector store. Reindex
+ * and the background mutation-refresh worker both acquire this so they never
+ * write concurrently and corrupt the store. Exported so `pm reindex` reuses the
+ * same id rather than duplicating the literal.
+ */
+export declare const REINDEX_LOCK_ID = "reindex";
+/**
+ * Mutation search refresh runs inline (blocking) under test runners, inside the
+ * background worker child itself, or when explicitly requested. Otherwise the
+ * semantic refresh is dispatched to a detached child so mutations return without
+ * waiting on embeddings. Mirrors the telemetry-flush inline gate so the full test
+ * suite stays deterministic.
+ */
+export declare function shouldRunSearchRefreshInForeground(): boolean;
+declare function pendingQueuePath(pmRoot: string): string;
+declare function acquireQueueGate(pmRoot: string): boolean;
+declare function releaseQueueGate(pmRoot: string): void;
+/** Merge mutated item ids into the persistent pending-refresh queue. */
+export declare function enqueuePendingRefreshIds(pmRoot: string, itemIds: string[]): Promise<void>;
+/** Atomically read and clear the pending-refresh queue, returning drained ids. */
+export declare function drainPendingRefreshIds(pmRoot: string): Promise<string[]>;
+/**
+ * Enqueue mutated ids and dispatch a detached worker child to refresh semantic
+ * embeddings without blocking the mutation. The reindex lock the worker acquires
+ * serializes concurrent refreshes, so the spawn itself stays unconditional and
+ * cheap; a worker that loses the lock exits and its ids are drained by the holder.
+ */
+export declare function scheduleBackgroundSemanticRefresh(pmRoot: string, itemIds: string[]): Promise<void>;
+export interface SemanticRefreshWorkerResult {
+    processed: string[];
+    rounds: number;
+    warnings: string[];
+}
+type SemanticRefreshFn = (pmRoot: string, itemIds: string[]) => Promise<{
+    refreshed: string[];
+    skipped: string[];
+    warnings: string[];
+}>;
+/**
+ * Drain the pending queue and refresh semantic vectors under the reindex lock so
+ * the local vector store is never rewritten concurrently. If the lock is held by
+ * another worker we exit immediately — that holder drains our enqueued ids. After
+ * releasing we re-check the queue once and re-dispatch if a sibling enqueued ids
+ * during our final window, guaranteeing eventual processing.
+ */
+export declare function runSemanticRefreshWorker(pmRoot: string, refresh: SemanticRefreshFn): Promise<SemanticRefreshWorkerResult>;
+export declare const _backgroundRefreshInternals: {
+    pendingQueuePath: typeof pendingQueuePath;
+    acquireQueueGate: typeof acquireQueueGate;
+    releaseQueueGate: typeof releaseQueueGate;
+};
+export {};

package/dist/core/search/background-refresh.js

@@ -0,0 +1,286 @@
+
+!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]="d8990236-9b78-570d-bafa-5da0ce621293")}catch(e){}}();
+import { spawn } from "node:child_process";
+import { mkdirSync, rmSync, statSync } from "node:fs";
+import path from "node:path";
+import { pathExists, readFileIfExists, writeFileAtomic } from "../fs/fs-utils.js";
+import { acquireLock } from "../lock/lock.js";
+import { resolvePmPackageRootFromModule } from "../packages/root.js";
+import { readSettings } from "../store/settings.js";
+import { toErrorMessage } from "../shared/primitives.js";
+import { resolveSettingsWithSemanticRuntimeDefaults } from "./semantic-defaults.js";
+/**
+ * Shared lock id for any process that rewrites the local vector store. Reindex
+ * and the background mutation-refresh worker both acquire this so they never
+ * write concurrently and corrupt the store. Exported so `pm reindex` reuses the
+ * same id rather than duplicating the literal.
+ */
+export const REINDEX_LOCK_ID = "reindex";
+const PENDING_QUEUE_REL_PATH = "search/pending-refresh.json";
+const PENDING_QUEUE_GATE_REL_PATH = "search/pending-refresh.gate.lock";
+const PENDING_QUEUE_GATE_STALE_MS = 30_000;
+// Bounded reindex-lock retry for the background worker (~3.2s worst case).
+const LOCK_ACQUIRE_ATTEMPTS = 8;
+const LOCK_ACQUIRE_BACKOFF_MS = 400;
+const SEARCH_REFRESH_INLINE_ENV = "PM_SEARCH_REFRESH_INLINE";
+const 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";
+}
+/**
+ * Mutation search refresh runs inline (blocking) under test runners, inside the
+ * background worker child itself, or when explicitly requested. Otherwise the
+ * semantic refresh is dispatched to a detached child so mutations return without
+ * waiting on embeddings. Mirrors the telemetry-flush inline gate so the full test
+ * suite stays deterministic.
+ */
+export 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 {
+        // Missing gate is the common case; fall through to create it.
+    }
+    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 {
+        // Best effort; a stale gate self-heals after PENDING_QUEUE_GATE_STALE_MS.
+    }
+}
+async function withQueueGate(pmRoot, fn, fallback) {
+    // Briefly serialize read-modify-write access to the pending queue across the
+    // mutation process and the worker child. Acquisition is best effort; if a
+    // healthy gate is held we skip rather than risk a torn queue.
+    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((resolve) => {
+        setTimeout(resolve, ms).unref?.();
+    });
+}
+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 })}\n`);
+}
+/** Merge mutated item ids into the persistent pending-refresh queue. */
+export 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 = [...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) {
+        // The gate stayed contended past the retry budget. Never silently drop a
+        // mutation's refresh work: fall back to a best-effort unguarded merge.
+        // writeFileAtomic keeps the file valid; the only risk is losing a concurrent
+        // writer's delta, which its own next dispatch and the vector_index_stale
+        // warning both recover.
+        await mergeIncoming();
+    }
+}
+/** Atomically read and clear the pending-refresh queue, returning drained ids. */
+export async function drainPendingRefreshIds(pmRoot) {
+    return withQueueGate(pmRoot, async () => {
+        const ids = await readPendingQueueIds(pmRoot);
+        if (ids.length > 0) {
+            await writePendingQueueIds(pmRoot, []);
+        }
+        return ids;
+    }, []);
+}
+function searchRefreshRunnerPath() {
+    return path.join(resolvePmPackageRootFromModule(import.meta.url, ["../../.."]), "dist", "cli", "search-refresh.js");
+}
+/**
+ * Spawn the detached refresh worker child for this pm root. Best effort: a
+ * failed dispatch must never keep the CLI alive or fail a mutation; the next
+ * mutation re-dispatches and `vector_index_stale` warns about the catch-up
+ * window in the meantime.
+ */
+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",
+            },
+        });
+        // A detached child can emit an async 'error' event (e.g. spawn EAGAIN/ENOENT,
+        // resource limits). Swallow it so it never becomes an unhandled error that
+        // crashes the parent CLI; dispatch is best effort.
+        child.on("error", () => { });
+        child.unref();
+    }
+    catch {
+        // Best effort — see doc comment above.
+    }
+}
+/**
+ * Enqueue mutated ids and dispatch a detached worker child to refresh semantic
+ * embeddings without blocking the mutation. The reindex lock the worker acquires
+ * serializes concurrent refreshes, so the spawn itself stays unconditional and
+ * cheap; a worker that loses the lock exits and its ids are drained by the holder.
+ */
+export async function scheduleBackgroundSemanticRefresh(pmRoot, itemIds) {
+    await enqueuePendingRefreshIds(pmRoot, itemIds);
+    dispatchRefreshChild(pmRoot);
+}
+/**
+ * Drain the pending queue and refresh semantic vectors under the reindex lock so
+ * the local vector store is never rewritten concurrently. If the lock is held by
+ * another worker we exit immediately — that holder drains our enqueued ids. After
+ * releasing we re-check the queue once and re-dispatch if a sibling enqueued ids
+ * during our final window, guaranteeing eventual processing.
+ */
+export async function runSemanticRefreshWorker(pmRoot, refresh) {
+    const warnings = [];
+    const processed = [];
+    if (!(await pathExists(pmRoot))) {
+        return { processed, rounds: 0, warnings };
+    }
+    let settings;
+    try {
+        settings = resolveSettingsWithSemanticRuntimeDefaults(await readSettings(pmRoot)).settings;
+    }
+    catch (error) {
+        return { processed, rounds: 0, warnings: [`search_background_refresh_settings_read_failed:${toErrorMessage(error)}`] };
+    }
+    // Retry the reindex lock with backoff rather than exiting on the first
+    // conflict: a sibling refresh worker holds it only briefly (~one embed), so a
+    // few retries pick up the queued ids in this run instead of stranding them
+    // until the next mutation. If a long `pm reindex` keeps it, we give up — that
+    // full pass re-embeds everything anyway and the next dispatch retries.
+    let release = null;
+    for (let attempt = 0; attempt < LOCK_ACQUIRE_ATTEMPTS && !release; attempt += 1) {
+        try {
+            release = await acquireLock(pmRoot, REINDEX_LOCK_ID, settings.locks.ttl_seconds, process.env.PM_AUTHOR ?? "pm-search-refresh", false, settings.governance.force_required_for_stale_lock);
+        }
+        catch {
+            if (attempt < LOCK_ACQUIRE_ATTEMPTS - 1) {
+                await delay(LOCK_ACQUIRE_BACKOFF_MS);
+            }
+        }
+    }
+    if (!release) {
+        return { processed, rounds: 0, warnings };
+    }
+    let rounds = 0;
+    let failed = false;
+    try {
+        for (;;) {
+            const ids = await drainPendingRefreshIds(pmRoot);
+            if (ids.length === 0) {
+                break;
+            }
+            rounds += 1;
+            try {
+                const result = await refresh(pmRoot, ids);
+                processed.push(...result.refreshed);
+                warnings.push(...result.warnings);
+            }
+            catch (error) {
+                warnings.push(`search_background_refresh_failed:${toErrorMessage(error)}`);
+                // Re-enqueue so the work is retried by a later dispatch rather than lost.
+                await enqueuePendingRefreshIds(pmRoot, ids);
+                failed = true;
+                break;
+            }
+        }
+    }
+    finally {
+        await release?.();
+    }
+    // Close the race where a sibling enqueued ids between our last empty drain and
+    // releasing the lock: re-dispatch so those ids are eventually processed. Skip
+    // this after a refresh failure — the failed ids were re-enqueued and an
+    // immediate respawn would just fail again, spinning indefinitely. They wait
+    // for the next mutation's dispatch instead.
+    const remaining = failed ? [] : await readPendingQueueIds(pmRoot);
+    if (remaining.length > 0) {
+        dispatchRefreshChild(pmRoot);
+    }
+    return { processed: [...new Set(processed)].sort((a, b) => a.localeCompare(b)), rounds, warnings };
+}
+// Expose internals for focused tests without widening the production surface
+// used by the mutation hot path.
+export const _backgroundRefreshInternals = {
+    pendingQueuePath,
+    acquireQueueGate,
+    releaseQueueGate,
+};
+//# sourceMappingURL=background-refresh.js.map
+//# debugId=d8990236-9b78-570d-bafa-5da0ce621293

package/dist/core/search/background-refresh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"background-refresh.js","sources":["core/search/background-refresh.ts"],"sourceRoot":"/","sourcesContent":["import { spawn } from \"node:child_process\";\nimport { mkdirSync, rmSync, statSync } from \"node:fs\";\nimport path from \"node:path\";\n\nimport { pathExists, readFileIfExists, writeFileAtomic } from \"../fs/fs-utils.js\";\nimport { acquireLock } from \"../lock/lock.js\";\nimport { resolvePmPackageRootFromModule } from \"../packages/root.js\";\nimport { readSettings } from \"../store/settings.js\";\nimport { toErrorMessage } from \"../shared/primitives.js\";\nimport { resolveSettingsWithSemanticRuntimeDefaults } from \"./semantic-defaults.js\";\n\n/**\n * Shared lock id for any process that rewrites the local vector store. Reindex\n * and the background mutation-refresh worker both acquire this so they never\n * write concurrently and corrupt the store. Exported so `pm reindex` reuses the\n * same id rather than duplicating the literal.\n */\nexport const REINDEX_LOCK_ID = \"reindex\";\n\nconst PENDING_QUEUE_REL_PATH = \"search/pending-refresh.json\";\nconst PENDING_QUEUE_GATE_REL_PATH = \"search/pending-refresh.gate.lock\";\nconst PENDING_QUEUE_GATE_STALE_MS = 30_000;\n\n// Bounded reindex-lock retry for the background worker (~3.2s worst case).\nconst LOCK_ACQUIRE_ATTEMPTS = 8;\nconst LOCK_ACQUIRE_BACKOFF_MS = 400;\n\nconst SEARCH_REFRESH_INLINE_ENV = \"PM_SEARCH_REFRESH_INLINE\";\nconst SEARCH_REFRESH_CHILD_ENV = \"PM_SEARCH_REFRESH_CHILD\";\n\nfunction parseBooleanTrueLike(value: string | undefined): boolean {\n  if (typeof value !== \"string\") {\n    return false;\n  }\n  const normalized = value.trim().toLowerCase();\n  return normalized === \"1\" || normalized === \"true\" || normalized === \"yes\" || normalized === \"on\";\n}\n\n/**\n * Mutation search refresh runs inline (blocking) under test runners, inside the\n * background worker child itself, or when explicitly requested. Otherwise the\n * semantic refresh is dispatched to a detached child so mutations return without\n * waiting on embeddings. Mirrors the telemetry-flush inline gate so the full test\n * suite stays deterministic.\n */\nexport function shouldRunSearchRefreshInForeground(): boolean {\n  if (parseBooleanTrueLike(process.env[SEARCH_REFRESH_INLINE_ENV])) {\n    return true;\n  }\n  if (parseBooleanTrueLike(process.env[SEARCH_REFRESH_CHILD_ENV])) {\n    return true;\n  }\n  const nodeEnv = (process.env.NODE_ENV ?? \"\").trim().toLowerCase();\n  return (\n    typeof process.env.VITEST === \"string\" ||\n    typeof process.env.VITEST_WORKER_ID === \"string\" ||\n    nodeEnv === \"test\"\n  );\n}\n\nfunction pendingQueuePath(pmRoot: string): string {\n  return path.join(pmRoot, PENDING_QUEUE_REL_PATH);\n}\n\nfunction pendingQueueGatePath(pmRoot: string): string {\n  return path.join(pmRoot, PENDING_QUEUE_GATE_REL_PATH);\n}\n\nfunction acquireQueueGate(pmRoot: string): boolean {\n  const gatePath = pendingQueueGatePath(pmRoot);\n  try {\n    if (Date.now() - statSync(gatePath).mtimeMs < PENDING_QUEUE_GATE_STALE_MS) {\n      return false;\n    }\n    rmSync(gatePath, { recursive: true, force: true });\n  } catch {\n    // Missing gate is the common case; fall through to create it.\n  }\n  try {\n    mkdirSync(path.dirname(gatePath), { recursive: true });\n    mkdirSync(gatePath);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nfunction releaseQueueGate(pmRoot: string): void {\n  try {\n    rmSync(pendingQueueGatePath(pmRoot), { recursive: true, force: true });\n  } catch {\n    // Best effort; a stale gate self-heals after PENDING_QUEUE_GATE_STALE_MS.\n  }\n}\n\nasync function withQueueGate<T>(pmRoot: string, fn: () => Promise<T>, fallback: T): Promise<T> {\n  // Briefly serialize read-modify-write access to the pending queue across the\n  // mutation process and the worker child. Acquisition is best effort; if a\n  // healthy gate is held we skip rather than risk a torn queue.\n  for (let attempt = 0; attempt < 50; attempt += 1) {\n    if (acquireQueueGate(pmRoot)) {\n      try {\n        return await fn();\n      } finally {\n        releaseQueueGate(pmRoot);\n      }\n    }\n    await delay(20);\n  }\n  return fallback;\n}\n\nfunction delay(ms: number): Promise<void> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, ms).unref?.();\n  });\n}\n\nasync function readPendingQueueIds(pmRoot: string): Promise<string[]> {\n  const raw = await readFileIfExists(pendingQueuePath(pmRoot));\n  if (!raw || raw.trim().length === 0) {\n    return [];\n  }\n  try {\n    const parsed = JSON.parse(raw) as { ids?: unknown };\n    if (!Array.isArray(parsed.ids)) {\n      return [];\n    }\n    return parsed.ids.filter((id): id is string => typeof id === \"string\" && id.length > 0);\n  } catch {\n    return [];\n  }\n}\n\nasync function writePendingQueueIds(pmRoot: string, ids: string[]): Promise<void> {\n  await writeFileAtomic(pendingQueuePath(pmRoot), `${JSON.stringify({ ids })}\\n`);\n}\n\n/** Merge mutated item ids into the persistent pending-refresh queue. */\nexport async function enqueuePendingRefreshIds(pmRoot: string, itemIds: string[]): Promise<void> {\n  const incoming = itemIds.filter((id) => typeof id === \"string\" && id.trim().length > 0);\n  if (incoming.length === 0) {\n    return;\n  }\n  const mergeIncoming = async (): Promise<void> => {\n    const existing = await readPendingQueueIds(pmRoot);\n    const merged = [...new Set([...existing, ...incoming])].sort((left, right) => left.localeCompare(right));\n    await writePendingQueueIds(pmRoot, merged);\n  };\n  const gated = await withQueueGate(\n    pmRoot,\n    async () => {\n      await mergeIncoming();\n      return true;\n    },\n    false,\n  );\n  if (!gated) {\n    // The gate stayed contended past the retry budget. Never silently drop a\n    // mutation's refresh work: fall back to a best-effort unguarded merge.\n    // writeFileAtomic keeps the file valid; the only risk is losing a concurrent\n    // writer's delta, which its own next dispatch and the vector_index_stale\n    // warning both recover.\n    await mergeIncoming();\n  }\n}\n\n/** Atomically read and clear the pending-refresh queue, returning drained ids. */\nexport async function drainPendingRefreshIds(pmRoot: string): Promise<string[]> {\n  return withQueueGate(\n    pmRoot,\n    async () => {\n      const ids = await readPendingQueueIds(pmRoot);\n      if (ids.length > 0) {\n        await writePendingQueueIds(pmRoot, []);\n      }\n      return ids;\n    },\n    [],\n  );\n}\n\nfunction searchRefreshRunnerPath(): string {\n  return path.join(\n    resolvePmPackageRootFromModule(import.meta.url, [\"../../..\"]),\n    \"dist\",\n    \"cli\",\n    \"search-refresh.js\",\n  );\n}\n\n/**\n * Spawn the detached refresh worker child for this pm root. Best effort: a\n * failed dispatch must never keep the CLI alive or fail a mutation; the next\n * mutation re-dispatches and `vector_index_stale` warns about the catch-up\n * window in the meantime.\n */\nfunction dispatchRefreshChild(pmRoot: string): void {\n  try {\n    const child = spawn(process.execPath, [searchRefreshRunnerPath()], {\n      detached: true,\n      stdio: \"ignore\",\n      env: {\n        ...process.env,\n        PM_PATH: pmRoot,\n        [SEARCH_REFRESH_CHILD_ENV]: \"1\",\n      },\n    });\n    // A detached child can emit an async 'error' event (e.g. spawn EAGAIN/ENOENT,\n    // resource limits). Swallow it so it never becomes an unhandled error that\n    // crashes the parent CLI; dispatch is best effort.\n    child.on(\"error\", () => {});\n    child.unref();\n  } catch {\n    // Best effort — see doc comment above.\n  }\n}\n\n/**\n * Enqueue mutated ids and dispatch a detached worker child to refresh semantic\n * embeddings without blocking the mutation. The reindex lock the worker acquires\n * serializes concurrent refreshes, so the spawn itself stays unconditional and\n * cheap; a worker that loses the lock exits and its ids are drained by the holder.\n */\nexport async function scheduleBackgroundSemanticRefresh(pmRoot: string, itemIds: string[]): Promise<void> {\n  await enqueuePendingRefreshIds(pmRoot, itemIds);\n  dispatchRefreshChild(pmRoot);\n}\n\nexport interface SemanticRefreshWorkerResult {\n  processed: string[];\n  rounds: number;\n  warnings: string[];\n}\n\ntype SemanticRefreshFn = (\n  pmRoot: string,\n  itemIds: string[],\n) => Promise<{ refreshed: string[]; skipped: string[]; warnings: string[] }>;\n\n/**\n * Drain the pending queue and refresh semantic vectors under the reindex lock so\n * the local vector store is never rewritten concurrently. If the lock is held by\n * another worker we exit immediately — that holder drains our enqueued ids. After\n * releasing we re-check the queue once and re-dispatch if a sibling enqueued ids\n * during our final window, guaranteeing eventual processing.\n */\nexport async function runSemanticRefreshWorker(\n  pmRoot: string,\n  refresh: SemanticRefreshFn,\n): Promise<SemanticRefreshWorkerResult> {\n  const warnings: string[] = [];\n  const processed: string[] = [];\n  if (!(await pathExists(pmRoot))) {\n    return { processed, rounds: 0, warnings };\n  }\n\n  let settings: Awaited<ReturnType<typeof readSettings>>;\n  try {\n    settings = resolveSettingsWithSemanticRuntimeDefaults(await readSettings(pmRoot)).settings;\n  } catch (error: unknown) {\n    return { processed, rounds: 0, warnings: [`search_background_refresh_settings_read_failed:${toErrorMessage(error)}`] };\n  }\n\n  // Retry the reindex lock with backoff rather than exiting on the first\n  // conflict: a sibling refresh worker holds it only briefly (~one embed), so a\n  // few retries pick up the queued ids in this run instead of stranding them\n  // until the next mutation. If a long `pm reindex` keeps it, we give up — that\n  // full pass re-embeds everything anyway and the next dispatch retries.\n  let release: (() => Promise<void>) | null = null;\n  for (let attempt = 0; attempt < LOCK_ACQUIRE_ATTEMPTS && !release; attempt += 1) {\n    try {\n      release = await acquireLock(\n        pmRoot,\n        REINDEX_LOCK_ID,\n        settings.locks.ttl_seconds,\n        process.env.PM_AUTHOR ?? \"pm-search-refresh\",\n        false,\n        settings.governance.force_required_for_stale_lock,\n      );\n    } catch {\n      if (attempt < LOCK_ACQUIRE_ATTEMPTS - 1) {\n        await delay(LOCK_ACQUIRE_BACKOFF_MS);\n      }\n    }\n  }\n  if (!release) {\n    return { processed, rounds: 0, warnings };\n  }\n\n  let rounds = 0;\n  let failed = false;\n  try {\n    for (;;) {\n      const ids = await drainPendingRefreshIds(pmRoot);\n      if (ids.length === 0) {\n        break;\n      }\n      rounds += 1;\n      try {\n        const result = await refresh(pmRoot, ids);\n        processed.push(...result.refreshed);\n        warnings.push(...result.warnings);\n      } catch (error: unknown) {\n        warnings.push(`search_background_refresh_failed:${toErrorMessage(error)}`);\n        // Re-enqueue so the work is retried by a later dispatch rather than lost.\n        await enqueuePendingRefreshIds(pmRoot, ids);\n        failed = true;\n        break;\n      }\n    }\n  } finally {\n    await release?.();\n  }\n\n  // Close the race where a sibling enqueued ids between our last empty drain and\n  // releasing the lock: re-dispatch so those ids are eventually processed. Skip\n  // this after a refresh failure — the failed ids were re-enqueued and an\n  // immediate respawn would just fail again, spinning indefinitely. They wait\n  // for the next mutation's dispatch instead.\n  const remaining = failed ? [] : await readPendingQueueIds(pmRoot);\n  if (remaining.length > 0) {\n    dispatchRefreshChild(pmRoot);\n  }\n\n  return { processed: [...new Set(processed)].sort((a, b) => a.localeCompare(b)), rounds, warnings };\n}\n\n// Expose internals for focused tests without widening the production surface\n// used by the mutation hot path.\nexport const _backgroundRefreshInternals = {\n  pendingQueuePath,\n  acquireQueueGate,\n  releaseQueueGate,\n};\n"],"names":[],"mappings":"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","debugId":"d8990236-9b78-570d-bafa-5da0ce621293"}