@principles/pd-cli 1.113.0 → 1.115.0

package/src/services/rulehost-pipeline-runner.ts

@@ -42,6 +42,8 @@ import {
   runAdversarialLoop,
   evaluateInRefinerSandbox,
   DEFAULT_MAX_ROUNDS,
+  SqliteApprovalQueueStore,
+  getChannelRiskLevel,
 } from '@principles/core/runtime-v2';
 import type {
   AdversarialLoopResult,
@@ -49,6 +51,7 @@ import type {
   PeerRunnerResult,
   RefinerRuleHostGateDeps,
   PIArtifactStore,
+  ApprovalRecord,
 } from '@principles/core/runtime-v2';
 /* eslint-disable @typescript-eslint/no-use-before-define -- helpers declared after main, matching codebase convention */
 import { compileDemoRule } from './demo-rule-compiler.js';
@@ -168,6 +171,14 @@ export interface RuleHostPipelineResult {
   readonly ruleArtifactId: string | null;
   /** Principle artifact ID (always present when scribe ran). */
   readonly principleArtifactId: string | null;
+  /**
+   * Approval ID when the candidate was auto-enqueued into the ApprovalQueue.
+   * Present when decision='candidate_ready_for_owner_review' and the pipeline
+   * successfully enqueued the candidate for owner review (P1 #1 fix).
+   * Null when the candidate was not enqueued (text_principle_only, rejected,
+   * or enqueue failed — check degradationReason for details).
+   */
+  readonly approvalId: string | null;
   /** Structured reason when decision is not candidate_ready_for_owner_review. */
   readonly degradationReason?: string;
 }
@@ -366,6 +377,44 @@ export async function runRuleHostPipeline(opts: RuleHostPipelineOptions): Promis
       ? 'candidate_ready_for_owner_review' as const
       : 'generation_rejected' as const;
 
+    // P1 #1 fix: auto-enqueue the candidate into the ApprovalQueue so the
+    // owner can review it. Without this, the pipeline produces a candidate
+    // artifact but it never enters the approval queue — the production chain
+    // is broken at step 2→3. Tests manually called enqueue(); production did not.
+    let approvalId: string | null = null;
+    if (pipelineDecision === 'candidate_ready_for_owner_review' && loopResult.ruleArtifactId) {
+      try {
+        const approvalStore = new SqliteApprovalQueueStore(stateManager.connection);
+        const riskLevel = getChannelRiskLevel(channel);
+        const enqueuedRecord: ApprovalRecord = await approvalStore.enqueue({
+          artifactId: loopResult.ruleArtifactId,
+          channel,
+          riskLevel,
+          summary: `RuleHost pipeline candidate for pain ${opts.painId}`,
+          triggerReason: `adversarial_loop_approved: pain=${opts.painId}, rule=${loopResult.ruleArtifactId}`,
+        }, new Date().toISOString());
+        const { approvalId: enqueuedApprovalId } = enqueuedRecord;
+        approvalId = enqueuedApprovalId;
+        onProgress('adversarial_loop', 'succeeded', `auto-enqueued as approval ${approvalId}`);
+      } catch (err: unknown) {
+        // Enqueue failed — the candidate artifact exists but is not in the
+        // approval queue. Degrade gracefully with a structured reason (ERR-002).
+        const enqueueErr = err instanceof Error ? err.message : String(err);
+        const degradeReason = `candidate_approved_but_enqueue_failed: ${enqueueErr}. Manual enqueue required: pd runtime activation dispatch --artifact-id ${loopResult.ruleArtifactId} --channel ${channel}`;
+        return {
+          decision: pipelineDecision,
+          painId: opts.painId,
+          stages,
+          scribeTaskId,
+          adversarialLoop: loopResult,
+          ruleArtifactId: loopResult.ruleArtifactId,
+          principleArtifactId: loopResult.principleArtifactId,
+          approvalId: null,
+          degradationReason: degradeReason,
+        };
+      }
+    }
+
     return {
       decision: pipelineDecision,
       painId: opts.painId,
@@ -374,6 +423,7 @@ export async function runRuleHostPipeline(opts: RuleHostPipelineOptions): Promis
       adversarialLoop: loopResult,
       ruleArtifactId: loopResult.ruleArtifactId,
       principleArtifactId: loopResult.principleArtifactId,
+      approvalId,
       degradationReason: loopResult.degradationReason,
     };
   } finally {
@@ -533,6 +583,7 @@ function rejectedResult(painId: string, stages: RuleHostPipelineStage[], degrada
     scribeTaskId: null,
     ruleArtifactId: null,
     principleArtifactId: null,
+    approvalId: null,
     degradationReason,
   };
 }
@@ -567,6 +618,7 @@ async function textPrincipleOnlyResult(
       scribeTaskId,
       ruleArtifactId: null,
       principleArtifactId: principleArt?.artifactId ?? null,
+      approvalId: null,
       degradationReason: `code_rule_capability_off: ${disabledReason}`,
     };
   } catch (error: unknown) {
@@ -578,6 +630,7 @@ async function textPrincipleOnlyResult(
       scribeTaskId,
       ruleArtifactId: null,
       principleArtifactId: null,
+      approvalId: null,
       degradationReason: `code_rule_capability_off: ${disabledReason}; principle_artifact_lookup_failed: ${message}`,
     };
   }

package/tests/commands/cli-command-tree.test.ts

@@ -62,4 +62,18 @@ describe('CLI command tree structure', () => {
     const output = runPdHelp(['runtime', '--help']);
     expect(output).toMatch(/health\s/);
   });
+
+  it('activation edit command exists under runtime activation (pd runtime activation edit --help)', () => {
+    const output = runPdHelp(['runtime', 'activation', 'edit', '--help']);
+    expect(output).toContain('--approval-id');
+    expect(output).toContain('--new-artifact-id');
+    expect(output).toContain('--edit-reason');
+    expect(output).toContain('--workspace');
+    expect(output).toContain('--json');
+  });
+
+  it('activation subcommand list includes edit (pd runtime activation --help)', () => {
+    const output = runPdHelp(['runtime', 'activation', '--help']);
+    expect(output).toMatch(/edit\s/);
+  });
 });

package/tests/commands/run-rulehost-handler.test.ts

@@ -0,0 +1,253 @@
+/**
+ * handleRunRuleHost behaviour tests (PRI-429) — input validation gates,
+ * dry-run output, and capability branches.
+ *
+ * The existing flag-wiring test only proves Commander parses the flags.
+ * This file verifies the handler's behavioural gates:
+ *   - mutual exclusivity of --dry-run and --confirm
+ *   - required pain-id (and whitespace-only forms)
+ *   - channel allowlist enforcement
+ *   - --max-rounds / --timeout-ms positive-integer validation
+ *   - default dry-run output (both plain-text and JSON)
+ *   - --json output parses as a single JSON object
+ *
+ * These gates are the CLI-gate contract for run-rulehost. If any of them
+ * regress, operators silently get undefined behaviour instead of a clear
+ * error + next-action recommendation.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import * as yaml from 'js-yaml';
+import { handleRunRuleHost } from '../../src/commands/runtime-internalization-run-rulehost.js';
+
+// ── workspace helpers ─────────────────────────────────────────────────────
+
+function mkTmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'pd-rulehost-handler-'));
+}
+
+function writeMinimalValidConfig(workspaceDir: string): void {
+  const configDir = path.join(workspaceDir, '.pd');
+  fs.mkdirSync(configDir, { recursive: true });
+  const cfg = {
+    version: 1,
+    features: {
+      prompt: { category: 'core', enabled: true },
+      code_tool_hook: { category: 'core', enabled: true },
+      defer_archive: { category: 'core', enabled: true },
+    },
+    workspace: { default: workspaceDir },
+    runtimeProfiles: {
+      'pi-ai.default': { type: 'pi-ai', provider: 'anthropic', model: 'claude-sonnet', apiKeyEnv: 'ANTHROPIC_API_KEY' },
+    },
+    internalAgents: {
+      defaultRuntime: 'pi-ai.default',
+      agents: {
+        dreamer: { enabled: true, runtimeProfile: 'pi-ai.default' },
+        philosopher: { enabled: true, runtimeProfile: 'pi-ai.default' },
+        scribe: { enabled: true, runtimeProfile: 'pi-ai.default' },
+        evaluator: { enabled: true, runtimeProfile: 'pi-ai.default' },
+      },
+    },
+  };
+  fs.writeFileSync(path.join(configDir, 'config.yaml'), yaml.dump(cfg), 'utf8');
+}
+
+// ── stdout/stderr capture helpers ──────────────────────────────────────
+
+interface StdIoState {
+  stdout: string;
+  stderr: string;
+  exitCode: number | undefined;
+}
+
+function parseJsonObject(text: string): Record<string, unknown> {
+  const parsed: unknown = JSON.parse(text);
+  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+    throw new Error('stdout is not a JSON object');
+  }
+  return parsed;
+}
+
+function captureStdio(fn: () => Promise<void>): Promise<StdIoState> {
+  return new Promise((resolve, reject) => {
+    const origExitCode = process.exitCode;
+    process.exitCode = undefined;
+    let stdout = '';
+    let stderr = '';
+    const stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation((chunk: string | Uint8Array) => {
+      stdout += typeof chunk === 'string' ? chunk : chunk.toString();
+      return true;
+    });
+    const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation((chunk: string | Uint8Array) => {
+      stderr += typeof chunk === 'string' ? chunk : chunk.toString();
+      return true;
+    });
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation((...args: unknown[]) => {
+      stderr += args.map((a) => (typeof a === 'string' ? a : String(a))).join(' ') + '\n';
+    });
+    fn()
+      .then(() => {
+        const captured = { stdout, stderr, exitCode: process.exitCode };
+        stdoutSpy.mockRestore();
+        stderrSpy.mockRestore();
+        consoleErrorSpy.mockRestore();
+        process.exitCode = origExitCode;
+        resolve(captured);
+      })
+      .catch((err) => {
+        stdoutSpy.mockRestore();
+        stderrSpy.mockRestore();
+        consoleErrorSpy.mockRestore();
+        process.exitCode = origExitCode;
+        reject(err);
+      });
+  });
+}
+
+describe('handleRunRuleHost — input validation gates', () => {
+  it('sets exitCode=1 and emits an error when both --dry-run and --confirm are passed (plain text)', async () => {
+    const { stdout, stderr, exitCode } = await captureStdio(() =>
+      handleRunRuleHost({ painId: 'pain-1', dryRun: true, confirm: true }),
+    );
+    expect(exitCode).toBe(1);
+    // plain-text mode: error on stderr includes 'mutually exclusive'
+    expect(stderr).toMatch(/mutually exclusive/i);
+    // stdout must not contain JSON object (handler writes to stderr).
+    expect(stdout.trim()).toBe('');
+  });
+
+  it('sets exitCode=1 and emits a JSON object when both --dry-run and --confirm are passed with --json', async () => {
+    const { stdout, exitCode } = await captureStdio(() =>
+      handleRunRuleHost({ painId: 'pain-1', dryRun: true, confirm: true, json: true }),
+    );
+    expect(exitCode).toBe(1);
+    const payload = parseJsonObject(stdout.trim());
+    expect(payload.status).toBe('failed');
+    expect(payload.nextAction).toBeDefined();
+    expect(typeof payload.reason).toBe('string');
+  });
+
+  it('sets exitCode=1 when --pain-id is missing (falsy string)', async () => {
+    const { exitCode } = await captureStdio(() => handleRunRuleHost({ painId: '' }));
+    expect(exitCode).toBe(1);
+  });
+
+  it('sets exitCode=1 when --pain-id is whitespace-only', async () => {
+    const { exitCode } = await captureStdio(() => handleRunRuleHost({ painId: '   \t ' }));
+    expect(exitCode).toBe(1);
+  });
+
+  it('sets exitCode=1 for unsupported channels (plain-text mode)', async () => {
+    const { exitCode, stderr } = await captureStdio(() =>
+      handleRunRuleHost({ painId: 'pain-1', channel: 'wizard' }),
+    );
+    expect(exitCode).toBe(1);
+    expect(stderr).toMatch(/wizard/);
+  });
+
+  it('sets exitCode=1 for unsupported channels (JSON mode)', async () => {
+    const { stdout, exitCode } = await captureStdio(() =>
+      handleRunRuleHost({ painId: 'pain-1', channel: 'wizard', json: true }),
+    );
+    expect(exitCode).toBe(1);
+    const payload = parseJsonObject(stdout.trim());
+    expect(payload.status).toBe('failed');
+    expect(payload.reason).toMatch(/wizard/);
+  });
+
+  it('sets exitCode=1 when --max-rounds is zero', async () => {
+    const { exitCode } = await captureStdio(() =>
+      handleRunRuleHost({ painId: 'pain-1', maxRounds: 0, dryRun: true }));
+    expect(exitCode).toBe(1);
+  });
+
+  it('sets exitCode=1 when --max-rounds is negative', async () => {
+    const { exitCode } = await captureStdio(() =>
+      handleRunRuleHost({ painId: 'pain-1', maxRounds: -5, dryRun: true }));
+    expect(exitCode).toBe(1);
+  });
+
+  it('sets exitCode=1 when --timeout-ms is zero', async () => {
+    const { exitCode } = await captureStdio(() =>
+      handleRunRuleHost({ painId: 'pain-1', timeoutMs: 0, dryRun: true }));
+    expect(exitCode).toBe(1);
+  });
+
+  it('sets exitCode=1 when --timeout-ms is negative', async () => {
+    const { exitCode } = await captureStdio(() =>
+      handleRunRuleHost({ painId: 'pain-1', timeoutMs: -100, dryRun: true }));
+    expect(exitCode).toBe(1);
+  });
+
+  it.each([
+    ['NaN maxRounds', { maxRounds: Number.NaN }],
+    ['fractional maxRounds', { maxRounds: 1.5 }],
+    ['NaN timeoutMs', { timeoutMs: Number.NaN }],
+    ['fractional timeoutMs', { timeoutMs: 1.5 }],
+  ])('sets exitCode=1 for %s', async (_label, invalidOption) => {
+    const { exitCode } = await captureStdio(() =>
+      handleRunRuleHost({ painId: 'pain-1', dryRun: true, ...invalidOption }),
+    );
+    expect(exitCode).toBe(1);
+  });
+});
+
+describe('handleRunRuleHost — dry-run mode output shape (with minimal pd-config.yaml', () => {
+  let workspaceDir: string;
+  let savedEnv: NodeJS.ProcessEnv;
+
+  beforeEach(() => {
+    workspaceDir = mkTmpDir();
+    writeMinimalValidConfig(workspaceDir);
+    savedEnv = { ...process.env };
+    process.env.ANTHROPIC_API_KEY = 'sk-ant-test-key';
+  });
+
+  afterEach(() => {
+    process.env = savedEnv;
+    try { fs.rmSync(workspaceDir, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it('emits a single JSON object in --json dry-run mode', async () => {
+    const { stdout, exitCode } = await captureStdio(() =>
+      handleRunRuleHost({ painId: 'pain-1', dryRun: true, json: true, workspace: workspaceDir }),
+    );
+    const payload = parseJsonObject(stdout.trim());
+    expect(payload.status).toBe('dry_run');
+    expect(typeof payload.capabilityStatus).toBe('string');
+    expect(typeof payload.nextAction).toBe('string');
+    expect(payload.painId).toBe('pain-1');
+    // Must not be error-exit for a valid dry-run.
+    expect(exitCode).toBeUndefined();
+  });
+
+  it('does NOT emit JSON on stdout in plain-text dry-run mode', async () => {
+    const { stdout } = await captureStdio(() =>
+      handleRunRuleHost({ painId: 'pain-1', dryRun: true, workspace: workspaceDir }),
+    );
+    expect(stdout).toMatch(/RuleHost Pipeline/);
+    // Plain text output should not start with '{'
+    expect(() => JSON.parse(stdout.trim())).toThrow();
+  });
+
+  it('defaults to dry-run behaviour when neither --dry-run nor --confirm is passed', async () => {
+    const { stdout } = await captureStdio(() =>
+      handleRunRuleHost({ painId: 'pain-1', json: true, workspace: workspaceDir }),
+    );
+    const payload = parseJsonObject(stdout.trim());
+    expect(payload.status).toBe('dry_run');
+  });
+
+  it('accepts the three supported channels and passes config', async () => {
+    for (const channel of ['prompt', 'code_tool_hook', 'defer_archive'] as const) {
+      const { exitCode } = await captureStdio(() =>
+        handleRunRuleHost({ painId: 'pain-1', channel, dryRun: true, workspace: workspaceDir }),
+      );
+      // Channel gate passed — exitCode should not be 1 for supported channels.
+      expect(exitCode).toBeUndefined();
+    }
+  });
+});