create-principles-disciple 1.133.0 → 1.133.2

package/host-runtime/dist/governance-observation-store.js

@@ -26,6 +26,7 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
+import { createHash } from 'node:crypto';
 import Database from 'better-sqlite3';
 import { sanitizeString, sanitizeValue } from '@principles/core/runtime-v2';
 // ─── Retention policy constants (Owner-approved, SPEC rev 2 §11) ────────────
@@ -33,7 +34,7 @@ export const GOVERNANCE_RETENTION_MAX_TURNS = 32;
 export const GOVERNANCE_RETENTION_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 export const GOVERNANCE_PROMOTION_PRECEDING_TURNS = 12;
 export const GOVERNANCE_PENDING_TAIL_STALE_MS = 7 * 24 * 60 * 60 * 1000;
-const GOVERNANCE_OBSERVATION_SCHEMA_VERSION = 2;
+const GOVERNANCE_OBSERVATION_SCHEMA_VERSION = 3;
 const MAX_TEXT_BOUND = 200; // matches MAX_EVIDENCE_VALUE_CHARS; guards stored identity fields
 const MAX_JSON_COLUMN = 8_000;
 function isRecord(value) {
@@ -154,11 +155,19 @@ const V2_ADDED_COLUMNS = [
     { table: 'governance_observations', name: 'source_order', type: 'INTEGER' },
     { table: 'governance_observations', name: 'source_ordinal', type: 'INTEGER' },
 ];
+/** Column additions in v3 (Slice D §15 quarantine: audited recovery metadata). */
+const V3_ADDED_COLUMNS = [
+    { table: 'governance_observations', name: 'quarantined_at', type: 'TEXT' },
+    { table: 'governance_observations', name: 'quarantine_reason', type: 'TEXT' },
+    { table: 'governance_observations', name: 'quarantine_digest', type: 'TEXT' },
+    { table: 'governance_observations', name: 'quarantine_operator', type: 'TEXT' },
+    { table: 'governance_observations', name: 'quarantine_gap', type: 'TEXT' },
+];
 function ensureGovernanceObservationSchema(db) {
     db.transaction(() => {
         for (const statement of CREATE_STATEMENTS)
             db.exec(statement);
-        for (const column of V2_ADDED_COLUMNS) {
+        for (const column of [...V2_ADDED_COLUMNS, ...V3_ADDED_COLUMNS]) {
             try {
                 db.exec(`ALTER TABLE ${column.table} ADD COLUMN ${column.name} ${column.type}`);
             }
@@ -460,7 +469,7 @@ export function ingestGovernanceObservations(input) {
         })();
         if (result === 'conflict') {
             return {
-                ok: false, reason: 'logical_key_content_conflict', nextAction: 'the first committed content was preserved and the observation is marked partial; run the audited quarantine/recovery command once available (Slice D) or re-ingest from a fresh rollout',
+                ok: false, reason: 'logical_key_content_conflict', nextAction: 'the first committed content was preserved and the observation is marked partial; run `pd codex ingest quarantine --workspace <path> --rollout <id> --record <id>` (audited, dry-run default) or re-ingest from a fresh rollout',
                 inserted, enriched, duplicates, checkpointCommitted: false, warnings: [`conflict:${conflictKey}`],
             };
         }
@@ -694,3 +703,179 @@ export function promoteGovernanceEvidence(input) {
         close();
     }
 }
+const QUARANTINE_REASON_MAX = 200;
+const QUARANTINE_OPERATOR_MAX = 80;
+function observationDigest(row) {
+    // Digest the row's stored content exactly as persisted (rc-8: hashing
+    // string columns only — never JSON.stringify of untrusted unknowns). The
+    // digest lets a future audit recognize the same record if it reappears.
+    const hash = createHash('sha256');
+    for (const column of ['rollout_identity', 'logical_key', 'transcript_record_key', 'kind', 'source', 'completeness', 'visible_text', 'sanitized_tool_facts_json', 'observed_at']) {
+        const value = row[column];
+        hash.update(`${column}=`);
+        hash.update(value === null || value === undefined ? '<null>' : String(value));
+        hash.update('\n');
+    }
+    return hash.digest('hex');
+}
+/**
+ * Audited quarantine for a permanently invalid governance observation
+ * (SPEC §15). Dry run is the contract default: without `confirm` the store
+ * reports what WOULD happen and mutates nothing. With `confirm`:
+ *  - bodies (visible_text / sanitized_tool_facts_json) are dropped;
+ *  - retention_class becomes `quarantined` (terminal class — never pruned,
+ *    never promoted);
+ *  - digest, reason, operator, timestamp, and the neighbor gap are recorded;
+ *  - the Codex transcript is never read or touched (this function opens only
+ *    the workspace trajectory.db).
+ * Promoted evidence is refused: Owner-decided evidence leaves only through
+ * the Owner governance cleanup commands.
+ */
+export function quarantineGovernanceObservation(args) {
+    const { workspaceDir, hostKind, rolloutIdentity, recordId, reason, operator, confirm = false } = args;
+    if (!Number.isInteger(recordId) || recordId <= 0) {
+        return { ok: false, reason: 'record_id_invalid', nextAction: 'Pass the numeric governance_observations.id (--record <id>); run `pd codex ingest catch-up --json` output or inspect trajectory.db to find it.' };
+    }
+    if (typeof reason !== 'string' || reason.trim().length === 0 || reason.length > QUARANTINE_REASON_MAX) {
+        return { ok: false, reason: 'reason_required', nextAction: `Provide a non-empty reason (≤ ${QUARANTINE_REASON_MAX} chars) describing why the record is permanently invalid.` };
+    }
+    if (typeof operator !== 'string' || operator.trim().length === 0 || operator.length > QUARANTINE_OPERATOR_MAX) {
+        return { ok: false, reason: 'operator_required', nextAction: `Provide the operator identity (≤ ${QUARANTINE_OPERATOR_MAX} chars).` };
+    }
+    const opened = openStore(workspaceDir, args.databaseFactory);
+    if (!('db' in opened))
+        return opened;
+    const { db, close } = opened;
+    try {
+        const outcome = db.transaction(() => {
+            const rolloutRow = db.prepare('SELECT id FROM governance_rollouts WHERE host_kind = ? AND rollout_identity = ?').get(hostKind, rolloutIdentity);
+            if (!isRecord(rolloutRow)) {
+                return { ok: false, reason: 'rollout_not_found', nextAction: `No governed rollout '${rolloutIdentity}' for host '${hostKind}' in this workspace; check the identity (see \`pd codex ingest catch-up\` output).` };
+            }
+            const rolloutRowId = rowField(rolloutRow, 'id');
+            const row = db.prepare('SELECT * FROM governance_observations WHERE id = ? AND rollout_row_id = ?').get(recordId, rolloutRowId);
+            if (!isRecord(row)) {
+                return { ok: false, reason: 'record_not_found', nextAction: `Record ${recordId} does not exist in rollout '${rolloutIdentity}' of this workspace; verify the id.` };
+            }
+            const retentionClassRaw = String(rowField(row, 'retention_class'));
+            // rc-2: the DB column is untrusted — only known classes enter the typed
+            // summary; anything else reads as 'expired' semantics for reporting but
+            // still fails the quarantinable check below.
+            const retentionClass = retentionClassRaw === 'operational' || retentionClassRaw === 'promoted'
+                || retentionClassRaw === 'quarantined' || retentionClassRaw === 'rolled_back'
+                ? retentionClassRaw
+                : 'expired';
+            const quarantinedAt = rowField(row, 'quarantined_at');
+            const sourceOrder = typeof rowField(row, 'source_order') === 'number' ? rowField(row, 'source_order') : null;
+            const neighborQuery = (direction) => {
+                if (sourceOrder === null)
+                    return 'none';
+                const comparison = direction === 'prev' ? '<' : '>';
+                const ordering = direction === 'prev' ? 'DESC' : 'ASC';
+                const neighbor = db.prepare(`SELECT source_order FROM governance_observations
+          WHERE rollout_row_id = ? AND source_order IS NOT NULL AND source_order ${comparison} ?
+          ORDER BY source_order ${ordering} LIMIT 1`).get(rolloutRowId, sourceOrder);
+                const value = isRecord(neighbor) ? rowField(neighbor, 'source_order') : undefined;
+                return typeof value === 'number' ? value : 'none';
+            };
+            const summary = {
+                id: recordId,
+                kind: String(rowField(row, 'kind')),
+                logicalKey: String(rowField(row, 'logical_key')),
+                observedAt: String(rowField(row, 'observed_at')),
+                retentionClass,
+                digest: observationDigest(row),
+                gap: `prev=${neighborQuery('prev')};next=${neighborQuery('next')};record=${sourceOrder === null ? 'null' : sourceOrder}`,
+            };
+            if (typeof quarantinedAt === 'string' && quarantinedAt.length > 0) {
+                // Already terminal: report the RECORDED audit digest/gap, not a
+                // re-hash of the row (bodies were dropped at quarantine time, so a
+                // fresh hash would silently differ from the audited one). dryRun
+                // reflects THIS invocation's intent — a dry-run call reports
+                // dryRun:true even on an already-quarantined row (review round 3).
+                const recordedDigest = rowField(row, 'quarantine_digest');
+                const recordedGap = rowField(row, 'quarantine_gap');
+                return {
+                    ok: true, dryRun: !confirm, alreadyQuarantined: true,
+                    record: {
+                        ...summary,
+                        digest: typeof recordedDigest === 'string' && recordedDigest.length > 0 ? recordedDigest : summary.digest,
+                        gap: typeof recordedGap === 'string' && recordedGap.length > 0 ? recordedGap : summary.gap,
+                    },
+                };
+            }
+            if (retentionClass === 'promoted') {
+                return { ok: false, reason: 'record_is_promoted_evidence', nextAction: 'Promoted evidence is Owner-decided governance evidence; quarantine never touches it. Use the existing Owner governance cleanup commands if the evidence must be removed.' };
+            }
+            if (retentionClass !== 'operational') {
+                return { ok: false, reason: `record_not_quarantinable:${retentionClass}`, nextAction: 'Only operational records can be quarantined; expired and rolled-back rows are already terminal.' };
+            }
+            if (!confirm) {
+                return { ok: true, dryRun: true, alreadyQuarantined: false, record: summary };
+            }
+            const now = new Date().toISOString();
+            db.prepare(`UPDATE governance_observations
+        SET visible_text = NULL, sanitized_tool_facts_json = NULL, retention_class = 'quarantined',
+            quarantined_at = ?, quarantine_reason = ?, quarantine_digest = ?, quarantine_operator = ?, quarantine_gap = ?
+        WHERE id = ? AND retention_class = 'operational'`)
+                .run(now, reason, summary.digest, operator, summary.gap, recordId);
+            return { ok: true, dryRun: false, alreadyQuarantined: false, record: summary };
+        })();
+        return outcome;
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200);
+        return { ok: false, reason: `governance_quarantine_failed:${detail}`, nextAction: 'inspect the workspace trajectory database and retry; the transaction rolled back, nothing was partially mutated' };
+    }
+    finally {
+        close();
+    }
+}
+/**
+ * Bounded read-only counts for the §15 health surface. Unknown is reported
+ * as a structured degradation — never silently as zero (§15: unknown is not
+ * reported as healthy).
+ */
+export function readGovernanceObservationStats(args) {
+    const opened = openStore(args.workspaceDir, args.databaseFactory);
+    if (!('db' in opened))
+        return opened;
+    const { db, close } = opened;
+    try {
+        const counts = db.prepare(`SELECT
+        SUM(CASE WHEN retention_class = 'operational' THEN 1 ELSE 0 END) AS operational,
+        SUM(CASE WHEN retention_class = 'promoted' THEN 1 ELSE 0 END) AS promoted,
+        SUM(CASE WHEN retention_class = 'quarantined' THEN 1 ELSE 0 END) AS quarantined,
+        SUM(CASE WHEN retention_class IN ('expired', 'rolled_back') THEN 1 ELSE 0 END) AS terminal_other,
+        MIN(CASE WHEN retention_class = 'operational' THEN observed_at END) AS oldest_operational,
+        MAX(observed_at) AS last_observation
+      FROM governance_observations`).get();
+        if (!isRecord(counts)) {
+            return { ok: false, reason: 'governance_stats_unavailable', nextAction: 'Inspect the workspace trajectory.db governance_observations table.' };
+        }
+        const numberOr = (value) => (typeof value === 'number' ? value : 0);
+        const stringOr = (value) => (typeof value === 'string' && value.length > 0 ? value : null);
+        const oldest = stringOr(own(counts, 'oldest_operational'));
+        const nextExpiry = oldest !== null && !Number.isNaN(Date.parse(oldest))
+            ? new Date(Date.parse(oldest) + GOVERNANCE_RETENTION_MAX_AGE_MS).toISOString()
+            : null;
+        return {
+            ok: true,
+            stats: {
+                operational: numberOr(own(counts, 'operational')),
+                promoted: numberOr(own(counts, 'promoted')),
+                quarantined: numberOr(own(counts, 'quarantined')),
+                terminalOther: numberOr(own(counts, 'terminal_other')),
+                nextExpiryAt: nextExpiry,
+                lastObservationAt: stringOr(own(counts, 'last_observation')),
+            },
+        };
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message.slice(0, 160) : String(error);
+        return { ok: false, reason: `governance_stats_failed:${detail}`, nextAction: 'Inspect the workspace trajectory.db; the health surface degraded without mutating anything.' };
+    }
+    finally {
+        close();
+    }
+}

package/host-runtime/dist/governance-signal-admission.d.ts

@@ -225,4 +225,30 @@ export interface ReconcileGovernanceContinuationResult {
  * Not a background worker — Slice C's Companion worker and the CLI call this.
  */
 export declare function reconcileGovernanceContinuation(input: ReconcileGovernanceContinuationInput): Promise<ReconcileGovernanceContinuationResult>;
+export interface GovernanceAdmissionCounts {
+    readonly admitted: number;
+    /** Admitted pains with no Diagnostician task link — the §15 orphan count. */
+    readonly admittedWithoutTask: number;
+    readonly pendingTails: number;
+    readonly staleTails: number;
+    readonly completedTails: number;
+    readonly lastAdmissionAt: string | null;
+}
+export type ReadGovernanceAdmissionCountsResult = {
+    ok: true;
+    counts: GovernanceAdmissionCounts;
+} | {
+    ok: false;
+    reason: string;
+    nextAction: string;
+};
+/**
+ * Bounded read-only counts for the §15 health surface: admitted-pain-without-
+ * task count and promotion-tail states. Read-only — reconciliation itself
+ * stays in `reconcileGovernanceContinuation`.
+ */
+export declare function readGovernanceAdmissionCounts(args: {
+    workspaceDir: string;
+    databaseFactory?: ObservationDatabaseFactory;
+}): ReadGovernanceAdmissionCountsResult;
 export {};

package/host-runtime/dist/governance-signal-admission.js

@@ -857,3 +857,50 @@ export async function reconcileGovernanceContinuation(input) {
         close();
     }
 }
+/**
+ * Bounded read-only counts for the §15 health surface: admitted-pain-without-
+ * task count and promotion-tail states. Read-only — reconciliation itself
+ * stays in `reconcileGovernanceContinuation`.
+ */
+export function readGovernanceAdmissionCounts(args) {
+    const opened = openAdmissionStore(args.workspaceDir, args.databaseFactory);
+    if (!('db' in opened))
+        return opened;
+    const { db, close } = opened;
+    try {
+        const admissions = db.prepare(`SELECT
+        SUM(CASE WHEN decision = 'admitted' THEN 1 ELSE 0 END) AS admitted,
+        SUM(CASE WHEN decision = 'admitted' AND diagnostician_task_id IS NULL THEN 1 ELSE 0 END) AS admitted_without_task,
+        MAX(created_at) AS last_admission
+      FROM governance_signal_admissions`).get();
+        if (!isRecord(admissions)) {
+            return { ok: false, reason: 'governance_admission_counts_unavailable', nextAction: 'Inspect the governance_signal_admissions table in the workspace trajectory.db.' };
+        }
+        const numberOr = (value) => (typeof value === 'number' ? value : 0);
+        const stringOr = (value) => (typeof value === 'string' && value.length > 0 ? value : null);
+        const tails = db.prepare(`SELECT
+        SUM(CASE WHEN state = 'pending' THEN 1 ELSE 0 END) AS pending,
+        SUM(CASE WHEN state = 'stale' THEN 1 ELSE 0 END) AS stale,
+        SUM(CASE WHEN state = 'completed' THEN 1 ELSE 0 END) AS completed
+      FROM governance_pending_promotion_tails`).get();
+        const tailRow = isRecord(tails) ? tails : {};
+        return {
+            ok: true,
+            counts: {
+                admitted: numberOr(own(admissions, 'admitted')),
+                admittedWithoutTask: numberOr(own(admissions, 'admitted_without_task')),
+                pendingTails: numberOr(own(tailRow, 'pending')),
+                staleTails: numberOr(own(tailRow, 'stale')),
+                completedTails: numberOr(own(tailRow, 'completed')),
+                lastAdmissionAt: stringOr(own(admissions, 'last_admission')),
+            },
+        };
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message.slice(0, 160) : String(error);
+        return { ok: false, reason: `governance_admission_counts_failed:${detail}`, nextAction: 'Inspect the workspace trajectory.db; the health surface degraded without mutating anything.' };
+    }
+    finally {
+        close();
+    }
+}

package/host-runtime/dist/index.d.ts

@@ -24,6 +24,11 @@ export * from './product-telemetry/eligibility.js';
 export * from './product-telemetry/exporter.js';
 export * from './product-telemetry/milestone-readers.js';
 export * from './product-telemetry/service.js';
+export * from './codex-disclosure.js';
+export * from './codex-ingestion-consent.js';
+export * from './codex-worker-status.js';
+export * from './codex-legacy-registration.js';
+export * from './codex-transcript-locate.js';
 export declare const HOST_RUNTIME_ROUTES: readonly ['before_prompt_build', 'before_tool_call', 'after_tool_call'];
 export type HostRuntimeRoute = (typeof HOST_RUNTIME_ROUTES)[number];
 export type HostRuntimePort = (event: HostEvent) => HostEventResult | Promise<HostEventResult>;

package/host-runtime/dist/index.js

@@ -33,6 +33,20 @@ export * from './product-telemetry/eligibility.js';
 export * from './product-telemetry/exporter.js';
 export * from './product-telemetry/milestone-readers.js';
 export * from './product-telemetry/service.js';
+// PRI-625 Slice D: Codex conversation-ingestion consent — G2A frozen
+// disclosure SSoT constant + workspace consent record (governance layer; the
+// runtime gate remains the feature flag alone).
+export * from './codex-disclosure.js';
+export * from './codex-ingestion-consent.js';
+// PRI-625 Slice D: ONE §15 worker-mode authority, moved from codex-adapter so
+// the CLI, the Console, and the worker share the same semantics.
+export * from './codex-worker-status.js';
+// PRI-625 Slice D: ONE legacy-registration predicate (installer refusal,
+// health dualRegistration, and future setup flows all read the same fact).
+export * from './codex-legacy-registration.js';
+// PRI-625 Slice D: transcript locator moved here so the §15 health service
+// computes per-rollout lag with the SAME locator the catch-up path uses.
+export * from './codex-transcript-locate.js';
 export const HOST_RUNTIME_ROUTES = [
     'before_prompt_build',
     'before_tool_call',

package/host-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principles/host-runtime",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "Shared host-neutral orchestration for Principles Disciple MVP-Core hook paths.",
   "type": "module",
   "main": "./dist/index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-principles-disciple",
-  "version": "1.133.0",
+  "version": "1.133.2",
   "description": "Interactive CLI installer for Principles Disciple OpenClaw plugin",
   "type": "module",
   "bin": {

package/pd-cli/dist/commands/codex-ingest-quarantine.d.ts

@@ -0,0 +1,12 @@
+interface CodexIngestQuarantineOptions {
+    workspace?: string;
+    rollout?: string;
+    record?: string;
+    reason?: string;
+    operator?: string;
+    confirm?: boolean;
+    json?: boolean;
+}
+export declare function handleCodexIngestQuarantine(options: CodexIngestQuarantineOptions): Promise<void>;
+export {};
+//# sourceMappingURL=codex-ingest-quarantine.d.ts.map

package/pd-cli/dist/commands/codex-ingest-quarantine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-ingest-quarantine.d.ts","sourceRoot":"","sources":["../../src/commands/codex-ingest-quarantine.ts"],"names":[],"mappings":"AAuBA,UAAU,4BAA4B;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAUD,wBAAsB,2BAA2B,CAAC,OAAO,EAAE,4BAA4B,GAAG,OAAO,CAAC,IAAI,CAAC,CAqFtG"}

package/pd-cli/dist/commands/codex-ingest-quarantine.js

@@ -0,0 +1,116 @@
+/**
+ * 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';
+function defaultOperator() {
+    try {
+        return os.userInfo().username.slice(0, 40) || 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+export async function handleCodexIngestQuarantine(options) {
+    const generatedAt = new Date().toISOString();
+    const refuse = (reason, nextAction) => {
+        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;
+    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.');
+    }
+}
+//# sourceMappingURL=codex-ingest-quarantine.js.map

package/pd-cli/dist/commands/codex-ingest-quarantine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-ingest-quarantine.js","sourceRoot":"","sources":["../../src/commands/codex-ingest-quarantine.ts"],"names":[],"mappings":"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"}

package/pd-cli/dist/commands/codex-setup.d.ts

@@ -0,0 +1,46 @@
+import { type CodexIngestionConsentDecision, type CodexIngestionConsentState } from '@principles/host-runtime';
+export interface CodexSetupOptions {
+    workspace?: string;
+    json?: boolean;
+    lang?: string;
+    accept?: boolean;
+    decline?: boolean;
+    showDisclosure?: boolean;
+}
+export interface CodexSetupReport {
+    generatedAt: string;
+    host: 'codex';
+    workspace: string;
+    status: 'ok' | 'degraded';
+    decision?: CodexIngestionConsentDecision;
+    consentStateBefore: CodexIngestionConsentState;
+    consentState: CodexIngestionConsentState;
+    disclosureVersion: string;
+    ingestionFlag: {
+        name: 'codex_conversation_ingestion';
+        enabled: boolean;
+        source: string;
+    };
+    hostCodexFlagEnabled: boolean;
+    warnings: string[];
+    reason?: string;
+    nextAction?: string;
+}
+type FlagWriteResult = {
+    ok: true;
+    enabled: boolean;
+} | {
+    ok: false;
+    reason: string;
+    nextAction: string;
+};
+/**
+ * Enable/disable `features.codex_conversation_ingestion.enabled` in the
+ * workspace config.yaml with a line-targeted edit that preserves all other
+ * content (comments included). Atomic write; round-trip verified with the
+ * production loader, restored on any mismatch.
+ */
+export declare function setCodexConversationIngestionFlag(workspaceDir: string, enabled: boolean): FlagWriteResult;
+export declare function handleCodexSetup(options: CodexSetupOptions): Promise<void>;
+export {};
+//# sourceMappingURL=codex-setup.d.ts.map

package/pd-cli/dist/commands/codex-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-setup.d.ts","sourceRoot":"","sources":["../../src/commands/codex-setup.ts"],"names":[],"mappings":"AAoCA,OAAO,EAQL,KAAK,6BAA6B,EAClC,KAAK,0BAA0B,EAEhC,MAAM,0BAA0B,CAAC;AAGlC,MAAM,WAAW,iBAAiB;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,IAAI,GAAG,UAAU,CAAC;IAC1B,QAAQ,CAAC,EAAE,6BAA6B,CAAC;IACzC,kBAAkB,EAAE,0BAA0B,CAAC;IAC/C,YAAY,EAAE,0BAA0B,CAAC;IACzC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE;QAAE,IAAI,EAAE,8BAA8B,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1F,oBAAoB,EAAE,OAAO,CAAC;IAC9B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAID,KAAK,eAAe,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC;AAuB1G;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,eAAe,CAyIzG;AA2BD,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA6MhF"}