@principles/pd-cli 1.152.12 → 1.152.14

package/src/services/demo-story-a-runner.ts

@@ -1,471 +0,0 @@
-import {
-  RuntimeStateManager,
-  ActivationDispatcher,
-  PromptWriter,
-  DeferArchiveWriter,
-  RuleHostWriter,
-  SqliteActivationStateStore,
-  SqliteApprovalQueueStore,
-  ApprovalCompletionService,
-  STORY_A_CHANNELS,
-  makeRunId,
-  makePrincipleArtifactRecord,
-  makeRuleArtifactRecord,
-  computeDemoStatus,
-  buildFollowUpObservation,
-  buildDemoNarrative,
-  validateDemoChannels,
-  evaluateDemoGoldenTrace,
-} from '@principles/core/runtime-v2';
-import type {
-  MvpChannel,
-  StoryADemoResult,
-  StoryADemoStage,
-  StoryADemoChannelOutcome,
-  ActivationDecision,
-  PIArtifactSnapshot,
-  DispatchInput,
-  ApprovalDecisionResult,
-} from '@principles/core/runtime-v2';
-import type { PIArtifactRecord } from '@principles/core/runtime-v2';
-
-function toSnapshot(record: PIArtifactRecord): PIArtifactSnapshot {
-  return {
-    artifactId: record.artifactId,
-    artifactKind: record.artifactKind,
-    sourceTaskId: record.sourceTaskId,
-    sourcePrincipleId: record.sourcePrincipleId,
-    sourceRuleId: record.sourceRuleId,
-    lineageArtifactIds: record.lineageArtifactIds,
-    validationStatus: record.validationStatus,
-    contentJson: record.contentJson,
-    createdAt: record.createdAt,
-    updatedAt: record.updatedAt,
-  };
-}
-
-export interface DemoStoryARunnerOptions {
-  channels?: MvpChannel[];
-  runId?: string;
-  workspaceDir: string;
-}
-
-interface DispatchContext {
-  stateManager: RuntimeStateManager;
-  snapshotCache: Map<string, PIArtifactSnapshot>;
-  runId: string;
-}
-
-function makeArtifactReadModel(ctx: DispatchContext) {
-  return {
-    getArtifactById: async (id: string): Promise<PIArtifactSnapshot | null> => {
-      const cached = ctx.snapshotCache.get(id);
-      if (cached) return cached;
-      const record = await ctx.stateManager.piArtifactStore.getArtifactById(id);
-      if (!record) return null;
-      const snapshot = toSnapshot(record);
-      ctx.snapshotCache.set(id, snapshot);
-      return snapshot;
-    },
-  };
-}
-
-async function dispatchChannel(
-  channel: MvpChannel,
-  artifactRecord: PIArtifactRecord,
-  ctx: DispatchContext,
-): Promise<{ dispatchDecision: ActivationDecision; approvalId?: string }> {
-  const snapshot = toSnapshot(artifactRecord);
-  ctx.snapshotCache.set(artifactRecord.artifactId, snapshot);
-
-  const artifactReadModel = makeArtifactReadModel(ctx);
-  const activationStateStore = new SqliteActivationStateStore(ctx.stateManager.connection);
-  const approvalStore = new SqliteApprovalQueueStore(ctx.stateManager.connection);
-
-  const writers = channel === 'code_tool_hook'
-    ? [new RuleHostWriter({ gateDeps: { evaluateInSandbox: () => ({ success: true, failedCases: [], executionTimeMs: 1, forbiddenPatternViolations: [] }) } })]
-    : channel === 'prompt'
-      ? [new PromptWriter()]
-      : [new DeferArchiveWriter()];
-
-  const dispatcher = new ActivationDispatcher(
-    artifactReadModel,
-    activationStateStore,
-    { writers, approvalQueueStore: approvalStore },
-  );
-
-  const dispatchInput: DispatchInput = {
-    artifactId: artifactRecord.artifactId,
-    channel,
-    rolloutDecision: channel === 'code_tool_hook' ? 'require_approval' : 'auto_activate',
-    actor: { kind: 'human', userId: 'demo-owner' },
-    idempotencyKey: `story-a-${ctx.runId}::${channel}`,
-    now: new Date().toISOString(),
-    confirm: true,
-  };
-
-  const decision = await dispatcher.dispatch(dispatchInput);
-
-  const {approvalId} = (decision as { approvalId?: string });
-  return { dispatchDecision: decision, approvalId };
-}
-
-interface ChannelDispatchInput {
-  channel: MvpChannel;
-  artifactRecord: PIArtifactRecord;
-  ctx: DispatchContext;
-}
-
-// Post-approval activation via the production ApprovalCompletionService.
-// PRI-811 Phase B: EVERY channel queues first (a rollout recommendation never
-// self-executes), so the demo completes queued items for all channels through
-// the same verified approve→dispatch('approved') path production uses.
-async function completePostApprovalActivation(
-  approvalId: string,
-  input: ChannelDispatchInput,
-): Promise<ActivationDecision> {
-  const { channel, artifactRecord, ctx } = input;
-  const approvalStore = new SqliteApprovalQueueStore(ctx.stateManager.connection);
-  const activationStateStore = new SqliteActivationStateStore(ctx.stateManager.connection);
-  const approveResult: ApprovalDecisionResult = await approvalStore.approve(approvalId, 'demo-owner', 'Demo: owner approves activation');
-  if (!approveResult.ok) {
-    return { decision: 'refused', reason: `approval_failed: ${approveResult.error}`, channel };
-  }
-
-  const snapshot = toSnapshot(artifactRecord);
-  ctx.snapshotCache.set(artifactRecord.artifactId, snapshot);
-
-  const writers = channel === 'code_tool_hook'
-    ? [new RuleHostWriter({ gateDeps: { evaluateInSandbox: () => ({ success: true, failedCases: [], executionTimeMs: 1, forbiddenPatternViolations: [] }) } })]
-    : channel === 'prompt'
-      ? [new PromptWriter()]
-      : [new DeferArchiveWriter()];
-  const dispatcher = new ActivationDispatcher(
-    makeArtifactReadModel(ctx),
-    activationStateStore,
-    { writers, approvalQueueStore: approvalStore },
-  );
-  const completionService = new ApprovalCompletionService(approvalStore, dispatcher, activationStateStore);
-  const completion = await completionService.completeApproval({
-    approvalId,
-    actor: { kind: 'human', userId: 'demo-owner' },
-    now: new Date().toISOString(),
-  });
-  if (!completion.ok) {
-    return { decision: 'refused', reason: completion.reason, channel };
-  }
-  return completion.decision;
-}
-
-function classifyDecision(decision: ActivationDecision): 'activated' | 'queued' | 'refused' | 'already' | 'other' {
-  if (decision.decision === 'activated' || decision.decision === 'would_activate') return 'activated';
-  if (decision.decision === 'queued_for_approval') return 'queued';
-  if (decision.decision === 'refused' || decision.decision === 'invalid_artifact') return 'refused';
-  if (decision.decision === 'already_activated') return 'already';
-  return 'other';
-}
-
-interface ChannelOutcomeInput {
-  channel: MvpChannel;
-  principleRecord: PIArtifactRecord;
-  ruleRecord: PIArtifactRecord;
-  ctx: DispatchContext;
-}
-
-async function runChannelOutcome(
-  input: ChannelOutcomeInput,
-): Promise<StoryADemoChannelOutcome> {
-  const { channel, principleRecord, ruleRecord, ctx } = input;
-  const artifactRecord = channel === 'code_tool_hook' ? ruleRecord : principleRecord;
-  const principleId = principleRecord.sourcePrincipleId ?? 'unknown';
-  const riskLevel = channel === 'code_tool_hook' ? 'high' as const : 'low' as const;
-
-  try {
-    const { dispatchDecision: firstDecision, approvalId } = await dispatchChannel(
-      channel, artifactRecord, ctx,
-    );
-
-    // PRI-811 Phase B: first dispatch queues for EVERY channel (a rollout
-    // recommendation never self-executes). Demo approves and completes the
-    // activation through the production ApprovalCompletionService.
-    if (classifyDecision(firstDecision) === 'queued' && approvalId) {
-      const postApprovalDecision = await completePostApprovalActivation(
-        approvalId, { channel, artifactRecord, ctx },
-      );
-
-      if (classifyDecision(postApprovalDecision) === 'activated') {
-        return {
-          channel,
-          status: 'passed',
-          activationDecision: postApprovalDecision,
-          canActivateResult: { ok: true, riskLevel },
-          evidence: {
-            approvalId,
-            approvedBy: 'demo-owner',
-            activationId: (postApprovalDecision as { activationId?: string }).activationId,
-            path: 'dispatch→queued → real_approve → ApprovalCompletionService(approved dispatch)',
-          },
-          evidenceSource: `ActivationDispatcher.dispatch→queued + SqliteApprovalQueueStore.approve + ApprovalCompletionService(${channel})`,
-          principleId,
-        };
-      }
-
-      // Approval succeeded but activation failed
-      return {
-        channel,
-        status: 'degraded',
-        activationDecision: postApprovalDecision,
-        canActivateResult: { ok: true, riskLevel },
-        evidence: {
-          approvalId,
-          approvedBy: 'demo-owner',
-          activationDecision: postApprovalDecision.decision,
-        },
-        evidenceSource: 'ActivationDispatcher.dispatch→queued + ApprovalCompletionService (activation incomplete)',
-        principleId,
-        failureReason: `Channel ${channel} approved but post-activation dispatch returned: ${postApprovalDecision.decision}`,
-        nextAction: `Check ${channel} writer canActivate and artifact contract`,
-      };
-    }
-
-    const kind = classifyDecision(firstDecision);
-
-    if (kind === 'activated') {
-      return {
-        channel,
-        status: 'passed',
-        activationDecision: firstDecision,
-        canActivateResult: { ok: true, riskLevel },
-        evidence: {
-          activationId: (firstDecision as { activationId?: string }).activationId,
-        },
-        evidenceSource: `ActivationDispatcher.dispatch → ${channel === 'prompt' ? 'PromptWriter' : 'DeferArchiveWriter'}`,
-        principleId,
-      };
-    }
-
-    if (kind === 'already') {
-      return {
-        channel,
-        status: 'passed',
-        activationDecision: firstDecision,
-        canActivateResult: { ok: true, riskLevel },
-        evidence: { activationId: (firstDecision as { activationId: string }).activationId },
-        evidenceSource: `ActivationDispatcher.dispatch → ${channel} (idempotent)`,
-        principleId,
-      };
-    }
-
-    // refused or other
-    const refusedReason = firstDecision.decision === 'refused'
-      ? (firstDecision as { reason: string }).reason
-      : firstDecision.decision;
-    return {
-      channel,
-      status: 'failed',
-      activationDecision: firstDecision,
-      canActivateResult: { ok: false, reason: refusedReason, riskLevel },
-      evidence: { decision: firstDecision },
-      evidenceSource: 'ActivationDispatcher.dispatch',
-      principleId,
-      failureReason: `Channel ${channel} dispatch refused: ${refusedReason}`,
-      nextAction: `Check ${channel} writer canActivate and artifact contract`,
-    };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return {
-      channel,
-      status: 'failed',
-      activationDecision: { decision: 'refused', reason: 'demo_exception', channel },
-      canActivateResult: { ok: false, reason: 'exception', riskLevel },
-      evidence: { error: msg },
-      evidenceSource: 'exception',
-      principleId,
-      failureReason: `Channel ${channel} threw: ${msg}`,
-      nextAction: `Inspect ${channel} demo exception`,
-    };
-  }
-}
-
-export async function runStoryADemo(opts: DemoStoryARunnerOptions): Promise<StoryADemoResult> {
-  const runId = makeRunId(opts);
-  const generatedAt = new Date().toISOString();
-  const channels = opts.channels ?? [...STORY_A_CHANNELS];
-
-  // Input validation
-  const validationFailure = validateDemoChannels(channels);
-  if (validationFailure) {
-    const isUnknown = validationFailure.reason === 'unknown_channels';
-    return {
-      status: 'failed',
-      generatedAt,
-      narrative: `Story A' demo failed: ${validationFailure.reason}.`,
-      storyDescription: isUnknown ? `Unknown channels: ${(validationFailure as { unknownChannels: string[] }).unknownChannels.join(', ')}` : 'Demo requires at least one MVP channel.',
-      stages: [],
-      channelOutcomes: [],
-      isRuntimeV2Exclusive: true,
-      workspaceDir: opts.workspaceDir,
-      inputValidationFailure: validationFailure,
-    };
-  }
-
-  const stateManager = new RuntimeStateManager({ workspaceDir: opts.workspaceDir });
-  await stateManager.initialize();
-
-  try {
-    // Persist artifacts to real workspace DB
-    const principleRecord = makePrincipleArtifactRecord(runId);
-    const ruleRecord = makeRuleArtifactRecord(runId, principleRecord);
-    // P1-3: Seed parent task record for FK validation. Both demo artifacts share
-    // sourceTaskId = `task-demo-${runId}`; createArtifact rejects it unless the
-    // task exists in the tasks table (ERR-009/ERR-010/ERR-002).
-    const demoTaskId = principleRecord.sourceTaskId;
-    stateManager.connection.getDb().prepare(
-      "INSERT OR IGNORE INTO tasks (task_id, task_kind, status, created_at, updated_at)" +
-      " VALUES (?, 'diagnosis', 'pending', ?, ?)",
-    ).run(demoTaskId, principleRecord.createdAt, principleRecord.createdAt);
-    await stateManager.piArtifactStore.createArtifact(principleRecord);
-    await stateManager.piArtifactStore.createArtifact(ruleRecord);
-
-    const principleId = principleRecord.sourcePrincipleId ?? `demo-principle-${runId}`;
-    const snapshotCache = new Map<string, PIArtifactSnapshot>();
-    const ctx: DispatchContext = { stateManager, snapshotCache, runId };
-    const stages: StoryADemoStage[] = [];
-
-    // Stage 1: Evidence seed — verify artifacts exist in DB
-    const storedPrinciple = await stateManager.piArtifactStore.getArtifactById(principleRecord.artifactId);
-    stages.push({
-      name: 'evidence_seed',
-      status: storedPrinciple ? 'passed' : 'failed',
-      evidenceRef: `pain://demo-${runId}`,
-      evidence: {
-        painId: `demo-${runId}`,
-        reason: 'Agent repeatedly wrote to /etc/passwd despite owner corrections',
-        occurrenceCount: 3,
-        evidenceType: 'repeated_owner_correction',
-        artifactPersisted: !!storedPrinciple,
-        artifactId: principleRecord.artifactId,
-        simulated: true,
-        simulatedNote: 'Pain evidence is a narrative fixture; artifact persistence is real DB I/O',
-      },
-      ...(storedPrinciple ? {} : {
-        reason: 'Failed to persist principle artifact to workspace DB',
-        nextAction: 'Check workspace directory permissions and state.db',
-      }),
-    });
-
-    // Stage 2: Principle proposal — verify both artifacts queryable
-    const storedRule = await stateManager.piArtifactStore.getArtifactById(ruleRecord.artifactId);
-    stages.push({
-      name: 'principle_proposal',
-      status: storedRule ? 'passed' : 'failed',
-      evidenceRef: principleRecord.artifactId,
-      evidence: {
-        artifactId: principleRecord.artifactId,
-        principleId,
-        principleText: 'Prevent writing to system-critical directories',
-        confidence: 0.95,
-        ruleArtifactId: ruleRecord.artifactId,
-        rulePersisted: !!storedRule,
-      },
-      ...(storedRule ? {} : {
-        reason: 'Failed to persist rule artifact to workspace DB',
-        nextAction: 'Check workspace directory permissions and state.db',
-      }),
-    });
-
-    // Stage 3: Owner review (demo owner approves)
-    stages.push({
-      name: 'owner_review',
-      status: 'passed',
-      evidenceRef: `review-${runId}`,
-      evidence: {
-        ownerDecided: true,
-        decidedBy: 'demo-owner',
-        decision: 'approve',
-        availableChannels: ['prompt', 'code_tool_hook', 'defer_archive'],
-        note: 'Demo: owner approves the principle for all three MVP channels',
-        simulated: true,
-        simulatedNote: 'Owner decision is a scripted approval; no real human review',
-      },
-    });
-
-    // Stage 4: Activation (per channel, with real dispatcher + real DB)
-    const channelOutcomes: StoryADemoChannelOutcome[] = [];
-    for (const channel of channels) {
-      channelOutcomes.push(await runChannelOutcome({ channel, principleRecord, ruleRecord, ctx }));
-    }
-
-    const activationPassed = channelOutcomes.every(o => o.status === 'passed');
-    stages.push({
-      name: 'activation',
-      status: activationPassed ? 'passed' : channelOutcomes.some(o => o.status === 'failed') ? 'failed' : 'degraded',
-      evidenceRef: `activation-${runId}`,
-      evidence: {
-        channelsActivated: channelOutcomes.map(o => ({
-          channel: o.channel,
-          decision: o.activationDecision.decision,
-          evidenceSource: o.evidenceSource,
-        })),
-        simulated: false,
-      },
-      ...(activationPassed ? {} : {
-        reason: `Some channels did not pass: ${channelOutcomes.filter(o => o.status !== 'passed').map(o => o.channel).join(', ')}`,
-        nextAction: 'Check individual channel outcomes for failure details',
-      }),
-    });
-
-    // Stage 5: Follow-up observation
-    const followUpEvidences = channelOutcomes.map(o => {
-      const sandboxResult = o.channel === 'code_tool_hook'
-        ? evaluateDemoGoldenTrace(ruleRecord)
-        : undefined;
-      return {
-        channel: o.channel,
-        ...buildFollowUpObservation(o.channel, o, sandboxResult).evidence,
-      };
-    });
-    const followUpPassed = channelOutcomes.every(o => o.status === 'passed');
-    stages.push({
-      name: 'follow_up_observation',
-      status: followUpPassed ? 'passed' : 'degraded',
-      evidenceRef: `followup-${runId}`,
-      evidence: { observations: followUpEvidences, simulated: false },
-      ...(followUpPassed ? {} : {
-        reason: 'Some follow-up observations degraded',
-        nextAction: 'Check channel outcomes',
-      }),
-    });
-
-    // Stage 6: Rollback proof
-    stages.push({
-      name: 'rollback_proof',
-      status: 'passed',
-      evidenceRef: `rollback-${runId}`,
-      evidence: {
-        rollbackAvailable: true,
-        paths: [
-          { channel: 'prompt', method: 'Principle can be deactivated via ledger update' },
-          { channel: 'code_tool_hook', method: 'Rule can be removed from tool hook registry' },
-          { channel: 'defer_archive', method: 'Archived principle can be reactivated if needed' },
-        ],
-      },
-    });
-
-    const status = computeDemoStatus(stages, channelOutcomes);
-    const narrative = buildDemoNarrative({ runId, principleId, channels, channelOutcomes });
-
-    return {
-      status,
-      generatedAt,
-      narrative,
-      storyDescription: 'Demo proves: (1) artifact persistence via SqlitePIArtifactStore, (2) activation dispatch via ActivationDispatcher.dispatch() with real gate logic, (3) approval queue via SqliteApprovalQueueStore.approve() + ApprovalCompletionService approved dispatch (PRI-811 Phase B: every channel queues for Owner approval), (4) sandbox enforcement via evaluateInRefinerSandbox against golden trace. Evidence seed and owner review are narrative fixtures (simulated: true).',
-      stages,
-      channelOutcomes,
-      isRuntimeV2Exclusive: true,
-      workspaceDir: opts.workspaceDir,
-    };
-  } finally {
-    await stateManager.close();
-  }
-}