@agenr/agenr-plugin 1.9.3 → 2.0.1

package/dist/{chunk-EMRMV2QR.js → chunk-Y2BC7RCE.js}

@@ -1,12 +1,14 @@
 import {
   buildLexicalPlan,
+  combinedRelevance,
+  computeLexicalScore,
   cosineSimilarity,
   describeClaimKeyNormalizationFailure,
   normalizeClaimKey,
   recall,
   resolveClaimSlotPolicy,
   tokenize
-} from "./chunk-GUDCFFRV.js";
+} from "./chunk-MEHOGUZE.js";
 
 // src/adapters/db/client.ts
 import fs from "fs/promises";
@@ -31,6 +33,9 @@ var CLAIM_KEY_SOURCES = [
 ];
 var CLAIM_SUPPORT_MODES = ["explicit", "normalized", "inferred"];
 var EPISODE_ACTIVITY_LEVELS = ["substantial", "minimal", "none"];
+var PROCEDURE_STEP_KINDS = ["run_command", "read_reference", "inspect_state", "edit_file", "ask_user", "invoke_tool", "verify"];
+var PROCEDURE_CONDITION_KINDS = ["harness_is", "tool_available", "file_exists", "path_exists", "env_flag", "repo_state", "user_confirmed"];
+var PROCEDURE_SOURCE_KINDS = ["skill", "doc", "entry", "episode", "repo_file", "manual"];
 
 // src/core/claim-key-lifecycle.ts
 var PRECOMPUTED_LIFECYCLE_FIELDS = ["claim_key_status", "claim_key_source", "claim_key_confidence", "claim_key_rationale"];
@@ -1136,8 +1141,817 @@ function toNullableInteger(value) {
   return value ?? null;
 }
 
+// src/adapters/db/procedure-queries.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/core/procedures/validation.ts
+import { parseDocument } from "yaml";
+function parseProcedureYaml(sourceText, filePath) {
+  const document = parseDocument(sourceText, {
+    merge: false,
+    prettyErrors: true,
+    uniqueKeys: true
+  });
+  if (document.errors.length > 0) {
+    const [firstError] = document.errors;
+    throw new Error(`Invalid procedure ${filePath}: ${firstError?.message ?? "YAML parsing failed."}`);
+  }
+  return document.toJS({ maxAliasCount: 0 });
+}
+function readProcedureRecord(value, label, filePath) {
+  if (!isRecord(value)) {
+    throw new Error(`Invalid procedure ${filePath}: ${label} must be an object.`);
+  }
+  return value;
+}
+function rejectUnexpectedProcedureFields(record, allowedKeys, label, filePath) {
+  const unexpected = Object.keys(record).filter((key) => !allowedKeys.has(key));
+  if (unexpected.length === 0) {
+    return;
+  }
+  throw new Error(`Invalid procedure ${filePath}: ${label} contains unsupported field "${unexpected[0]}".`);
+}
+function readRequiredProcedureString(value, label, filePath) {
+  if (typeof value !== "string") {
+    throw new Error(`Invalid procedure ${filePath}: ${label} must be a non-empty string.`);
+  }
+  const normalized = normalizeWhitespace(value);
+  if (normalized.length === 0) {
+    throw new Error(`Invalid procedure ${filePath}: ${label} must be a non-empty string.`);
+  }
+  return normalized;
+}
+function readOptionalProcedureString(value, label, filePath) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return readRequiredProcedureString(value, label, filePath);
+}
+function readProcedureStringArray(value, label, filePath, options = {}) {
+  if (value === void 0) {
+    if (options.required) {
+      throw new Error(`Invalid procedure ${filePath}: ${label} must be an array.`);
+    }
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    throw new Error(`Invalid procedure ${filePath}: ${label} must be an array.`);
+  }
+  const normalized = value.map((item, index) => readRequiredProcedureString(item, `${label}[${index}]`, filePath));
+  if (options.minItems !== void 0 && normalized.length < options.minItems) {
+    throw new Error(`Invalid procedure ${filePath}: ${label} must contain at least ${options.minItems} item(s).`);
+  }
+  return normalized;
+}
+function readProcedureRecordArray(value, label, filePath, options = {}) {
+  if (value === void 0) {
+    if (options.required) {
+      throw new Error(`Invalid procedure ${filePath}: ${label} must be an array.`);
+    }
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    throw new Error(`Invalid procedure ${filePath}: ${label} must be an array.`);
+  }
+  const records = value.map((item, index) => readProcedureRecord(item, `${label}[${index}]`, filePath));
+  if (options.minItems !== void 0 && records.length < options.minItems) {
+    throw new Error(`Invalid procedure ${filePath}: ${label} must contain at least ${options.minItems} item(s).`);
+  }
+  return records;
+}
+function readProcedureStepKind(value, label, filePath, supportedKinds) {
+  const normalized = readRequiredProcedureString(value, label, filePath);
+  if (!supportedKinds.includes(normalized)) {
+    throw new Error(`Invalid procedure ${filePath}: ${label} has unsupported step kind "${normalized}".`);
+  }
+  return normalized;
+}
+function readProcedureConditionKind(value, label, filePath, supportedKinds) {
+  const normalized = readRequiredProcedureString(value, label, filePath);
+  if (!supportedKinds.includes(normalized)) {
+    throw new Error(`Invalid procedure ${filePath}: ${label} has unsupported condition kind "${normalized}".`);
+  }
+  return normalized;
+}
+function readProcedureSourceKind(value, label, filePath, supportedKinds) {
+  const normalized = readRequiredProcedureString(value, label, filePath);
+  if (!supportedKinds.includes(normalized)) {
+    throw new Error(`Invalid procedure ${filePath}: ${label} has unsupported source kind "${normalized}".`);
+  }
+  return normalized;
+}
+function normalizeProcedureToolArgumentValue(value, label, filePath) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error(`Invalid procedure ${filePath}: ${label} must not contain non-finite numbers.`);
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item, index) => normalizeProcedureToolArgumentValue(item, `${label}[${index}]`, filePath));
+  }
+  if (!isRecord(value)) {
+    throw new Error(`Invalid procedure ${filePath}: ${label} must be JSON-like data.`);
+  }
+  const normalizedEntries = Object.entries(value).map(([key, entryValue]) => {
+    const normalizedKey = key.trim();
+    if (normalizedKey.length === 0) {
+      throw new Error(`Invalid procedure ${filePath}: ${label} must not contain blank object keys.`);
+    }
+    return [normalizedKey, normalizeProcedureToolArgumentValue(entryValue, `${label}.${normalizedKey}`, filePath)];
+  }).sort(([left], [right]) => left.localeCompare(right));
+  return Object.fromEntries(normalizedEntries);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeWhitespace(value) {
+  return value.replace(/\s+/gu, " ").trim();
+}
+
+// src/core/procedures/normalization.ts
+var PROCEDURE_KEYS = /* @__PURE__ */ new Set([
+  "procedure_key",
+  "title",
+  "goal",
+  "when_to_use",
+  "when_not_to_use",
+  "prerequisites",
+  "steps",
+  "verification",
+  "failure_modes",
+  "sources"
+]);
+var STEP_BASE_KEYS = /* @__PURE__ */ new Set(["id", "kind", "instruction", "conditions", "stop_if"]);
+var READ_REFERENCE_STEP_KEYS = /* @__PURE__ */ new Set([...STEP_BASE_KEYS, "ref"]);
+var RUN_COMMAND_STEP_KEYS = /* @__PURE__ */ new Set([...STEP_BASE_KEYS, "command"]);
+var INSPECT_STATE_STEP_KEYS = /* @__PURE__ */ new Set([...STEP_BASE_KEYS, "target", "query"]);
+var EDIT_FILE_STEP_KEYS = /* @__PURE__ */ new Set([...STEP_BASE_KEYS, "path", "edit"]);
+var ASK_USER_STEP_KEYS = /* @__PURE__ */ new Set([...STEP_BASE_KEYS, "prompt"]);
+var INVOKE_TOOL_STEP_KEYS = /* @__PURE__ */ new Set([...STEP_BASE_KEYS, "tool", "arguments"]);
+var VERIFY_STEP_KEYS = /* @__PURE__ */ new Set([...STEP_BASE_KEYS, "checks"]);
+var SOURCE_KEYS = /* @__PURE__ */ new Set(["kind", "path", "locator", "label"]);
+var HARNESS_CONDITION_KEYS = /* @__PURE__ */ new Set(["kind", "value"]);
+var TOOL_AVAILABLE_CONDITION_KEYS = /* @__PURE__ */ new Set(["kind", "value"]);
+var FILE_EXISTS_CONDITION_KEYS = /* @__PURE__ */ new Set(["kind", "path"]);
+var PATH_EXISTS_CONDITION_KEYS = /* @__PURE__ */ new Set(["kind", "path"]);
+var ENV_FLAG_CONDITION_KEYS = /* @__PURE__ */ new Set(["kind", "name", "value"]);
+var REPO_STATE_CONDITION_KEYS = /* @__PURE__ */ new Set(["kind", "value"]);
+var USER_CONFIRMED_CONDITION_KEYS = /* @__PURE__ */ new Set(["kind", "value"]);
+function parseAndNormalizeProcedureYaml(sourceText, filePath) {
+  return normalizeProcedureDefinition(parseProcedureYaml(sourceText, filePath), filePath);
+}
+function normalizeProcedureDefinition(value, filePath) {
+  const record = readProcedureRecord(value, "Procedure root", filePath);
+  rejectUnexpectedProcedureFields(record, PROCEDURE_KEYS, "Procedure root", filePath);
+  return {
+    procedure_key: normalizeProcedureKey(record.procedure_key, filePath),
+    title: readRequiredProcedureString(record.title, "title", filePath),
+    goal: readRequiredProcedureString(record.goal, "goal", filePath),
+    when_to_use: readProcedureStringArray(record.when_to_use, "when_to_use", filePath),
+    when_not_to_use: readProcedureStringArray(record.when_not_to_use, "when_not_to_use", filePath),
+    prerequisites: readProcedureStringArray(record.prerequisites, "prerequisites", filePath),
+    steps: normalizeProcedureSteps(record.steps, filePath),
+    verification: readProcedureStringArray(record.verification, "verification", filePath, { required: true, minItems: 1 }),
+    failure_modes: readProcedureStringArray(record.failure_modes, "failure_modes", filePath, { required: true, minItems: 1 }),
+    sources: normalizeProcedureSources(record.sources, "sources", filePath, { required: true, minItems: 1 })
+  };
+}
+function normalizeProcedureKey(value, filePath) {
+  const normalized = readRequiredProcedureString(value, "procedure_key", filePath).toLowerCase();
+  if (!normalized.includes("/") || !/^[a-z0-9][a-z0-9._/-]*$/u.test(normalized)) {
+    throw new Error(`Invalid procedure ${filePath}: procedure_key must be a lowercase slash-delimited identifier like "agenr/release".`);
+  }
+  return normalized;
+}
+function normalizeProcedureSteps(value, filePath) {
+  const records = readProcedureRecordArray(value, "steps", filePath, { required: true, minItems: 1 });
+  const steps = records.map((record, index) => normalizeProcedureStep(record, `steps[${index}]`, filePath));
+  const stepIds = /* @__PURE__ */ new Set();
+  for (const step of steps) {
+    if (stepIds.has(step.id)) {
+      throw new Error(`Invalid procedure ${filePath}: steps must not contain duplicate id "${step.id}".`);
+    }
+    stepIds.add(step.id);
+  }
+  return steps;
+}
+function normalizeProcedureStep(record, label, filePath) {
+  const kind = readProcedureStepKind(record.kind, `${label}.kind`, filePath, PROCEDURE_STEP_KINDS);
+  const base = normalizeProcedureStepBase(record, label, filePath);
+  switch (kind) {
+    case "run_command":
+      rejectUnexpectedProcedureFields(record, RUN_COMMAND_STEP_KEYS, label, filePath);
+      return {
+        ...base,
+        kind,
+        command: readRequiredProcedureString(record.command, `${label}.command`, filePath)
+      };
+    case "read_reference":
+      rejectUnexpectedProcedureFields(record, READ_REFERENCE_STEP_KEYS, label, filePath);
+      return {
+        ...base,
+        kind,
+        ref: normalizeProcedureSource(readProcedureRecord(record.ref, `${label}.ref`, filePath), `${label}.ref`, filePath)
+      };
+    case "inspect_state": {
+      rejectUnexpectedProcedureFields(record, INSPECT_STATE_STEP_KEYS, label, filePath);
+      const target = readOptionalProcedureString(record.target, `${label}.target`, filePath);
+      const query = readOptionalProcedureString(record.query, `${label}.query`, filePath);
+      if (!target && !query) {
+        throw new Error(`Invalid procedure ${filePath}: ${label} must define target, query, or both.`);
+      }
+      return {
+        ...base,
+        kind,
+        ...target ? { target } : {},
+        ...query ? { query } : {}
+      };
+    }
+    case "edit_file":
+      rejectUnexpectedProcedureFields(record, EDIT_FILE_STEP_KEYS, label, filePath);
+      return {
+        ...base,
+        kind,
+        path: readRequiredProcedureString(record.path, `${label}.path`, filePath),
+        edit: readRequiredProcedureString(record.edit, `${label}.edit`, filePath)
+      };
+    case "ask_user":
+      rejectUnexpectedProcedureFields(record, ASK_USER_STEP_KEYS, label, filePath);
+      return {
+        ...base,
+        kind,
+        prompt: readRequiredProcedureString(record.prompt, `${label}.prompt`, filePath)
+      };
+    case "invoke_tool":
+      rejectUnexpectedProcedureFields(record, INVOKE_TOOL_STEP_KEYS, label, filePath);
+      return {
+        ...base,
+        kind,
+        tool: readRequiredProcedureString(record.tool, `${label}.tool`, filePath),
+        ...record.arguments !== void 0 ? {
+          arguments: normalizeProcedureArguments(record.arguments, `${label}.arguments`, filePath)
+        } : {}
+      };
+    case "verify":
+      rejectUnexpectedProcedureFields(record, VERIFY_STEP_KEYS, label, filePath);
+      return {
+        ...base,
+        kind,
+        checks: readProcedureStringArray(record.checks, `${label}.checks`, filePath, { required: true, minItems: 1 })
+      };
+  }
+}
+function normalizeProcedureStepBase(record, label, filePath) {
+  return {
+    id: readRequiredProcedureString(record.id, `${label}.id`, filePath),
+    instruction: readRequiredProcedureString(record.instruction, `${label}.instruction`, filePath),
+    ...record.conditions !== void 0 ? { conditions: normalizeProcedureConditions(record.conditions, `${label}.conditions`, filePath) } : {},
+    ...record.stop_if !== void 0 ? { stop_if: normalizeProcedureConditions(record.stop_if, `${label}.stop_if`, filePath) } : {}
+  };
+}
+function normalizeProcedureArguments(value, label, filePath) {
+  const record = readProcedureRecord(value, label, filePath);
+  return normalizeProcedureToolArgumentValue(record, label, filePath);
+}
+function normalizeProcedureConditions(value, label, filePath) {
+  return readProcedureRecordArray(value, label, filePath, { required: true, minItems: 1 }).map(
+    (record, index) => normalizeProcedureCondition(record, `${label}[${index}]`, filePath)
+  );
+}
+function normalizeProcedureCondition(record, label, filePath) {
+  const kind = readProcedureConditionKind(record.kind, `${label}.kind`, filePath, PROCEDURE_CONDITION_KINDS);
+  switch (kind) {
+    case "harness_is":
+      rejectUnexpectedProcedureFields(record, HARNESS_CONDITION_KEYS, label, filePath);
+      return {
+        kind,
+        value: readRequiredProcedureString(record.value, `${label}.value`, filePath)
+      };
+    case "tool_available":
+      rejectUnexpectedProcedureFields(record, TOOL_AVAILABLE_CONDITION_KEYS, label, filePath);
+      return {
+        kind,
+        value: readRequiredProcedureString(record.value, `${label}.value`, filePath)
+      };
+    case "file_exists":
+      rejectUnexpectedProcedureFields(record, FILE_EXISTS_CONDITION_KEYS, label, filePath);
+      return {
+        kind,
+        path: readRequiredProcedureString(record.path, `${label}.path`, filePath)
+      };
+    case "path_exists":
+      rejectUnexpectedProcedureFields(record, PATH_EXISTS_CONDITION_KEYS, label, filePath);
+      return {
+        kind,
+        path: readRequiredProcedureString(record.path, `${label}.path`, filePath)
+      };
+    case "env_flag":
+      rejectUnexpectedProcedureFields(record, ENV_FLAG_CONDITION_KEYS, label, filePath);
+      return {
+        kind,
+        name: readRequiredProcedureString(record.name, `${label}.name`, filePath),
+        ...record.value !== void 0 ? { value: readRequiredProcedureString(record.value, `${label}.value`, filePath) } : {}
+      };
+    case "repo_state":
+      rejectUnexpectedProcedureFields(record, REPO_STATE_CONDITION_KEYS, label, filePath);
+      return {
+        kind,
+        value: readRequiredProcedureString(record.value, `${label}.value`, filePath)
+      };
+    case "user_confirmed":
+      rejectUnexpectedProcedureFields(record, USER_CONFIRMED_CONDITION_KEYS, label, filePath);
+      return {
+        kind,
+        value: readRequiredProcedureString(record.value, `${label}.value`, filePath)
+      };
+  }
+}
+function normalizeProcedureSources(value, label, filePath, options = {}) {
+  return readProcedureRecordArray(value, label, filePath, options).map((record, index) => normalizeProcedureSource(record, `${label}[${index}]`, filePath));
+}
+function normalizeProcedureSource(record, label, filePath) {
+  rejectUnexpectedProcedureFields(record, SOURCE_KEYS, label, filePath);
+  const kind = readProcedureSourceKind(record.kind, `${label}.kind`, filePath, PROCEDURE_SOURCE_KINDS);
+  const path3 = readOptionalProcedureString(record.path, `${label}.path`, filePath);
+  const locator = readOptionalProcedureString(record.locator, `${label}.locator`, filePath);
+  const sourceLabel = readOptionalProcedureString(record.label, `${label}.label`, filePath);
+  switch (kind) {
+    case "skill":
+    case "doc":
+    case "repo_file":
+      if (!path3) {
+        throw new Error(`Invalid procedure ${filePath}: ${label}.${kind} sources require a path.`);
+      }
+      break;
+    case "entry":
+    case "episode":
+      if (!locator) {
+        throw new Error(`Invalid procedure ${filePath}: ${label}.${kind} sources require a locator.`);
+      }
+      break;
+    case "manual":
+      if (!sourceLabel && !locator) {
+        throw new Error(`Invalid procedure ${filePath}: ${label}.manual sources require a label or locator.`);
+      }
+      break;
+  }
+  return {
+    kind,
+    ...path3 ? { path: path3 } : {},
+    ...locator ? { locator } : {},
+    ...sourceLabel ? { label: sourceLabel } : {}
+  };
+}
+
+// src/adapters/db/procedure-row-mapping.ts
+var ACTIVE_PROCEDURE_CLAUSE = "retired = 0 AND superseded_by IS NULL";
+var PROCEDURE_SELECT_COLUMNS = `
+  id,
+  procedure_key,
+  title,
+  goal,
+  body_json,
+  recall_text,
+  source_file,
+  source_hash,
+  revision_hash,
+  embedding,
+  retired,
+  retired_at,
+  retired_reason,
+  superseded_by,
+  created_at,
+  updated_at
+`;
+function buildActiveProcedureClause(alias) {
+  if (!alias) {
+    return ACTIVE_PROCEDURE_CLAUSE;
+  }
+  return `${alias}.retired = 0 AND ${alias}.superseded_by IS NULL`;
+}
+function serializeProcedureBody(procedure) {
+  return JSON.stringify(procedure);
+}
+function mapProcedureRow(row) {
+  const definition = parseProcedureBody(readRequiredString(row, "body_json"));
+  return {
+    id: readRequiredString(row, "id"),
+    procedure_key: readRequiredString(row, "procedure_key"),
+    title: readRequiredString(row, "title"),
+    goal: readRequiredString(row, "goal"),
+    when_to_use: definition.when_to_use,
+    when_not_to_use: definition.when_not_to_use,
+    prerequisites: definition.prerequisites,
+    steps: definition.steps,
+    verification: definition.verification,
+    failure_modes: definition.failure_modes,
+    sources: definition.sources,
+    recall_text: readRequiredString(row, "recall_text"),
+    revision_hash: readRequiredString(row, "revision_hash"),
+    source_hash: readRequiredString(row, "source_hash"),
+    source_file: readOptionalString(row, "source_file"),
+    embedding: readEmbedding(row, "embedding"),
+    retired: readBoolean(row, "retired"),
+    retired_at: readOptionalString(row, "retired_at"),
+    retired_reason: readOptionalString(row, "retired_reason"),
+    superseded_by: readOptionalString(row, "superseded_by"),
+    created_at: readRequiredString(row, "created_at"),
+    updated_at: readRequiredString(row, "updated_at")
+  };
+}
+function parseProcedureBody(bodyJson) {
+  let parsed;
+  try {
+    parsed = JSON.parse(bodyJson);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid procedures.body_json payload: ${message}`, {
+      cause: error
+    });
+  }
+  return normalizeProcedureDefinition(parsed, "procedures.body_json");
+}
+
+// src/adapters/db/procedure-queries.ts
+var LOOKUP_CHUNK_SIZE = 100;
+var FTS_TIERS = ["exact", "all_tokens", "any_tokens"];
+async function upsertProcedure(executor, procedure) {
+  const payload = normalizeStoredProcedure(procedure);
+  const id = payload.id.trim().length > 0 ? payload.id.trim() : randomUUID2();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const createdAt = normalizeTimestamp(payload.created_at) ?? now;
+  const updatedAt = normalizeTimestamp(payload.updated_at) ?? now;
+  const vectorJson = serializeEmbeddingForVector(payload.embedding ?? []);
+  await executor.execute({
+    sql: `
+      INSERT INTO procedures (
+        id,
+        procedure_key,
+        title,
+        goal,
+        body_json,
+        recall_text,
+        source_file,
+        source_hash,
+        revision_hash,
+        embedding,
+        retired,
+        retired_at,
+        retired_reason,
+        superseded_by,
+        created_at,
+        updated_at
+      )
+      VALUES (
+        ?, ?, ?, ?, ?, ?, ?, ?, ?,
+        CASE WHEN ? IS NULL THEN NULL ELSE vector32(?) END,
+        ?, ?, ?, ?, ?, ?
+      )
+      ON CONFLICT(id) DO UPDATE SET
+        procedure_key = excluded.procedure_key,
+        title = excluded.title,
+        goal = excluded.goal,
+        body_json = excluded.body_json,
+        recall_text = excluded.recall_text,
+        source_file = excluded.source_file,
+        source_hash = excluded.source_hash,
+        revision_hash = excluded.revision_hash,
+        embedding = excluded.embedding,
+        retired = excluded.retired,
+        retired_at = excluded.retired_at,
+        retired_reason = excluded.retired_reason,
+        superseded_by = excluded.superseded_by,
+        updated_at = excluded.updated_at
+    `,
+    args: [
+      id,
+      payload.procedure_key,
+      payload.title,
+      payload.goal,
+      serializeProcedureBody(payload.body),
+      payload.recall_text,
+      toNullableString2(payload.source_file),
+      payload.source_hash,
+      payload.revision_hash,
+      vectorJson,
+      vectorJson,
+      payload.retired ? 1 : 0,
+      toNullableString2(payload.retired_at),
+      toNullableString2(payload.retired_reason),
+      toNullableString2(payload.superseded_by),
+      createdAt,
+      updatedAt
+    ]
+  });
+  return getProcedureById(executor, id);
+}
+async function getProcedure(executor, id) {
+  const [procedure] = await hydrateProcedures(executor, [id]);
+  return procedure ?? null;
+}
+async function hydrateProcedures(executor, ids) {
+  const normalizedIds = dedupeStrings(ids);
+  if (normalizedIds.length === 0) {
+    return [];
+  }
+  const byId = /* @__PURE__ */ new Map();
+  for (const chunk of chunkValues(normalizedIds, LOOKUP_CHUNK_SIZE)) {
+    const placeholders = chunk.map(() => "?").join(", ");
+    const result = await executor.execute({
+      sql: `
+        SELECT
+          ${PROCEDURE_SELECT_COLUMNS}
+        FROM procedures
+        WHERE id IN (${placeholders})
+          AND ${ACTIVE_PROCEDURE_CLAUSE}
+      `,
+      args: chunk
+    });
+    for (const row of result.rows) {
+      const procedure = mapProcedureRow(row);
+      byId.set(procedure.id, procedure);
+    }
+  }
+  return ids.map((id) => byId.get(id.trim())).filter((procedure) => procedure !== void 0);
+}
+async function findActiveProcedureByKey(executor, procedureKey) {
+  const normalizedKey = normalizeOptionalString3(procedureKey);
+  if (!normalizedKey) {
+    return null;
+  }
+  const result = await executor.execute({
+    sql: `
+      SELECT ${PROCEDURE_SELECT_COLUMNS}
+      FROM procedures
+      WHERE procedure_key = ?
+        AND ${ACTIVE_PROCEDURE_CLAUSE}
+      LIMIT 1
+    `,
+    args: [normalizedKey]
+  });
+  const row = result.rows[0];
+  return row ? mapProcedureRow(row) : null;
+}
+async function procedureVectorSearch(executor, params) {
+  if (params.limit <= 0 || params.embedding.length === 0) {
+    return [];
+  }
+  const serializedEmbedding = serializeEmbeddingForVector(params.embedding);
+  if (!serializedEmbedding) {
+    return [];
+  }
+  let result;
+  try {
+    result = await executor.execute({
+      sql: `
+        SELECT ${prefixColumns2(PROCEDURE_SELECT_COLUMNS, "p")}
+        FROM vector_top_k('idx_procedures_embedding', vector32(?), ?) AS v
+        JOIN procedures AS p ON p.rowid = v.id
+        WHERE ${buildActiveProcedureClause("p")}
+        LIMIT ?
+      `,
+      args: [serializedEmbedding, params.limit, params.limit]
+    });
+  } catch (error) {
+    throw wrapProcedureVectorError(error);
+  }
+  return result.rows.map((row) => {
+    const procedure = mapProcedureRow(row);
+    return {
+      procedure,
+      vectorSim: cosineSimilarity(params.embedding, procedure.embedding ?? [])
+    };
+  }).filter((candidate) => candidate.vectorSim > 0).sort((left, right) => right.vectorSim - left.vectorSim).slice(0, params.limit);
+}
+async function procedureFtsSearch(executor, params) {
+  const query = normalizeOptionalString3(params.text);
+  if (!query || params.limit <= 0) {
+    return [];
+  }
+  const plan = buildLexicalPlan(query);
+  if (plan.length === 0) {
+    return [];
+  }
+  const matches = /* @__PURE__ */ new Map();
+  for (const tier of plan) {
+    let result;
+    try {
+      result = await executor.execute({
+        sql: `
+          SELECT
+            ${prefixColumns2(PROCEDURE_SELECT_COLUMNS, "p")},
+            bm25(procedures_fts, 1.0, 2.0) AS rank
+          FROM procedures_fts
+          JOIN procedures AS p ON p.rowid = procedures_fts.rowid
+          WHERE procedures_fts MATCH ?
+            AND ${buildActiveProcedureClause("p")}
+          ORDER BY bm25(procedures_fts, 1.0, 2.0)
+          LIMIT ?
+        `,
+        args: [compileLexicalTier(tier), params.limit]
+      });
+    } catch {
+      continue;
+    }
+    for (const row of result.rows) {
+      const procedure = mapProcedureRow(row);
+      if (matches.has(procedure.id)) {
+        continue;
+      }
+      matches.set(procedure.id, {
+        procedure,
+        rank: readNumber(row, "rank", Number.POSITIVE_INFINITY),
+        tier: tier.tier
+      });
+    }
+  }
+  return Array.from(matches.values()).sort(compareProcedureFtsMatches).slice(0, params.limit).map(({ procedure, rank }) => ({
+    procedure,
+    rank
+  }));
+}
+async function listProceduresWithoutEmbeddings(executor, limit) {
+  const normalizedLimit = normalizePositiveInteger2(limit);
+  const result = await executor.execute({
+    sql: `
+      SELECT ${PROCEDURE_SELECT_COLUMNS}
+      FROM procedures
+      WHERE ${ACTIVE_PROCEDURE_CLAUSE}
+        AND embedding IS NULL
+      ORDER BY created_at DESC, id ASC
+      ${normalizedLimit ? "LIMIT ?" : ""}
+    `,
+    args: normalizedLimit ? [normalizedLimit] : []
+  });
+  return result.rows.map((row) => mapProcedureRow(row));
+}
+async function updateProcedureEmbedding(executor, id, embedding) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const vectorJson = serializeEmbeddingForVector(embedding);
+  await executor.execute({
+    sql: `
+      UPDATE procedures
+      SET embedding = CASE WHEN ? IS NULL THEN NULL ELSE vector32(?) END,
+          updated_at = ?
+      WHERE id = ?
+    `,
+    args: [vectorJson, vectorJson, now, id]
+  });
+}
+async function retireProcedure(executor, id, reason) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const result = await executor.execute({
+    sql: `
+      UPDATE procedures
+      SET retired = 1,
+          retired_at = ?,
+          retired_reason = ?,
+          updated_at = ?
+      WHERE id = ?
+        AND ${ACTIVE_PROCEDURE_CLAUSE}
+    `,
+    args: [now, toNullableString2(normalizeOptionalString3(reason)), now, id]
+  });
+  return result.rowsAffected > 0;
+}
+async function supersedeProcedure(executor, oldId, newId, reason) {
+  const normalizedOldId = normalizeOptionalString3(oldId);
+  const normalizedNewId = normalizeOptionalString3(newId);
+  if (!normalizedOldId || !normalizedNewId || normalizedOldId === normalizedNewId) {
+    return false;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const result = await executor.execute({
+    sql: `
+      UPDATE procedures
+      SET superseded_by = ?,
+          retired_reason = COALESCE(?, retired_reason),
+          updated_at = ?
+      WHERE id = ?
+        AND ${ACTIVE_PROCEDURE_CLAUSE}
+    `,
+    args: [normalizedNewId, toNullableString2(normalizeOptionalString3(reason)), now, normalizedOldId]
+  });
+  return result.rowsAffected > 0;
+}
+async function getProcedureById(executor, id) {
+  const result = await executor.execute({
+    sql: `
+      SELECT ${PROCEDURE_SELECT_COLUMNS}
+      FROM procedures
+      WHERE id = ?
+      LIMIT 1
+    `,
+    args: [id]
+  });
+  const row = result.rows[0];
+  if (!row) {
+    throw new Error(`Procedure ${id} was not found after persistence.`);
+  }
+  return mapProcedureRow(row);
+}
+function normalizeStoredProcedure(procedure) {
+  const body = normalizeProcedureDefinition(
+    {
+      procedure_key: procedure.procedure_key,
+      title: procedure.title,
+      goal: procedure.goal,
+      when_to_use: procedure.when_to_use,
+      when_not_to_use: procedure.when_not_to_use,
+      prerequisites: procedure.prerequisites,
+      steps: procedure.steps,
+      verification: procedure.verification,
+      failure_modes: procedure.failure_modes,
+      sources: procedure.sources
+    },
+    "procedure write payload"
+  );
+  return {
+    ...procedure,
+    ...body,
+    body,
+    recall_text: normalizeRequiredText(procedure.recall_text, "recall_text"),
+    revision_hash: normalizeRequiredText(procedure.revision_hash, "revision_hash"),
+    source_hash: normalizeRequiredText(procedure.source_hash, "source_hash"),
+    source_file: normalizeOptionalString3(procedure.source_file),
+    retired_at: normalizeOptionalString3(procedure.retired_at),
+    retired_reason: normalizeOptionalString3(procedure.retired_reason),
+    superseded_by: normalizeOptionalString3(procedure.superseded_by),
+    embedding: normalizeEmbedding2(procedure.embedding)
+  };
+}
+function normalizeRequiredText(value, label) {
+  const normalized = normalizeOptionalString3(value);
+  if (!normalized) {
+    throw new Error(`Procedure ${label} must be a non-empty string.`);
+  }
+  return normalized;
+}
+function normalizeOptionalString3(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function normalizeTimestamp(value) {
+  return normalizeOptionalString3(value);
+}
+function normalizeEmbedding2(embedding) {
+  if (!embedding || embedding.length === 0) {
+    return void 0;
+  }
+  return embedding.map((value) => Number.isFinite(value) ? value : 0);
+}
+function normalizePositiveInteger2(value) {
+  if (value === void 0 || !Number.isFinite(value) || value <= 0) {
+    return void 0;
+  }
+  return Math.trunc(value);
+}
+function chunkValues(values, size) {
+  const chunks = [];
+  for (let index = 0; index < values.length; index += size) {
+    chunks.push(values.slice(index, index + size));
+  }
+  return chunks;
+}
+function dedupeStrings(values) {
+  return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
+}
+function prefixColumns2(columns, alias) {
+  return columns.split(",").map((column) => column.trim()).filter((column) => column.length > 0).map((column) => `${alias}.${column}`).join(", ");
+}
+function compareProcedureFtsMatches(left, right) {
+  const tierDelta = ftsTierPriority(left.tier) - ftsTierPriority(right.tier);
+  if (tierDelta !== 0) {
+    return tierDelta;
+  }
+  if (left.rank !== right.rank) {
+    return left.rank - right.rank;
+  }
+  return left.procedure.procedure_key.localeCompare(right.procedure.procedure_key);
+}
+function ftsTierPriority(tier) {
+  return FTS_TIERS.indexOf(tier);
+}
+function compileLexicalTier(tier) {
+  if (tier.tier === "exact") {
+    return `"${tier.text.replaceAll('"', '""')}"`;
+  }
+  return tier.tier === "all_tokens" ? tier.tokens.join(" ") : tier.tokens.join(" OR ");
+}
+function wrapProcedureVectorError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return new Error(`Procedure vector search is unavailable: ${message}`);
+}
+function toNullableString2(value) {
+  return value ?? null;
+}
+
 // src/adapters/db/queries.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 
 // src/core/temporal-validity.ts
 function validateTemporalValidityRange(validFrom, validTo) {
@@ -1189,13 +2003,13 @@ function normalizeOptionalTimestamp(value) {
 }
 
 // src/adapters/db/queries.ts
-var LOOKUP_CHUNK_SIZE = 100;
+var LOOKUP_CHUNK_SIZE2 = 100;
 var DEFAULT_QUALITY_SCORE2 = 0.5;
 async function insertEntry(executor, entry, embedding, contentHash) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const id = entry.id.trim().length > 0 ? entry.id.trim() : randomUUID2();
-  const createdAt = normalizeTimestamp(entry.created_at) ?? now;
-  const updatedAt = normalizeTimestamp(entry.updated_at) ?? now;
+  const id = entry.id.trim().length > 0 ? entry.id.trim() : randomUUID3();
+  const createdAt = normalizeTimestamp2(entry.created_at) ?? now;
+  const updatedAt = normalizeTimestamp2(entry.updated_at) ?? now;
   const vectorJson = serializeEmbeddingForVector(embedding);
   await executor.execute({
     sql: `
@@ -1254,37 +2068,37 @@ async function insertEntry(executor, entry, embedding, contentHash) {
       normalizeInteger(entry.importance, 0),
       entry.expiry,
       serializeTags(entry.tags),
-      normalizeOptionalString3(entry.source_file),
-      normalizeOptionalString3(entry.source_context),
+      normalizeOptionalString4(entry.source_file),
+      normalizeOptionalString4(entry.source_context),
       vectorJson,
       vectorJson,
       contentHash.trim(),
-      normalizeOptionalString3(entry.norm_content_hash),
+      normalizeOptionalString4(entry.norm_content_hash),
       null,
       normalizeNumber(entry.quality_score, DEFAULT_QUALITY_SCORE2),
       normalizeInteger(entry.recall_count, 0),
-      normalizeOptionalString3(entry.last_recalled_at),
-      normalizeOptionalString3(entry.superseded_by),
-      normalizeOptionalString3(entry.valid_from),
-      normalizeOptionalString3(entry.valid_to),
-      normalizeOptionalString3(entry.claim_key),
-      normalizeOptionalString3(entry.claim_key_raw),
-      normalizeOptionalString3(entry.claim_key_status),
-      normalizeOptionalString3(entry.claim_key_source),
+      normalizeOptionalString4(entry.last_recalled_at),
+      normalizeOptionalString4(entry.superseded_by),
+      normalizeOptionalString4(entry.valid_from),
+      normalizeOptionalString4(entry.valid_to),
+      normalizeOptionalString4(entry.claim_key),
+      normalizeOptionalString4(entry.claim_key_raw),
+      normalizeOptionalString4(entry.claim_key_status),
+      normalizeOptionalString4(entry.claim_key_source),
       normalizeOptionalNumber(entry.claim_key_confidence),
-      normalizeOptionalString3(entry.claim_key_rationale),
-      normalizeOptionalString3(entry.claim_support_source_kind),
-      normalizeOptionalString3(entry.claim_support_locator),
-      normalizeOptionalString3(entry.claim_support_observed_at),
-      normalizeOptionalString3(entry.claim_support_mode),
-      normalizeOptionalString3(entry.supersession_kind),
-      normalizeOptionalString3(entry.supersession_reason),
-      normalizeOptionalString3(entry.cluster_id),
-      normalizeOptionalString3(entry.user_id),
-      normalizeOptionalString3(entry.project),
+      normalizeOptionalString4(entry.claim_key_rationale),
+      normalizeOptionalString4(entry.claim_support_source_kind),
+      normalizeOptionalString4(entry.claim_support_locator),
+      normalizeOptionalString4(entry.claim_support_observed_at),
+      normalizeOptionalString4(entry.claim_support_mode),
+      normalizeOptionalString4(entry.supersession_kind),
+      normalizeOptionalString4(entry.supersession_reason),
+      normalizeOptionalString4(entry.cluster_id),
+      normalizeOptionalString4(entry.user_id),
+      normalizeOptionalString4(entry.project),
       entry.retired ? 1 : 0,
-      normalizeOptionalString3(entry.retired_at),
-      normalizeOptionalString3(entry.retired_reason),
+      normalizeOptionalString4(entry.retired_at),
+      normalizeOptionalString4(entry.retired_reason),
       createdAt,
       updatedAt
     ]
@@ -1292,12 +2106,12 @@ async function insertEntry(executor, entry, embedding, contentHash) {
   return id;
 }
 async function getEntries(executor, ids) {
-  const normalizedIds = dedupeStrings(ids);
+  const normalizedIds = dedupeStrings2(ids);
   if (normalizedIds.length === 0) {
     return [];
   }
   const byId = /* @__PURE__ */ new Map();
-  for (const chunk of chunkValues(normalizedIds, LOOKUP_CHUNK_SIZE)) {
+  for (const chunk of chunkValues2(normalizedIds, LOOKUP_CHUNK_SIZE2)) {
     const placeholders = chunk.map(() => "?").join(", ");
     const result = await executor.execute({
       sql: `
@@ -1321,12 +2135,12 @@ async function getEntry(executor, id) {
   return entry ?? null;
 }
 async function findExistingHashes(executor, hashes) {
-  const normalizedHashes = dedupeStrings(hashes);
+  const normalizedHashes = dedupeStrings2(hashes);
   if (normalizedHashes.length === 0) {
     return /* @__PURE__ */ new Set();
   }
   const matches = /* @__PURE__ */ new Set();
-  for (const chunk of chunkValues(normalizedHashes, LOOKUP_CHUNK_SIZE)) {
+  for (const chunk of chunkValues2(normalizedHashes, LOOKUP_CHUNK_SIZE2)) {
     const placeholders = chunk.map(() => "?").join(", ");
     const result = await executor.execute({
       sql: `
@@ -1344,12 +2158,12 @@ async function findExistingHashes(executor, hashes) {
   return matches;
 }
 async function findExistingNormHashes(executor, hashes) {
-  const normalizedHashes = dedupeStrings(hashes);
+  const normalizedHashes = dedupeStrings2(hashes);
   if (normalizedHashes.length === 0) {
     return /* @__PURE__ */ new Set();
   }
   const matches = /* @__PURE__ */ new Set();
-  for (const chunk of chunkValues(normalizedHashes, LOOKUP_CHUNK_SIZE)) {
+  for (const chunk of chunkValues2(normalizedHashes, LOOKUP_CHUNK_SIZE2)) {
     const placeholders = chunk.map(() => "?").join(", ");
     const result = await executor.execute({
       sql: `
@@ -1378,7 +2192,7 @@ async function retireEntry(executor, id, reason) {
       WHERE id = ?
         AND ${ACTIVE_ENTRY_CLAUSE}
     `,
-    args: [now, normalizeOptionalString3(reason), now, id]
+    args: [now, normalizeOptionalString4(reason), now, id]
   });
   return result.rowsAffected > 0;
 }
@@ -1412,7 +2226,7 @@ async function supersedeEntry(executor, oldId, newId, kind, reason) {
       WHERE id = ?
         AND ${ACTIVE_ENTRY_CLAUSE}
     `,
-    args: [normalizedNewId, normalizeOptionalString3(kind) ?? "update", normalizeOptionalString3(reason), now, normalizedOldId]
+    args: [normalizedNewId, normalizeOptionalString4(kind) ?? "update", normalizeOptionalString4(reason), now, normalizedOldId]
   });
   return result.rowsAffected > 0;
 }
@@ -1552,25 +2366,25 @@ async function updateEntry(executor, id, fields, options) {
     assignments.push("claim_support_observed_at = ?");
     assignments.push("claim_support_mode = ?");
     args.push(
-      normalizeOptionalString3(lifecycleUpdate.claim_key),
-      normalizeOptionalString3(lifecycleUpdate.claim_key_raw),
-      normalizeOptionalString3(lifecycleUpdate.claim_key_status),
-      normalizeOptionalString3(lifecycleUpdate.claim_key_source),
+      normalizeOptionalString4(lifecycleUpdate.claim_key),
+      normalizeOptionalString4(lifecycleUpdate.claim_key_raw),
+      normalizeOptionalString4(lifecycleUpdate.claim_key_status),
+      normalizeOptionalString4(lifecycleUpdate.claim_key_source),
       normalizeOptionalNumber(lifecycleUpdate.claim_key_confidence),
-      normalizeOptionalString3(lifecycleUpdate.claim_key_rationale),
-      normalizeOptionalString3(lifecycleUpdate.claim_support_source_kind),
-      normalizeOptionalString3(lifecycleUpdate.claim_support_locator),
-      normalizeTimestamp(lifecycleUpdate.claim_support_observed_at),
-      normalizeOptionalString3(lifecycleUpdate.claim_support_mode)
+      normalizeOptionalString4(lifecycleUpdate.claim_key_rationale),
+      normalizeOptionalString4(lifecycleUpdate.claim_support_source_kind),
+      normalizeOptionalString4(lifecycleUpdate.claim_support_locator),
+      normalizeTimestamp2(lifecycleUpdate.claim_support_observed_at),
+      normalizeOptionalString4(lifecycleUpdate.claim_support_mode)
     );
   }
   if (fields.valid_from !== void 0) {
     assignments.push("valid_from = ?");
-    args.push(normalizeOptionalString3(fields.valid_from));
+    args.push(normalizeOptionalString4(fields.valid_from));
   }
   if (fields.valid_to !== void 0) {
     assignments.push("valid_to = ?");
-    args.push(normalizeOptionalString3(fields.valid_to));
+    args.push(normalizeOptionalString4(fields.valid_to));
   }
   if (assignments.length === 0) {
     return false;
@@ -1636,7 +2450,7 @@ async function recordRecallEvent(executor, entryId, query, sessionKey) {
       )
       VALUES (?, ?, ?, ?, ?)
     `,
-    args: [randomUUID2(), entryId, query, normalizeOptionalString3(sessionKey), now]
+    args: [randomUUID3(), entryId, query, normalizeOptionalString4(sessionKey), now]
   });
 }
 async function getIngestLogEntry(executor, filePath) {
@@ -1676,25 +2490,25 @@ async function insertIngestLogEntry(executor, filePath, fileHash, entryCount) {
     args: [filePath, fileHash, (/* @__PURE__ */ new Date()).toISOString(), normalizeInteger(entryCount, 0)]
   });
 }
-function dedupeStrings(values) {
+function dedupeStrings2(values) {
   return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
 }
-function chunkValues(values, size) {
+function chunkValues2(values, size) {
   const chunks = [];
   for (let index = 0; index < values.length; index += size) {
     chunks.push(values.slice(index, index + size));
   }
   return chunks;
 }
-function normalizeOptionalString3(value) {
+function normalizeOptionalString4(value) {
   if (value === void 0) {
     return null;
   }
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : null;
 }
-function normalizeTimestamp(value) {
-  return normalizeOptionalString3(value);
+function normalizeTimestamp2(value) {
+  return normalizeOptionalString4(value);
 }
 function normalizeOptionalNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
@@ -1721,9 +2535,10 @@ function normalizeInteger(value, fallback) {
 }
 
 // src/adapters/db/schema.ts
-var SCHEMA_VERSION = "9";
+var SCHEMA_VERSION = "10";
 var VECTOR_INDEX_NAME = "idx_entries_embedding";
 var EPISODE_VECTOR_INDEX_NAME = "idx_episodes_embedding";
+var PROCEDURE_VECTOR_INDEX_NAME = "idx_procedures_embedding";
 var BULK_WRITE_STATE_META_KEY = "bulk_write_state";
 var LAST_BULK_INGEST_META_KEY = "last_bulk_ingest_at";
 var CREATE_ENTRIES_TABLE_SQL = `
@@ -1839,6 +2654,59 @@ var CREATE_EPISODES_TABLE_SQL = `
     updated_at TEXT NOT NULL
   )
 `;
+var CREATE_PROCEDURES_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS procedures (
+    id TEXT PRIMARY KEY,
+    procedure_key TEXT NOT NULL,
+    title TEXT NOT NULL,
+    goal TEXT NOT NULL,
+    body_json TEXT NOT NULL,
+    recall_text TEXT NOT NULL,
+    source_file TEXT,
+    source_hash TEXT NOT NULL,
+    revision_hash TEXT NOT NULL,
+    embedding F32_BLOB(1024),
+    retired INTEGER NOT NULL DEFAULT 0,
+    retired_at TEXT,
+    retired_reason TEXT,
+    superseded_by TEXT REFERENCES procedures(id),
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  )
+`;
+var CREATE_PROCEDURES_FTS_TABLE_SQL = `
+  CREATE VIRTUAL TABLE IF NOT EXISTS procedures_fts USING fts5(
+    title,
+    recall_text,
+    content=procedures,
+    content_rowid=rowid
+  )
+`;
+var CREATE_PROCEDURES_FTS_INSERT_TRIGGER_SQL = `
+  CREATE TRIGGER IF NOT EXISTS procedures_ai AFTER INSERT ON procedures
+  WHEN new.retired = 0 AND new.superseded_by IS NULL BEGIN
+    INSERT INTO procedures_fts(rowid, title, recall_text)
+    VALUES (new.rowid, new.title, new.recall_text);
+  END
+`;
+var CREATE_PROCEDURES_FTS_DELETE_TRIGGER_SQL = `
+  CREATE TRIGGER IF NOT EXISTS procedures_ad AFTER DELETE ON procedures
+  WHEN old.retired = 0 AND old.superseded_by IS NULL BEGIN
+    INSERT INTO procedures_fts(procedures_fts, rowid, title, recall_text)
+    VALUES ('delete', old.rowid, old.title, old.recall_text);
+  END
+`;
+var CREATE_PROCEDURES_FTS_UPDATE_TRIGGER_SQL = `
+  CREATE TRIGGER IF NOT EXISTS procedures_au AFTER UPDATE ON procedures BEGIN
+    INSERT INTO procedures_fts(procedures_fts, rowid, title, recall_text)
+    SELECT 'delete', old.rowid, old.title, old.recall_text
+    WHERE old.retired = 0 AND old.superseded_by IS NULL;
+
+    INSERT INTO procedures_fts(rowid, title, recall_text)
+    SELECT new.rowid, new.title, new.recall_text
+    WHERE new.retired = 0 AND new.superseded_by IS NULL;
+  END
+`;
 var CREATE_RECALL_EVENTS_TABLE_SQL = `
   CREATE TABLE IF NOT EXISTS recall_events (
     id TEXT PRIMARY KEY,
@@ -2006,6 +2874,32 @@ var CREATE_EPISODES_SOURCE_SOURCE_ID_UNIQUE_INDEX_SQL = `
   ON episodes(source, source_id)
   WHERE source_id IS NOT NULL
 `;
+var CREATE_PROCEDURES_PROCEDURE_KEY_INDEX_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_procedures_procedure_key
+  ON procedures(procedure_key)
+`;
+var CREATE_PROCEDURES_REVISION_HASH_INDEX_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_procedures_revision_hash
+  ON procedures(revision_hash)
+`;
+var CREATE_PROCEDURES_SOURCE_HASH_INDEX_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_procedures_source_hash
+  ON procedures(source_hash)
+`;
+var CREATE_PROCEDURES_RETIRED_INDEX_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_procedures_retired
+  ON procedures(retired)
+`;
+var CREATE_PROCEDURES_CREATED_AT_INDEX_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_procedures_created_at
+  ON procedures(created_at)
+`;
+var CREATE_PROCEDURES_ACTIVE_KEY_UNIQUE_INDEX_SQL = `
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_procedures_active_procedure_key
+  ON procedures(procedure_key)
+  WHERE retired = 0
+    AND superseded_by IS NULL
+`;
 var CREATE_RECALL_EVENTS_ENTRY_ID_INDEX_SQL = `
   CREATE INDEX IF NOT EXISTS idx_recall_events_entry_id
   ON recall_events(entry_id)
@@ -2040,6 +2934,19 @@ var CREATE_EPISODES_EMBEDDING_INDEX_SQL = `
     AND retired = 0
     AND superseded_by IS NULL
 `;
+var CREATE_PROCEDURES_EMBEDDING_INDEX_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_procedures_embedding ON procedures (
+    libsql_vector_idx(
+      embedding,
+      'metric=cosine',
+      'compress_neighbors=float8',
+      'max_neighbors=50'
+    )
+  )
+  WHERE embedding IS NOT NULL
+    AND retired = 0
+    AND superseded_by IS NULL
+`;
 var SCHEMA_STATEMENTS = [
   CREATE_ENTRIES_TABLE_SQL,
   CREATE_ENTRIES_FTS_TABLE_SQL,
@@ -2048,6 +2955,11 @@ var SCHEMA_STATEMENTS = [
   CREATE_ENTRIES_FTS_UPDATE_TRIGGER_SQL,
   CREATE_INGEST_LOG_TABLE_SQL,
   CREATE_EPISODES_TABLE_SQL,
+  CREATE_PROCEDURES_TABLE_SQL,
+  CREATE_PROCEDURES_FTS_TABLE_SQL,
+  CREATE_PROCEDURES_FTS_INSERT_TRIGGER_SQL,
+  CREATE_PROCEDURES_FTS_DELETE_TRIGGER_SQL,
+  CREATE_PROCEDURES_FTS_UPDATE_TRIGGER_SQL,
   CREATE_RECALL_EVENTS_TABLE_SQL,
   CREATE_SURGEON_RUNS_TABLE_SQL,
   CREATE_SURGEON_RUN_ACTIONS_TABLE_SQL,
@@ -2076,6 +2988,12 @@ var SCHEMA_STATEMENTS = [
   CREATE_EPISODES_SOURCE_ID_INDEX_SQL,
   CREATE_EPISODES_RETIRED_INDEX_SQL,
   CREATE_EPISODES_SOURCE_SOURCE_ID_UNIQUE_INDEX_SQL,
+  CREATE_PROCEDURES_PROCEDURE_KEY_INDEX_SQL,
+  CREATE_PROCEDURES_REVISION_HASH_INDEX_SQL,
+  CREATE_PROCEDURES_SOURCE_HASH_INDEX_SQL,
+  CREATE_PROCEDURES_RETIRED_INDEX_SQL,
+  CREATE_PROCEDURES_CREATED_AT_INDEX_SQL,
+  CREATE_PROCEDURES_ACTIVE_KEY_UNIQUE_INDEX_SQL,
   CREATE_RECALL_EVENTS_ENTRY_ID_INDEX_SQL,
   CREATE_RECALL_EVENTS_RECALLED_AT_INDEX_SQL
 ];
@@ -2099,7 +3017,12 @@ async function initSchema(db) {
     await migrateV8ToV9(db);
     currentVersion = "9";
   }
+  if (currentVersion === "9") {
+    await migrateV9ToV10(db);
+    currentVersion = "10";
+  }
   const hadEntriesFts = await tableExists(db, "entries_fts");
+  const hadProceduresFts = await tableExists(db, "procedures_fts");
   for (const statement of SCHEMA_STATEMENTS) {
     await db.execute(statement);
   }
@@ -2115,13 +3038,13 @@ async function initSchema(db) {
     await finalizeBulkWrites(db);
     return;
   }
-  if (currentVersion !== SCHEMA_VERSION || !hadEntriesFts) {
+  if (currentVersion !== SCHEMA_VERSION || !hadEntriesFts || !hadProceduresFts) {
     await rebuildFts(db);
   }
   await ensureVectorIndexes(db);
 }
 async function assertSupportedSchemaState(db, currentVersion) {
-  if (currentVersion && currentVersion !== "5" && currentVersion !== "6" && currentVersion !== "7" && currentVersion !== "8" && currentVersion !== SCHEMA_VERSION) {
+  if (currentVersion && currentVersion !== "5" && currentVersion !== "6" && currentVersion !== "7" && currentVersion !== "8" && currentVersion !== "9" && currentVersion !== SCHEMA_VERSION) {
     throw new Error(
       `Unsupported agenr database schema version "${currentVersion}". This build only supports schema version ${SCHEMA_VERSION}. Create a fresh database with \`agenr db reset\` or manually migrate the data into a new database.`
     );
@@ -2207,8 +3130,22 @@ async function migrateV8ToV9(db) {
   }
   await db.execute(CREATE_SURGEON_RUN_PROPOSALS_REVIEW_STATUS_INDEX_SQL);
 }
+async function migrateV9ToV10(db) {
+  await db.execute(CREATE_PROCEDURES_TABLE_SQL);
+  await db.execute(CREATE_PROCEDURES_FTS_TABLE_SQL);
+  await db.execute(CREATE_PROCEDURES_FTS_INSERT_TRIGGER_SQL);
+  await db.execute(CREATE_PROCEDURES_FTS_DELETE_TRIGGER_SQL);
+  await db.execute(CREATE_PROCEDURES_FTS_UPDATE_TRIGGER_SQL);
+  await db.execute(CREATE_PROCEDURES_PROCEDURE_KEY_INDEX_SQL);
+  await db.execute(CREATE_PROCEDURES_REVISION_HASH_INDEX_SQL);
+  await db.execute(CREATE_PROCEDURES_SOURCE_HASH_INDEX_SQL);
+  await db.execute(CREATE_PROCEDURES_RETIRED_INDEX_SQL);
+  await db.execute(CREATE_PROCEDURES_CREATED_AT_INDEX_SQL);
+  await db.execute(CREATE_PROCEDURES_ACTIVE_KEY_UNIQUE_INDEX_SQL);
+}
 async function rebuildFts(db) {
   await db.execute("INSERT INTO entries_fts(entries_fts) VALUES ('rebuild')");
+  await db.execute("INSERT INTO procedures_fts(procedures_fts) VALUES ('rebuild')");
 }
 async function prepareBulkWrites(db) {
   await runImmediateTransaction(db, async () => {
@@ -2223,6 +3160,9 @@ async function prepareBulkWrites(db) {
     await db.execute("DROP TRIGGER IF EXISTS entries_ai");
     await db.execute("DROP TRIGGER IF EXISTS entries_ad");
     await db.execute("DROP TRIGGER IF EXISTS entries_au");
+    await db.execute("DROP TRIGGER IF EXISTS procedures_ai");
+    await db.execute("DROP TRIGGER IF EXISTS procedures_ad");
+    await db.execute("DROP TRIGGER IF EXISTS procedures_au");
     await dropVectorIndexes(db);
   });
 }
@@ -2231,6 +3171,9 @@ async function finalizeBulkWrites(db) {
     await db.execute(CREATE_ENTRIES_FTS_INSERT_TRIGGER_SQL);
     await db.execute(CREATE_ENTRIES_FTS_DELETE_TRIGGER_SQL);
     await db.execute(CREATE_ENTRIES_FTS_UPDATE_TRIGGER_SQL);
+    await db.execute(CREATE_PROCEDURES_FTS_INSERT_TRIGGER_SQL);
+    await db.execute(CREATE_PROCEDURES_FTS_DELETE_TRIGGER_SQL);
+    await db.execute(CREATE_PROCEDURES_FTS_UPDATE_TRIGGER_SQL);
     await rebuildFts(db);
     await ensureVectorIndexes(db);
     await db.execute({
@@ -2316,6 +3259,7 @@ async function ensureVectorIndexes(db) {
   try {
     await db.execute(CREATE_ENTRIES_EMBEDDING_INDEX_SQL);
     await db.execute(CREATE_EPISODES_EMBEDDING_INDEX_SQL);
+    await db.execute(CREATE_PROCEDURES_EMBEDDING_INDEX_SQL);
   } catch (error) {
     if (!isVectorUnavailableError(error)) {
       throw error;
@@ -2326,6 +3270,7 @@ async function dropVectorIndexes(db) {
   try {
     await db.execute(`DROP INDEX IF EXISTS ${VECTOR_INDEX_NAME}`);
     await db.execute(`DROP INDEX IF EXISTS ${EPISODE_VECTOR_INDEX_NAME}`);
+    await db.execute(`DROP INDEX IF EXISTS ${PROCEDURE_VECTOR_INDEX_NAME}`);
   } catch (error) {
     if (!isVectorUnavailableError(error)) {
       throw error;
@@ -2416,6 +3361,46 @@ var LibsqlDatabase = class _LibsqlDatabase {
   async updateEpisodeEmbedding(id, embedding) {
     await updateEpisodeEmbedding(this.executor, id, embedding);
   }
+  /** Inserts or updates one procedure revision row. */
+  async upsertProcedure(procedure) {
+    return upsertProcedure(this.executor, procedure);
+  }
+  /** Loads one active procedure by primary key. */
+  async getProcedure(id) {
+    return getProcedure(this.executor, id);
+  }
+  /** Hydrates active procedures by ID while preserving caller order. */
+  async hydrateProcedures(ids) {
+    return hydrateProcedures(this.executor, ids);
+  }
+  /** Loads one active procedure revision by stable procedure key. */
+  async findActiveProcedureByKey(procedureKey) {
+    return findActiveProcedureByKey(this.executor, procedureKey);
+  }
+  /** Finds active procedures by vector similarity. */
+  async procedureVectorSearch(params) {
+    return procedureVectorSearch(this.executor, params);
+  }
+  /** Finds active procedures by lexical FTS search. */
+  async procedureFtsSearch(params) {
+    return procedureFtsSearch(this.executor, params);
+  }
+  /** Lists active procedures that still need embeddings. */
+  async listProceduresWithoutEmbeddings(limit) {
+    return listProceduresWithoutEmbeddings(this.executor, limit);
+  }
+  /** Updates only the embedding payload for one procedure row. */
+  async updateProcedureEmbedding(id, embedding) {
+    await updateProcedureEmbedding(this.executor, id, embedding);
+  }
+  /** Marks one active procedure revision as retired. */
+  async retireProcedure(id, reason) {
+    return retireProcedure(this.executor, id, reason);
+  }
+  /** Marks one active procedure revision as superseded by a newer revision. */
+  async supersedeProcedure(oldId, newId, reason) {
+    return supersedeProcedure(this.executor, oldId, newId, reason);
+  }
   /** Finds which normalized content hashes already exist in storage. */
   async findExistingNormHashes(hashes) {
     return findExistingNormHashes(this.executor, hashes);
@@ -2530,7 +3515,7 @@ import path2 from "path";
 import { fileURLToPath } from "url";
 
 // src/adapters/shared/validation.ts
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function pushIssue(issues, path3, message) {
@@ -2765,7 +3750,7 @@ function normalizeAgenrConfig(value, options) {
       }
     };
   }
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     return {
       ok: false,
       issues: [{ path: "config", message: "Expected a JSON object." }]
@@ -2884,7 +3869,7 @@ function parseCredentials(value, path3, issues) {
   if (value === void 0) {
     return void 0;
   }
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     pushIssue(issues, path3, "Expected an object.");
     return void 0;
   }
@@ -2907,7 +3892,7 @@ function parseModelConfig(value, path3, issues) {
   if (value === void 0) {
     return void 0;
   }
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     pushIssue(issues, path3, "Expected an object.");
     return void 0;
   }
@@ -2933,7 +3918,7 @@ function parseClaimExtractionConfig(value, path3, issues) {
       resolved: defaults
     };
   }
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     pushIssue(issues, path3, "Expected an object.");
     return {
       resolved: defaults
@@ -2978,7 +3963,7 @@ function parseSurgeonConfig(value, path3, issues) {
       resolved: defaults
     };
   }
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     pushIssue(issues, path3, "Expected an object.");
     return {
       resolved: defaults
@@ -3030,7 +4015,7 @@ function parseRetirementPassConfig(value, path3, issues) {
       resolved: defaults
     };
   }
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     pushIssue(issues, path3, "Expected an object.");
     return {
       resolved: defaults
@@ -3047,7 +4032,7 @@ function parseRetirementPassConfig(value, path3, issues) {
       resolved: defaults
     };
   }
-  if (!isRecord(retirement)) {
+  if (!isRecord2(retirement)) {
     pushIssue(issues, `${path3}.retirement`, "Expected an object.");
     return {
       resolved: defaults
@@ -3221,11 +4206,11 @@ function resolveConfigDir() {
   return process.env.AGENR_CONFIG_DIR ?? DEFAULT_CONFIG_DIR;
 }
 function resolveConfigPath(options = {}) {
-  const envConfigPath = normalizeOptionalString4(process.env.AGENR_CONFIG_PATH);
+  const envConfigPath = normalizeOptionalString5(process.env.AGENR_CONFIG_PATH);
   if (envConfigPath) {
     return envConfigPath;
   }
-  const explicitConfigPath = normalizeOptionalString4(options.configPath);
+  const explicitConfigPath = normalizeOptionalString5(options.configPath);
   if (explicitConfigPath) {
     return explicitConfigPath;
   }
@@ -3236,7 +4221,7 @@ function resolveConfigPath(options = {}) {
   return path2.join(resolveConfigDir(), "config.json");
 }
 function resolveDbPath(config) {
-  return normalizeOptionalString4(process.env.AGENR_DB_PATH) ?? normalizeOptionalString4(config?.dbPath) ?? resolvePersistedDefaultDbPath();
+  return normalizeOptionalString5(process.env.AGENR_DB_PATH) ?? normalizeOptionalString5(config?.dbPath) ?? resolvePersistedDefaultDbPath();
 }
 function resolveClaimExtractionConfig(config) {
   if (config && "enabled" in (config.claimExtraction ?? {})) {
@@ -3327,7 +4312,7 @@ function writeConfig(config, options = {}) {
   }
 }
 function resolveAdjacentConfigPath(dbPath) {
-  const normalizedDbPath = normalizeOptionalString4(dbPath);
+  const normalizedDbPath = normalizeOptionalString5(dbPath);
   if (!normalizedDbPath || normalizedDbPath === ":memory:") {
     return void 0;
   }
@@ -3340,7 +4325,7 @@ function resolveAdjacentConfigPath(dbPath) {
   }
   return path2.join(path2.dirname(normalizedDbPath), "config.json");
 }
-function normalizeOptionalString4(value) {
+function normalizeOptionalString5(value) {
   const normalized = value?.trim();
   return normalized && normalized.length > 0 ? normalized : void 0;
 }
@@ -3358,7 +4343,7 @@ function resolvePersistedDefaultDbPath() {
   return path2.join(resolveConfigDir(), DEFAULT_DB_NAME);
 }
 function resolveReadDefaultDbPath(options) {
-  return normalizeOptionalString4(process.env.AGENR_DB_PATH) ?? normalizeOptionalString4(options.dbPath) ?? resolvePersistedDefaultDbPath();
+  return normalizeOptionalString5(process.env.AGENR_DB_PATH) ?? normalizeOptionalString5(options.dbPath) ?? resolvePersistedDefaultDbPath();
 }
 function formatConfigValidationError(configPath, issues) {
   const details = issues.map((issue) => `${issue.path}: ${issue.message}`).join("; ");
@@ -3405,7 +4390,7 @@ async function embedTexts(texts, apiKey, model) {
   if (texts.length === 0) {
     return [];
   }
-  const chunks = chunkValues2(texts, EMBEDDING_BATCH_SIZE);
+  const chunks = chunkValues3(texts, EMBEDDING_BATCH_SIZE);
   const chunkResults = new Array(chunks.length);
   let nextChunkIndex = 0;
   await Promise.all(
@@ -3525,7 +4510,7 @@ function getErrorSnippet(rawBody) {
   const maxLength = 200;
   return trimmed.length <= maxLength ? trimmed : `${trimmed.slice(0, maxLength)}...`;
 }
-function chunkValues2(values, chunkSize) {
+function chunkValues3(values, chunkSize) {
   const chunks = [];
   for (let index = 0; index < values.length; index += chunkSize) {
     chunks.push(values.slice(index, index + chunkSize));
@@ -3558,7 +4543,7 @@ var RECALL_CANDIDATE_SELECT_COLUMNS = `
   e.retired,
   e.created_at
 `;
-var FTS_TIERS = ["exact", "all_tokens", "any_tokens"];
+var FTS_TIERS2 = ["exact", "all_tokens", "any_tokens"];
 var PREDECESSOR_EXPANSION_LIMIT_PER_SEED = 8;
 var PREDECESSOR_EXPANSION_MAX_RESULTS = 40;
 function createRecallAdapter(executor, embeddingPort) {
@@ -3625,7 +4610,7 @@ var LibsqlRecallAdapter = class {
     const filters = buildEntryFilterClause(params.filters, "e");
     const matches = /* @__PURE__ */ new Map();
     for (const tier of plan) {
-      const query = compileLexicalTier(tier);
+      const query = compileLexicalTier2(tier);
       let result;
       try {
         result = await this.executor.execute({
@@ -3814,16 +4799,16 @@ function normalizeStrings(values) {
   return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
 }
 function compareFtsCandidates(left, right) {
-  const tierDelta = ftsTierPriority(left.tier) - ftsTierPriority(right.tier);
+  const tierDelta = ftsTierPriority2(left.tier) - ftsTierPriority2(right.tier);
   if (tierDelta !== 0) {
     return tierDelta;
   }
   return left.rank - right.rank;
 }
-function ftsTierPriority(tier) {
-  return FTS_TIERS.indexOf(tier);
+function ftsTierPriority2(tier) {
+  return FTS_TIERS2.indexOf(tier);
 }
-function compileLexicalTier(tier) {
+function compileLexicalTier2(tier) {
   if (tier.tier === "exact") {
     return `"${tier.text.replaceAll('"', '""')}"`;
   }
@@ -3893,7 +4878,7 @@ function flattenClaimCentricRecallFamilies(families) {
 }
 function projectClaimCentricRecallEntry(recall2, options = {}) {
   const entry = recall2.entry;
-  const claimKey = normalizeOptionalString5(entry.claim_key);
+  const claimKey = normalizeOptionalString6(entry.claim_key);
   const familyKey = claimKey ?? `entry:${entry.id}`;
   const slotPolicy = resolveClaimSlotPolicy(claimKey, options.slotPolicyConfig).policy;
   const asOfResolution = buildAsOfResolution(recall2, options.asOf);
@@ -3919,38 +4904,38 @@ function resolveMemoryState(recall2, asOfResolution) {
       if (asOfResolution.relation === "active") {
         return "current";
       }
-      return normalizeOptionalString5(entry.superseded_by) ? "superseded" : "historical";
+      return normalizeOptionalString6(entry.superseded_by) ? "superseded" : "historical";
     }
     if (asOfResolution.relation === "observed_after" || asOfResolution.relation === "created_after") {
       return "historical";
     }
-    if (normalizeOptionalString5(entry.superseded_by)) {
+    if (normalizeOptionalString6(entry.superseded_by)) {
       return "superseded";
     }
-    if (entry.retired || normalizeOptionalString5(entry.valid_to)) {
+    if (entry.retired || normalizeOptionalString6(entry.valid_to)) {
       return "historical";
     }
     return "current";
   }
-  if (normalizeOptionalString5(entry.superseded_by)) {
+  if (normalizeOptionalString6(entry.superseded_by)) {
     return "superseded";
   }
-  if (entry.retired || normalizeOptionalString5(entry.valid_to)) {
+  if (entry.retired || normalizeOptionalString6(entry.valid_to)) {
     return "historical";
   }
   return "current";
 }
 function resolveClaimStatus(recall2) {
   const entry = recall2.entry;
-  if (!normalizeOptionalString5(entry.claim_key)) {
+  if (!normalizeOptionalString6(entry.claim_key)) {
     return "no_key";
   }
   return entry.claim_key_status ?? "legacy";
 }
 function buildFreshness(recall2, memoryState, asOfResolution) {
   const entry = recall2.entry;
-  const validFrom = normalizeOptionalString5(entry.valid_from);
-  const validTo = normalizeOptionalString5(entry.valid_to);
+  const validFrom = normalizeOptionalString6(entry.valid_from);
+  const validTo = normalizeOptionalString6(entry.valid_to);
   const createdAt = entry.created_at;
   const labelParts = [`created ${createdAt}`];
   if (validFrom || validTo) {
@@ -3978,12 +4963,12 @@ function buildFreshness(recall2, memoryState, asOfResolution) {
 function buildProvenance(recall2) {
   const entry = recall2.entry;
   return {
-    ...normalizeOptionalString5(entry.superseded_by) ? { supersededById: entry.superseded_by } : {},
-    ...normalizeOptionalString5(entry.supersession_kind) ? { supersessionKind: entry.supersession_kind } : {},
-    ...normalizeOptionalString5(entry.supersession_reason) ? { supersessionReason: entry.supersession_reason } : {},
-    ...normalizeOptionalString5(entry.claim_support_source_kind) ? { supportSourceKind: entry.claim_support_source_kind } : {},
-    ...normalizeOptionalString5(entry.claim_support_locator) ? { supportLocator: entry.claim_support_locator } : {},
-    ...normalizeOptionalString5(entry.claim_support_observed_at) ? { supportObservedAt: entry.claim_support_observed_at } : {},
+    ...normalizeOptionalString6(entry.superseded_by) ? { supersededById: entry.superseded_by } : {},
+    ...normalizeOptionalString6(entry.supersession_kind) ? { supersessionKind: entry.supersession_kind } : {},
+    ...normalizeOptionalString6(entry.supersession_reason) ? { supersessionReason: entry.supersession_reason } : {},
+    ...normalizeOptionalString6(entry.claim_support_source_kind) ? { supportSourceKind: entry.claim_support_source_kind } : {},
+    ...normalizeOptionalString6(entry.claim_support_locator) ? { supportLocator: entry.claim_support_locator } : {},
+    ...normalizeOptionalString6(entry.claim_support_observed_at) ? { supportObservedAt: entry.claim_support_observed_at } : {},
     ...entry.claim_support_mode ? { supportMode: entry.claim_support_mode } : {}
   };
 }
@@ -4019,12 +5004,12 @@ function buildWhySurfaced(recall2, asOfResolution) {
 function formatScore(value) {
   return value.toFixed(2);
 }
-function normalizeOptionalString5(value) {
+function normalizeOptionalString6(value) {
   const normalized = value?.trim();
   return normalized && normalized.length > 0 ? normalized : void 0;
 }
 function buildAsOfResolution(recall2, asOf) {
-  const normalizedAsOf = normalizeOptionalString5(asOf);
+  const normalizedAsOf = normalizeOptionalString6(asOf);
   if (!normalizedAsOf) {
     return void 0;
   }
@@ -4088,7 +5073,7 @@ function formatAsOfRelation(relation) {
   }
 }
 function parseTimestamp(value) {
-  const normalized = normalizeOptionalString5(value);
+  const normalized = normalizeOptionalString6(value);
   if (!normalized) {
     return void 0;
   }
@@ -4585,7 +5570,7 @@ async function searchEpisodes(query, database, now = /* @__PURE__ */ new Date())
   if (limit === 0) {
     return [];
   }
-  const normalizedEmbedding = normalizeEmbedding2(query.embedding);
+  const normalizedEmbedding = normalizeEmbedding3(query.embedding);
   const bounds = query.timeWindow ? resolveTemporalWindowBounds(query.timeWindow, now) : null;
   const hasTemporal = bounds !== null;
   const hasSemantic = normalizedEmbedding.length > 0;
@@ -4618,7 +5603,7 @@ function normalizeLimit(value) {
 function computeCandidateLimit(limit) {
   return Math.min(Math.max(limit * CANDIDATE_MULTIPLIER, MIN_CANDIDATE_LIMIT), MAX_CANDIDATE_LIMIT);
 }
-function normalizeEmbedding2(embedding) {
+function normalizeEmbedding3(embedding) {
   if (!embedding || embedding.length === 0) {
     return [];
   }
@@ -4668,6 +5653,156 @@ function compareAscending2(left, right) {
   return left.localeCompare(right);
 }
 
+// src/app/procedures/recall/service.ts
+var DEFAULT_LIMIT2 = 5;
+var DEFAULT_CANONICAL_THRESHOLD = 0.55;
+var DEFAULT_CANONICAL_MARGIN = 0.08;
+var LEXICAL_CANDIDATE_MULTIPLIER = 3;
+var VECTOR_CANDIDATE_MULTIPLIER = 4;
+var VECTOR_ONLY_CANONICAL_FLOOR = 0.6;
+var LEXICAL_ONLY_NOTICE = "Semantic procedure search unavailable - using lexical-only procedure ranking.";
+var LEXICAL_ONLY_FALLBACK_NOTICE = "Semantic procedure search failed during procedure recall - using lexical-only procedure ranking.";
+async function runProcedureRecall(input, deps) {
+  const text = input.text.trim();
+  const limit = normalizeLimit2(input.limit);
+  if (text.length === 0 || limit === 0) {
+    return {
+      candidates: [],
+      notices: []
+    };
+  }
+  const lexicalLimit = limit * LEXICAL_CANDIDATE_MULTIPLIER;
+  const vectorLimit = limit * VECTOR_CANDIDATE_MULTIPLIER;
+  const notices = [];
+  const lexicalMatches = await deps.db.procedureFtsSearch({
+    text,
+    limit: lexicalLimit
+  });
+  const queryEmbedding = await maybeEmbedQuery(text, deps.embedQuery, notices);
+  const vectorMatches = queryEmbedding.length > 0 ? await deps.db.procedureVectorSearch({
+    embedding: queryEmbedding,
+    limit: vectorLimit
+  }).catch(() => {
+    notices.push(LEXICAL_ONLY_FALLBACK_NOTICE);
+    return [];
+  }) : [];
+  const ranked = rankProcedureCandidates(text, lexicalMatches, vectorMatches).slice(0, limit);
+  const canonicalProcedure = selectCanonicalProcedure(ranked, input.threshold);
+  return {
+    ...canonicalProcedure ? { canonicalProcedure } : {},
+    candidates: ranked,
+    notices: dedupePreservingOrder(notices)
+  };
+}
+async function maybeEmbedQuery(text, embedQuery, notices) {
+  if (!embedQuery) {
+    notices.push(LEXICAL_ONLY_NOTICE);
+    return [];
+  }
+  try {
+    const embedding = await embedQuery(text);
+    if (embedding.length === 0) {
+      notices.push(LEXICAL_ONLY_NOTICE);
+      return [];
+    }
+    return embedding;
+  } catch {
+    notices.push(LEXICAL_ONLY_FALLBACK_NOTICE);
+    return [];
+  }
+}
+function rankProcedureCandidates(query, lexicalMatches, vectorMatches) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const match of lexicalMatches) {
+    const lexical = computeProcedureLexicalScore(query, match.procedure);
+    merged.set(match.procedure.id, {
+      procedure: match.procedure,
+      lexical,
+      vector: 0
+    });
+  }
+  for (const match of vectorMatches) {
+    const existing = merged.get(match.procedure.id);
+    merged.set(match.procedure.id, {
+      procedure: match.procedure,
+      lexical: existing?.lexical ?? computeProcedureLexicalScore(query, match.procedure),
+      vector: Math.max(existing?.vector ?? 0, match.vectorSim)
+    });
+  }
+  return Array.from(merged.values()).map((candidate) => {
+    const relevance = combinedRelevance(candidate.vector, candidate.lexical);
+    return {
+      procedure: candidate.procedure,
+      score: relevance,
+      scores: {
+        relevance,
+        lexical: candidate.lexical,
+        vector: candidate.vector
+      }
+    };
+  }).filter((candidate) => candidate.score > 0).sort(compareProcedureCandidates);
+}
+function computeProcedureLexicalScore(query, procedure) {
+  return computeLexicalScore(query, procedure.title, procedure.recall_text);
+}
+function selectCanonicalProcedure(ranked, threshold) {
+  const leader = ranked[0];
+  if (!leader) {
+    return void 0;
+  }
+  const minimumScore = normalizeThreshold(threshold);
+  if (leader.score < minimumScore) {
+    return void 0;
+  }
+  if (leader.scores.lexical === 0 && leader.scores.vector < VECTOR_ONLY_CANONICAL_FLOOR) {
+    return void 0;
+  }
+  const runnerUp = ranked[1];
+  if (runnerUp && leader.score - runnerUp.score < DEFAULT_CANONICAL_MARGIN) {
+    return void 0;
+  }
+  return leader.procedure;
+}
+function compareProcedureCandidates(left, right) {
+  if (left.score !== right.score) {
+    return right.score - left.score;
+  }
+  if (left.scores.lexical !== right.scores.lexical) {
+    return right.scores.lexical - left.scores.lexical;
+  }
+  if (left.scores.vector !== right.scores.vector) {
+    return right.scores.vector - left.scores.vector;
+  }
+  if (left.procedure.updated_at !== right.procedure.updated_at) {
+    return right.procedure.updated_at.localeCompare(left.procedure.updated_at);
+  }
+  return left.procedure.procedure_key.localeCompare(right.procedure.procedure_key);
+}
+function normalizeLimit2(value) {
+  if (value === void 0 || !Number.isFinite(value)) {
+    return DEFAULT_LIMIT2;
+  }
+  return Math.max(0, Math.trunc(value));
+}
+function normalizeThreshold(value) {
+  if (value === void 0 || !Number.isFinite(value)) {
+    return DEFAULT_CANONICAL_THRESHOLD;
+  }
+  return Math.min(1, Math.max(0, value));
+}
+function dedupePreservingOrder(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const value of values) {
+    if (seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    deduped.push(value);
+  }
+  return deduped;
+}
+
 // src/app/recall/transitions.ts
 function buildClaimTransitionExplanations(params) {
   if (params.families.length === 0 || params.detectedIntent === "temporal_narrative") {
@@ -4754,7 +5889,7 @@ function selectEpisodeContext(family, episodes) {
 var EPISODE_FRESHNESS_NOTICE = "Episodes cover consolidated prior sessions only; the most recent completed session may not appear yet.";
 var EPISODE_SEMANTIC_FALLBACK_NOTICE = "Semantic episode search unavailable - showing temporal results only.";
 var EPISODE_SEMANTIC_UNAVAILABLE_NOTICE = "Semantic episode search unavailable - no semantic episode results could be returned.";
-var ENTRY_FILTER_NOTICE = "Threshold, type filters, and tag filters were applied to entries only.";
+var ENTRY_FILTER_NOTICE = "Type and tag filters were applied to entries only.";
 var HISTORICAL_STATE_PATTERNS = [
   "what was the previous",
   "what was the earlier",
@@ -4775,6 +5910,35 @@ var HISTORICAL_STATE_REGEX_PATTERNS = [
   /\bwhat\b.*\bplan\b.*\bearlier\b/u,
   /\bwhat\b.*\bplan\b.*\bbefore\b/u
 ];
+var PROCEDURAL_PATTERNS = [
+  "how do i",
+  "how should i",
+  "how can i",
+  "what steps",
+  "which steps",
+  "walk me through",
+  "guide me through",
+  "step by step",
+  "step-by-step",
+  "checklist for",
+  "process for",
+  "procedure for",
+  "method for",
+  "instructions for",
+  "best way to",
+  "recommended way to"
+];
+var PROCEDURAL_REGEX_PATTERNS = [
+  /\bhow (?:do|should|can) (?:i|we)\b/u,
+  /\bhow to\b/u,
+  /\bwhat (?:are the )?steps\b/u,
+  /\bwhich steps\b/u,
+  /\bwalk me through\b/u,
+  /\bguide me through\b/u,
+  /\bstep(?: |-)?by(?: |-)?step\b/u,
+  /\b(?:checklist|playbook|runbook|procedure|process|instructions?|workflow|method)\b.*\b(?:for|to)\b/u,
+  /\bwhat(?:'s| is) the (?:best|recommended|right) way to\b/u
+];
 async function runUnifiedRecall(input, deps) {
   const now = deps.now ?? /* @__PURE__ */ new Date();
   const requested = normalizeMode(input.mode);
@@ -4782,9 +5946,13 @@ async function runUnifiedRecall(input, deps) {
   const hasEntryFilters = hasEntryScopedFilters(input);
   const topicAnchor = hasTopicAnchor(input.text, hasEntryFilters);
   const historicalStatePattern = detectHistoricalStatePattern(input.text);
+  const proceduralPattern = detectProceduralPattern(input.text);
   if (historicalStatePattern) {
     deps.debugLog?.(`[agenr] unified recall matched historical-state pattern=${JSON.stringify(historicalStatePattern)} query=${JSON.stringify(input.text)}`);
   }
+  if (proceduralPattern) {
+    deps.debugLog?.(`[agenr] unified recall matched procedural pattern=${JSON.stringify(proceduralPattern)} query=${JSON.stringify(input.text)}`);
+  }
   const routing = routeRecall({
     requested,
     text: input.text,
@@ -4811,6 +5979,20 @@ async function runUnifiedRecall(input, deps) {
   if (routing.queried.includes("episodes") && hasEntryScopedFilters(input)) {
     notices.push(ENTRY_FILTER_NOTICE);
   }
+  const procedureResults = routing.queried.includes("procedures") ? await runProcedureRecall(
+    {
+      text: input.text,
+      ...input.limit !== void 0 ? { limit: input.limit } : {},
+      ...input.threshold !== void 0 ? { threshold: input.threshold } : {}
+    },
+    {
+      db: deps.procedures,
+      ...deps.embedQuery ? { embedQuery: deps.embedQuery } : {}
+    }
+  ) : {
+    candidates: [],
+    notices: []
+  };
   const entries = await maybeRunEntryRecall({
     input,
     deps,
@@ -4846,13 +6028,16 @@ async function runUnifiedRecall(input, deps) {
       }
     } : {},
     ...input.asOf ? { asOf: input.asOf.trim() } : {},
+    ...procedureResults.canonicalProcedure ? { procedure: procedureResults.canonicalProcedure } : {},
+    procedureCandidates: procedureResults.candidates,
+    procedureNotices: dedupePreservingOrder2(procedureResults.notices),
     episodes,
     entries: rawEntries,
     projectedEntries,
     entryFamilies,
     claimTransitions,
-    notices: dedupePreservingOrder(notices),
-    count: episodes.length + rawEntries.length
+    notices: dedupePreservingOrder2(notices),
+    count: procedureResults.candidates.length + episodes.length + rawEntries.length
   };
 }
 function routeRecall(params) {
@@ -4860,6 +6045,7 @@ function routeRecall(params) {
   const factual = /^(when did|when was|what decision|what preference|what(?:'s| is) the default|which version|what threshold)\b/.test(lower);
   const narrative = /\b(what happened|what were we doing|what was going on|summarize|catch me up)\b/.test(lower);
   const historicalState = detectHistoricalStatePattern(params.text) !== void 0;
+  const procedural = detectProceduralPattern(params.text) !== void 0;
   const topicAnchor = hasTopicAnchor(params.text, params.hasEntryFilters);
   if (params.requested === "entries") {
     return {
@@ -4877,20 +6063,60 @@ function routeRecall(params) {
       reason: params.parsedTimeWindow ? "Explicit mode=episodes override with a resolved time window." : "Explicit mode=episodes override without a resolved time window."
     };
   }
+  if (params.requested === "procedures") {
+    return {
+      requested: params.requested,
+      detectedIntent: "procedural",
+      queried: ["procedures"],
+      reason: "Explicit mode=procedures override."
+    };
+  }
   if (historicalState) {
     return {
       requested: params.requested,
       detectedIntent: "historical_state",
-      queried: ["entries", "episodes"],
-      reason: params.parsedTimeWindow ? "The query asks about a previous state or transition and includes a supported time expression, so both entries and episodes were queried." : "The query asks about a previous state or transition, so both entries and episodes were queried."
+      queried: procedural ? ["procedures", "entries", "episodes"] : ["entries", "episodes"],
+      reason: params.parsedTimeWindow ? procedural ? "The query asks for steps around a previous state or transition and includes a supported time expression, so procedures, entries, and episodes were queried." : "The query asks about a previous state or transition and includes a supported time expression, so both entries and episodes were queried." : procedural ? "The query asks for steps around a previous state or transition, so procedures, entries, and episodes were queried." : "The query asks about a previous state or transition, so both entries and episodes were queried."
     };
   }
   if (factual && params.parsedTimeWindow) {
     return {
       requested: params.requested,
       detectedIntent: "mixed",
-      queried: ["entries", "episodes"],
-      reason: "The query combines a factual phrase with a supported time expression, so both entries and episodes were queried."
+      queried: procedural ? ["procedures", "entries", "episodes"] : ["entries", "episodes"],
+      reason: procedural ? "The query combines a procedural ask with factual and time-based signals, so procedures, entries, and episodes were queried." : "The query combines a factual phrase with a supported time expression, so both entries and episodes were queried."
+    };
+  }
+  if (procedural && params.parsedTimeWindow && topicAnchor) {
+    return {
+      requested: params.requested,
+      detectedIntent: "mixed",
+      queried: ["procedures", "episodes", "entries"],
+      reason: "The query asks for steps, includes a supported time expression, and names a topic anchor, so procedures were queried first with supporting episodes and entries."
+    };
+  }
+  if (procedural && params.parsedTimeWindow) {
+    return {
+      requested: params.requested,
+      detectedIntent: "mixed",
+      queried: ["procedures", "episodes"],
+      reason: "The query asks for steps and includes a supported time expression, so procedures were queried first with supporting episodes."
+    };
+  }
+  if (procedural && topicAnchor) {
+    return {
+      requested: params.requested,
+      detectedIntent: "mixed",
+      queried: ["procedures", "entries"],
+      reason: "The query asks for steps and includes a topic anchor, so procedures were queried first with supporting entries."
+    };
+  }
+  if (procedural) {
+    return {
+      requested: params.requested,
+      detectedIntent: "procedural",
+      queried: ["procedures"],
+      reason: "The query asks how to do something or requests a step-by-step method, so procedure recall was used first."
     };
   }
   if (factual) {
@@ -5027,11 +6253,20 @@ function detectHistoricalStatePattern(text) {
   const regexPattern = HISTORICAL_STATE_REGEX_PATTERNS.find((pattern) => pattern.test(lower));
   return regexPattern?.source;
 }
+function detectProceduralPattern(text) {
+  const lower = text.trim().toLowerCase();
+  const explicitPattern = PROCEDURAL_PATTERNS.find((pattern) => lower.includes(pattern));
+  if (explicitPattern) {
+    return explicitPattern;
+  }
+  const regexPattern = PROCEDURAL_REGEX_PATTERNS.find((pattern) => pattern.test(lower));
+  return regexPattern?.source;
+}
 function normalizeMode(value) {
-  return value === "entries" || value === "episodes" ? value : "auto";
+  return value === "entries" || value === "episodes" || value === "procedures" ? value : "auto";
 }
 function hasEntryScopedFilters(input) {
-  return Boolean(input.threshold !== void 0 || hasNonEmptyArray(input.types) || hasNonEmptyArray(input.tags));
+  return Boolean(hasNonEmptyArray(input.types) || hasNonEmptyArray(input.tags));
 }
 function hasNonEmptyArray(value) {
   return Array.isArray(value) && value.length > 0;
@@ -5051,7 +6286,7 @@ async function maybeEmbedEpisodeQuery(text, embedQuery) {
     return void 0;
   }
 }
-function dedupePreservingOrder(values) {
+function dedupePreservingOrder2(values) {
   const seen = /* @__PURE__ */ new Set();
   const deduped = [];
   for (const value of values) {
@@ -5101,6 +6336,8 @@ export {
   readNumber,
   readBoolean,
   mapEntryRow,
+  parseAndNormalizeProcedureYaml,
+  normalizeProcedureDefinition,
   validateTemporalValidityRange,
   insertEntry,
   getEntry,
@@ -5110,7 +6347,7 @@ export {
   VECTOR_INDEX_NAME,
   getLastBulkIngestAt,
   createDatabase,
-  isRecord,
+  isRecord2 as isRecord,
   pushIssue,
   pushUnexpectedFields,
   parseRequiredTrimmedString,