@principles/pd-cli 1.118.0 → 1.120.0

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

@@ -76,4 +76,44 @@ describe('CLI command tree structure', () => {
     const output = runPdHelp(['runtime', 'activation', '--help']);
     expect(output).toMatch(/edit\s/);
   });
+
+  it('rulecode command exists with spec/validate/replay subcommands (pd rulecode --help)', () => {
+    const output = runPdHelp(['rulecode', '--help']);
+    expect(output).toContain('spec');
+    expect(output).toContain('validate');
+    expect(output).toContain('replay');
+  });
+
+  it('rulecode spec subcommand has --json and --workspace (pd rulecode spec --help)', () => {
+    const output = runPdHelp(['rulecode', 'spec', '--help']);
+    expect(output).toContain('--json');
+    expect(output).toContain('--workspace');
+  });
+
+  it('rulecode validate subcommand has --code, --code-file, --json (pd rulecode validate --help)', () => {
+    const output = runPdHelp(['rulecode', 'validate', '--help']);
+    expect(output).toContain('--code');
+    expect(output).toContain('--code-file');
+    expect(output).toContain('--json');
+  });
+
+  it('rulecode replay subcommand has --golden-trace (required), --code, --json (pd rulecode replay --help)', () => {
+    const output = runPdHelp(['rulecode', 'replay', '--help']);
+    expect(output).toContain('--golden-trace');
+    expect(output).toContain('--code');
+    expect(output).toContain('--json');
+  });
+
+  it('legacy cleanup subcommand has --dry-run, --apply, --json (pd legacy cleanup --help)', () => {
+    const output = runPdHelp(['legacy', 'cleanup', '--help']);
+    expect(output).toContain('--dry-run');
+    expect(output).toContain('--apply');
+    expect(output).toContain('--json');
+    expect(output).toContain('--workspace');
+  });
+
+  it('legacy cleanup description mentions V1 Artificer artifacts', () => {
+    const output = runPdHelp(['legacy', 'cleanup', '--help']);
+    expect(output).toContain('V1 Artificer');
+  });
 });

package/tests/commands/runtime.test.ts

@@ -365,7 +365,7 @@ describe('pd runtime probe', () => {
     // Ensure NONEXISTENT_VAR is NOT set
     delete process.env.NONEXISTENT_VAR;
 
-    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
     const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
 
     await handleRuntimeProbe({
@@ -376,11 +376,17 @@ describe('pd runtime probe', () => {
       json: true,
     } as RuntimeProbeOptions);
 
-    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('NONEXISTENT_VAR'));
+    const output = consoleSpy.mock.calls.map(([chunk]) => String(chunk)).join('');
+    expect(JSON.parse(output)).toEqual(expect.objectContaining({
+      status: 'failed',
+      reason: 'api_key_not_set',
+      message: expect.stringContaining('NONEXISTENT_VAR'),
+      nextAction: expect.any(String),
+    }));
     expect(exitSpy).toHaveBeenCalledWith(1);
     expect(vi.mocked(probeRuntime)).not.toHaveBeenCalled();
 
-    consoleErrorSpy.mockRestore();
+    consoleSpy.mockRestore();
     exitSpy.mockRestore();
   });
 });

package/tests/e2e/cross-package-acceptance.test.ts

@@ -208,7 +208,7 @@ function makeTmpDir(): string {
 
 async function seedDreamerWithId(sm: RuntimeStateManager, taskId: string, painId: string): Promise<void> {
   const baseMetadata = JSON.parse(createPITaskDiagnosticJson({
-    dependencyTaskIds: [], channel: 'prompt', timeoutMs: 1000, inputArtifactRefs: [], outputArtifactRefs: [],
+    dependencyTaskIds: [], channel: 'code_tool_hook', timeoutMs: 1000, inputArtifactRefs: [], outputArtifactRefs: [],
   })) as Record<string, unknown>;
   const diagnosticJson = JSON.stringify({ ...baseMetadata, sourcePainId: painId });
   await sm.createTask({ taskId, taskKind: 'dreamer', status: 'pending', attemptCount: 0, maxAttempts: 3, diagnosticJson });

package/tests/services/rulehost-pipeline-runner.test.ts

@@ -197,9 +197,14 @@ function makeAdapter(opts?: { evaluator?: EvaluatorFactory }): ScriptedAdapter {
  * diagnosticJson (outside the pi_metadata envelope). This mirrors the pattern
  * from source-trace-locator.test.ts and PainSignalBridge.
  */
-async function seedDreamerWithId(sm: RuntimeStateManager, taskId: string, painId: string): Promise<void> {
+async function seedDreamerWithId(
+  sm: RuntimeStateManager,
+  taskId: string,
+  painId: string,
+  channel: 'prompt' | 'code_tool_hook' | 'defer_archive' = 'code_tool_hook',
+): Promise<void> {
   const baseMetadata = JSON.parse(createPITaskDiagnosticJson({
-    dependencyTaskIds: [], channel: 'prompt', timeoutMs: 1000, inputArtifactRefs: [], outputArtifactRefs: [],
+    dependencyTaskIds: [], channel, timeoutMs: 1000, inputArtifactRefs: [], outputArtifactRefs: [],
   })) as Record<string, unknown>;
   const diagnosticJson = JSON.stringify({ ...baseMetadata, sourcePainId: painId });
   await sm.createTask({ taskId, taskKind: 'dreamer', status: 'pending', attemptCount: 0, maxAttempts: 3, diagnosticJson });
@@ -441,6 +446,85 @@ describe('runRuleHostPipeline (PRI-429) — atomic capability + exact pain match
     expect(result.stages[0]?.status).toBe('failed');
   }, 60_000);
 
+  it('selects the Dreamer task matching the requested activation channel', async () => {
+    tmpDir = makeTmpDir();
+    const sm = new RuntimeStateManager({ workspaceDir: tmpDir });
+    await sm.initialize();
+    await seedDreamerWithId(sm, 'dreamer-prompt', 'pain-multi-channel', 'prompt');
+    await seedDreamerWithId(sm, 'dreamer-code-hook', 'pain-multi-channel', 'code_tool_hook');
+    await sm.close();
+
+    const adapter = makeAdapter();
+    const result = await runRuleHostPipeline({
+      workspaceDir: tmpDir,
+      painId: 'pain-multi-channel',
+      runtimeAdapter: adapter,
+      channel: 'code_tool_hook',
+      pollIntervalMs: 5,
+      timeoutMs: 1000,
+      onStoreReady: (store) => { adapter.artifactStore = store; },
+    });
+
+    expect(result.stages[0]).toMatchObject({
+      name: 'pain_lookup',
+      status: 'succeeded',
+      taskId: 'dreamer-code-hook',
+    });
+  }, 60_000);
+
+  it('uses the sole pain-linked Dreamer seed when its source channel differs from the target channel', async () => {
+    tmpDir = makeTmpDir();
+    const sm = new RuntimeStateManager({ workspaceDir: tmpDir });
+    await sm.initialize();
+    await seedDreamerWithId(sm, 'dreamer-prompt-seed', 'pain-cross-channel', 'prompt');
+    await sm.close();
+
+    const adapter = makeAdapter();
+    const result = await runRuleHostPipeline({
+      workspaceDir: tmpDir,
+      painId: 'pain-cross-channel',
+      runtimeAdapter: adapter,
+      channel: 'code_tool_hook',
+      pollIntervalMs: 5,
+      timeoutMs: 1000,
+      onStoreReady: (store) => { adapter.artifactStore = store; },
+    });
+
+    expect(result.stages[0]).toMatchObject({
+      name: 'pain_lookup',
+      status: 'succeeded',
+      taskId: 'dreamer-prompt-seed',
+    });
+  }, 60_000);
+
+  it('resumes from a succeeded Dreamer seed instead of trying to lease it again', async () => {
+    tmpDir = makeTmpDir();
+    const sm = new RuntimeStateManager({ workspaceDir: tmpDir });
+    await sm.initialize();
+    await seedDreamerWithId(sm, 'dreamer-resume', 'pain-resume');
+    await sm.close();
+
+    const firstAdapter = makeAdapter();
+    await runRuleHostPipeline({
+      workspaceDir: tmpDir, painId: 'pain-resume', runtimeAdapter: firstAdapter,
+      pollIntervalMs: 5, timeoutMs: 1000,
+      onStoreReady: (store) => { firstAdapter.artifactStore = store; },
+    });
+
+    const resumedAdapter = makeAdapter();
+    const resumed = await runRuleHostPipeline({
+      workspaceDir: tmpDir, painId: 'pain-resume', runtimeAdapter: resumedAdapter,
+      pollIntervalMs: 5, timeoutMs: 1000,
+      onStoreReady: (store) => { resumedAdapter.artifactStore = store; },
+    });
+
+    expect(resumed.stages.slice(0, 2)).toEqual([
+      { name: 'pain_lookup', status: 'succeeded', taskId: 'dreamer-resume' },
+      { name: 'dreamer', taskId: 'dreamer-resume', status: 'succeeded' },
+    ]);
+    expect(resumed.degradationReason).not.toContain('lease');
+  }, 60_000);
+
   // ── Test 8 (E fix): retried status is NOT terminal — bounded retry succeeds ──
   it('retried status triggers bounded retry and eventually succeeds (E fix)', async () => {
     tmpDir = makeTmpDir();