@principles/pd-cli 1.80.0 → 1.82.0

package/tests/commands/runtime-internalization-run-once.test.ts

@@ -535,7 +535,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
     expect(text).toContain('resultRef: philosopher://run-phil-002');
   });
 
-  it('successful dreamer + --enqueue-next returns successorTaskId', async () => {
+  it('auto-enqueue: successful dreamer returns successor info by default', async () => {
     mockWakeOnce.mockResolvedValue({
       decision: 'would_lease',
       taskId: 'task-dreamer-enq-001',
@@ -564,11 +564,11 @@ describe('handleRuntimeInternalizationRunOnce', () => {
 
     const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
     expect(output.enqueueDecision).toBe('successor_created');
-    expect(output.successorTaskId).toBe('task-phil-enq-001');
+    expect(output.successorTaskIds![0]).toBe('task-phil-enq-001');
     expect(output.successorKind).toBe('philosopher');
   });
 
-  it('repeated --enqueue-next returns existing successorTaskId', async () => {
+  it('auto-enqueue: repeated run returns existing successorTaskId', async () => {
     mockWakeOnce.mockResolvedValue({
       decision: 'would_lease',
       taskId: 'task-dreamer-enq-002',
@@ -597,11 +597,11 @@ describe('handleRuntimeInternalizationRunOnce', () => {
 
     const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
     expect(output.enqueueDecision).toBe('successor_exists');
-    expect(output.successorTaskId).toBe('task-phil-enq-002');
+    expect(output.successorTaskIds![0]).toBe('task-phil-enq-002');
     expect(output.successorKind).toBe('philosopher');
   });
 
-  it('--enqueue-next with no_successor does not set successorTaskId', async () => {
+  it('auto-enqueue: no_successor does not set successor info', async () => {
     mockWakeOnce.mockResolvedValue({
       decision: 'would_lease',
       taskId: 'task-dreamer-enq-003',
@@ -629,10 +629,10 @@ describe('handleRuntimeInternalizationRunOnce', () => {
 
     const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
     expect(output.enqueueDecision).toBe('no_successor');
-    expect(output.successorTaskId).toBeUndefined();
+    expect(output.successorTaskIds).toEqual([]);
   });
 
-  it('--enqueue-next with failed run does not call commitNextTaskProposal', async () => {
+  it('auto-enqueue: failed run does not call commitNextTaskProposal', async () => {
     mockWakeOnce.mockResolvedValue({
       decision: 'would_lease',
       taskId: 'task-dreamer-enq-004',
@@ -652,7 +652,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
     expect(mockCommitNextTaskProposal).not.toHaveBeenCalled();
   });
 
-  it('--enqueue-next without --allow-test-double still blocked', async () => {
+  it('auto-enqueue without --allow-test-double still blocked', async () => {
     await handleRuntimeInternalizationRunOnce({ workspace: WS, runner: 'dreamer', runtime: 'test-double', enqueueNext: true });
 
     expect(process.exitCode).toBe(1);
@@ -880,7 +880,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
     expect(output.runnerResult.status).toBe('succeeded');
   });
 
-  it('--runner scribe --enqueue-next creates artificer successor', async () => {
+  it('auto-enqueue: --runner scribe creates artificer successor', async () => {
     mockWakeOnce.mockResolvedValue({
       decision: 'would_lease',
       taskId: 'task-scribe-enq-001',
@@ -916,7 +916,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
 
     const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
     expect(output.enqueueDecision).toBe('successor_created');
-    expect(output.successorTaskId).toBe('task-artificer-enq-001');
+    expect(output.successorTaskIds![0]).toBe('task-artificer-enq-001');
     expect(output.successorKind).toBe('artificer');
   });
 
@@ -979,7 +979,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
     expect(output.runnerResult.status).toBe('succeeded');
   });
 
-  it('--runner artificer --enqueue-next returns successor decision', async () => {
+  it('auto-enqueue: --runner artificer returns successor decision', async () => {
     mockWakeOnce.mockResolvedValue({
       decision: 'would_lease',
       taskId: 'task-artificer-enq-001',
@@ -1022,7 +1022,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
 
     const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
     expect(output.enqueueDecision).toBe('successor_created');
-    expect(output.successorTaskId).toBe('task-evaluator-enq-001');
+    expect(output.successorTaskIds![0]).toBe('task-evaluator-enq-001');
     expect(output.successorKind).toBe('evaluator');
   });
 
@@ -1112,7 +1112,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
     expect(output.runnerResult.status).toBe('succeeded');
   });
 
-  it('--runner evaluator --enqueue-next returns successor decision', async () => {
+  it('auto-enqueue: --runner evaluator returns successor decision', async () => {
     mockWakeOnce.mockResolvedValue({
       decision: 'would_lease',
       taskId: 'task-evaluator-enq-001',
@@ -1155,7 +1155,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
 
     const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
     expect(output.enqueueDecision).toBe('successor_created');
-    expect(output.successorTaskId).toBe('task-rollout-reviewer-enq-001');
+    expect(output.successorTaskIds![0]).toBe('task-rollout-reviewer-enq-001');
     expect(output.successorKind).toBe('rollout_reviewer');
   });
 
@@ -1208,7 +1208,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
     expect(output.runnerResult.status).toBe('succeeded');
   });
 
-  it('--runner rollout_reviewer --enqueue-next returns no_successor for prompt channel', async () => {
+  it('auto-enqueue: --runner rollout_reviewer returns no_successor for prompt channel', async () => {
     mockWakeOnce.mockResolvedValue({
       decision: 'would_lease',
       taskId: 'task-rollout-reviewer-enq-001',
@@ -1315,4 +1315,276 @@ describe('handleRuntimeInternalizationRunOnce', () => {
     expect(output.nextAction).toBeTruthy();
     expect(process.exitCode).toBe(1);
   });
+
+  // === Default enqueue successor tests ===
+
+  it('default behavior (no --no-enqueue-next) auto-enqueues successor on runner success', async () => {
+    mockWakeOnce.mockResolvedValue({
+      decision: 'would_lease',
+      taskId: 'task-dreamer-auto-001',
+      taskKind: 'dreamer',
+    });
+
+    mockRun.mockResolvedValue({
+      status: 'succeeded',
+      taskId: 'task-dreamer-auto-001',
+      runId: 'run-auto-001',
+      artifactId: 'pi-art-auto-001',
+      resultRef: 'dreamer://run-auto-001',
+      contextHash: 'ctx-auto',
+      output: { valid: true, taskId: 'task-dreamer-auto-001', candidates: VALID_DREAMER_CANDIDATES, contextRefs: [], generatedAt: new Date().toISOString() },
+      attemptCount: 1,
+    });
+
+    mockCommitNextTaskProposal.mockResolvedValue({
+      decision: 'successor_created',
+      sourceTaskId: 'task-dreamer-auto-001',
+      successorTaskId: 'task-phil-auto-001',
+      successorKind: 'philosopher',
+    });
+
+    // No enqueueNext specified — default should auto-enqueue
+    await handleRuntimeInternalizationRunOnce({ workspace: WS, runner: 'dreamer', runtime: 'test-double', allowTestDouble: true, json: true });
+
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(output.successorEnqueueAttempted).toBe(true);
+    expect(output.successorTasksCreated).toBe(1);
+    expect(output.successorTaskIds).toContain('task-phil-auto-001');
+    expect(output.enqueueDecision).toBe('successor_created');
+    expect(output.successorKind).toBe('philosopher');
+    expect(mockCommitNextTaskProposal).toHaveBeenCalledWith('task-dreamer-auto-001');
+  });
+
+  it('--no-enqueue-next (enqueueNext: false) skips successor enqueue', async () => {
+    mockWakeOnce.mockResolvedValue({
+      decision: 'would_lease',
+      taskId: 'task-dreamer-skip-001',
+      taskKind: 'dreamer',
+    });
+
+    mockRun.mockResolvedValue({
+      status: 'succeeded',
+      taskId: 'task-dreamer-skip-001',
+      runId: 'run-skip-001',
+      artifactId: 'pi-art-skip-001',
+      resultRef: 'dreamer://run-skip-001',
+      contextHash: 'ctx-skip',
+      output: { valid: true, taskId: 'task-dreamer-skip-001', candidates: VALID_DREAMER_CANDIDATES, contextRefs: [], generatedAt: new Date().toISOString() },
+      attemptCount: 1,
+    });
+
+    await handleRuntimeInternalizationRunOnce({ workspace: WS, runner: 'dreamer', runtime: 'test-double', allowTestDouble: true, enqueueNext: false, json: true });
+
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(output.successorEnqueueAttempted).toBe(false);
+    expect(output.nextAction).toContain('--no-enqueue-next');
+    expect(mockCommitNextTaskProposal).not.toHaveBeenCalled();
+  });
+
+  it('successor enqueue failure outputs partial_success with reason and nextAction', async () => {
+    mockWakeOnce.mockResolvedValue({
+      decision: 'would_lease',
+      taskId: 'task-dreamer-fail-001',
+      taskKind: 'dreamer',
+    });
+
+    mockRun.mockResolvedValue({
+      status: 'succeeded',
+      taskId: 'task-dreamer-fail-001',
+      runId: 'run-fail-001',
+      artifactId: 'pi-art-fail-001',
+      resultRef: 'dreamer://run-fail-001',
+      contextHash: 'ctx-fail',
+      output: { valid: true, taskId: 'task-dreamer-fail-001', candidates: VALID_DREAMER_CANDIDATES, contextRefs: [], generatedAt: new Date().toISOString() },
+      attemptCount: 1,
+    });
+
+    mockCommitNextTaskProposal.mockRejectedValue(new Error('database locked'));
+
+    await handleRuntimeInternalizationRunOnce({ workspace: WS, runner: 'dreamer', runtime: 'test-double', allowTestDouble: true, json: true });
+
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(output.decision).toBe('partial_success');
+    expect(output.successorEnqueueAttempted).toBe(true);
+    expect(output.enqueueDecision).toBe('enqueue_failed');
+    expect(output.enqueueReason).toContain('database locked');
+    expect(output.nextAction).toContain('enqueue-successors');
+    expect(output.successorTasksCreated).toBe(0);
+    expect(output.successorTaskIds).toEqual([]);
+  });
+
+  it('runner failure never enqueues successor (default behavior)', async () => {
+    mockWakeOnce.mockResolvedValue({
+      decision: 'would_lease',
+      taskId: 'task-dreamer-nofail-001',
+      taskKind: 'dreamer',
+    });
+
+    mockRun.mockResolvedValue({
+      status: 'failed',
+      taskId: 'task-dreamer-nofail-001',
+      errorCategory: 'execution_failed',
+      failureReason: 'Runtime unavailable',
+      attemptCount: 1,
+    });
+
+    // Default behavior (no --no-enqueue-next)
+    await handleRuntimeInternalizationRunOnce({ workspace: WS, runner: 'dreamer', runtime: 'test-double', allowTestDouble: true, json: true });
+
+    expect(mockCommitNextTaskProposal).not.toHaveBeenCalled();
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(output.successorEnqueueAttempted).toBeUndefined();
+  });
+
+  it('JSON output is single parseable JSON with successor fields', async () => {
+    mockWakeOnce.mockResolvedValue({
+      decision: 'would_lease',
+      taskId: 'task-dreamer-json-001',
+      taskKind: 'dreamer',
+    });
+
+    mockRun.mockResolvedValue({
+      status: 'succeeded',
+      taskId: 'task-dreamer-json-001',
+      runId: 'run-json-001',
+      artifactId: 'pi-art-json-001',
+      resultRef: 'dreamer://run-json-001',
+      contextHash: 'ctx-json',
+      output: { valid: true, taskId: 'task-dreamer-json-001', candidates: VALID_DREAMER_CANDIDATES, contextRefs: [], generatedAt: new Date().toISOString() },
+      attemptCount: 1,
+    });
+
+    mockCommitNextTaskProposal.mockResolvedValue({
+      decision: 'successor_created',
+      sourceTaskId: 'task-dreamer-json-001',
+      successorTaskId: 'task-phil-json-001',
+      successorKind: 'philosopher',
+    });
+
+    await handleRuntimeInternalizationRunOnce({ workspace: WS, runner: 'dreamer', runtime: 'test-double', allowTestDouble: true, json: true });
+
+    const rawOutput = consoleLogSpy.mock.calls[0][0];
+    // Must be single parseable JSON
+    const output = JSON.parse(rawOutput);
+    expect(output).toHaveProperty('successorEnqueueAttempted');
+    expect(output).toHaveProperty('successorTasksCreated');
+    expect(output).toHaveProperty('successorTaskIds');
+    // nextAction may be undefined when successor is successfully created
+    // but must be present on partial_success / no_successor / skipped
+  });
+
+  it('text output for auto-enqueue shows successor info', async () => {
+    mockWakeOnce.mockResolvedValue({
+      decision: 'would_lease',
+      taskId: 'task-dreamer-text-001',
+      taskKind: 'dreamer',
+    });
+
+    mockRun.mockResolvedValue({
+      status: 'succeeded',
+      taskId: 'task-dreamer-text-001',
+      runId: 'run-text-001',
+      artifactId: 'pi-art-text-001',
+      resultRef: 'dreamer://run-text-001',
+      contextHash: 'ctx-text',
+      output: { valid: true, taskId: 'task-dreamer-text-001', candidates: VALID_DREAMER_CANDIDATES, contextRefs: [], generatedAt: new Date().toISOString() },
+      attemptCount: 1,
+    });
+
+    mockCommitNextTaskProposal.mockResolvedValue({
+      decision: 'successor_created',
+      sourceTaskId: 'task-dreamer-text-001',
+      successorTaskId: 'task-phil-text-001',
+      successorKind: 'philosopher',
+    });
+
+    await handleRuntimeInternalizationRunOnce({ workspace: WS, runner: 'dreamer', runtime: 'test-double', allowTestDouble: true, json: false });
+
+    const text = consoleLogSpy.mock.calls.map((c: string[]) => c[0]).join('\n');
+    expect(text).toContain('successor: task-phil-text-001');
+    expect(text).toContain('enqueue_attempted: true');
+    expect(text).toContain('successors_created: 1');
+  });
+});
+
+// === Commander parser-level tests for --no-enqueue-next ===
+// These tests verify that Commander correctly maps --no-enqueue-next to opts.enqueueNext.
+// They exercise the real Commander parsing path, NOT the handler directly.
+// See ERR-063: previous code used opts.noEnqueueNext (always undefined) instead of opts.enqueueNext.
+
+describe('Commander --no-enqueue-next parser wiring', () => {
+  function buildRunOnceCommand(capturedOpts: Record<string, unknown>) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { Command } = require('commander') as typeof import('commander');
+    const program = new Command();
+    program.exitOverride(); // prevent process.exit during tests
+
+    const internalizationCmd = program.command('internalization');
+    internalizationCmd
+      .command('run-once')
+      .description('Wake-and-run: lease the next PI task and execute it')
+      .option('-w, --workspace <path>', 'Workspace directory')
+      .option('--runner <kind>', 'Runner kind', 'dreamer')
+      .option('--runtime <kind>', 'Runtime adapter kind', 'config')
+      .option('--allow-test-double', 'Acknowledge test-double runtime')
+      .option('--no-enqueue-next', 'Skip successor enqueue after successful runner')
+      .option('--timeout-ms <ms>', 'Runner timeout', parseInt)
+      .option('--json', 'Output raw JSON')
+      .action(async (opts) => {
+        Object.assign(capturedOpts, opts);
+      });
+
+    return program;
+  }
+
+  it('with --no-enqueue-next, Commander sets enqueueNext=false', async () => {
+    const captured: Record<string, unknown> = {};
+    const program = buildRunOnceCommand(captured);
+
+    await program.parseAsync([
+      'node', 'pd', 'internalization', 'run-once',
+      '--no-enqueue-next',
+      '--workspace', '/tmp/test',
+      '--runtime', 'test-double',
+      '--allow-test-double',
+      '--json',
+    ]);
+
+    expect(captured).toHaveProperty('enqueueNext', false);
+    expect(captured).not.toHaveProperty('noEnqueueNext');
+  });
+
+  it('without --no-enqueue-next, Commander sets enqueueNext=true (default)', async () => {
+    const captured: Record<string, unknown> = {};
+    const program = buildRunOnceCommand(captured);
+
+    await program.parseAsync([
+      'node', 'pd', 'internalization', 'run-once',
+      '--workspace', '/tmp/test',
+      '--runtime', 'test-double',
+      '--allow-test-double',
+      '--json',
+    ]);
+
+    expect(captured).toHaveProperty('enqueueNext', true);
+  });
+
+  it('opts has no noEnqueueNext property regardless of flag presence', async () => {
+    const capturedWith: Record<string, unknown> = {};
+    const programWith = buildRunOnceCommand(capturedWith);
+    await programWith.parseAsync([
+      'node', 'pd', 'internalization', 'run-once',
+      '--no-enqueue-next', '--workspace', '/tmp/test',
+    ]);
+
+    const capturedWithout: Record<string, unknown> = {};
+    const programWithout = buildRunOnceCommand(capturedWithout);
+    await programWithout.parseAsync([
+      'node', 'pd', 'internalization', 'run-once',
+      '--workspace', '/tmp/test',
+    ]);
+
+    expect(capturedWith).not.toHaveProperty('noEnqueueNext');
+    expect(capturedWithout).not.toHaveProperty('noEnqueueNext');
+  });
 });