haansi 0.1.45 → 0.1.46

package/dist/haansi.js

@@ -95,7 +95,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "haansi",
-      version: "0.1.45",
+      version: "0.1.46",
       description: "Haansi CLI - Session collector and MCP server for Claude Code & OpenAI Codex",
       bin: {
         haansi: "./dist/haansi.js"
@@ -958,12 +958,24 @@ function normKey(key) {
 function isSensitiveKey(key) {
   return SENSITIVE_KEY_RE.test(normKey(key));
 }
+function isUserContentKey(key) {
+  return USER_CONTENT_KEY_RE.test(normKey(key));
+}
+function redactUserContent(value) {
+  if (typeof value === "string") return `[REDACTED ${value.length} chars]`;
+  if (Array.isArray(value)) return `[REDACTED ${value.length} items]`;
+  if (value === null || value === void 0) return value;
+  if (typeof value === "object") return "[REDACTED]";
+  return value;
+}
 function sanitizeMetadata(obj, depth = 0) {
   if (depth > 5) return obj;
   const result = {};
   for (const [k, v] of Object.entries(obj)) {
     if (isSensitiveKey(k)) {
       result[k] = "[REDACTED]";
+    } else if (isUserContentKey(k)) {
+      result[k] = redactUserContent(v);
     } else if (v !== null && typeof v === "object" && !Array.isArray(v) && !(v instanceof Date)) {
       result[k] = sanitizeMetadata(v, depth + 1);
     } else {
@@ -972,6 +984,17 @@ function sanitizeMetadata(obj, depth = 0) {
   }
   return result;
 }
+function causeForFirstLine(metadata) {
+  const error2 = metadata?.error;
+  const raw = typeof error2 === "string" ? error2 : error2 && typeof error2 === "object" ? error2.message : void 0;
+  if (typeof raw !== "string") return "";
+  const text = raw.replace(/\s+/g, " ").trim();
+  if (!text) return "";
+  const name = error2 && typeof error2 === "object" ? error2.name : void 0;
+  const kind = typeof name === "string" && name && name !== "Error" ? `${name}: ` : "";
+  const words = text.length > FIRST_LINE_CAUSE_CHARS ? `${text.slice(0, FIRST_LINE_CAUSE_CHARS - 1)}\u2026` : text;
+  return ` \u2014 ${kind}${words}`;
+}
 function normalizeErrorMetadata(error2, metadata) {
   if (!error2) return metadata;
   if (error2 instanceof Error) {
@@ -998,7 +1021,7 @@ function createLogger(serviceName, projectId) {
     projectId === null ? void 0 : projectId || process.env.GCP_PROJECT_ID
   );
 }
-var import_async_hooks, _cloudBackend, SENSITIVE_KEY_RE, traceStorage, StructuredLogger, TraceContext;
+var import_async_hooks, _cloudBackend, SENSITIVE_KEY_RE, USER_CONTENT_KEY_RE, FIRST_LINE_CAUSE_CHARS, traceStorage, StructuredLogger, TraceContext;
 var init_logger = __esm({
   "../../packages/@company/observability/src/logger.ts"() {
     "use strict";
@@ -1006,6 +1029,8 @@ var init_logger = __esm({
     init_esm_node();
     init_types();
     SENSITIVE_KEY_RE = /^(password|passwd|secret|token|apikey|authorization|auth|authtoken|authkey|credentials?|connectionstring|privatekey)$/;
+    USER_CONTENT_KEY_RE = /^(question|questiontext|query|querytext|q|searchquery|searchtext|searchterm|searchterms|userquery|prompt|userprompt|usermessage|messagetext|messagecontent)$/;
+    FIRST_LINE_CAUSE_CHARS = 300;
     traceStorage = new import_async_hooks.AsyncLocalStorage();
     StructuredLogger = class {
       serviceName;
@@ -1061,7 +1086,7 @@ var init_logger = __esm({
         const traceInfo = entry2.traceId ? ` [trace: ${entry2.traceId.slice(0, 8)}]` : "";
         const orgInfo = entry2.organizationId ? ` [org: ${entry2.organizationId.slice(0, 8)}]` : "";
         const prefix = `[${timestamp}] [${entry2.severity}] [${this.serviceName}]${traceInfo}${orgInfo}`;
-        const message = `${prefix} ${entry2.message}`;
+        const message = `${prefix} ${entry2.message}${causeForFirstLine(entry2.metadata)}`;
         const metadata = entry2.metadata ? `
 ${JSON.stringify(entry2.metadata, null, 2)}` : "";
         switch (entry2.severity) {
@@ -1699,6 +1724,22 @@ var init_scaling_metrics = __esm({
         treatMissingData: "breaching",
         missingDataRationale: "The reconciler is the only publisher and runs on a schedule independent of every worker. Its silence means the reconciler itself is broken, and the backlog it was watching is unobserved rather than empty. Scaling out against an unknown backlog wastes money; scaling in loses the queue. Breaching keeps capacity up until a human looks."
       }),
+      MINING_REPLAYS_IN_PROGRESS: spec({
+        name: "haansi/mining/replays_in_progress",
+        unit: "Count",
+        description: "Orgs whose mining is held by a re-run (hard reset or re-mine): organization_mining_config.rerun_in_progress.",
+        dimensions: ["environment"],
+        treatMissingData: "breaching",
+        missingDataRationale: "A re-run embeds and classifies every event through Presidio and the embedders, but it is not request-driven, so nothing else marks those services busy while it runs. Silence means the reconciler failed, not that no re-run is running; breaching keeps them awake."
+      }),
+      REPLAY_PENDING_EVENTS: spec({
+        name: "haansi/replay/pending_events",
+        unit: "Count",
+        description: "source_events a RUNNING re-run (live hard-reset lease) has yet to replay, past its watermark, all orgs.",
+        dimensions: ["environment"],
+        treatMissingData: "breaching",
+        missingDataRationale: "A re-run embeds every event inline through the batch embedders, but those rows are already normalized and never become claims, so neither backlog_rows nor claims_pending nor canonical_backlog_events can see the demand: one TEI task served a whole re-run at ~1 s/text (dev 2026-10-06). This is the only publisher of that demand; silence means it is unobserved, not finished. Breaching keeps the embedders up."
+      }),
       CANONICAL_BACKLOG_OLDEST_SECONDS: spec({
         name: "haansi/ingestion/canonical_backlog_oldest_seconds",
         unit: "Seconds",
@@ -2130,11 +2171,19 @@ var init_detect = __esm({
   }
 });
 
+// ../../packages/@company/encryption/src/org-binding.ts
+var init_org_binding = __esm({
+  "../../packages/@company/encryption/src/org-binding.ts"() {
+    "use strict";
+  }
+});
+
 // ../../packages/@company/encryption/src/org-keys.ts
 var DEK_CACHE_TTL_MS, DEK_CACHE_MAX, HKDF_SALT;
 var init_org_keys = __esm({
   "../../packages/@company/encryption/src/org-keys.ts"() {
     "use strict";
+    init_org_binding();
     DEK_CACHE_TTL_MS = Number(
       process.env.ORG_DEK_CACHE_TTL_MS ?? 10 * 6e4
     );
@@ -16363,6 +16412,98 @@ var init_redis_client = __esm({
   }
 });
 
+// ../../packages/@company/security/src/service-delegation.ts
+var ORG, SERVICE_INTELLIGENCE_RULES;
+var init_service_delegation = __esm({
+  "../../packages/@company/security/src/service-delegation.ts"() {
+    "use strict";
+    ORG = "[0-9a-fA-F-]{36}";
+    SERVICE_INTELLIGENCE_RULES = [
+      {
+        caller: "service-capture",
+        method: "POST",
+        path: /^\/ingest$/,
+        action: "ingest"
+      },
+      ...["service-capture", "service-pipeline", "api"].map(
+        (caller) => ({
+          caller,
+          method: "POST",
+          path: /^\/replay$/,
+          action: "replay"
+        })
+      ),
+      {
+        caller: "api",
+        method: "GET",
+        path: new RegExp(`^/replay/${ORG}$`),
+        action: "replay.read"
+      },
+      { caller: "api", method: "GET", path: /^\/replays$/, action: "replay.read" },
+      {
+        caller: "api",
+        method: "POST",
+        path: /^\/quiesce$/,
+        action: "mining.quiesce"
+      },
+      {
+        caller: "api",
+        method: "POST",
+        path: /^\/resume$/,
+        action: "mining.resume"
+      },
+      {
+        caller: "service-pipeline",
+        method: "POST",
+        path: /^\/cron\/[a-z-]+$/,
+        action: "cron"
+      },
+      {
+        caller: "api",
+        method: "POST",
+        path: new RegExp(`^/processes/refresh-stats/${ORG}$`),
+        action: "processes.refresh"
+      },
+      {
+        caller: "api",
+        method: "GET",
+        path: new RegExp(`^/mining-config/${ORG}$`),
+        action: "mining-config.read"
+      },
+      {
+        caller: "api",
+        method: "PATCH",
+        path: new RegExp(`^/mining-config/${ORG}$`),
+        action: "mining-config.write"
+      },
+      {
+        caller: "api",
+        method: "POST",
+        path: /^\/graph\/connections$/,
+        action: "graph.connections"
+      },
+      {
+        caller: "api",
+        method: "POST",
+        path: /^\/on-integration$/,
+        action: "integration.connected"
+      },
+      {
+        caller: "api",
+        method: "POST",
+        path: /^\/debug\/classify-preview$/,
+        action: "debug.classify"
+      },
+      {
+        caller: "api",
+        method: "GET",
+        path: new RegExp(`^/diagnostics/${ORG}$`),
+        action: "diagnostics.read"
+      }
+    ];
+  }
+});
+
 // ../../packages/@company/security/src/index.ts
 var init_src3 = __esm({
   "../../packages/@company/security/src/index.ts"() {
@@ -16372,6 +16513,7 @@ var init_src3 = __esm({
     init_rate_limiter();
     init_in_process_rate_limiter();
     init_redis_client();
+    init_service_delegation();
   }
 });
 
@@ -16384,6 +16526,7 @@ var init_decrypt_rows = __esm({
     init_src2();
     init_detect();
     init_org_keys();
+    init_org_binding();
     obs2 = createObservabilityService("decrypt-rows");
   }
 });
@@ -16416,6 +16559,14 @@ var init_encrypt_write = __esm({
     init_column_registry();
     init_jsonb_leaf_policy();
     init_hmac();
+    init_org_binding();
+  }
+});
+
+// ../../packages/@company/encryption/src/write-refusal.ts
+var init_write_refusal = __esm({
+  "../../packages/@company/encryption/src/write-refusal.ts"() {
+    "use strict";
   }
 });
 
@@ -16434,22 +16585,43 @@ var init_exclusions = __esm({
   }
 });
 
+// ../../packages/@company/encryption/src/audit.ts
+var init_audit = __esm({
+  "../../packages/@company/encryption/src/audit.ts"() {
+    "use strict";
+    init_detect();
+    init_jsonb_leaf_policy();
+  }
+});
+
+// ../../packages/@company/encryption/src/rebind.ts
+var init_rebind = __esm({
+  "../../packages/@company/encryption/src/rebind.ts"() {
+    "use strict";
+    init_detect();
+    init_org_keys();
+  }
+});
+
 // ../../packages/@company/encryption/src/org-encryption-service.ts
 var init_org_encryption_service = __esm({
   "../../packages/@company/encryption/src/org-encryption-service.ts"() {
     "use strict";
     init_src3();
     init_org_keys();
+    init_org_binding();
   }
 });
 
 // ../../packages/@company/encryption/src/install-org-key-warmer.ts
-var WARM_TTL_MS;
+var import_node_async_hooks, WARM_TTL_MS, warmingInThisChain;
 var init_install_org_key_warmer = __esm({
   "../../packages/@company/encryption/src/install-org-key-warmer.ts"() {
     "use strict";
+    import_node_async_hooks = require("node:async_hooks");
     init_org_keys();
     WARM_TTL_MS = Number(process.env.ORG_KEY_WARM_TTL_MS ?? 5 * 6e4);
+    warmingInThisChain = new import_node_async_hooks.AsyncLocalStorage();
   }
 });
 
@@ -16461,6 +16633,14 @@ var init_provision_hook = __esm({
   }
 });
 
+// ../../packages/@company/encryption/src/org-data-key-wrapper.ts
+var init_org_data_key_wrapper = __esm({
+  "../../packages/@company/encryption/src/org-data-key-wrapper.ts"() {
+    "use strict";
+    init_org_encryption_service();
+  }
+});
+
 // ../../packages/@company/encryption/src/index.ts
 var init_src4 = __esm({
   "../../packages/@company/encryption/src/index.ts"() {
@@ -16472,13 +16652,18 @@ var init_src4 = __esm({
     init_decrypt_rows();
     init_encrypt_write();
     init_write_plan();
+    init_write_refusal();
     init_jsonb_leaf_policy();
     init_read_gate();
     init_exclusions();
+    init_audit();
     init_org_keys();
+    init_org_binding();
+    init_rebind();
     init_org_encryption_service();
     init_install_org_key_warmer();
     init_provision_hook();
+    init_org_data_key_wrapper();
   }
 });
 
@@ -21545,12 +21730,23 @@ var init_listener_connection = __esm({
   }
 });
 
+// ../../packages/@company/db/src/release-after-callback.ts
+var observability3;
+var init_release_after_callback = __esm({
+  "../../packages/@company/db/src/release-after-callback.ts"() {
+    "use strict";
+    init_src2();
+    observability3 = createObservabilityService("db-release-after-callback");
+  }
+});
+
 // ../../packages/@company/db/src/byod/routed-pool.ts
 var logger, ROUTED_TENANT_CONTEXT, ROUTED_TENANT_RAW_POOL, ADMITTED_TENANT_CONTEXT;
 var init_routed_pool = __esm({
   "../../packages/@company/db/src/byod/routed-pool.ts"() {
     "use strict";
     init_src2();
+    init_release_after_callback();
     logger = createLogger("db-byod-routed-pool");
     ROUTED_TENANT_CONTEXT = Symbol.for("haansi.db.routedTenantContext");
     ROUTED_TENANT_RAW_POOL = Symbol.for("haansi.db.routedTenantRawPool");
@@ -21559,18 +21755,28 @@ var init_routed_pool = __esm({
 });
 
 // ../../packages/@company/db/src/org-context.ts
-var observability3, DECRYPTING_CLIENT;
+var observability4, DECRYPTING_CLIENT;
 var init_org_context = __esm({
   "../../packages/@company/db/src/org-context.ts"() {
     "use strict";
     init_src4();
     init_src2();
     init_routed_pool();
-    observability3 = createObservabilityService("db-org-context");
+    init_release_after_callback();
+    observability4 = createObservabilityService("db-org-context");
     DECRYPTING_CLIENT = Symbol.for("haansi.db.decryptingClient");
   }
 });
 
+// ../../packages/@company/db/src/admin-pools.ts
+var init_admin_pools = __esm({
+  "../../packages/@company/db/src/admin-pools.ts"() {
+    "use strict";
+    init_client();
+    init_org_context();
+  }
+});
+
 // ../../packages/@company/types/src/timeline.ts
 var init_timeline = __esm({
   "../../packages/@company/types/src/timeline.ts"() {
@@ -21578,6 +21784,13 @@ var init_timeline = __esm({
   }
 });
 
+// ../../packages/@company/types/src/qna.ts
+var init_qna = __esm({
+  "../../packages/@company/types/src/qna.ts"() {
+    "use strict";
+  }
+});
+
 // ../../packages/@company/types/src/artifact.ts
 var init_artifact = __esm({
   "../../packages/@company/types/src/artifact.ts"() {
@@ -21706,10 +21919,10 @@ var init_taxonomy = __esm({
         category: "report",
         label: "Onboarding Guide",
         description: "Onboarding guide (or legacy onboarding packet) built from selected team knowledge. Served only after its sources are checked for the viewer; read and written only by the onboarding guide service.",
-        icon: "GraduationCap",
+        icon: "Sprout",
         aliases: ["onboarding_packet", "onboarding-packet"],
         autoApproved: false,
-        producedBy: ["POST /api/v1/memory/reports/onboarding"],
+        producedBy: ["POST /api/v1/memory/onboarding/guides/:id/generate"],
         // docs/product/plans/2026-09-24-onboarding-guides.md D11: no generic
         // reader or writer may touch a guide.
         reserved: true
@@ -21721,7 +21934,9 @@ var init_taxonomy = __esm({
         icon: "GitPullRequest",
         aliases: ["pr_context", "pr-context"],
         autoApproved: true,
-        producedBy: ["POST /api/v1/memory/reports/pr"]
+        // PR generation is parked until workstream-backed context retrieval exists.
+        // producedBy: ["POST /api/v1/memory/reports/pr"],
+        producedBy: []
       },
       expert: {
         category: "expert",
@@ -21752,6 +21967,18 @@ var init_taxonomy = __esm({
         autoApproved: true,
         producedBy: ["POST /api/v1/memory/recall/messages/:id/feedback"]
       },
+      skill: {
+        category: "solution",
+        label: "Skill",
+        description: "Reusable, agent-loadable procedure in SKILL.md form, skillified from mined solutions or imported. One immutable revision per row; lifecycle and access live in the skills tables and are applied only by the skill service.",
+        icon: "Wand2",
+        aliases: ["skills", "playbook"],
+        autoApproved: false,
+        producedBy: [],
+        // docs/product/plans/2026-10-10-memory-skills.md §3.1: no generic reader
+        // or writer may touch a skill revision.
+        reserved: true
+      },
       digest_entry: {
         category: "digest",
         label: "Digest Entry",
@@ -21842,16 +22069,825 @@ var init_report_template = __esm({
   }
 });
 
+// ../../packages/@company/types/src/mining-config-fields.ts
+var MINING_FIELDS, MINING_PARAMETER_FIELDS, MINING_BUILTIN_DEFAULTS, MINING_FIELDS_BY_KEY;
+var init_mining_config_fields = __esm({
+  "../../packages/@company/types/src/mining-config-fields.ts"() {
+    "use strict";
+    MINING_FIELDS = [
+      {
+        key: "matcher_mode",
+        camel: "matcherMode",
+        label: "Matcher mode",
+        kind: "select",
+        group: "matcher",
+        options: ["heuristic", "classifier"],
+        help: "Heuristic score vs the trained event-pair classifier. Classifier requires a version.",
+        platformDefault: false
+      },
+      {
+        key: "classifier_name",
+        camel: "classifierName",
+        label: "Classifier model",
+        kind: "text",
+        group: "classifier",
+        help: "Model name served by ml-inference (default event-pair-classifier)."
+      },
+      {
+        key: "pair_cap_graph",
+        camel: "pairCapGraph",
+        label: "Pair candidates \u2014 graph",
+        kind: "number",
+        group: "sampling",
+        min: 0,
+        max: 1e3,
+        integer: true,
+        help: "Candidate pairs sampled per feedback event from graph neighbours. Raising it produces more labels per event and a denser training set; lowering it keeps materialization cheap.",
+        default: 4
+      },
+      {
+        key: "pair_cap_temporal",
+        camel: "pairCapTemporal",
+        label: "Pair candidates \u2014 temporal",
+        kind: "number",
+        group: "sampling",
+        min: 0,
+        max: 1e3,
+        integer: true,
+        help: "Candidate pairs sampled per feedback event from temporal neighbours.",
+        default: 4
+      },
+      {
+        key: "pair_cap_object",
+        camel: "pairCapObject",
+        label: "Pair candidates \u2014 object",
+        kind: "number",
+        group: "sampling",
+        min: 0,
+        max: 1e3,
+        integer: true,
+        help: "Candidate pairs sampled per feedback event from shared-object neighbours.",
+        default: 4
+      },
+      {
+        key: "pair_cap_random",
+        camel: "pairCapRandom",
+        label: "Pair candidates \u2014 random",
+        kind: "number",
+        group: "sampling",
+        min: 0,
+        max: 1e3,
+        integer: true,
+        help: "Random candidate pairs per feedback event. These are the cheap negatives that keep the model from learning only from near-misses.",
+        default: 2
+      },
+      {
+        key: "test_component_size_guard",
+        camel: "testComponentSizeGuard",
+        label: "Holdout component size guard",
+        kind: "number",
+        group: "sampling",
+        min: 1,
+        help: "How much larger than its quota a connected component may be and still be taken for test or golden. Holdout allocation moves whole components, so without a ceiling one oversized component can swallow the training set. Raising it makes holdouts easier to fill on a corpus where labels have fused into few large components; lowering it protects train.",
+        default: 5
+      },
+      {
+        key: "min_new_labels",
+        camel: "minNewLabels",
+        label: "Retrain \u2014 min new labels (any split)",
+        kind: "number",
+        group: "sampling",
+        min: 0,
+        max: 1e6,
+        integer: true,
+        help: "Cheap pre-filter before the TRAIN-split floors are evaluated: this many new labels of any kind must have landed since the last completed run. The train-specific floors below are what actually decide whether a retrain is worth running.",
+        default: 50
+      },
+      {
+        key: "min_new_train_labels",
+        camel: "minNewTrainLabels",
+        label: "Retrain \u2014 min new train labels",
+        kind: "number",
+        group: "sampling",
+        min: 0,
+        max: 1e6,
+        integer: true,
+        help: "New TRAIN-split labels required before a retrain is queued. Deliberately separate from materialization, which drains feedback continuously \u2014 new eval/test rows change what a run is measured on, not what it can learn from, so they never trigger one. Mirrors the floor the trainer itself enforces, so the trigger does not enqueue runs the trainer will reject.",
+        default: 400
+      },
+      {
+        key: "min_new_train_positive",
+        camel: "minNewTrainPositive",
+        label: "Retrain \u2014 min new positives",
+        kind: "number",
+        group: "sampling",
+        min: 0,
+        max: 1e6,
+        integer: true,
+        help: "New TRAIN positives required before a retrain is queued.",
+        default: 200
+      },
+      {
+        key: "min_new_train_negative",
+        camel: "minNewTrainNegative",
+        label: "Retrain \u2014 min new negatives",
+        kind: "number",
+        group: "sampling",
+        min: 0,
+        max: 1e6,
+        integer: true,
+        help: "New TRAIN negatives required before a retrain is queued. Negatives are usually the scarce side, so this is the floor most likely to gate retraining.",
+        default: 30
+      },
+      {
+        key: "retrain_growth_fraction",
+        camel: "retrainGrowthFraction",
+        label: "Retrain \u2014 growth fraction",
+        kind: "number",
+        group: "sampling",
+        min: 0,
+        max: 1,
+        help: "Extra new TRAIN data required, as a fraction of what the LAST COMPLETED run trained on. A flat floor has a mature org retraining forever for negligible gain: 100 new rows on top of 200 can move a model, on top of 20,000 they cannot. 0.25 means 'retrain once the training set has grown by a quarter', giving roughly logarithmic retrain frequency. 0 disables escalation and keeps the flat floors.",
+        default: 0.25
+      },
+      {
+        key: "max_new_train_labels",
+        camel: "maxNewTrainLabels",
+        label: "Retrain \u2014 max new labels (cap)",
+        kind: "number",
+        group: "sampling",
+        min: 0,
+        max: 1e6,
+        integer: true,
+        help: "Ceiling on the escalated requirement, as a budget on TOTAL new train labels. Without it a percentage of a large corpus stops being achievable \u2014 25% of 500k is 125,000 new human labels, which no org produces, so the org silently stops retraining. The per-class bars take shares of this budget apportioned by the corpus class mix, rather than each demanding the full cap. 0 removes the cap.",
+        default: 2e3
+      },
+      {
+        key: "train_lookback_days",
+        camel: "trainLookbackDays",
+        label: "Train lookback (days)",
+        kind: "number",
+        group: "sampling",
+        min: 0,
+        max: 1e5,
+        integer: true,
+        help: "How far back the TRAIN split may reach. Older labels age out of training, so the corpus stops growing without bound and the retrain growth bar plateaus instead of escalating past what an org can ever label. Applied to train ONLY: eval/test/golden keep every label, because the snapshot id is a hash of the evaluated set and ranking versions is only meaningful within a snapshot \u2014 a sliding holdout would score each version against different data. 0 disables the window. Note that shrinking this can push a split back under the per-class floors and stop training entirely, since rare classes thin out first.",
+        default: 365
+      },
+      {
+        key: "classifier_accept_min_f1",
+        camel: "classifierAcceptMinF1",
+        label: "Accept classifier \u2014 min best F1",
+        kind: "number",
+        group: "classifier",
+        min: 0,
+        max: 1,
+        help: "A classifier must reach at least this best-F1 on the evaluated snapshot before it can be promoted and take over from the heuristic matcher. Measured at the model's OWN best threshold, not at 0.5, so an uncalibrated model is judged on its ranking rather than on where the cut happens to sit. This is an absolute floor \u2014 'better than the incumbent' is already enforced by the rank gate.",
+        default: 0.75
+      },
+      {
+        key: "classifier_accept_min_pr_auc",
+        camel: "classifierAcceptMinPrAuc",
+        label: "Accept classifier \u2014 min PR-AUC",
+        kind: "number",
+        group: "classifier",
+        min: 0,
+        max: 1,
+        help: "Minimum average precision (PR-AUC) before a classifier can be promoted. Threshold-free, so it measures ranking quality independently of any operating point.",
+        default: 0.8
+      },
+      {
+        key: "global_classifier_versions",
+        camel: "globalClassifierVersions",
+        label: "Global classifier catalog",
+        kind: "text",
+        group: "classifier",
+        help: "Comma-separated versions offered to orgs that have not trained their own model yet \u2014 the cold-start candidates evaluated against an org's labels once it has enough of them. Blank means every version in the model bucket is a candidate, including half-finished experiments, so setting this is how you curate. A version an org has already adopted is always kept even if it is not listed, so editing this cannot drop the model currently deciding; and a version an org archives is dropped for that org only, never globally."
+      },
+      {
+        key: "classifier_version",
+        camel: "classifierVersion",
+        label: "Classifier version",
+        kind: "select",
+        group: "classifier",
+        help: "Required when mode = classifier. Choices come from the model versions in S3.",
+        platformDefault: false
+      },
+      {
+        key: "classifier_precision_target",
+        camel: "classifierPrecisionTarget",
+        label: "Attach precision target",
+        kind: "number",
+        group: "classifier",
+        min: 0,
+        max: 1,
+        help: "Minimum precision required to attach automatically. The score cutoff is DERIVED from this against each version's own test evaluation \u2014 the lowest cut that still meets the target, so recall is not given away. Set what error rate you accept (0.97 = at most three wrong links in a hundred); the number that implements it changes every retrain, because the same score means different things on different models. If a version cannot reach this precision at any cut, no attach threshold is installed and the previous one stands.",
+        default: 0.97
+      },
+      {
+        key: "classifier_review_precision_target",
+        camel: "classifierReviewPrecisionTarget",
+        label: "Review precision target",
+        kind: "number",
+        group: "classifier",
+        min: 0,
+        max: 1,
+        help: "Minimum precision required to send a candidate to the LLM rather than reject it outright. Must be at or below the attach target \u2014 scores between the two cuts are the ambiguous middle the LLM adjudicates. A value above the attach target would make that band empty and silently remove the LLM safety net, so it is clamped down to the attach target.",
+        default: 0.93
+      },
+      {
+        key: "seed_aggregation",
+        camel: "seedAggregation",
+        label: "Seed discovery \u2014 score aggregation",
+        kind: "select",
+        group: "classifier",
+        options: ["mean", "median", "max", "min", "trimmed_mean"],
+        help: "How a candidate's per-seed pair scores collapse to one number when a curator asks for related events on /timelines. mean makes every seed vote, so a candidate has to resemble the seed set rather than any one seed; median is the outlier-tolerant version of that. max asks only 'is there a seed this candidate clearly belongs with?' \u2014 it keeps the score on the per-pair scale the attach cut was calibrated on, but one coincidental neighbour is enough to pull a candidate in. min demands every seed agree; trimmed_mean drops the weakest seed, then averages. Blank uses the built-in default (mean)."
+      },
+      {
+        key: "seed_expansion_paths",
+        camel: "seedExpansionPaths",
+        label: "Seed discovery \u2014 candidate paths",
+        kind: "select",
+        group: "classifier",
+        options: ["graph", "graph_objects", "graph_objects_semantic"],
+        help: "Which paths find candidates when a curator asks for related events. graph walks activity_graph_edges only. The object and semantic paths mirror how the miner finds candidates, but the miner scores them against an established process; a curator-seeded set has no such history, so those paths mostly surface events that merely share a busy channel, a repo or a topic \u2014 they inflate the list without changing what gets approved. Widen only for an org whose graph is too thin to surface anything at all; the per-path counts in the discovery note tell you which one is empty. Blank uses the built-in default (graph)."
+      },
+      {
+        key: "seed_llm_defer_top_n",
+        camel: "seedLlmDeferTopN",
+        label: "Seed discovery \u2014 LLM adjudication (top N)",
+        kind: "number",
+        group: "classifier",
+        min: 0,
+        integer: true,
+        help: "How many ambiguous-band candidates (score between the review and attach cuts) are sent to the LLM per 'find related events' click. The band is exactly where the classifier says 'not confident either way', so something other than a number has to decide; the LLM sees the seed set once and rules on all N in a single call. The curator is waiting, so this is a latency and cost budget as much as a quality knob. 0 disables adjudication and leaves band candidates unapproved. Blank uses the built-in default (10). Requires the org to have a reasoning model configured."
+      },
+      {
+        key: "classifier_max_second_hop_per_process",
+        camel: "classifierMaxSecondHopPerProcess",
+        label: "Max 2nd-hop / process",
+        kind: "number",
+        group: "classifier",
+        min: 1,
+        integer: true,
+        help: "Cap on 2nd-hop neighbors scored per process. Default 8."
+      },
+      {
+        key: "shadow_classifier_enabled",
+        camel: "shadowClassifierEnabled",
+        label: "Shadow candidate",
+        kind: "boolean",
+        group: "classifier",
+        help: "Score a candidate model on live events without changing process assignment.",
+        platformDefault: false
+      },
+      {
+        key: "shadow_classifier_name",
+        camel: "shadowClassifierName",
+        label: "Shadow model",
+        kind: "text",
+        group: "classifier",
+        help: "Candidate model name to score live in shadow mode."
+      },
+      {
+        key: "shadow_classifier_version",
+        camel: "shadowClassifierVersion",
+        label: "Shadow version",
+        kind: "select",
+        group: "classifier",
+        help: "Candidate classifier version to shadow-score before promotion.",
+        platformDefault: false
+      },
+      {
+        key: "shadow_classifier_sample_rate",
+        camel: "shadowClassifierSampleRate",
+        label: "Shadow sample rate",
+        kind: "number",
+        group: "classifier",
+        min: 0,
+        max: 1,
+        help: "Fraction of live events to shadow-score with the candidate (0\u20131). Default 1."
+      },
+      {
+        key: "semantic_negative_max_process_similarity",
+        camel: "semanticNegativeMaxProcessSimilarity",
+        label: "Negatives: max workstream similarity",
+        kind: "number",
+        group: "sampling",
+        min: 0,
+        max: 1,
+        help: "Two workstreams must be at or below this cosine similarity before their members can be paired as negatives.",
+        default: 0.35
+      },
+      {
+        key: "semantic_negative_max_event_similarity",
+        camel: "semanticNegativeMaxEventSimilarity",
+        label: "Negatives: max event similarity",
+        kind: "number",
+        group: "sampling",
+        min: 0,
+        max: 1,
+        help: "Two events must ALSO be at or below this cosine similarity to be labeled a negative. Distance at both levels is what keeps the label safe.",
+        default: 0.35
+      },
+      {
+        key: "semantic_negative_pairs_per_process_pair",
+        camel: "semanticNegativePairsPerProcessPair",
+        label: "Negatives: pairs per workstream pair",
+        kind: "number",
+        group: "sampling",
+        min: 1,
+        help: "Cap on negatives minted from one pair of workstreams per sweep.",
+        default: 20
+      },
+      {
+        key: "semantic_negative_max_process_pairs",
+        camel: "semanticNegativeMaxProcessPairs",
+        label: "Negatives: workstream pairs per sweep",
+        kind: "number",
+        group: "sampling",
+        min: 1,
+        help: "Cap on how many workstream pairs one sweep considers.",
+        default: 40
+      },
+      {
+        key: "enable_llm",
+        camel: "enableLlm",
+        label: "Enable LLM escalation",
+        kind: "boolean",
+        group: "escalation",
+        help: "When on, ambiguous events escalate to the reasoning LLM (and it may create new processes).",
+        platformDefault: false
+      },
+      {
+        key: "heuristic_threshold_mode",
+        camel: "heuristicThresholdMode",
+        label: "Threshold mode",
+        kind: "select",
+        group: "thresholds",
+        options: ["fixed", "calibrated"],
+        help: "fixed: use the attach/review/reactivation values below. calibrated: mining waits until the org has enough events, then derives the three thresholds from percentiles of heuristic scores between random event pairs, and replays the org with them.",
+        default: "fixed"
+      },
+      {
+        key: "calibration_attach_percentile",
+        camel: "calibrationAttachPercentile",
+        label: "Attach percentile",
+        kind: "number",
+        group: "thresholds",
+        minExclusive: 0,
+        max: 1,
+        help: "Attach threshold = this percentile of random-pair scores (0\u20131). Random pairs are mostly unrelated work, so 0.97 means about 3% of unrelated pairs would clear the bar.",
+        default: 0.97,
+        visibleWhen: { key: "heuristic_threshold_mode", in: ["calibrated"] }
+      },
+      {
+        key: "calibration_review_percentile",
+        camel: "calibrationReviewPercentile",
+        label: "Review percentile",
+        kind: "number",
+        group: "thresholds",
+        minExclusive: 0,
+        max: 1,
+        help: "Review (LLM) threshold = this percentile of random-pair scores (0\u20131). Must be below the attach percentile.",
+        default: 0.9,
+        visibleWhen: { key: "heuristic_threshold_mode", in: ["calibrated"] }
+      },
+      {
+        key: "calibration_reactivation_percentile",
+        camel: "calibrationReactivationPercentile",
+        label: "Reactivation percentile",
+        kind: "number",
+        group: "thresholds",
+        minExclusive: 0,
+        max: 1,
+        help: "Reactivation threshold = this percentile of random-pair scores (0\u20131). Must be at or above the attach percentile.",
+        default: 0.99,
+        visibleWhen: { key: "heuristic_threshold_mode", in: ["calibrated"] }
+      },
+      {
+        key: "calibration_min_events",
+        camel: "calibrationMinEvents",
+        label: "Calibrate after (events)",
+        kind: "number",
+        group: "thresholds",
+        min: 50,
+        integer: true,
+        help: "Process assignment waits until the org has this many non-noise events; then thresholds are calibrated and the org is replayed.",
+        default: 1e3,
+        visibleWhen: { key: "heuristic_threshold_mode", in: ["calibrated"] }
+      },
+      {
+        key: "calibration_sample_pairs",
+        camel: "calibrationSamplePairs",
+        label: "Calibration sample pairs",
+        kind: "number",
+        group: "thresholds",
+        min: 100,
+        max: 2e4,
+        integer: true,
+        help: "How many random event pairs are scored. Tail percentiles need a large sample: at 2000 pairs the 99th percentile rests on ~20 scores.",
+        default: 2e3,
+        visibleWhen: { key: "heuristic_threshold_mode", in: ["calibrated"] }
+      },
+      {
+        key: "attach_threshold",
+        camel: "attachThreshold",
+        label: "Attach threshold",
+        kind: "number",
+        group: "thresholds",
+        min: 0,
+        max: 1,
+        help: "Heuristic score \u2265 this attaches the event (0\u20131). Overrides the global 0.55.",
+        visibleWhen: { key: "heuristic_threshold_mode", in: ["fixed"] }
+      },
+      {
+        key: "review_threshold",
+        camel: "reviewThreshold",
+        label: "Review threshold",
+        kind: "number",
+        group: "thresholds",
+        min: 0,
+        max: 1,
+        help: "Score in [review, attach) defers to the LLM; below it starts a new context. Also the floor for name-based dedup (0\u20131). Overrides the global 0.4.",
+        visibleWhen: { key: "heuristic_threshold_mode", in: ["fixed"] }
+      },
+      {
+        key: "reactivation_threshold",
+        camel: "reactivationThreshold",
+        label: "Reactivation threshold",
+        kind: "number",
+        group: "thresholds",
+        min: 0,
+        max: 1,
+        help: "Score \u2265 this reactivates a dormant context (0\u20131). Overrides the global 0.7.",
+        visibleWhen: { key: "heuristic_threshold_mode", in: ["fixed"] }
+      },
+      {
+        key: "max_attaches",
+        camel: "maxAttaches",
+        label: "Max attaches / event",
+        kind: "number",
+        group: "thresholds",
+        min: 1,
+        integer: true,
+        help: "Max contexts one event attaches to. Overrides the global 5."
+      },
+      // ── Group B: heuristic scoring weights (null → global default) ────────────
+      {
+        key: "weight_entity",
+        camel: "weightEntity",
+        label: "Weight \xB7 entity",
+        kind: "number",
+        group: "weights",
+        min: 0,
+        max: 1,
+        help: "Shared-object overlap weight (0\u20131). Global default 0.25. Weights should sum to ~1."
+      },
+      {
+        key: "weight_author",
+        camel: "weightAuthor",
+        label: "Weight \xB7 author",
+        kind: "number",
+        group: "weights",
+        min: 0,
+        max: 1,
+        help: "Same-author weight (0\u20131). Global default 0.15."
+      },
+      {
+        key: "weight_temporal",
+        camel: "weightTemporal",
+        label: "Weight \xB7 temporal",
+        kind: "number",
+        group: "weights",
+        min: 0,
+        max: 1,
+        help: "Time-proximity weight (0\u20131). Global default 0.10."
+      },
+      {
+        key: "weight_semantic",
+        camel: "weightSemantic",
+        label: "Weight \xB7 semantic",
+        kind: "number",
+        group: "weights",
+        min: 0,
+        max: 1,
+        help: "Embedding-similarity weight (0\u20131). Global default 0.35."
+      },
+      {
+        key: "weight_graph",
+        camel: "weightGraph",
+        label: "Weight \xB7 graph",
+        kind: "number",
+        group: "weights",
+        min: 0,
+        max: 1,
+        help: "Graph-walk signal weight (0\u20131). Global default 0.15."
+      },
+      {
+        key: "idf_strength",
+        camel: "idfStrength",
+        label: "IDF strength",
+        kind: "number",
+        group: "weights",
+        min: 0,
+        max: 1,
+        help: "Frequency-damping for the entity/author/graph terms (each signal weighted by 1/df^strength, df = object fan-in). 0 = off (legacy full weight); 0.5 = default; 1 = full inverse frequency. Blank = inherit global 0.5. Demotes super-node objects and a single dominant author so specific signals drive matches."
+      },
+      {
+        key: "summary_embedding_decay",
+        camel: "summaryEmbeddingDecay",
+        label: "Summary embedding decay",
+        kind: "number",
+        group: "weights",
+        min: 0.01,
+        max: 1,
+        help: "Recency weighting for a process's summary embedding: the newest member weighs 1, the one i events back weighs decay^i. 1 = plain mean; 0.95 = default (about 36% weight 20 events back). Blank = inherit global 0.95."
+      },
+      // ── Group B: object-graph edge caps + matcher budget ─────────────────────
+      {
+        key: "matcher_max_neighbors",
+        camel: "matcherMaxNeighbors",
+        label: "Matcher max neighbors",
+        kind: "number",
+        group: "graph",
+        min: 1,
+        integer: true,
+        help: "Graph-walk neighbour budget per event. Global default 50. Raise when per-type caps thin a node's neighbourhood below this and starve candidate discovery."
+      },
+      {
+        key: "matcher_min_edge_weight",
+        camel: "matcherMinEdgeWeight",
+        label: "Matcher min edge weight",
+        kind: "number",
+        group: "graph",
+        min: 0,
+        max: 1,
+        help: "Weight floor for candidate edges (0\u20131). Global default 0.2."
+      },
+      {
+        key: "late_event_window_hours",
+        camel: "lateEventWindowHours",
+        label: "Late-event window (hours)",
+        kind: "number",
+        group: "graph",
+        min: 1,
+        help: "A live event older than this (behind the org's newest processed event) is not scored inline; it waits for the windowed replay so it is scored in order. Global default 24."
+      },
+      {
+        key: "max_edges_co_object",
+        camel: "maxEdgesCoObject",
+        label: "Cap \xB7 co_object edges",
+        kind: "number",
+        group: "graph",
+        min: 1,
+        integer: true,
+        help: "Top-N co_object edges kept per event. Global default 5. Raising this is the durable fix for edge-cap-starved matching."
+      },
+      {
+        key: "max_edges_time_neighbor",
+        camel: "maxEdgesTimeNeighbor",
+        label: "Cap \xB7 time_neighbor edges",
+        kind: "number",
+        group: "graph",
+        min: 1,
+        integer: true,
+        help: "Top-N time_neighbor edges kept per event. Global default 5."
+      },
+      {
+        key: "max_edges_same_semantic",
+        camel: "maxEdgesSameSemantic",
+        label: "Cap \xB7 same_semantic edges",
+        kind: "number",
+        group: "graph",
+        min: 1,
+        integer: true,
+        help: "Top-N same_semantic edges kept per event. Global default 8."
+      },
+      {
+        key: "max_edges_similar_authors",
+        camel: "maxEdgesSimilarAuthors",
+        label: "Cap \xB7 similar_authors edges",
+        kind: "number",
+        group: "graph",
+        min: 1,
+        integer: true,
+        help: "Top-N similar_authors edges kept per event. Global default 8."
+      },
+      {
+        key: "max_edges_pr_to_issue",
+        camel: "maxEdgesPrToIssue",
+        label: "Cap \xB7 pr_to_issue edges",
+        kind: "number",
+        group: "graph",
+        min: 1,
+        integer: true,
+        help: "Top-N pr_to_issue edges kept per event. Global default 8."
+      },
+      // ─── Split allocation + training data shape (object-graph/070, /071) ──────
+      // These existed as columns and behaviour before they existed as controls,
+      // which meant the only way to configure a split was raw SQL — and an unset
+      // quota silently meant "no holdout at all".
+      {
+        key: "golden_target_events",
+        camel: "goldenTargetEvents",
+        label: "Golden target (events)",
+        kind: "number",
+        group: "sampling",
+        min: 1,
+        integer: true,
+        help: "How many EVENTS to hold out as golden. Blank derives ~5% of eligible events. Sized in events, not labels: labels are quadratic in events, so a label count overstates evaluation power. Holdout is bounded by component count \u2014 with few curated workstreams you are choosing which components, not how many events."
+      },
+      {
+        key: "test_target_events",
+        camel: "testTargetEvents",
+        label: "Test target (events)",
+        kind: "number",
+        group: "sampling",
+        min: 1,
+        integer: true,
+        help: "How many EVENTS to hold out as test. Blank derives ~15% of eligible events."
+      },
+      {
+        key: "min_split_labels",
+        camel: "minSplitLabels",
+        label: "Min labels per split",
+        kind: "number",
+        group: "sampling",
+        min: 0,
+        max: 1e6,
+        integer: true,
+        help: "Floor each of train/eval/test must clear. Also the precondition for the golden fallback: once all three clear it, golden may take a component the size guard would otherwise refuse, so the split is never permanently empty.",
+        default: 100
+      },
+      {
+        key: "min_train_class_labels",
+        camel: "minTrainClassLabels",
+        label: "Min labels per class \u2014 train",
+        kind: "number",
+        group: "sampling",
+        min: 0,
+        max: 1e6,
+        integer: true,
+        help: "Floor EACH class must clear in the TRAIN split before fitting. This is a capacity question, not a statistical one: below roughly this many examples per class the model memorises rather than generalises. Train is also the split that can be topped up \u2014 fallback negatives are borrowed at extraction time and the set is then downsampled to balance \u2014 so it can carry a higher bar than the holdouts.",
+        default: 200
+      },
+      {
+        key: "min_eval_class_labels",
+        camel: "minEvalClassLabels",
+        label: "Min labels per class \u2014 eval / test",
+        kind: "number",
+        group: "sampling",
+        min: 0,
+        max: 1e6,
+        integer: true,
+        help: "Floor EACH class must clear in EACH of eval and test. A split can pass the total floor on volume alone and still be single-class \u2014 dev's test split held 142 labels, all positive, which any always-say-same model scores 100% on. This one is about whether a measurement means anything: a 95% interval on an observed 0.80 accuracy is roughly +/-0.14 at 30 per class and +/-0.08 at 100. Held-out splits cannot borrow negatives, so setting this above what your data can supply blocks training rather than improving it.",
+        default: 10
+      },
+      {
+        key: "label_conflict_policy",
+        camel: "labelConflictPolicy",
+        label: "Conflicting label policy",
+        kind: "select",
+        group: "sampling",
+        options: ["keep_both", "replace", "withhold"],
+        help: "What happens when new curation contradicts an existing human label on the same pair. keep_both (default) keeps both judgements, so training sees the ambiguity and the model is less confident there. replace supersedes the older one, for when later curation is the correction. withhold discards the new label and holds the event for review \u2014 the old behaviour, which silently dropped most removal labels."
+      },
+      {
+        key: "train_negative_fallback_enabled",
+        camel: "trainNegativeFallbackEnabled",
+        label: "Borrow negatives for training",
+        kind: "boolean",
+        group: "sampling",
+        help: "When train (or eval) has too few negatives, borrow them from sources the routing rules do not admit \u2014 typically LLM review removals. NEVER touches test or golden, and never borrows a label whose events sit in a held-out split. These are labels no human checked.",
+        default: true
+      },
+      {
+        key: "train_min_negative_share",
+        camel: "trainMinNegativeShare",
+        label: "Min negative share (train)",
+        kind: "number",
+        group: "sampling",
+        min: 0,
+        max: 1,
+        help: "Below this share of negatives, the fallback engages.",
+        default: 0.5
+      },
+      {
+        key: "train_negative_fallback_max_ratio",
+        camel: "trainNegativeFallbackMaxRatio",
+        label: "Borrowed negatives cap (x positives)",
+        kind: "number",
+        group: "sampling",
+        min: 0,
+        help: "Ceiling on borrowed negatives as a multiple of the split's positives, so a large ineligible pool cannot swamp a small human-labelled one.",
+        default: 1
+      },
+      {
+        key: "train_balance_strategy",
+        camel: "trainBalanceStrategy",
+        label: "Training class balance",
+        kind: "select",
+        group: "sampling",
+        options: ["none", "downsample_majority", "oversample_minority"],
+        help: "Applied to the training split after extraction. Downsampling loses data but adds no duplicates; oversampling keeps all signal but repeats rows, which inflates confidence.",
+        default: "downsample_majority"
+      },
+      {
+        key: "min_golden_curators",
+        camel: "minGoldenCurators",
+        label: "Min curators for golden",
+        kind: "number",
+        group: "sampling",
+        min: 1,
+        integer: true,
+        help: "Distinct human curators required on a workstream before its explicit labels are auto-promoted to golden.",
+        default: 2
+      },
+      {
+        key: "feedback_triage_max_contradictions",
+        camel: "feedbackTriageMaxContradictions",
+        label: "Feedback triage \u2014 max contradictions",
+        kind: "number",
+        group: "sampling",
+        min: 1,
+        integer: true,
+        help: "A curator feedback event contradicted by more than this many other curators is held rather than turned into labels.",
+        default: 1
+      },
+      {
+        key: "feedback_triage_max_selection_size",
+        camel: "feedbackTriageMaxSelectionSize",
+        label: "Feedback triage \u2014 max selection",
+        kind: "number",
+        group: "sampling",
+        min: 1,
+        integer: true,
+        help: "A feedback event selecting more activities than this is held (likely a bulk action, not a judgement).",
+        default: 400
+      },
+      {
+        key: "process_review_step_1",
+        camel: "processReviewStep1",
+        label: "Review at (step 1)",
+        kind: "number",
+        group: "review",
+        min: 1,
+        integer: true,
+        help: "Members a process must reach before its first automated review (re-describe, rename, recategorize, drop unrelated members). Must be below step 2. Whether an org is reviewed at all is its mining_process_review feature flag.",
+        default: 5
+      },
+      {
+        key: "process_review_step_2",
+        camel: "processReviewStep2",
+        label: "Review again at (step 2)",
+        kind: "number",
+        group: "review",
+        min: 2,
+        integer: true,
+        help: "Members at which the process is reviewed a second time, once more of it is known. Must be above step 1.",
+        default: 10
+      },
+      {
+        key: "notes",
+        camel: "notes",
+        label: "Notes",
+        kind: "text",
+        group: "meta",
+        help: "Free-text admin note.",
+        platformDefault: false
+      }
+    ];
+    MINING_PARAMETER_FIELDS = MINING_FIELDS.filter(
+      (field) => field.platformDefault !== false
+    );
+    MINING_BUILTIN_DEFAULTS = Object.freeze(
+      Object.fromEntries(
+        MINING_FIELDS.filter((f) => f.default !== void 0).map((f) => [
+          f.key,
+          f.default
+        ])
+      )
+    );
+    MINING_FIELDS_BY_KEY = new Map(
+      MINING_FIELDS.map((f) => [f.key, f])
+    );
+  }
+});
+
 // ../../packages/@company/types/src/index.ts
 var init_src5 = __esm({
   "../../packages/@company/types/src/index.ts"() {
     init_timeline();
+    init_qna();
     init_artifact();
     init_taxonomy();
     init_embedding();
     init_repo_file_url();
     init_query_dialect();
     init_report_template();
+    init_mining_config_fields();
   }
 });
 
@@ -21869,7 +22905,7 @@ var init_search_vector_write = __esm({
 });
 
 // ../../packages/@company/db/src/org-purge.ts
-var observability4;
+var observability5;
 var init_org_purge = __esm({
   "../../packages/@company/db/src/org-purge.ts"() {
     "use strict";
@@ -21877,12 +22913,12 @@ var init_org_purge = __esm({
     init_src2();
     init_client();
     init_org_context();
-    observability4 = createObservabilityService("org-purge");
+    observability5 = createObservabilityService("org-purge");
   }
 });
 
 // ../../packages/@company/db/src/org-orphan-scan.ts
-var observability5;
+var observability6;
 var init_org_orphan_scan = __esm({
   "../../packages/@company/db/src/org-orphan-scan.ts"() {
     "use strict";
@@ -21890,7 +22926,7 @@ var init_org_orphan_scan = __esm({
     init_src2();
     init_org_context();
     init_org_purge();
-    observability5 = createObservabilityService("org-orphan-scan");
+    observability6 = createObservabilityService("org-orphan-scan");
   }
 });
 
@@ -21938,12 +22974,13 @@ var init_expert_areas = __esm({
 });
 
 // ../../packages/@company/db/src/exchange-context.ts
-var observability6;
+var observability7;
 var init_exchange_context = __esm({
   "../../packages/@company/db/src/exchange-context.ts"() {
     "use strict";
     init_src2();
-    observability6 = createObservabilityService("db-exchange-context");
+    init_org_context();
+    observability7 = createObservabilityService("db-exchange-context");
   }
 });
 
@@ -21972,14 +23009,30 @@ var init_data_access = __esm({
   }
 });
 
+// ../../packages/@company/db/src/byod/host-guard.ts
+var init_host_guard = __esm({
+  "../../packages/@company/db/src/byod/host-guard.ts"() {
+    "use strict";
+  }
+});
+
+// ../../packages/@company/db/src/byod/admission-policy.ts
+var init_admission_policy = __esm({
+  "../../packages/@company/db/src/byod/admission-policy.ts"() {
+    "use strict";
+  }
+});
+
 // ../../packages/@company/db/src/byod/pool-manager.ts
-var observability7, IDLE_TIMEOUT_MS;
+var observability8, IDLE_TIMEOUT_MS;
 var init_pool_manager = __esm({
   "../../packages/@company/db/src/byod/pool-manager.ts"() {
     "use strict";
     init_esm();
     init_src2();
-    observability7 = createObservabilityService("byod-pool-manager");
+    init_host_guard();
+    init_admission_policy();
+    observability8 = createObservabilityService("byod-pool-manager");
     IDLE_TIMEOUT_MS = 5 * 60 * 1e3;
   }
 });
@@ -22014,6 +23067,7 @@ var init_org_db_resolver = __esm({
   "../../packages/@company/db/src/byod/org-db-resolver.ts"() {
     "use strict";
     init_pool_manager();
+    init_admission_policy();
     init_routed_pool();
   }
 });
@@ -22060,7 +23114,7 @@ function entry(database, dbName, table, orgScoping, opts = {}) {
       identity: {
         kind: "columns",
         columns: opts.mergePolicy.identityKey,
-        version: 1
+        version: opts.identityVersion ?? 1
       }
     } : DEFAULT_RECONCILIATION)
   };
@@ -22069,15 +23123,27 @@ function standardIntegrationTables(database, dbName) {
   return [
     entry(database, dbName, "source_events", "direct", {
       scopingColumn: "organization_id",
+      // v2: the identity gained source_account_id (A0).
+      identityVersion: 2,
       // PK `source_event_id` is a generated uuid; identity is the natural key.
       // Two databases capturing the same event agree on the natural key and
       // disagree on the uuid, so a PK arbiter never fires and the insert
       // violates the natural key instead — the failure that made move-back
-      // impossible. This is also exactly the key the write path already treats
-      // as identity (`ON CONFLICT … DO NOTHING` in appendSourceEvent), so
-      // migration and ingestion now agree on what "the same event" means.
+      // impossible.
+      //
+      // The natural key includes the ACCOUNT (source-events-standard-tables/
+      // 008): two accounts of one platform can produce the same
+      // source_event_key and those are distinct events. While a destination
+      // still has the old (org, platform, key) unique index, the copier's
+      // preflight refuses to fold such rows together — see
+      // `assertMergeKeysSafe` in migration-utils.ts.
       mergePolicy: {
-        identityKey: ["organization_id", "source_platform", "source_event_key"],
+        identityKey: [
+          "organization_id",
+          "source_platform",
+          "source_account_id",
+          "source_event_key"
+        ],
         // Keep the destination's uuid on conflict. NOT because it is the more
         // referenced one — measured on dev, 6,124 of 7,717 referenced uuids
         // (79%) existed only on the BYOD side — but because rewriting a primary
@@ -22143,6 +23209,14 @@ var init_table_registry = __esm({
       entry("intelligence", INTELLIGENCE_DB, "qna_conversation_shares", "direct", {
         scopingColumn: "organization_id"
       }),
+      // Charts saved with their answer (qna-charts/001); child of qna_messages.
+      entry("intelligence", INTELLIGENCE_DB, "qna_charts", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      // Retry-safe Q&A writes + notification outbox (qna-charts/002).
+      entry("intelligence", INTELLIGENCE_DB, "qna_write_operations", "direct", {
+        scopingColumn: "organization_id"
+      }),
       entry("intelligence", INTELLIGENCE_DB, "incidents", "direct", {
         scopingColumn: "organization_id",
         hasVectorColumn: true
@@ -22225,6 +23299,10 @@ var init_table_registry = __esm({
       entry("intelligence", INTELLIGENCE_DB, "expert_profile_facts", "direct", {
         scopingColumn: "organization_id"
       }),
+      // Durable pending-decision queue for process membership (object-graph/113).
+      entry("intelligence", INTELLIGENCE_DB, "mining_pending_decisions", "direct", {
+        scopingColumn: "organization_id"
+      }),
       // A member's "this wasn't me", awaiting the identities admin (object-graph/107).
       entry("intelligence", INTELLIGENCE_DB, "identity_disputes", "direct", {
         scopingColumn: "organization_id"
@@ -22255,6 +23333,10 @@ var init_table_registry = __esm({
       entry("intelligence", INTELLIGENCE_DB, "expert_area_merge_log", "direct", {
         scopingColumn: "organization_id"
       }),
+      // Load-cycle gate for profile generation (object-graph/127).
+      entry("intelligence", INTELLIGENCE_DB, "expert_load_cycle_state", "direct", {
+        scopingColumn: "organization_id"
+      }),
       entry("intelligence", INTELLIGENCE_DB, "expert_profile_curation", "direct", {
         scopingColumn: "organization_id"
       }),
@@ -22294,12 +23376,40 @@ var init_table_registry = __esm({
         "direct",
         { scopingColumn: "organization_id" }
       ),
+      // Memory → Skills (migrations/skills/001): lifecycle, revisions,
+      // publications, dependencies and temporary Skillify output. skills and
+      // skill_revisions reference `skill` rows in knowledge_artifacts, so they
+      // ride on the same database as the artifacts.
+      entry("intelligence", INTELLIGENCE_DB, "skills", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      entry("intelligence", INTELLIGENCE_DB, "skill_revisions", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      entry("intelligence", INTELLIGENCE_DB, "skill_publications", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      entry("intelligence", INTELLIGENCE_DB, "skill_sources", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      entry("intelligence", INTELLIGENCE_DB, "skill_generation_outputs", "direct", {
+        scopingColumn: "organization_id"
+      }),
       entry("intelligence", INTELLIGENCE_DB, "activity_graph_edges", "direct", {
         scopingColumn: "organization_id"
       }),
       entry("intelligence", INTELLIGENCE_DB, "process_registry", "direct", {
         scopingColumn: "organization_id"
       }),
+      // Append-only history of a process's scored state (object-graph/114). After
+      // process_registry: composite FK to it.
+      entry("intelligence", INTELLIGENCE_DB, "process_state_history", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      // Late live events awaiting a windowed replay (object-graph/115).
+      entry("intelligence", INTELLIGENCE_DB, "mining_awaiting_replay", "direct", {
+        scopingColumn: "organization_id"
+      }),
       // Incident overlay + evidence signals + audit — the incident-specific
       // projection keyed by (organization_id, process_id) on top of
       // process_registry (category='incident_response'). Rides to BYOD with the
@@ -22413,19 +23523,12 @@ var init_table_registry = __esm({
       entry("intelligence", INTELLIGENCE_DB, "artifact_cluster_members", "direct", {
         scopingColumn: "organization_id"
       }),
-      // Graph-enrichment watermark + deadletter ride to BYOD with the object graph
-      // they walk. audit round 4 (#3).
-      entry("intelligence", INTELLIGENCE_DB, "graph_enrichment_state", "direct", {
-        scopingColumn: "organization_id"
-      }),
       entry(
         "intelligence",
         INTELLIGENCE_DB,
-        "graph_enrichment_deadletter",
+        "artifact_cluster_workstreams",
         "direct",
-        {
-          scopingColumn: "organization_id"
-        }
+        { scopingColumn: "organization_id" }
       )
     ];
     INTEGRATIONS_DB = "haansi_integrations_prod";
@@ -22452,6 +23555,7 @@ var init_schema_provisioner = __esm({
     path = __toESM(require("path"));
     init_src2();
     init_pool_manager();
+    init_host_guard();
     init_table_registry();
     SCHEMAS_DIR = path.join(__dirname, "schemas");
     logger2 = createLogger("db-byod-schema-provisioner");
@@ -22459,7 +23563,7 @@ var init_schema_provisioner = __esm({
 });
 
 // ../../packages/@company/db/src/byod/host-resolver.ts
-var observability8;
+var observability9;
 var init_host_resolver = __esm({
   "../../packages/@company/db/src/byod/host-resolver.ts"() {
     "use strict";
@@ -22467,7 +23571,9 @@ var init_host_resolver = __esm({
     init_src2();
     init_config_cache();
     init_pool_manager();
-    observability8 = createObservabilityService("byod-host-resolver");
+    init_host_guard();
+    init_admission_policy();
+    observability9 = createObservabilityService("byod-host-resolver");
   }
 });
 
@@ -23395,6 +24501,7 @@ var init_migration_service = __esm({
     "use strict";
     init_esm();
     init_pool_manager();
+    init_host_guard();
     init_org_context();
     init_client();
     init_src2();
@@ -23429,6 +24536,8 @@ var init_byod = __esm({
   "../../packages/@company/db/src/byod/index.ts"() {
     "use strict";
     init_pool_manager();
+    init_host_guard();
+    init_admission_policy();
     init_config_cache();
     init_control_plane_residency();
     init_integration_storage();
@@ -23463,6 +24572,7 @@ var init_src6 = __esm({
     init_client();
     init_listener_connection();
     init_org_context();
+    init_admin_pools();
     init_search_vector_write();
     init_org_purge();
     init_org_orphan_scan();
@@ -80049,10 +81159,10 @@ __export(setup_mcp_exports, {
 });
 function parseTarget(arg) {
   if (!arg || arg === "all") return "all";
-  if (arg === "solutions" || arg === "exchange" || arg === "digests" || arg === "onboarding")
+  if (arg === "solutions" || arg === "exchange" || arg === "digests" || arg === "onboarding" || arg === "skills")
     return arg;
   throw new Error(
-    `Unknown target: ${arg}. Use one of: solutions, exchange, digests, onboarding, all (default).`
+    `Unknown target: ${arg}. Use one of: solutions, exchange, digests, onboarding, skills, all (default).`
   );
 }
 function httpServerUrl(path2) {
@@ -80192,6 +81302,13 @@ var init_setup_mcp = __esm({
         target: "onboarding",
         name: "haansi-onboarding",
         path: "/api/v1/memory/onboarding/mcp"
+      },
+      // Published team skills, loaded progressively by coding agents
+      // (docs/product/plans/2026-10-10-memory-skills.md §7).
+      {
+        target: "skills",
+        name: "haansi-skills",
+        path: "/api/v1/memory/skills/mcp"
       }
     ];
     WRITERS = {