0sec-cli 0.24.1 → 0.25.0

package/chunks/{chunk-BOBIAHKA.js → chunk-WK6VUCKK.js}

@@ -2,335 +2,9 @@
 import { createRequire as __0CreateRequire } from "node:module";
 const require = __0CreateRequire(import.meta.url);
 import {
-  jitterFor
-} from "./chunk-X2ZMSRTP.js";
-import {
-  scanExecutionSignal
-} from "./chunk-BD7WULFS.js";
-
-// packages/core/dist/scope/rate-limit.js
-var TokenBucket = class {
-  state;
-  nowFn;
-  sleepFn;
-  jitter;
-  constructor(rps, capacity = rps, nowFn = () => Date.now(), sleepFn = defaultSleep, jitter) {
-    if (!Number.isFinite(rps) || rps <= 0) {
-      throw new Error(`TokenBucket: rps must be a positive finite number, got ${rps}`);
-    }
-    if (!Number.isFinite(capacity) || capacity <= 0) {
-      throw new Error(`TokenBucket: capacity must be a positive finite number, got ${capacity}`);
-    }
-    this.nowFn = nowFn;
-    this.sleepFn = sleepFn;
-    this.jitter = jitter && jitter.baseMs > 0 ? jitter : void 0;
-    this.state = {
-      tokens: capacity,
-      refillRatePerMs: rps / 1e3,
-      capacity,
-      lastRefill: nowFn(),
-      retryUntil: 0
-    };
-  }
-  refill() {
-    const now = this.nowFn();
-    const elapsed = now - this.state.lastRefill;
-    if (elapsed > 0) {
-      this.state.tokens = Math.min(this.state.capacity, this.state.tokens + elapsed * this.state.refillRatePerMs);
-      this.state.lastRefill = now;
-    }
-  }
-  /**
-   * Non-blocking. Returns true and consumes `n` tokens if available;
-   * returns false and consumes nothing otherwise. Blocked during 429
-   * cool-off (returns false until park expires).
-   */
-  tryConsume(n = 1) {
-    if (this.nowFn() < this.state.retryUntil)
-      return false;
-    this.refill();
-    if (this.state.tokens >= n) {
-      this.state.tokens -= n;
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Block until `n` tokens are available, then consume them. Honours
-   * the 429 park deadline first, then refill-and-spin with sleeps
-   * sized to the exact next-token-available time.
-   */
-  async acquire(n = 1, signal = scanExecutionSignal()) {
-    signal?.throwIfAborted();
-    if (n > this.state.capacity) {
-      n = this.state.capacity;
-    }
-    while (this.nowFn() < this.state.retryUntil) {
-      const wait = this.state.retryUntil - this.nowFn();
-      await this.sleepFn(Math.max(1, Math.min(wait, 1e3)), signal);
-    }
-    while (true) {
-      signal?.throwIfAborted();
-      this.refill();
-      if (this.state.tokens >= n) {
-        this.state.tokens -= n;
-        await this.pace(signal);
-        return;
-      }
-      const tokensNeeded = n - this.state.tokens;
-      const waitMs = Math.max(1, Math.ceil(tokensNeeded / this.state.refillRatePerMs));
-      await this.sleepFn(waitMs, signal);
-    }
-  }
-  /**
-   * Sleep the configured full-jitter delay. No-op (and no `await`-visible
-   * sleep) when no jitter is configured, so the default path is unchanged.
-   *
-   * Reuses `jitterFor` from `waf-detect.ts` — attempt 0 with an injected rng
-   * yields full jitter in `[0, baseMs]` — rather than growing a second
-   * jitter implementation.
-   */
-  async pace(signal = scanExecutionSignal()) {
-    signal?.throwIfAborted();
-    if (!this.jitter)
-      return;
-    const ms = jitterFor(0, this.jitter.baseMs, this.jitter.rng ?? Math.random);
-    if (ms > 0)
-      await this.sleepFn(ms, signal);
-  }
-  /**
-   * Park the bucket until `deadline` (ms since epoch). Subsequent
-   * `acquire`/`tryConsume` calls block until the deadline passes.
-   * Idempotent in the "later wins" sense: a longer park overrides a
-   * shorter one, but a shorter park does NOT shorten an existing one.
-   */
-  markRetryUntil(deadline) {
-    if (deadline > this.state.retryUntil) {
-      this.state.retryUntil = deadline;
-    }
-  }
-  /** Test introspection. */
-  _peek() {
-    this.refill();
-    return {
-      tokens: this.state.tokens,
-      retryUntil: this.state.retryUntil,
-      capacity: this.state.capacity
-    };
-  }
-};
-var RateLimiter = class _RateLimiter {
-  buckets = /* @__PURE__ */ new Map();
-  defaultCfg;
-  perHost;
-  jitter;
-  nowFn;
-  sleepFn;
-  /**
-   * Conservative cool-off floor when a 429 lands without a useful
-   * `Retry-After`, or with a tiny one. 60s matches the PoC-runtime
-   * precedent in #206 — a target that just told us to slow down has
-   * earned more than a one-second pause.
-   */
-  static RETRY_AFTER_FLOOR_MS = 6e4;
-  /**
-   * Optional observer invoked once whenever a fetch is actually throttled:
-   * either an `acquire` that had to block because the bucket was dry, or a
-   * 429 response parking the host. Used by the http_audit enforcement
-   * tracker to populate `rate_limited_count`. No-op when unset, so the
-   * normal scan path is unaffected.
-   */
-  onThrottle;
-  constructor(config, opts = {}) {
-    this.defaultCfg = config.default;
-    this.jitter = config.jitter;
-    this.perHost = {};
-    if (config.perHost) {
-      for (const [host, cfg] of Object.entries(config.perHost)) {
-        this.perHost[host.toLowerCase()] = cfg;
-      }
-    }
-    this.nowFn = opts.nowFn ?? (() => Date.now());
-    this.sleepFn = opts.sleepFn ?? defaultSleep;
-    this.onThrottle = opts.onThrottle;
-  }
-  /**
-   * Normalize a URL or host string to a bucket key. Lowercased,
-   * port-stripped, IPv6 brackets retained on the literal but dropped
-   * from the port suffix (e.g. `[::1]:443` → `[::1]`).
-   */
-  hostKey(urlOrHost) {
-    let host;
-    try {
-      host = new URL(urlOrHost).hostname;
-    } catch {
-      const trimmed = urlOrHost.trim();
-      if (!trimmed)
-        return null;
-      if (trimmed.startsWith("[")) {
-        const close = trimmed.indexOf("]");
-        if (close < 0)
-          return null;
-        host = trimmed.slice(0, close + 1);
-      } else {
-        host = trimmed.split(":")[0];
-      }
-    }
-    return host.toLowerCase();
-  }
-  getBucket(host) {
-    let bucket = this.buckets.get(host);
-    if (!bucket) {
-      const cfg = this.perHost[host] ?? this.defaultCfg;
-      bucket = new TokenBucket(cfg.rps, cfg.burst ?? cfg.rps, this.nowFn, this.sleepFn, this.jitter);
-      this.buckets.set(host, bucket);
-    }
-    return bucket;
-  }
-  /**
-   * Block until a token is available for `urlOrHost`'s host, then
-   * consume it. Unparseable input is treated as a no-op (returns
-   * immediately) — callers should not rely on rate-limiting unknowable
-   * hosts. The fetch sites that wire this up always pass full URLs.
-   */
-  async acquire(urlOrHost, n = 1, signal = scanExecutionSignal()) {
-    signal?.throwIfAborted();
-    const host = this.hostKey(urlOrHost);
-    if (!host)
-      return;
-    const bucket = this.getBucket(host);
-    if (bucket.tryConsume(n)) {
-      await bucket.pace(signal);
-      return;
-    }
-    this.onThrottle?.();
-    await bucket.acquire(n, signal);
-  }
-  /**
-   * Non-blocking variant. Returns true and consumes if available,
-   * false otherwise. Used by callers that want to fall through to a
-   * fast-path / degrade rather than wait.
-   */
-  tryAcquire(urlOrHost, n = 1) {
-    const host = this.hostKey(urlOrHost);
-    if (!host)
-      return true;
-    return this.getBucket(host).tryConsume(n);
-  }
-  /**
-   * Inspect a fetch response and, if it's a 429, park the host's
-   * bucket until `Retry-After` (or 60s, whichever is longer). The
-   * parsed value supports both delta-seconds (RFC 7231 §7.1.3) and
-   * HTTP-date forms; anything else falls back to the floor.
-   *
-   * No-ops on non-429 responses, or on hosts with no bucket yet
-   * (which can't happen if the caller acquired before fetching, but
-   * we don't depend on that).
-   */
-  noteResponse(urlOrHost, res) {
-    if (res.status !== 429)
-      return;
-    const host = this.hostKey(urlOrHost);
-    if (!host)
-      return;
-    this.onThrottle?.();
-    const bucket = this.getBucket(host);
-    const retryAfter = readHeader(res.headers, "retry-after");
-    const delayMs = parseRetryAfter(retryAfter, this.nowFn());
-    const deadline = this.nowFn() + Math.max(delayMs, _RateLimiter.RETRY_AFTER_FLOOR_MS);
-    bucket.markRetryUntil(deadline);
-  }
-  /** Test-only. Reset all buckets. */
-  _reset() {
-    this.buckets.clear();
-  }
-};
-function defaultSleep(ms, signal) {
-  signal?.throwIfAborted();
-  const { promise, resolve, reject } = Promise.withResolvers();
-  const timer = setTimeout(() => {
-    signal?.removeEventListener("abort", abort);
-    resolve();
-  }, ms);
-  const abort = () => {
-    clearTimeout(timer);
-    reject(signal?.reason ?? new Error("Rate-limit wait cancelled."));
-  };
-  signal?.addEventListener("abort", abort, { once: true });
-  return promise;
-}
-function readHeader(headers, name) {
-  if (typeof headers.get === "function") {
-    return headers.get(name);
-  }
-  return null;
-}
-function parseRetryAfter(value, now) {
-  if (!value)
-    return 0;
-  const trimmed = value.trim();
-  if (!trimmed)
-    return 0;
-  if (/^\d+$/.test(trimmed)) {
-    const seconds = parseInt(trimmed, 10);
-    return Number.isFinite(seconds) && seconds > 0 ? seconds * 1e3 : 0;
-  }
-  const date = Date.parse(trimmed);
-  if (Number.isFinite(date)) {
-    return Math.max(0, date - now);
-  }
-  return 0;
-}
-function parseRateLimitFlag(spec, fallbackRps = 5) {
-  const trimmed = spec.trim();
-  if (!trimmed) {
-    return { default: { rps: fallbackRps } };
-  }
-  const parts = trimmed.split(",").map((p) => p.trim()).filter(Boolean);
-  let defaultCfg = null;
-  const perHost = {};
-  for (const part of parts) {
-    const eq = part.indexOf("=");
-    if (eq < 0) {
-      const cfg = parseRpsBurst(part);
-      defaultCfg = cfg;
-    } else {
-      const host = part.slice(0, eq).trim().toLowerCase();
-      const cfg = parseRpsBurst(part.slice(eq + 1));
-      if (!host) {
-        throw new Error(`--rate-limit: empty host in "${part}"`);
-      }
-      perHost[host] = cfg;
-    }
-  }
-  return {
-    default: defaultCfg ?? { rps: fallbackRps },
-    perHost: Object.keys(perHost).length > 0 ? perHost : void 0
-  };
-}
-function parseRpsBurst(s) {
-  const trimmed = s.trim();
-  if (!trimmed) {
-    throw new Error(`--rate-limit: empty rps value`);
-  }
-  const colon = trimmed.indexOf(":");
-  if (colon < 0) {
-    const rps2 = Number(trimmed);
-    if (!Number.isFinite(rps2) || rps2 <= 0) {
-      throw new Error(`--rate-limit: invalid rps "${trimmed}"`);
-    }
-    return { rps: rps2 };
-  }
-  const rps = Number(trimmed.slice(0, colon));
-  const burst = Number(trimmed.slice(colon + 1));
-  if (!Number.isFinite(rps) || rps <= 0) {
-    throw new Error(`--rate-limit: invalid rps "${trimmed.slice(0, colon)}"`);
-  }
-  if (!Number.isFinite(burst) || burst <= 0) {
-    throw new Error(`--rate-limit: invalid burst "${trimmed.slice(colon + 1)}"`);
-  }
-  return { rps, burst };
-}
+  RateLimiter,
+  parseRateLimitFlag
+} from "./chunk-OFPF26WL.js";
 
 // packages/core/dist/stages/web.js
 import { randomUUID } from "node:crypto";
@@ -923,10 +597,6 @@ function summarizeWebStackFingerprint(result) {
 }
 
 export {
-  TokenBucket,
-  RateLimiter,
-  parseRetryAfter,
-  parseRateLimitFlag,
   runWebDiscoveryProbe,
   runBaselineWebChecks,
   fingerprintWebStack,

package/chunks/{chunk-IXT64DV5.js → chunk-XPDJE537.js}

@@ -8107,6 +8107,99 @@ function errMessage(err) {
   }
 }
 
+// packages/core/dist/triage/can-auto-suppress.js
+var PROTECTED_SEVERITIES = /* @__PURE__ */ new Set([
+  "critical",
+  "high"
+]);
+var HIGH_IMPACT_CATEGORIES = /* @__PURE__ */ new Set([
+  // Remote code / command / code execution
+  "command-injection",
+  "code-injection",
+  // Injection into the data store
+  "sql-injection",
+  // Unsafe deserialization is a classic RCE primitive
+  "unsafe-deserialization",
+  // Server-side request forgery (pivot / internal network reach)
+  "ssrf",
+  // Arbitrary file read/write
+  "path-traversal",
+  // Memory corruption / binary / kernel classes
+  "heap-overflow",
+  "out-of-bounds-read",
+  "out-of-bounds-write",
+  "use-after-free",
+  "stack-buffer-overflow",
+  "integer-overflow",
+  "type-confusion",
+  "double-free",
+  "format-string",
+  "uninitialized-memory",
+  "race-condition",
+  "toctou",
+  // Supply-chain compromise (known-vulnerable / malicious package)
+  "known-vulnerable-package",
+  "supply-chain",
+  // Prototype-pollution gadget → auth bypass / RCE when chained. We actively
+  // disclose these (e.g. the jsonwebtoken verify() gadget), so they must never
+  // be auto-dropped on a score alone.
+  "prototype-pollution",
+  // Cryptographic misuse — hardcoded keys/IVs, JWT alg-confusion (alg=none /
+  // HS-vs-RS), and predictable RNG for secrets are direct key-leak / auth-bypass
+  // primitives, so the class is protected from score-only auto-drop.
+  "crypto-misuse",
+  // AI-system adversarial classes — the core 0 "adversarial reliability"
+  // thesis (authorization-boundary break, unsafe tool use, data exfiltration,
+  // prompt hijack). A missed one of these is a disclosure-grade loss.
+  "prompt-injection",
+  "data-exfiltration",
+  "tool-misuse"
+]);
+function canAutoSuppressDetailed(finding) {
+  if (PROTECTED_SEVERITIES.has(finding.severity)) {
+    return {
+      canSuppress: false,
+      guard: "high_severity",
+      reason: `severity=${finding.severity} is disclosure-grade; routed to verification instead of auto-drop`
+    };
+  }
+  if (HIGH_IMPACT_CATEGORIES.has(finding.category)) {
+    return {
+      canSuppress: false,
+      guard: "high_impact_class",
+      reason: `category=${finding.category} is a high-impact class; routed to verification instead of auto-drop`
+    };
+  }
+  return {
+    canSuppress: true,
+    reason: `severity=${finding.severity}, category=${finding.category} eligible for score/heuristic auto-suppression`
+  };
+}
+
+// packages/core/dist/triage/verify-verdict.js
+var REPRODUCING_LAYERS = /* @__PURE__ */ new Set(["poc_gen", "pov_gate", "oracle"]);
+function evidenceKindForFinding(finding) {
+  const hasPocSteps = Array.isArray(finding.pocSteps) && finding.pocSteps.length > 0;
+  const reproduced = hasPocSteps && (finding.layerVerdicts ?? []).some((v) => v.verdict === "pass" && REPRODUCING_LAYERS.has(v.layer));
+  return reproduced ? "reproduced-poc" : "source-only";
+}
+function outcomeOf(verdict) {
+  return typeof verdict === "string" ? verdict : verdict.verdict;
+}
+function isDisclosureWorthy(finding, verdict) {
+  if (outcomeOf(verdict) !== "rejected") {
+    return {
+      keep: true,
+      reason: `verdict=${outcomeOf(verdict)}: not a rejection \u2014 finding kept`
+    };
+  }
+  const guard = canAutoSuppressDetailed(finding);
+  if (guard.canSuppress) {
+    return { keep: false, reason: guard.reason };
+  }
+  return { keep: true, guard: guard.guard, reason: guard.reason };
+}
+
 export {
   require_dist,
   hasKnownMarkerText,
@@ -8121,5 +8214,8 @@ export {
   resolveUrl,
   mergePersonaHeaders,
   evaluateExpect,
-  aggregateVerdict
+  aggregateVerdict,
+  canAutoSuppressDetailed,
+  evidenceKindForFinding,
+  isDisclosureWorthy
 };

package/chunks/{chunk-BMDG6T7D.js → chunk-YXTV2FRE.js}

@@ -8,7 +8,7 @@ import {
   homeStateDir,
   parseSecurityWorkflowInput,
   runStateDir
-} from "./chunk-GXXX7AGH.js";
+} from "./chunk-S3B6HFSM.js";
 import {
   __export
 } from "./chunk-VCSFCHAJ.js";
@@ -91,11 +91,11 @@ var ShimmedDatabase = class {
   constructor(engine) {
     this.engine = engine;
   }
-  prepare(sql) {
-    return new StatementShim(this.engine.prepare(sql));
+  prepare(sql2) {
+    return new StatementShim(this.engine.prepare(sql2));
   }
-  exec(sql) {
-    this.engine.exec(sql);
+  exec(sql2) {
+    this.engine.exec(sql2);
     return this;
   }
   /**
@@ -157,13 +157,13 @@ function createWasmEngine(path) {
   const { Database: WasmDatabaseCtor } = sqliteWasm;
   const wasm = new WasmDatabaseCtor(path);
   const prepared = /* @__PURE__ */ new Set();
-  const wrapStatement = (sql) => {
-    let initial = wasm.prepare(sql);
+  const wrapStatement = (sql2) => {
+    let initial = wasm.prepare(sql2);
     prepared.add(initial);
     const execute = (operation) => {
       if (!wasm.isOpen)
         throw new Error("Database already closed");
-      const statement = initial ?? wasm.prepare(sql);
+      const statement = initial ?? wasm.prepare(sql2);
       initial = void 0;
       prepared.add(statement);
       let succeeded = false;
@@ -195,9 +195,9 @@ function createWasmEngine(path) {
     };
   };
   return {
-    prepare: (sql) => wrapStatement(sql),
-    exec: (sql) => {
-      wasm.exec(sql);
+    prepare: (sql2) => wrapStatement(sql2),
+    exec: (sql2) => {
+      wasm.exec(sql2);
     },
     close: () => {
       for (const statement of prepared)
@@ -230,9 +230,9 @@ function createBunEngine(path) {
     values: (bind) => bind === void 0 ? stmt.values() : stmt.values(bind)
   });
   return {
-    prepare: (sql) => wrapStatement(db.prepare(sql)),
-    exec: (sql) => {
-      db.exec(sql);
+    prepare: (sql2) => wrapStatement(db.prepare(sql2)),
+    exec: (sql2) => {
+      db.exec(sql2);
     },
     close: () => db.close(),
     get inTransaction() {
@@ -276,7 +276,7 @@ function ensureDatabaseDirectory(path) {
 }
 
 // packages/db/dist/database.js
-import { asc, eq, desc, and, gt, inArray, or } from "drizzle-orm";
+import { asc, eq, desc, and, gt, inArray, or, sql } from "drizzle-orm";
 import { createHash, randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { closeSync, existsSync as existsSync2, openSync, readSync, renameSync, rmSync, statSync, writeSync } from "node:fs";
@@ -1901,6 +1901,14 @@ var osecDB = class {
       conditions.push(eq(pipelineEvents.eventType, opts.eventType));
     return this.db.select().from(pipelineEvents).where(and(...conditions)).orderBy(pipelineEvents.timestamp).all();
   }
+  /** Bounded retained receipts for explicit verification lifecycle recovery. */
+  getRecentScanEvents(scanId, eventType, limit2 = 100, tools) {
+    if (!Number.isSafeInteger(limit2) || limit2 < 1 || limit2 > 500)
+      throw new Error("invalid scan event limit");
+    if (tools && (!tools.length || tools.length > 10 || tools.some((tool) => !/^[a-z_]{1,64}$/.test(tool))))
+      throw new Error("invalid receipt tools");
+    return this.db.select().from(pipelineEvents).where(and(eq(pipelineEvents.scanId, scanId), eq(pipelineEvents.eventType, eventType), tools ? inArray(sql`CASE WHEN json_valid(${pipelineEvents.payload}) THEN json_extract(${pipelineEvents.payload}, '$.tool') ELSE '' END`, tools) : void 0)).orderBy(desc(pipelineEvents.timestamp), desc(pipelineEvents.id)).limit(limit2).all();
+  }
   listRecentEvents(limit2 = 50) {
     return this.db.select({
       id: pipelineEvents.id,
@@ -2996,6 +3004,81 @@ var LearningStore = class {
   getKnowledge(id) {
     return read(this.#db, "learning_knowledge", id);
   }
+  /** Export is explicit and fails rather than silently truncating a large memory library. */
+  exportKnowledge(projectId) {
+    if (projectId !== void 0)
+      bounded(projectId, "project ID");
+    const entries = this.#db.prepare("SELECT body FROM learning_knowledge WHERE (? IS NULL OR project_id=?) ORDER BY updated_at DESC,id LIMIT 201").all(projectId ?? null, projectId ?? null).map((row) => JSON.parse(row.body));
+    if (entries.length > 200)
+      fail("More than 200 lessons. Export one project at a time.", 413);
+    return entries;
+  }
+  #importIdentity(input) {
+    return createHash2("sha256").update(JSON.stringify({ projectId: input.projectId, summary: input.summary, sourceLinks: [...input.sourceLinks].sort((a, b) => a.path.localeCompare(b.path) || a.hash.localeCompare(b.hash)) })).digest("hex");
+  }
+  #existingImport(input) {
+    const identity = this.#importIdentity(input);
+    const entries = this.#db.prepare("SELECT body FROM learning_knowledge WHERE project_id=? AND json_extract(body,'$.summary')=?").all(input.projectId, input.summary);
+    return entries.some((row) => this.#importIdentity(JSON.parse(row.body)) === identity);
+  }
+  previewKnowledgeImport(inputs, exportedAt) {
+    if (!Array.isArray(inputs) || inputs.length > 200)
+      fail("At most 200 lessons can be imported.");
+    if (!Number.isFinite(Date.parse(exportedAt)))
+      fail("Invalid export timestamp.");
+    const seen = /* @__PURE__ */ new Set();
+    return inputs.map((input) => {
+      bounded(input.id, "original lesson ID");
+      bounded(input.projectId, "project ID");
+      bounded(input.summary, "knowledge summary", 4e3);
+      sources(input.sourceLinks);
+      if (!Number.isFinite(Date.parse(input.createdAt)))
+        fail("Invalid lesson timestamp.");
+      for (const link of input.sourceLinks)
+        if (isAbsolute2(link.path) || /^[A-Za-z]:[\\/]|^\\\\/.test(link.path) || /(?:^|[\\/])\.\.(?:[\\/]|$)/.test(link.path) || !/^sha256:[a-f0-9]{64}$/i.test(link.hash))
+          fail("Imported source links must use relative paths and SHA-256 hashes.");
+      if (!Array.isArray(input.provenance) || input.provenance.length > 64)
+        fail("Invalid lesson provenance.");
+      for (const evidence of input.provenance) {
+        bounded(evidence.id, "original evidence ID");
+        bounded(evidence.kind, "evidence kind");
+        if (!Number.isFinite(Date.parse(evidence.createdAt)))
+          fail("Invalid evidence timestamp.");
+      }
+      const identity = this.#importIdentity(input);
+      const duplicate = seen.has(identity) || this.#existingImport(input);
+      seen.add(identity);
+      return duplicate;
+    });
+  }
+  /** Imported prose is retained for inspection only, never admitted as current source evidence. */
+  importKnowledge(inputs, exportedAt) {
+    return this.#db.transaction(() => {
+      const duplicates = this.previewKnowledgeImport(inputs, exportedAt);
+      let imported = 0;
+      inputs.forEach((input, index2) => {
+        if (duplicates[index2])
+          return;
+        const fingerprint = this.#importIdentity(input);
+        const event = appendLearningEvent(this.#db, { idempotencyKey: `memory-import:${fingerprint}`, projectId: input.projectId, kind: "memory-import", outcome: "retained-disabled", evidenceStrength: "hypothesis", summary: "Imported lesson retained as disabled; original provenance is untrusted data.", sourceLinks: input.sourceLinks });
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const entry = {
+          id: `knowledge:import:${fingerprint}`,
+          projectId: input.projectId,
+          summary: input.summary,
+          sourceLinks: input.sourceLinks,
+          evidenceEventIds: [event.id],
+          status: "disabled",
+          createdAt: now,
+          updatedAt: now,
+          importedFrom: { id: input.id, projectId: input.projectId, createdAt: input.createdAt, exportedAt, evidence: input.provenance }
+        };
+        write(this.#db, "learning_knowledge", entry);
+        imported++;
+      });
+      return { imported, duplicates: duplicates.filter(Boolean).length, disabled: true };
+    })();
+  }
   #checkEvidence(projectId, ids) {
     refs(ids, "evidence event IDs");
     if (!ids.length)
@@ -3006,19 +3089,27 @@ var LearningStore = class {
         fail("Evidence must belong to the same project.");
     }
   }
+  /** Match operator-disabled source lessons independently of library pagination. */
+  findDisabledSourceKnowledge(projectId, summary, sourceLinks) {
+    const fingerprint = (links) => JSON.stringify([...links].sort((a, b) => a.path.localeCompare(b.path) || a.hash.localeCompare(b.hash)));
+    const matching = this.#db.prepare("SELECT body FROM learning_knowledge WHERE project_id=? AND json_extract(body,'$.summary')=? AND json_extract(body,'$.status')='disabled'").all(projectId, summary);
+    const requested = fingerprint(sourceLinks);
+    for (const row of matching) {
+      const prior = JSON.parse(row.body);
+      if (fingerprint(prior.sourceLinks) === requested)
+        return prior;
+    }
+    return null;
+  }
   putKnowledge(input) {
     bounded(input.projectId, "project ID");
     bounded(input.summary, "knowledge summary", 4e3);
     sources(input.sourceLinks);
     this.#checkEvidence(input.projectId, input.evidenceEventIds);
     if (input.sourceLinks.length) {
-      const fingerprint = (links) => JSON.stringify([...links].sort((a, b) => a.path.localeCompare(b.path) || a.hash.localeCompare(b.hash)));
-      const matching = this.#db.prepare("SELECT body FROM learning_knowledge WHERE project_id=? AND json_extract(body,'$.summary')=? AND json_extract(body,'$.status')='disabled'").all(input.projectId, input.summary);
-      for (const row of matching) {
-        const prior = JSON.parse(row.body);
-        if (fingerprint(prior.sourceLinks) === fingerprint(input.sourceLinks))
-          return prior;
-      }
+      const disabled = this.findDisabledSourceKnowledge(input.projectId, input.summary, input.sourceLinks);
+      if (disabled)
+        return disabled;
     }
     const identity = `knowledge:${createHash2("sha256").update(JSON.stringify({ projectId: input.projectId, summary: input.summary, sourceLinks: [...input.sourceLinks].sort((a, b) => a.path.localeCompare(b.path)), evidenceEventIds: [...input.evidenceEventIds].sort() })).digest("hex")}`;
     const existing = this.getKnowledge(identity);

package/chunks/{chunk-SZDD77KX.js → chunk-YYFODVZG.js}

@@ -5,23 +5,19 @@ import {
   source_default
 } from "./chunk-HLFS6WV2.js";
 import {
-  agenticScan
-} from "./chunk-ZM6ANQZJ.js";
-import {
+  agenticScan,
+  getToolsForRole,
   runAgentLoop
-} from "./chunk-YSQWZ67M.js";
-import {
-  getToolsForRole
-} from "./chunk-5WAHHZBF.js";
+} from "./chunk-HFUOUT2B.js";
 import {
   createRuntime
-} from "./chunk-K74DRDC5.js";
+} from "./chunk-DHNYJ2ML.js";
 import {
   osecDB
-} from "./chunk-BMDG6T7D.js";
+} from "./chunk-YXTV2FRE.js";
 import {
   LlmApiRuntime
-} from "./chunk-IJ6UPW3H.js";
+} from "./chunk-EIONVEFN.js";
 
 // packages/cli/src/commands/orchestrate.ts
 import { randomUUID } from "node:crypto";