limen-ai 1.0.0

package/dist/learning/migration/008_learning_outcomes.js

@@ -0,0 +1,79 @@
+/**
+ * Forward-only migration v17: Learning Outcome Tracking
+ * S ref: S29.5 (effectiveness tracking), I-07 (agent isolation), FM-10 (tenant isolation)
+ *
+ * Phase: 4E-2d (Certification — EffectivenessTracker + RetirementEvaluator)
+ *
+ * Adds:
+ *   - learning_outcomes table (per-technique outcome records)
+ *   - Indexes for technique+tenant lookup and rolling window query
+ *   - Tenant immutability trigger (same pattern as Phase 4B)
+ *
+ * Schema derives from EffectivenessTracker.recordOutcome interface:
+ *   Stores outcome classification per technique per interaction.
+ *   No FOREIGN KEY to learning_techniques — audit history survives
+ *   technique retirement (same rationale as learning_applications).
+ */
+import { createHash } from 'node:crypto';
+// ─── Migration v17: Learning Outcomes Table ───
+const MIGRATION_017_SQL = `
+-- Migration 017: Learning Outcome Tracking
+-- S ref: S29.5 (effectiveness tracking), I-07 (agent isolation), FM-10 (tenant isolation)
+-- Phase: 4E-2d
+-- Constraint: C-05 (forward-only migration)
+
+-- ────────────────────────────────────────────────────────────
+-- Outcome tracking table
+-- Each row records a single outcome observation for a technique.
+-- Used by EffectivenessTracker.getSuccessRate for rolling window.
+-- No FK to learning_techniques: audit history survives retirement.
+-- ────────────────────────────────────────────────────────────
+
+CREATE TABLE learning_outcomes (
+  id              TEXT    PRIMARY KEY,
+  technique_id    TEXT    NOT NULL,
+  tenant_id       TEXT    NOT NULL,
+  outcome         TEXT    NOT NULL CHECK (outcome IN ('positive', 'neutral', 'negative')),
+  created_at      TEXT    NOT NULL
+);
+
+-- ────────────────────────────────────────────────────────────
+-- Indexes
+-- Primary: technique + tenant lookup (all queries scoped by both)
+-- Secondary: rolling window query (ORDER BY created_at DESC LIMIT 50)
+-- ────────────────────────────────────────────────────────────
+
+CREATE INDEX idx_lo_technique_tenant ON learning_outcomes(technique_id, tenant_id);
+CREATE INDEX idx_lo_technique_tenant_time ON learning_outcomes(technique_id, tenant_id, created_at DESC);
+
+-- ────────────────────────────────────────────────────────────
+-- Tenant immutability trigger (same pattern as Phase 4B)
+-- Prevents tenant_id from being changed after INSERT.
+-- ────────────────────────────────────────────────────────────
+
+CREATE TRIGGER learning_outcomes_tenant_immutable
+  BEFORE UPDATE OF tenant_id ON learning_outcomes
+  WHEN OLD.tenant_id IS NOT NULL AND NEW.tenant_id IS NOT OLD.tenant_id
+  BEGIN
+    SELECT RAISE(ABORT, 'I-MUT: tenant_id is immutable after INSERT on learning_outcomes');
+  END;
+`;
+// ─── Build Migration Entry ───
+function buildEntry(version, name, sql) {
+    return {
+        version,
+        name,
+        sql,
+        checksum: createHash('sha256').update(sql).digest('hex'),
+    };
+}
+/**
+ * Get Phase 4E-2d (Learning Outcomes) migration.
+ * Version 17 continues from Phase 4E-2a's version 16.
+ */
+export function getPhase4E2dOutcomesMigration() {
+    return [
+        buildEntry(17, 'learning_outcomes', MIGRATION_017_SQL),
+    ];
+}
+//# sourceMappingURL=008_learning_outcomes.js.map

package/dist/learning/migration/008_learning_outcomes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"008_learning_outcomes.js","sourceRoot":"","sources":["../../../src/learning/migration/008_learning_outcomes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAGzC,iDAAiD;AAEjD,MAAM,iBAAiB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCzB,CAAC;AAEF,gCAAgC;AAEhC,SAAS,UAAU,CAAC,OAAe,EAAE,IAAY,EAAE,GAAW;IAC5D,OAAO;QACL,OAAO;QACP,IAAI;QACJ,GAAG;QACH,QAAQ,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;KACzD,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,6BAA6B;IAC3C,OAAO;QACL,UAAU,CAAC,EAAE,EAAE,mBAAmB,EAAE,iBAAiB,CAAC;KACvD,CAAC;AACJ,CAAC"}

package/dist/learning/migration/009_learning_applications.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Forward-only migration v18: Learning System Application Log
+ * S ref: S29.4 (application recording), I-03 (audit), I-07 (agent isolation)
+ *
+ * Phase: 4E-2c (Certification — Learning System TechniqueApplicator)
+ *
+ * Adds:
+ *   - learning_applications table (application recording log)
+ *   - Indexes for technique-level and tenant-level lookup
+ *   - Tenant immutability trigger
+ *
+ * Design decisions:
+ *   R-07: NO foreign key to learning_techniques. Application records are an
+ *   append-only audit log. Techniques may be retired and eventually tombstoned
+ *   (GDPR, I-03) while application history is preserved. Phantom technique IDs
+ *   are acceptable — the log records what was attempted, not what currently exists.
+ *   Contract test #18 exercises this with phantom IDs ('t-1', 't-2').
+ */
+import type { MigrationEntry } from '../../kernel/interfaces/index.js';
+/**
+ * Get Phase 4E-2c (Learning Applications) migration.
+ * Version 18 continues from Phase 4E-2d's version 17 (learning_outcomes).
+ */
+export declare function getPhase4E2cApplicationsMigration(): MigrationEntry[];
+//# sourceMappingURL=009_learning_applications.d.ts.map

package/dist/learning/migration/009_learning_applications.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"009_learning_applications.d.ts","sourceRoot":"","sources":["../../../src/learning/migration/009_learning_applications.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AA2DvE;;;GAGG;AACH,wBAAgB,iCAAiC,IAAI,cAAc,EAAE,CAIpE"}

package/dist/learning/migration/009_learning_applications.js

@@ -0,0 +1,82 @@
+/**
+ * Forward-only migration v18: Learning System Application Log
+ * S ref: S29.4 (application recording), I-03 (audit), I-07 (agent isolation)
+ *
+ * Phase: 4E-2c (Certification — Learning System TechniqueApplicator)
+ *
+ * Adds:
+ *   - learning_applications table (application recording log)
+ *   - Indexes for technique-level and tenant-level lookup
+ *   - Tenant immutability trigger
+ *
+ * Design decisions:
+ *   R-07: NO foreign key to learning_techniques. Application records are an
+ *   append-only audit log. Techniques may be retired and eventually tombstoned
+ *   (GDPR, I-03) while application history is preserved. Phantom technique IDs
+ *   are acceptable — the log records what was attempted, not what currently exists.
+ *   Contract test #18 exercises this with phantom IDs ('t-1', 't-2').
+ */
+import { createHash } from 'node:crypto';
+// ─── Migration v18: Learning Applications Table ───
+const MIGRATION_018_SQL = `
+-- Migration 018: Learning System Application Log
+-- S ref: S29.4 (application recording), I-03 (audit), R-07 (no FK)
+-- Phase: 4E-2c
+-- Constraint: C-05 (forward-only migration)
+
+-- ────────────────────────────────────────────────────────────
+-- Application log table
+-- Append-only record of technique applications per interaction.
+-- No FK to learning_techniques (R-07) — techniques may be
+-- tombstoned while application history is preserved for audit.
+-- ────────────────────────────────────────────────────────────
+
+CREATE TABLE learning_applications (
+  id              TEXT    PRIMARY KEY,
+  technique_id    TEXT    NOT NULL,
+  interaction_id  TEXT    NOT NULL,
+  tenant_id       TEXT    NOT NULL,
+  timestamp       TEXT    NOT NULL,
+  applied         INTEGER NOT NULL DEFAULT 1  -- 1=applied, 0=skipped due to context limits (S29.4)
+);
+
+-- ────────────────────────────────────────────────────────────
+-- Indexes
+-- Primary: technique-level aggregation for effectiveness tracking
+-- Secondary: tenant-scoped queries for tenant isolation
+-- ────────────────────────────────────────────────────────────
+
+CREATE INDEX idx_la_technique ON learning_applications(technique_id);
+CREATE INDEX idx_la_tenant_technique ON learning_applications(tenant_id, technique_id);
+
+-- ────────────────────────────────────────────────────────────
+-- Tenant immutability trigger (same pattern as Phase 4B, 4E-2a)
+-- Prevents tenant_id from being changed after INSERT.
+-- ────────────────────────────────────────────────────────────
+
+CREATE TRIGGER learning_applications_tenant_immutable
+  BEFORE UPDATE OF tenant_id ON learning_applications
+  WHEN OLD.tenant_id IS NOT NULL AND NEW.tenant_id IS NOT OLD.tenant_id
+  BEGIN
+    SELECT RAISE(ABORT, 'I-MUT: tenant_id is immutable after INSERT on learning_applications');
+  END;
+`;
+// ─── Build Migration Entry ───
+function buildEntry(version, name, sql) {
+    return {
+        version,
+        name,
+        sql,
+        checksum: createHash('sha256').update(sql).digest('hex'),
+    };
+}
+/**
+ * Get Phase 4E-2c (Learning Applications) migration.
+ * Version 18 continues from Phase 4E-2d's version 17 (learning_outcomes).
+ */
+export function getPhase4E2cApplicationsMigration() {
+    return [
+        buildEntry(18, 'learning_applications', MIGRATION_018_SQL),
+    ];
+}
+//# sourceMappingURL=009_learning_applications.js.map

package/dist/learning/migration/009_learning_applications.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"009_learning_applications.js","sourceRoot":"","sources":["../../../src/learning/migration/009_learning_applications.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAGzC,qDAAqD;AAErD,MAAM,iBAAiB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CzB,CAAC;AAEF,gCAAgC;AAEhC,SAAS,UAAU,CAAC,OAAe,EAAE,IAAY,EAAE,GAAW;IAC5D,OAAO;QACL,OAAO;QACP,IAAI;QACJ,GAAG;QACH,QAAQ,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;KACzD,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,iCAAiC;IAC/C,OAAO;QACL,UAAU,CAAC,EAAE,EAAE,uBAAuB,EAAE,iBAAiB,CAAC;KAC3D,CAAC;AACJ,CAAC"}

package/dist/learning/migration/010_learning_quarantine.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Forward-only migration v19: Learning System Quarantine Entries
+ * S ref: S29.7 (quarantine cascade), FM-01 (memory poisoning defense), I-03 (audit)
+ *
+ * Phase: 4E-2e (Certification — Learning System Convergence Subsystems)
+ *
+ * Adds:
+ *   - learning_quarantine_entries table (quarantine tracking)
+ *   - Index for tenant + resolution status (getPending queries)
+ *   - Tenant immutability trigger (same pattern as Phase 4B)
+ *
+ * Schema derives from QuarantineEntry interface in learning_types.ts:
+ *   id, technique_id, agent_id, tenant_id, reason,
+ *   quarantined_at, resolved_at, resolution
+ */
+import type { MigrationEntry } from '../../kernel/interfaces/index.js';
+/**
+ * Get Phase 4E-2e (Learning QuarantineManager) migration.
+ * Version 19 continues from Phase 4E-2d's version 18.
+ */
+export declare function getPhase4E2eQuarantineMigration(): MigrationEntry[];
+//# sourceMappingURL=010_learning_quarantine.d.ts.map

package/dist/learning/migration/010_learning_quarantine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"010_learning_quarantine.d.ts","sourceRoot":"","sources":["../../../src/learning/migration/010_learning_quarantine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AA0DvE;;;GAGG;AACH,wBAAgB,+BAA+B,IAAI,cAAc,EAAE,CAIlE"}

package/dist/learning/migration/010_learning_quarantine.js

@@ -0,0 +1,78 @@
+/**
+ * Forward-only migration v19: Learning System Quarantine Entries
+ * S ref: S29.7 (quarantine cascade), FM-01 (memory poisoning defense), I-03 (audit)
+ *
+ * Phase: 4E-2e (Certification — Learning System Convergence Subsystems)
+ *
+ * Adds:
+ *   - learning_quarantine_entries table (quarantine tracking)
+ *   - Index for tenant + resolution status (getPending queries)
+ *   - Tenant immutability trigger (same pattern as Phase 4B)
+ *
+ * Schema derives from QuarantineEntry interface in learning_types.ts:
+ *   id, technique_id, agent_id, tenant_id, reason,
+ *   quarantined_at, resolved_at, resolution
+ */
+import { createHash } from 'node:crypto';
+// ─── Migration v19: Learning Quarantine Entries Table ───
+const MIGRATION_019_SQL = `
+-- Migration 019: Learning System Quarantine Entries
+-- S ref: S29.7 (quarantine cascade), FM-01 (memory poisoning defense)
+-- Phase: 4E-2e
+-- Constraint: C-05 (forward-only migration)
+
+-- ────────────────────────────────────────────────────────────
+-- Quarantine entries track technique suspensions from FM-01.
+-- Resolution requires human authority (HITL review).
+-- No FK to learning_techniques — entries survive technique lifecycle.
+-- ────────────────────────────────────────────────────────────
+
+CREATE TABLE learning_quarantine_entries (
+  id              TEXT    PRIMARY KEY,
+  technique_id    TEXT    NOT NULL,
+  agent_id        TEXT    NOT NULL,
+  tenant_id       TEXT    NOT NULL,
+  reason          TEXT    NOT NULL,
+  quarantined_at  TEXT    NOT NULL,
+  resolved_at     TEXT,
+  resolution      TEXT    CHECK (resolution IS NULL OR resolution IN ('reactivated', 'permanently_retired')),
+  created_at      TEXT    NOT NULL
+);
+
+-- ────────────────────────────────────────────────────────────
+-- Indexes
+-- Primary access pattern: getPending queries tenant + unresolved
+-- ────────────────────────────────────────────────────────────
+
+CREATE INDEX idx_lqe_tenant_pending ON learning_quarantine_entries(tenant_id, resolved_at);
+
+-- ────────────────────────────────────────────────────────────
+-- Tenant immutability trigger (same pattern as Phase 4B)
+-- ────────────────────────────────────────────────────────────
+
+CREATE TRIGGER learning_quarantine_entries_tenant_immutable
+  BEFORE UPDATE OF tenant_id ON learning_quarantine_entries
+  WHEN OLD.tenant_id IS NOT NULL AND NEW.tenant_id IS NOT OLD.tenant_id
+  BEGIN
+    SELECT RAISE(ABORT, 'I-MUT: tenant_id is immutable after INSERT on learning_quarantine_entries');
+  END;
+`;
+// ─── Build Migration Entry ───
+function buildEntry(version, name, sql) {
+    return {
+        version,
+        name,
+        sql,
+        checksum: createHash('sha256').update(sql).digest('hex'),
+    };
+}
+/**
+ * Get Phase 4E-2e (Learning QuarantineManager) migration.
+ * Version 19 continues from Phase 4E-2d's version 18.
+ */
+export function getPhase4E2eQuarantineMigration() {
+    return [
+        buildEntry(19, 'learning_quarantine_entries', MIGRATION_019_SQL),
+    ];
+}
+//# sourceMappingURL=010_learning_quarantine.js.map

package/dist/learning/migration/010_learning_quarantine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"010_learning_quarantine.js","sourceRoot":"","sources":["../../../src/learning/migration/010_learning_quarantine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAGzC,2DAA2D;AAE3D,MAAM,iBAAiB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCzB,CAAC;AAEF,gCAAgC;AAEhC,SAAS,UAAU,CAAC,OAAe,EAAE,IAAY,EAAE,GAAW;IAC5D,OAAO;QACL,OAAO;QACP,IAAI;QACJ,GAAG;QACH,QAAQ,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;KACzD,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,+BAA+B;IAC7C,OAAO;QACL,UAAU,CAAC,EAAE,EAAE,6BAA6B,EAAE,iBAAiB,CAAC;KACjE,CAAC;AACJ,CAAC"}

package/dist/learning/migration/011_learning_transfers.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Forward-only migration v20: Learning System Transfer Requests
+ * S ref: S29.8 (cross-agent transfer protocol), I-07 (agent isolation), DEC-4E-002
+ *
+ * Phase: 4E-2e (Certification — Learning System Convergence Subsystems)
+ *
+ * Adds:
+ *   - learning_transfer_requests table (transfer lifecycle tracking)
+ *   - Index for tenant + status (pending request queries)
+ *   - Tenant immutability trigger (same pattern as Phase 4B)
+ *
+ * Schema derives from TransferRequest interface in learning_types.ts:
+ *   id, tenant_id, source_agent_id, target_agent_id, technique_id,
+ *   status, created_at, resolved_at
+ */
+import type { MigrationEntry } from '../../kernel/interfaces/index.js';
+/**
+ * Get Phase 4E-2e (Learning CrossAgentTransfer) migration.
+ * Version 20 continues from Phase 4E-2e's quarantine migration v19.
+ */
+export declare function getPhase4E2eTransferMigration(): MigrationEntry[];
+//# sourceMappingURL=011_learning_transfers.d.ts.map

package/dist/learning/migration/011_learning_transfers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"011_learning_transfers.d.ts","sourceRoot":"","sources":["../../../src/learning/migration/011_learning_transfers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAyDvE;;;GAGG;AACH,wBAAgB,6BAA6B,IAAI,cAAc,EAAE,CAIhE"}

package/dist/learning/migration/011_learning_transfers.js

@@ -0,0 +1,77 @@
+/**
+ * Forward-only migration v20: Learning System Transfer Requests
+ * S ref: S29.8 (cross-agent transfer protocol), I-07 (agent isolation), DEC-4E-002
+ *
+ * Phase: 4E-2e (Certification — Learning System Convergence Subsystems)
+ *
+ * Adds:
+ *   - learning_transfer_requests table (transfer lifecycle tracking)
+ *   - Index for tenant + status (pending request queries)
+ *   - Tenant immutability trigger (same pattern as Phase 4B)
+ *
+ * Schema derives from TransferRequest interface in learning_types.ts:
+ *   id, tenant_id, source_agent_id, target_agent_id, technique_id,
+ *   status, created_at, resolved_at
+ */
+import { createHash } from 'node:crypto';
+// ─── Migration v20: Learning Transfer Requests Table ───
+const MIGRATION_020_SQL = `
+-- Migration 020: Learning System Transfer Requests
+-- S ref: S29.8 (cross-agent transfer), DEC-4E-002 (cross-tenant blocked)
+-- Phase: 4E-2e
+-- Constraint: C-05 (forward-only migration)
+
+-- ────────────────────────────────────────────────────────────
+-- Transfer requests track cross-agent technique transfers.
+-- Single tenant_id field — cross-tenant structurally impossible (DEC-4E-002).
+-- No FK to learning_techniques — request survives technique lifecycle.
+-- ────────────────────────────────────────────────────────────
+
+CREATE TABLE learning_transfer_requests (
+  id                TEXT    PRIMARY KEY,
+  tenant_id         TEXT    NOT NULL,
+  source_agent_id   TEXT    NOT NULL,
+  target_agent_id   TEXT    NOT NULL,
+  technique_id      TEXT    NOT NULL,
+  status            TEXT    NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'approved', 'rejected')),
+  created_at        TEXT    NOT NULL,
+  resolved_at       TEXT
+);
+
+-- ────────────────────────────────────────────────────────────
+-- Indexes
+-- Primary access pattern: pending requests by tenant
+-- ────────────────────────────────────────────────────────────
+
+CREATE INDEX idx_ltr_tenant_status ON learning_transfer_requests(tenant_id, status);
+
+-- ────────────────────────────────────────────────────────────
+-- Tenant immutability trigger (same pattern as Phase 4B)
+-- ────────────────────────────────────────────────────────────
+
+CREATE TRIGGER learning_transfer_requests_tenant_immutable
+  BEFORE UPDATE OF tenant_id ON learning_transfer_requests
+  WHEN OLD.tenant_id IS NOT NULL AND NEW.tenant_id IS NOT OLD.tenant_id
+  BEGIN
+    SELECT RAISE(ABORT, 'I-MUT: tenant_id is immutable after INSERT on learning_transfer_requests');
+  END;
+`;
+// ─── Build Migration Entry ───
+function buildEntry(version, name, sql) {
+    return {
+        version,
+        name,
+        sql,
+        checksum: createHash('sha256').update(sql).digest('hex'),
+    };
+}
+/**
+ * Get Phase 4E-2e (Learning CrossAgentTransfer) migration.
+ * Version 20 continues from Phase 4E-2e's quarantine migration v19.
+ */
+export function getPhase4E2eTransferMigration() {
+    return [
+        buildEntry(20, 'learning_transfer_requests', MIGRATION_020_SQL),
+    ];
+}
+//# sourceMappingURL=011_learning_transfers.js.map

package/dist/learning/migration/011_learning_transfers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"011_learning_transfers.js","sourceRoot":"","sources":["../../../src/learning/migration/011_learning_transfers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAGzC,0DAA0D;AAE1D,MAAM,iBAAiB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCzB,CAAC;AAEF,gCAAgC;AAEhC,SAAS,UAAU,CAAC,OAAe,EAAE,IAAY,EAAE,GAAW;IAC5D,OAAO;QACL,OAAO;QACP,IAAI;QACJ,GAAG;QACH,QAAQ,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;KACzD,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,6BAA6B;IAC3C,OAAO;QACL,UAAU,CAAC,EAAE,EAAE,4BAA4B,EAAE,iBAAiB,CAAC;KAChE,CAAC;AACJ,CAAC"}

package/dist/learning/quarantine/quarantine_manager.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Limen — QuarantineManager Implementation
+ * Phase 4E-2e: Learning System Convergence Subsystems
+ *
+ * Implements the QuarantineManager interface from learning_types.ts.
+ * FM-01 defense: atomic suspension of suspected techniques.
+ * Resolution requires human authority (HITL review).
+ *
+ * S ref: S29.7 (quarantine cascade), FM-01 (memory poisoning),
+ *        I-03 (audit atomicity), I-07 (agent isolation)
+ *
+ * Engineering decisions:
+ *   D1: Already-retired techniques in cascade are SKIPPED (FS-04: cannot suspend retired).
+ *       A quarantine entry is NOT created for skipped retired techniques — they're
+ *       already out of service. Creating an entry would pollute getPending.
+ *   D2: Already-suspended techniques in cascade: quarantine entry IS created, but
+ *       store.suspend() is NOT called (suspended→suspended is invalid transition).
+ *       The entry tracks the quarantine reason even though the technique was already suspended.
+ *   D3: resolve() checks technique's current status before acting. If technique was
+ *       retired between quarantine and resolution (e.g., by RetirementEvaluator), the
+ *       entry is still resolved but the reactivation fails gracefully.
+ *   D4: Cross-agent quarantine: quarantine() is the only operation that crosses agent
+ *       boundaries within a tenant. It queries by id+tenant_id (no agentId filter)
+ *       because memory poisoning affects all agents referencing that memory.
+ */
+import type { QuarantineManager, TechniqueStore, LearningDeps } from '../interfaces/index.js';
+/**
+ * Create a QuarantineManager implementation.
+ * Follows the Limen store pattern: factory → Object.freeze.
+ *
+ * S29.7: "memory quarantine + technique suspension in one SQLite transaction (I-03)."
+ */
+export declare function createQuarantineManager(deps: LearningDeps, store: TechniqueStore): QuarantineManager;
+//# sourceMappingURL=quarantine_manager.d.ts.map

package/dist/learning/quarantine/quarantine_manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quarantine_manager.d.ts","sourceRoot":"","sources":["../../../src/learning/quarantine/quarantine_manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,KAAK,EACV,iBAAiB,EACJ,cAAc,EAAE,YAAY,EAC1C,MAAM,wBAAwB,CAAC;AAsDhC;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,cAAc,GAAG,iBAAiB,CAyMpG"}

package/dist/learning/quarantine/quarantine_manager.js

@@ -0,0 +1,200 @@
+/**
+ * Limen — QuarantineManager Implementation
+ * Phase 4E-2e: Learning System Convergence Subsystems
+ *
+ * Implements the QuarantineManager interface from learning_types.ts.
+ * FM-01 defense: atomic suspension of suspected techniques.
+ * Resolution requires human authority (HITL review).
+ *
+ * S ref: S29.7 (quarantine cascade), FM-01 (memory poisoning),
+ *        I-03 (audit atomicity), I-07 (agent isolation)
+ *
+ * Engineering decisions:
+ *   D1: Already-retired techniques in cascade are SKIPPED (FS-04: cannot suspend retired).
+ *       A quarantine entry is NOT created for skipped retired techniques — they're
+ *       already out of service. Creating an entry would pollute getPending.
+ *   D2: Already-suspended techniques in cascade: quarantine entry IS created, but
+ *       store.suspend() is NOT called (suspended→suspended is invalid transition).
+ *       The entry tracks the quarantine reason even though the technique was already suspended.
+ *   D3: resolve() checks technique's current status before acting. If technique was
+ *       retired between quarantine and resolution (e.g., by RetirementEvaluator), the
+ *       entry is still resolved but the reactivation fails gracefully.
+ *   D4: Cross-agent quarantine: quarantine() is the only operation that crosses agent
+ *       boundaries within a tenant. It queries by id+tenant_id (no agentId filter)
+ *       because memory poisoning affects all agents referencing that memory.
+ */
+import { randomUUID } from 'node:crypto';
+import { CONFIDENCE_RESET_REACTIVATION } from '../interfaces/index.js';
+function rowToEntry(row) {
+    return {
+        id: row.id,
+        techniqueId: row.technique_id,
+        tenantId: row.tenant_id,
+        agentId: row.agent_id,
+        reason: row.reason,
+        quarantinedAt: row.quarantined_at,
+        resolvedAt: row.resolved_at,
+        resolution: row.resolution,
+    };
+}
+// ─── Audit Helpers ───
+function actorType(ctx) {
+    if (ctx.userId)
+        return 'user';
+    if (ctx.agentId)
+        return 'agent';
+    return 'system';
+}
+function actorId(ctx) {
+    return (ctx.userId ?? ctx.agentId ?? 'system');
+}
+// ─── Factory ───
+/**
+ * Create a QuarantineManager implementation.
+ * Follows the Limen store pattern: factory → Object.freeze.
+ *
+ * S29.7: "memory quarantine + technique suspension in one SQLite transaction (I-03)."
+ */
+export function createQuarantineManager(deps, store) {
+    // ─── quarantine ───
+    function quarantine(conn, ctx, techniqueIds, tenantId, reason) {
+        const entries = [];
+        const now = deps.time.nowISO();
+        conn.transaction(() => {
+            for (const tid of techniqueIds) {
+                // Query directly by id + tenant_id (no agentId — cross-agent quarantine, D4)
+                const technique = conn.get(`SELECT id, tenant_id, agent_id, status FROM learning_techniques WHERE id = ? AND tenant_id = ?`, [tid, tenantId]);
+                if (!technique)
+                    continue; // Technique not found — skip silently
+                // D1: Skip already-retired techniques (FS-04)
+                if (technique.status === 'retired')
+                    continue;
+                // D2: If already suspended, create entry but skip suspend call
+                if (technique.status === 'active') {
+                    store.suspend(conn, ctx, tid, tenantId);
+                }
+                const entryId = randomUUID();
+                conn.run(`INSERT INTO learning_quarantine_entries
+            (id, technique_id, agent_id, tenant_id, reason, quarantined_at, resolved_at, resolution, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, NULL, NULL, ?)`, [entryId, tid, technique.agent_id, tenantId, reason, now, now]);
+                entries.push({
+                    id: entryId,
+                    techniqueId: tid,
+                    tenantId,
+                    agentId: technique.agent_id,
+                    reason,
+                    quarantinedAt: now,
+                    resolvedAt: null,
+                    resolution: null,
+                });
+            }
+            deps.audit.append(conn, {
+                tenantId,
+                actorType: actorType(ctx),
+                actorId: actorId(ctx),
+                operation: `quarantine.cascade:${techniqueIds.length}`,
+                resourceType: 'quarantine',
+                resourceId: entries.map(e => e.id).join(','),
+            });
+        });
+        return { ok: true, value: entries };
+    }
+    // ─── resolve ───
+    function resolve(conn, ctx, entryId, resolution) {
+        const callerTenantId = ctx.tenantId;
+        const entry = conn.get(`SELECT * FROM learning_quarantine_entries WHERE id = ? AND tenant_id = ?`, [entryId, callerTenantId]);
+        if (!entry) {
+            return {
+                ok: false,
+                error: {
+                    code: 'QUARANTINE_ENTRY_NOT_FOUND',
+                    message: `Quarantine entry ${entryId} not found`,
+                    spec: 'S29.7',
+                },
+            };
+        }
+        if (entry.resolved_at !== null) {
+            return {
+                ok: false,
+                error: {
+                    code: 'ALREADY_RESOLVED',
+                    message: `Quarantine entry ${entryId} already resolved as ${entry.resolution}`,
+                    spec: 'S29.7',
+                },
+            };
+        }
+        const techniqueId = entry.technique_id;
+        const entryTenantId = entry.tenant_id;
+        const now = deps.time.nowISO();
+        // BRK-IMPL-006: Check store operation result BEFORE updating quarantine entry.
+        // If the technique's state has changed since quarantine (e.g., retired through
+        // another path), the store operation will fail. We must not mark the entry as
+        // resolved with an incorrect resolution.
+        let storeResult;
+        if (resolution === 'reactivated') {
+            storeResult = store.reactivate(conn, ctx, techniqueId, entryTenantId, CONFIDENCE_RESET_REACTIVATION);
+        }
+        else {
+            // permanently_retired
+            storeResult = store.retire(conn, ctx, techniqueId, entryTenantId, 'quarantine_retired');
+        }
+        if (!storeResult.ok) {
+            return {
+                ok: false,
+                error: {
+                    code: 'TECHNIQUE_STATE_CHANGED',
+                    message: `Cannot resolve quarantine as '${resolution}': ${storeResult.error.message}`,
+                    spec: 'S29.7',
+                },
+            };
+        }
+        // Store operation succeeded — now update quarantine entry
+        conn.transaction(() => {
+            conn.run(`UPDATE learning_quarantine_entries SET resolved_at = ?, resolution = ? WHERE id = ?`, [now, resolution, entryId]);
+            deps.audit.append(conn, {
+                tenantId: entryTenantId,
+                actorType: actorType(ctx),
+                actorId: actorId(ctx),
+                operation: `quarantine.resolve:${resolution}`,
+                resourceType: 'quarantine',
+                resourceId: entryId,
+            });
+        });
+        return { ok: true, value: undefined };
+    }
+    // ─── getPending ───
+    function getPending(conn, tenantId) {
+        const rows = conn.query(`SELECT * FROM learning_quarantine_entries WHERE tenant_id = ? AND resolved_at IS NULL ORDER BY quarantined_at ASC`, [tenantId]);
+        return { ok: true, value: rows.map(rowToEntry) };
+    }
+    // ─── cascadeFromMemory (BRK-IMPL-007) ───
+    /**
+     * BRK-IMPL-007: GDPR cascade — when a source memory is tombstoned/poisoned,
+     * find all derived techniques via getBySourceMemory and quarantine them.
+     * Bridges memory → technique → quarantine in one operation.
+     *
+     * S ref: S29.7 (quarantine cascade), FM-01 (memory poisoning), GDPR Art. 17
+     */
+    function cascadeFromMemory(conn, ctx, memoryId, tenantId, reason) {
+        // Step 1: Find all techniques derived from this memory
+        const techniquesResult = store.getBySourceMemory(conn, memoryId, tenantId);
+        if (!techniquesResult.ok)
+            return techniquesResult;
+        const techniques = techniquesResult.value;
+        if (techniques.length === 0) {
+            // No derived techniques — cascade is a no-op (valid case)
+            return { ok: true, value: [] };
+        }
+        // Step 2: Quarantine all derived techniques
+        const techniqueIds = techniques.map(t => t.id);
+        return quarantine(conn, ctx, techniqueIds, tenantId, reason);
+    }
+    // ─── Return frozen manager ───
+    return Object.freeze({
+        quarantine,
+        resolve,
+        getPending,
+        cascadeFromMemory,
+    });
+}
+//# sourceMappingURL=quarantine_manager.js.map