principles-disciple 1.123.0 → 1.124.0

package/tests/hooks/gate-auto-correct-shadow.test.ts

@@ -52,7 +52,6 @@ vi.mock('../../src/core/rule-host.js', () => ({
 
 vi.mock('../../src/core/principle-tree-ledger.js', () => ({
   loadLedger: vi.fn(),
-  listImplementationsByLifecycleState: vi.fn(() => []),
 }));
 
 vi.mock('../../src/hooks/gate-block-helper.js', () => ({

package/tests/hooks/gate-auto-correct.test.ts

@@ -55,7 +55,6 @@ vi.mock('../../src/core/rule-host.js', () => ({
 
 vi.mock('../../src/core/principle-tree-ledger.js', () => ({
   loadLedger: vi.fn(),
-  listImplementationsByLifecycleState: vi.fn(() => []),
 }));
 
 vi.mock('../../src/hooks/gate-block-helper.js', () => ({

package/tests/hooks/gate-no-path-write-tool.test.ts

@@ -54,7 +54,6 @@ vi.mock('../../src/core/rule-host.js', () => ({
 
 vi.mock('../../src/core/principle-tree-ledger.js', () => ({
   loadLedger: vi.fn(),
-  listImplementationsByLifecycleState: vi.fn(() => []),
 }));
 
 // Mock WorkspaceContext to return a controlled instance with our mockEventLog.

package/tests/hooks/gate-rule-host-pipeline.test.ts

@@ -53,7 +53,6 @@ vi.mock('../../src/core/rule-host.js', () => ({
 
 vi.mock('../../src/core/principle-tree-ledger.js', () => ({
   loadLedger: vi.fn(),
-  listImplementationsByLifecycleState: vi.fn(() => []),
 }));
 
 describe('Gate Rule Host Only Pipeline', () => {

package/tests/integration/pain-id-chain-e2e.test.ts

@@ -26,8 +26,8 @@ import { RuleHost } from '../../src/core/rule-host.js';
 import { EvolutionReducerImpl } from '../../src/core/evolution-reducer.js';
 import {
   loadLedger,
-  transitionImplementationState,
 } from '../../src/core/principle-tree-ledger.js';
+import { SqliteConnection, SqliteActivationStateStore } from '@principles/core/runtime-v2';
 import { safeRmDir } from '../test-utils.js';
 import type { RuleHostInput } from '../../src/core/rule-host-types.js';
 
@@ -58,6 +58,60 @@ function disposeTestWorkspace(ws: TestWorkspace): void {
   safeRmDir(ws.workspaceDir);
 }
 
+/**
+ * PRI-436: Insert compiled rule code as a pi_artifacts row + activations row
+ * so RuleHost can load it from SQLite (the sole production source).
+ */
+function activateCompiledRule(
+  workspaceDir: string,
+  ruleId: string,
+  implementationCode: string,
+  principleId: string,
+): void {
+  const sqliteConn = new SqliteConnection(workspaceDir);
+  try {
+    const db = sqliteConn.getDb();
+    const now = new Date().toISOString();
+    const artifactId = `art-${ruleId}`;
+
+    const contentJson = JSON.stringify({
+      principleId,
+      ruleId,
+      implementationCode,
+    });
+
+    db.prepare(`
+      INSERT INTO pi_artifacts (artifact_id, artifact_kind, source_task_id, source_principle_id, source_rule_id, lineage_artifact_ids, validation_status, content_json, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      artifactId,
+      'rule',
+      `task-${ruleId}`,
+      principleId,
+      ruleId,
+      '[]',
+      'validated',
+      contentJson,
+      now,
+      now,
+    );
+
+    const store = new SqliteActivationStateStore(sqliteConn);
+    store.recordActivation({
+      activationId: `act_code_${ruleId}`,
+      idempotencyKey: `${artifactId}::code_tool_hook`,
+      artifactId,
+      channel: 'code_tool_hook',
+      action: 'code_tool_hook_shadow_activate',
+      targetRef: `impl://${ruleId}`,
+      activatedAt: now,
+      deactivatedAt: null,
+    });
+  } finally {
+    try { sqliteConn.close(); } catch { /* best-effort */ }
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -134,16 +188,16 @@ describe('Pain ID Chain E2E: pain event → principle → compile → RuleHost',
     expect(compileResult.ruleId).toBeDefined();
     expect(compileResult.implementationId).toBeDefined();
 
-    // Verify implementation is candidate (not active — must be promoted before enforcing)
+    // Verify implementation is candidate (not active — must be activated before enforcing)
     const updatedLedger = loadLedger(ws.stateDir);
     const impl = updatedLedger.tree.implementations[compileResult.implementationId!];
     expect(impl.lifecycleState).toBe('candidate');
 
-    // ── Step 5: Promote to active so RuleHost will enforce ──
-    transitionImplementationState(ws.stateDir, compileResult.implementationId!, 'active');
+    // ── Step 5: Activate via SQLite (PRI-436: sole production source) ──
+    activateCompiledRule(ws.workspaceDir, compileResult.ruleId!, compileResult.code!, principleId!);
 
     // ── Step 6: RuleHost.evaluate(matching input) → block ──
-    const host = new RuleHost(ws.stateDir, { warn: () => {} });
+    const host = new RuleHost(ws.stateDir, { warn: () => {} }, { workspaceDir: ws.workspaceDir });
 
     const matchingInput: RuleHostInput = {
       action: {

package/tests/integration/principle-compiler-e2e.test.ts

@@ -21,8 +21,8 @@ import { RuleHost } from '../../src/core/rule-host.js';
 import {
   loadLedger,
   saveLedger,
-  transitionImplementationState,
 } from '../../src/core/principle-tree-ledger.js';
+import { SqliteConnection, SqliteActivationStateStore } from '@principles/core/runtime-v2';
 import type { RuleHostInput } from '../../src/core/rule-host-types.js';
 
 // ---------------------------------------------------------------------------
@@ -50,6 +50,60 @@ function disposeTestWorkspace(ws: TestWorkspace): void {
   fs.rmSync(ws.workspaceDir, { recursive: true, force: true });
 }
 
+/**
+ * PRI-436: Insert compiled rule code as a pi_artifacts row + activations row
+ * so RuleHost can load it from SQLite (the sole production source).
+ */
+function activateCompiledRule(
+  workspaceDir: string,
+  ruleId: string,
+  implementationCode: string,
+  principleId: string,
+): void {
+  const sqliteConn = new SqliteConnection(workspaceDir);
+  try {
+    const db = sqliteConn.getDb();
+    const now = new Date().toISOString();
+    const artifactId = `art-${ruleId}`;
+
+    const contentJson = JSON.stringify({
+      principleId,
+      ruleId,
+      implementationCode,
+    });
+
+    db.prepare(`
+      INSERT INTO pi_artifacts (artifact_id, artifact_kind, source_task_id, source_principle_id, source_rule_id, lineage_artifact_ids, validation_status, content_json, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      artifactId,
+      'rule',
+      `task-${ruleId}`,
+      principleId,
+      ruleId,
+      '[]',
+      'validated',
+      contentJson,
+      now,
+      now,
+    );
+
+    const store = new SqliteActivationStateStore(sqliteConn);
+    store.recordActivation({
+      activationId: `act_code_${ruleId}`,
+      idempotencyKey: `${artifactId}::code_tool_hook`,
+      artifactId,
+      channel: 'code_tool_hook',
+      action: 'code_tool_hook_shadow_activate',
+      targetRef: `impl://${ruleId}`,
+      activatedAt: now,
+      deactivatedAt: null,
+    });
+  } finally {
+    try { sqliteConn.close(); } catch { /* best-effort */ }
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -168,21 +222,16 @@ describe('Principle Compiler E2E: compile → promote → RuleHost blocks', () =
       },
     };
 
-    // ── Step 4: RuleHost should NOT block yet (candidate not loaded) ──
-    const hostBeforePromote = new RuleHost(ws.stateDir, { warn: () => {} });
+    // ── Step 4: RuleHost should NOT block yet (no SQLite activation yet) ──
+    const hostBeforePromote = new RuleHost(ws.stateDir, { warn: () => {} }, { workspaceDir: ws.workspaceDir });
     const noBlockResult = hostBeforePromote.evaluate(matchingInput);
-    expect(noBlockResult).toBeUndefined(); // candidate not loaded → no block
-
-    // ── Step 5: Promote to 'active' so RuleHost will enforce ──
-    transitionImplementationState(ws.stateDir, implId, 'active');
+    expect(noBlockResult).toBeUndefined(); // no activation → no block
 
-    // Verify promotion
-    const ledgerAfterPromote = loadLedger(ws.stateDir);
-    const implAfterPromote = ledgerAfterPromote.tree.implementations[implId];
-    expect(implAfterPromote.lifecycleState).toBe('active');
+    // ── Step 5: Activate via SQLite (PRI-436: sole production source) ──
+    activateCompiledRule(ws.workspaceDir, result.ruleId!, result.code!, principleId);
 
     // ── Step 6: Create RuleHost and evaluate with matching input ──
-    const host = new RuleHost(ws.stateDir, { warn: () => {} });
+    const host = new RuleHost(ws.stateDir, { warn: () => {} }, { workspaceDir: ws.workspaceDir });
 
     // Matching input: bash tool with a heartbeat command (defined in Step 4)
     const blockResult = host.evaluate(matchingInput);
@@ -224,7 +273,7 @@ describe('Principle Compiler E2E: compile → promote → RuleHost blocks', () =
   });
 
   it('should return undefined when no active implementations exist', () => {
-    const host = new RuleHost(ws.stateDir, { warn: () => {} });
+    const host = new RuleHost(ws.stateDir, { warn: () => {} }, { workspaceDir: ws.workspaceDir });
 
     const input: RuleHostInput = {
       action: {