@principles/pd-cli 1.152.12 → 1.152.14

package/src/commands/codex-ingest-catchup.ts

@@ -1,114 +0,0 @@
-/**
- * pd codex ingest catch-up command implementation (Codex Governance Closure
- * Slice C, PRI-624; SPEC §13/§15 recovery command).
- *
- * Performs ONE bounded non-destructive catch-up pass over the workspace's
- * durable Codex checkpoints: resolves each previously-authenticated rollout
- * by exact uuid, re-authorizes the transcript path, and resumes the bounded
- * incremental ingestion from the checkpoint — then feeds any admission
- * candidates through the same Slice B admission/continuation pass the hook
- * uses. Flag-off (`codex_conversation_ingestion=false`) performs ZERO
- * transcript filesystem I/O and reports a structured skip.
- *
- * This is the manual-mode counterpart of the Companion worker's catch-up
- * step (worker cycle step 2); it creates no LLM execution.
- *
- * CLI gate compliance:
- * - cli-1: --json outputs exactly one parseable JSON object on stdout.
- * - cli-2: exit paths stop execution.
- * - cli-5/6: skipped/degraded results carry reason + nextAction; nothing is
- *   mutated on failure (the ingestion seam is transactional per rollout).
- */
-import { resolveWorkspaceDir } from '../resolve-workspace.js';
-import { catchUpCodexIngestion, type CodexCatchUpResult } from '@principles/codex-adapter';
-
-interface CodexIngestCatchUpOptions {
-  workspace?: string;
-  json?: boolean;
-  maxRollouts?: number;
-}
-
-export interface CodexIngestCatchUpReport {
-  generatedAt: string;
-  host: 'codex';
-  workspace: string;
-  status: 'ok' | 'degraded' | 'skipped';
-  reason?: string;
-  nextAction?: string;
-  rolloutsProcessed: number;
-  remainingLagRollouts: string[];
-  unexaminedRollouts: string[];
-  degradations: string[];
-}
-
-function buildReport(generatedAt: string, workspace: string, result: CodexCatchUpResult): CodexIngestCatchUpReport {
-  if (result.status === 'skipped') {
-    return {
-      generatedAt,
-      host: 'codex',
-      workspace,
-      status: 'skipped',
-      reason: result.reason,
-      nextAction: result.nextAction,
-      rolloutsProcessed: 0,
-      remainingLagRollouts: [],
-      unexaminedRollouts: [],
-      degradations: [],
-    };
-  }
-  const degradations: string[] = [];
-  for (const rollout of result.rollouts) {
-    for (const degradation of rollout.admissionDegradations) {
-      degradations.push(`${rollout.rolloutIdentity}: ${degradation.reason}`);
-    }
-    if (rollout.outcome.status === 'degraded') {
-      degradations.push(`${rollout.rolloutIdentity}: ${rollout.outcome.reason}`);
-    }
-  }
-  return {
-    generatedAt,
-    host: 'codex',
-    workspace,
-    status: result.status,
-    rolloutsProcessed: result.rollouts.length,
-    remainingLagRollouts: [...result.remainingLagRollouts],
-    unexaminedRollouts: [...result.unexaminedRollouts],
-    degradations: degradations.slice(0, 10),
-    ...(degradations.length > 0 && result.status === 'degraded'
-      ? { reason: 'one or more rollouts degraded; committed observations remain durable', nextAction: 'Inspect the per-rollout degradations; re-run catch-up after fixing the underlying condition (Slice D adds the audited quarantine command).' }
-      : {}),
-  };
-}
-
-export async function handleCodexIngestCatchUp(options: CodexIngestCatchUpOptions): Promise<void> {
-  const generatedAt = new Date().toISOString();
-  const workspace = resolveWorkspaceDir(options.workspace);
-
-  const result = await catchUpCodexIngestion({
-    workspaceDir: workspace,
-    env: { CODEX_HOME: process.env.CODEX_HOME },
-    ...(typeof options.maxRollouts === 'number' ? { maxRollouts: options.maxRollouts } : {}),
-  });
-
-  const report = buildReport(generatedAt, workspace, result);
-  if (options.json) {
-    console.log(JSON.stringify(report));
-    if (report.status === 'degraded') process.exitCode = 1;
-    return;
-  }
-
-  const lines = [
-    `Codex ingestion catch-up (${workspace})`,
-    `  status:             ${report.status}`,
-    `  rollouts processed: ${report.rolloutsProcessed}`,
-    `  remaining lag:      ${report.remainingLagRollouts.length}`,
-    `  unexamined (bound): ${report.unexaminedRollouts.length}`,
-  ];
-  for (const degradation of report.degradations) {
-    lines.push(`  degradation: ${degradation}`);
-  }
-  if (report.reason !== undefined) lines.push(`  reason: ${report.reason}`);
-  if (report.nextAction !== undefined) lines.push(`  next action: ${report.nextAction}`);
-  console.log(lines.join('\n'));
-  if (report.status === 'degraded') process.exitCode = 1;
-}

package/src/commands/codex-ingest-quarantine.ts

@@ -1,127 +0,0 @@
-/**
- * pd codex ingest quarantine — audited recovery for permanently invalid
- * governance observations (Codex Governance Closure Slice D, PRI-625;
- * SPEC rev 2 §15).
- *
- * Contract (§15 verbatim requirements):
- * - dry run by DEFAULT; `--confirm` is required to actually quarantine;
- * - the quarantine record captures digest, reason, operator, timestamp, and
- *   the neighbor gap;
- * - the Codex transcript is NEVER edited or read (only the workspace
- *   trajectory.db opens — asserted by the store tests via a port spy);
- * - promoted (Owner-decided) evidence is refused;
- * - --json emits exactly one documented object; failed validation mutates
- *   nothing.
- *
- * CLI gate compliance: cli-1 (single JSON object), cli-2 (exit paths stop),
- * cli-5 (failed validation performs no mutation), cli-6 (reason + nextAction
- * on every refusal).
- */
-import * as os from 'os';
-import { quarantineGovernanceObservation } from '@principles/host-runtime';
-import { resolveWorkspaceDir } from '../resolve-workspace.js';
-
-interface CodexIngestQuarantineOptions {
-  workspace?: string;
-  rollout?: string;
-  record?: string;
-  reason?: string;
-  operator?: string;
-  confirm?: boolean;
-  json?: boolean;
-}
-
-function defaultOperator(): string {
-  try {
-    return os.userInfo().username.slice(0, 40) || 'unknown';
-  } catch {
-    return 'unknown';
-  }
-}
-
-export async function handleCodexIngestQuarantine(options: CodexIngestQuarantineOptions): Promise<void> {
-  const generatedAt = new Date().toISOString();
-
-  const refuse = (reason: string, nextAction: string): void => {
-    const report = { generatedAt, host: 'codex', op: 'quarantine', status: 'refused', confirmed: options.confirm === true, reason, nextAction };
-    if (options.json) {
-      console.log(JSON.stringify(report));
-    } else {
-      console.log('Codex observation quarantine');
-      console.log(`  status: ${report.status}`);
-      console.log(`  reason: ${reason}`);
-      console.log(`  next action: ${nextAction}`);
-    }
-    process.exitCode = 1;
-  };
-
-  const rollout = typeof options.rollout === 'string' ? options.rollout.trim() : '';
-  if (rollout.length === 0) {
-    refuse('rollout_required', 'Pass --rollout <id> (the rollout identity whose record is invalid).');
-    return;
-  }
-  const recordRaw = typeof options.record === 'string' ? options.record.trim() : '';
-  const recordId = /^\d+$/.test(recordRaw) ? Number.parseInt(recordRaw, 10) : Number.NaN;
-  if (!Number.isInteger(recordId) || recordId <= 0) {
-    refuse('record_required', 'Pass --record <id> with the numeric governance_observations.id to quarantine.');
-    return;
-  }
-  const reason = typeof options.reason === 'string' ? options.reason.trim() : '';
-  if (reason.length === 0 || reason.length > 200) {
-    refuse('reason_required', 'Pass --reason "<why>" (1-200 chars) describing why the record is permanently invalid.');
-    return;
-  }
-  const operator = (typeof options.operator === 'string' && options.operator.trim().length > 0 ? options.operator.trim() : defaultOperator()).slice(0, 80);
-
-  // resolveWorkspaceDir throws when no workspace can be determined — wrap so
-  // --json still emits exactly one structured refusal (cli-1/cli-6).
-  let workspaceDir: string;
-  try {
-    workspaceDir = resolveWorkspaceDir(options.workspace);
-  } catch (error) {
-    const message = error instanceof Error ? error.message.slice(0, 160) : String(error);
-    refuse('workspace_unresolved: ' + message, 'Run from inside a PD workspace or pass -w/--workspace <path> with an initialized .pd directory.');
-    return;
-  }
-
-  const result = quarantineGovernanceObservation({
-    workspaceDir,
-    hostKind: 'codex',
-    rolloutIdentity: rollout,
-    recordId,
-    reason,
-    operator,
-    confirm: options.confirm === true,
-  });
-
-  if (!result.ok) {
-    refuse(result.reason, result.nextAction);
-    return;
-  }
-
-  const report = {
-    generatedAt,
-    host: 'codex',
-    op: 'quarantine',
-    status: 'ok',
-    dryRun: result.dryRun,
-    alreadyQuarantined: result.alreadyQuarantined,
-    confirmed: options.confirm === true,
-    record: result.record,
-    ...(result.dryRun ? { nextAction: 'Dry run only — nothing was mutated. Re-run with --confirm to quarantine this record.' } : {}),
-    transcriptTouched: false,
-  };
-  if (options.json) {
-    console.log(JSON.stringify(report));
-  } else {
-    console.log('Codex observation quarantine');
-    console.log(`  status:      ${result.dryRun ? 'dry-run' : 'quarantined'}`);
-    if (result.alreadyQuarantined) console.log('  note:        record was already quarantined (idempotent)');
-    console.log(`  record id:   ${result.record.id} (${result.record.kind}, ${result.record.retentionClass})`);
-    console.log(`  logical key: ${result.record.logicalKey}`);
-    console.log(`  observed at: ${result.record.observedAt}`);
-    console.log(`  digest:      ${result.record.digest}`);
-    console.log(`  gap:         ${result.record.gap}`);
-    if (result.dryRun) console.log('  next action: Dry run only — nothing was mutated. Re-run with --confirm to quarantine this record.');
-  }
-}

package/src/commands/codex-reconcile.ts

@@ -1,84 +0,0 @@
-/**
- * pd codex reconcile command implementation (Codex Governance Closure
- * Slice B, PRI-623; SPEC §13/§20).
- *
- * Runs the narrow idempotent reconciliation pass between the governance
- * admission markers (trajectory.db) and the Runtime V2 task store
- * (.pd/state.db): creates missing Diagnostician tasks for admitted pains,
- * repairs task links, retries pending promotion tails, and reports stale
- * tails — without a background worker (the Slice C Companion worker will
- * call the same seam).
- *
- * CLI gate compliance:
- * - cli-1: --json outputs exactly one parseable JSON object on stdout.
- * - cli-2: exit paths stop execution.
- * - cli-6: degraded results include reason + nextAction.
- */
-import { resolveWorkspaceDir } from '../resolve-workspace.js';
-import { reconcileGovernanceContinuation } from '@principles/host-runtime';
-
-interface CodexReconcileOptions {
-  workspace?: string;
-  json?: boolean;
-  limit?: number;
-}
-
-export interface CodexReconcileReport {
-  generatedAt: string;
-  host: 'codex';
-  workspace: string;
-  ok: boolean;
-  reason?: string;
-  nextAction?: string;
-  tasksEnsured: number;
-  linksRepaired: number;
-  pendingTails: number;
-  completedTails: number;
-  staleTails: number;
-  degradations: string[];
-}
-
-export async function handleCodexReconcile(options: CodexReconcileOptions): Promise<void> {
-  const generatedAt = new Date().toISOString();
-  const workspace = resolveWorkspaceDir(options.workspace);
-
-  const result = await reconcileGovernanceContinuation({
-    workspaceDir: workspace,
-    ...(typeof options.limit === 'number' ? { limit: options.limit } : {}),
-  });
-
-  const report: CodexReconcileReport = {
-    generatedAt,
-    host: 'codex',
-    workspace,
-    ok: result.ok,
-    tasksEnsured: result.tasksEnsured,
-    linksRepaired: result.linksRepaired,
-    pendingTails: result.pendingTails,
-    completedTails: result.completedTails,
-    staleTails: result.staleTails,
-    degradations: [...result.degradations],
-    ...(result.ok ? {} : { reason: result.reason ?? 'reconciliation_failed', nextAction: result.nextAction ?? 'Inspect the listed degradations; admitted pains and evidence remain durable.' }),
-  };
-
-  if (options.json) {
-    console.log(JSON.stringify(report));
-    if (!report.ok) process.exitCode = 1;
-    return;
-  }
-
-  const lines = [
-    `Codex governance reconciliation (${workspace})`,
-    `  tasks ensured:      ${report.tasksEnsured} (links repaired: ${report.linksRepaired})`,
-    `  promotion tails:    pending=${report.pendingTails} completed-now=${report.completedTails} stale=${report.staleTails}`,
-  ];
-  for (const degradation of report.degradations) {
-    lines.push(`  degradation: ${degradation}`);
-  }
-  if (!report.ok) {
-    lines.push(`  reason: ${report.reason}`);
-    lines.push(`  next action: ${report.nextAction}`);
-  }
-  console.log(lines.join('\n'));
-  if (!report.ok) process.exitCode = 1;
-}