oxe-cc 1.0.0 → 1.3.0

package/lib/runtime/decision/decision-memo.js

@@ -0,0 +1,173 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrategySelector = void 0;
+exports.buildBlastRadius = buildBlastRadius;
+exports.buildRollbackPlan = buildRollbackPlan;
+exports.buildMemo = buildMemo;
+exports.saveMemo = saveMemo;
+exports.loadMemo = loadMemo;
+exports.listMemos = listMemos;
+const crypto_1 = __importDefault(require("crypto"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+// ─── BlastRadius estimation ───────────────────────────────────────────────────
+function deriveSubsystems(mutationScope) {
+    const seen = new Set();
+    for (const p of mutationScope) {
+        const parts = p.replace(/\\/g, '/').split('/');
+        if (parts.length >= 2)
+            seen.add(parts[0]);
+        else
+            seen.add(p);
+    }
+    return [...seen];
+}
+function estimateRiskScore(mutationScope, retryCount, riskLevel) {
+    let score = 0;
+    score += Math.min(0.4, mutationScope.length * 0.05);
+    score += retryCount > 0 ? Math.min(0.2, retryCount * 0.05) : 0;
+    switch (riskLevel) {
+        case 'critical':
+            score += 0.4;
+            break;
+        case 'high':
+            score += 0.3;
+            break;
+        case 'medium':
+            score += 0.15;
+            break;
+        case 'low':
+            score += 0.05;
+            break;
+        default: break;
+    }
+    return Math.min(1, score);
+}
+function buildBlastRadius(mutationScope, retryCount, riskLevel) {
+    const risk_score = estimateRiskScore(mutationScope, retryCount, riskLevel);
+    return {
+        estimated_files: mutationScope.length,
+        subsystems: deriveSubsystems(mutationScope),
+        risk_score: Math.round(risk_score * 100) / 100,
+        reversible: riskLevel !== 'critical' && mutationScope.length <= 10,
+    };
+}
+// ─── RollbackPlan ─────────────────────────────────────────────────────────────
+function buildRollbackPlan(blastRadius, retryCount) {
+    if (blastRadius.risk_score >= 0.7 || !blastRadius.reversible) {
+        return {
+            strategy: 'restore_workspace',
+            steps: ['snapshot workspace before mutation', 'restore snapshot on failure', 'verify clean state'],
+            estimated_cost: 'high',
+            preconditions: ['workspace snapshot available', 'no shared-state mutations'],
+        };
+    }
+    if (retryCount > 1 || blastRadius.estimated_files > 5) {
+        return {
+            strategy: 'revert_commit',
+            steps: ['record commit SHA before change', 'git revert on failure'],
+            estimated_cost: 'medium',
+            preconditions: ['git repo initialized', 'changes committed atomically'],
+        };
+    }
+    return {
+        strategy: 'undo_patch',
+        steps: ['apply inverse patch'],
+        estimated_cost: 'low',
+        preconditions: ['original file state recorded'],
+    };
+}
+// ─── StrategySelector ────────────────────────────────────────────────────────
+class StrategySelector {
+    select(mutationScope, retryCount, riskLevel) {
+        if (riskLevel === 'critical')
+            return 'feature_flag';
+        if (retryCount > 1)
+            return 'minimal_patch';
+        if (mutationScope.length > 8)
+            return 'isolated_refactor';
+        if (riskLevel === 'high')
+            return 'feature_flag';
+        if (mutationScope.length > 3)
+            return 'expand_contract';
+        if (mutationScope.length === 0)
+            return 'no_op';
+        return 'minimal_patch';
+    }
+    alternatives(chosen, mutationScope, riskLevel) {
+        const all = ['minimal_patch', 'isolated_refactor', 'expand_contract', 'feature_flag', 'no_op'];
+        return all
+            .filter((s) => s !== chosen)
+            .map((s) => ({ strategy: s, reason: this.rejectionReason(s, chosen, mutationScope, riskLevel) }));
+    }
+    rejectionReason(s, chosen, mutationScope, riskLevel) {
+        switch (s) {
+            case 'no_op': return 'mutation scope is non-empty; no-op would not satisfy requirements';
+            case 'feature_flag': return riskLevel !== 'critical' && riskLevel !== 'high' ? 'risk level does not warrant feature flag overhead' : `${chosen} preferred for scope size`;
+            case 'isolated_refactor': return mutationScope.length <= 8 ? 'scope is small enough for simpler strategy' : `${chosen} preferred`;
+            case 'expand_contract': return 'expand-contract requires coordinated deployment; overhead not justified here';
+            case 'minimal_patch': return `${chosen} preferred due to scope or risk level`;
+            default: return 'not applicable';
+        }
+    }
+}
+exports.StrategySelector = StrategySelector;
+function buildMemo(input) {
+    const selector = new StrategySelector();
+    const chosen = selector.select(input.mutation_scope, input.retry_count, input.risk_level);
+    const blast_radius = buildBlastRadius(input.mutation_scope, input.retry_count, input.risk_level);
+    const rollback_plan = buildRollbackPlan(blast_radius, input.retry_count);
+    const alternatives_rejected = selector.alternatives(chosen, input.mutation_scope, input.risk_level);
+    return {
+        memo_id: `memo-${crypto_1.default.randomBytes(4).toString('hex')}`,
+        work_item_id: input.work_item_id,
+        run_id: input.run_id,
+        problem_summary: input.problem_summary,
+        chosen_strategy: chosen,
+        alternatives_rejected,
+        blast_radius,
+        rollback_plan,
+        min_evidence_required: input.min_evidence_required ?? [],
+        confidence: input.confidence ?? (1 - blast_radius.risk_score),
+        created_at: new Date().toISOString(),
+    };
+}
+function memoDir(projectRoot, runId) {
+    return path_1.default.join(projectRoot, '.oxe', 'runs', runId, 'memos');
+}
+function saveMemo(projectRoot, memo) {
+    const dir = memoDir(projectRoot, memo.run_id);
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(dir, `${memo.memo_id}.json`), JSON.stringify(memo, null, 2), 'utf8');
+}
+function loadMemo(projectRoot, runId, memoId) {
+    const p = path_1.default.join(memoDir(projectRoot, runId), `${memoId}.json`);
+    if (!fs_1.default.existsSync(p))
+        return null;
+    try {
+        return JSON.parse(fs_1.default.readFileSync(p, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function listMemos(projectRoot, runId) {
+    const dir = memoDir(projectRoot, runId);
+    if (!fs_1.default.existsSync(dir))
+        return [];
+    return fs_1.default
+        .readdirSync(dir)
+        .filter((f) => f.endsWith('.json'))
+        .map((f) => {
+        try {
+            return JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, f), 'utf8'));
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((m) => m !== null);
+}

package/lib/runtime/decision/index.d.ts

@@ -0,0 +1,2 @@
+export * from './decision-engine';
+export * from './decision-memo';

package/lib/runtime/decision/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./decision-engine"), exports);
+__exportStar(require("./decision-memo"), exports);

package/lib/runtime/delivery/branch-manager.d.ts

@@ -15,5 +15,6 @@ export declare class BranchManager {
     listOxeBranches(): BranchInfo[];
     mergeWorktreeBranch(worktreeBranch: string, targetBranch: string): void;
     branchExists(name: string): boolean;
+    push(remote: string, branchName: string, setUpstream?: boolean): void;
     private git;
 }

package/lib/runtime/delivery/branch-manager.js

@@ -68,6 +68,13 @@ class BranchManager {
         });
         return result.status === 0;
     }
+    push(remote, branchName, setUpstream = false) {
+        const args = ['push'];
+        if (setUpstream)
+            args.push('-u');
+        args.push(remote, branchName);
+        this.git(args);
+    }
     git(args) {
         return (0, child_process_1.execFileSync)('git', args, {
             cwd: this.projectRoot,

package/lib/runtime/delivery/ci-checks.js

@@ -41,6 +41,25 @@ exports.verifyAcceptanceCheck = {
     name: 'oxe-verify-acceptance',
     description: 'Checks that VERIFY.md exists and contains no failed criteria',
     async run(ctx) {
+        const manifestPath = path_1.default.join(ctx.projectRoot, '.oxe', 'runs', ctx.runId || '', 'verification-manifest.json');
+        if (ctx.runId && fs_1.default.existsSync(manifestPath)) {
+            try {
+                const manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf8'));
+                const failCount = Number(manifest.summary?.fail || 0);
+                const errorCount = Number(manifest.summary?.error || 0);
+                return failCount === 0 && errorCount === 0
+                    ? { check: this.name, status: 'pass', message: `Manifest reports ${manifest.summary.total} checks with no failures` }
+                    : {
+                        check: this.name,
+                        status: 'fail',
+                        message: `Manifest reports ${failCount} failed and ${errorCount} errored checks`,
+                        details: manifest.summary,
+                    };
+            }
+            catch (err) {
+                return { check: this.name, status: 'error', message: `Failed to parse verification manifest: ${String(err)}` };
+            }
+        }
         const verifyPath = ctx.sessionId
             ? path_1.default.join(ctx.projectRoot, '.oxe', ctx.sessionId, 'verification', 'VERIFY.md')
             : path_1.default.join(ctx.projectRoot, '.oxe', 'VERIFY.md');
@@ -86,7 +105,21 @@ exports.policyCheck = {
                     details: pending.map((g) => ({ gate_id: g.gate_id, scope: g.scope })),
                 };
             }
-            return { check: this.name, status: 'pass', message: 'All gates resolved' };
+            if (ctx.runId) {
+                const policyPath = path_1.default.join(ctx.projectRoot, '.oxe', 'runs', ctx.runId, 'policy-decisions.json');
+                if (fs_1.default.existsSync(policyPath)) {
+                    const policyDecisions = JSON.parse(fs_1.default.readFileSync(policyPath, 'utf8'));
+                    const withoutRationale = policyDecisions.filter((decision) => decision.override && !decision.rationale);
+                    if (withoutRationale.length > 0) {
+                        return {
+                            check: this.name,
+                            status: 'fail',
+                            message: `${withoutRationale.length} policy override(s) without rationale`,
+                        };
+                    }
+                }
+            }
+            return { check: this.name, status: 'pass', message: 'All gates resolved and policy overrides are justified' };
         }
         catch (err) {
             return { check: this.name, status: 'error', message: `Failed to read GATES.json: ${String(err)}` };

package/lib/runtime/delivery/delivery-records.d.ts

@@ -0,0 +1,34 @@
+export type PromotionTarget = 'local_commit' | 'remote_promotion';
+export type PromotionRemoteTarget = 'pr_draft' | 'branch_push';
+export interface CommitRecord {
+    run_id: string;
+    branch: string;
+    commit_sha: string | null;
+    status: 'pending' | 'committed' | 'blocked';
+    created_at: string;
+    committed_at: string | null;
+    message: string | null;
+    summary_path: string | null;
+}
+export interface PromotionRecord {
+    run_id: string;
+    target: PromotionTarget;
+    target_kind: PromotionRemoteTarget;
+    branch: string;
+    status: 'pending' | 'open' | 'merged' | 'closed' | 'blocked' | 'promoted';
+    created_at: string;
+    promoted_at: string | null;
+    summary_path: string | null;
+    remote: string | null;
+    target_ref: string | null;
+    pr_url: string | null;
+    pr_number: number | null;
+    reasons?: string[];
+    coverage_percent?: number | null;
+}
+export declare function commitRecordPath(projectRoot: string, runId: string): string;
+export declare function promotionRecordPath(projectRoot: string, runId: string): string;
+export declare function saveCommitRecord(projectRoot: string, runId: string, record: CommitRecord): void;
+export declare function loadCommitRecord(projectRoot: string, runId: string): CommitRecord | null;
+export declare function savePromotionRecord(projectRoot: string, runId: string, record: PromotionRecord): void;
+export declare function loadPromotionRecord(projectRoot: string, runId: string): PromotionRecord | null;

package/lib/runtime/delivery/delivery-records.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commitRecordPath = commitRecordPath;
+exports.promotionRecordPath = promotionRecordPath;
+exports.saveCommitRecord = saveCommitRecord;
+exports.loadCommitRecord = loadCommitRecord;
+exports.savePromotionRecord = savePromotionRecord;
+exports.loadPromotionRecord = loadPromotionRecord;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function runDir(projectRoot, runId) {
+    return path_1.default.join(projectRoot, '.oxe', 'runs', runId);
+}
+function saveJson(filePath, payload) {
+    fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
+    fs_1.default.writeFileSync(filePath, JSON.stringify(payload, null, 2), 'utf8');
+}
+function loadJson(filePath) {
+    if (!fs_1.default.existsSync(filePath))
+        return null;
+    try {
+        return JSON.parse(fs_1.default.readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function commitRecordPath(projectRoot, runId) {
+    return path_1.default.join(runDir(projectRoot, runId), 'commit-record.json');
+}
+function promotionRecordPath(projectRoot, runId) {
+    return path_1.default.join(runDir(projectRoot, runId), 'promotion-record.json');
+}
+function saveCommitRecord(projectRoot, runId, record) {
+    saveJson(commitRecordPath(projectRoot, runId), record);
+}
+function loadCommitRecord(projectRoot, runId) {
+    return loadJson(commitRecordPath(projectRoot, runId));
+}
+function savePromotionRecord(projectRoot, runId, record) {
+    saveJson(promotionRecordPath(projectRoot, runId), record);
+}
+function loadPromotionRecord(projectRoot, runId) {
+    return loadJson(promotionRecordPath(projectRoot, runId));
+}

package/lib/runtime/delivery/index.d.ts

@@ -1,3 +1,5 @@
 export * from './branch-manager';
 export * from './pr-manager';
 export * from './ci-checks';
+export * from './delivery-records';
+export * from './promotion-pipeline';

package/lib/runtime/delivery/index.js

@@ -17,3 +17,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./branch-manager"), exports);
 __exportStar(require("./pr-manager"), exports);
 __exportStar(require("./ci-checks"), exports);
+__exportStar(require("./delivery-records"), exports);
+__exportStar(require("./promotion-pipeline"), exports);

package/lib/runtime/delivery/promotion-pipeline.d.ts

@@ -0,0 +1,63 @@
+import type { PRManager } from './pr-manager';
+import type { BranchManager } from './branch-manager';
+import type { VerificationManifest, ResidualRiskLedger } from '../verification/verification-manifest';
+import type { EvidenceCoverageSummary } from '../verification/verification-manifest';
+import type { RunResult } from '../scheduler/scheduler';
+import type { GateToken } from '../gate/gate-manager';
+import { type CommitRecord, type PromotionRecord, type PromotionRemoteTarget } from './delivery-records';
+export interface RunPRLink {
+    run_id: string;
+    branch: string;
+    pr_url: string | null;
+    pr_number: number | null;
+    status: 'pending' | 'open' | 'merged' | 'closed' | 'blocked';
+    created_at: string;
+    merged_at: string | null;
+}
+export interface PromotionOptions {
+    baseBranch?: string;
+    draftPR?: boolean;
+    autoMerge?: boolean;
+    mergeMethod?: 'merge' | 'squash' | 'rebase';
+    targetRef?: string;
+    remote?: string;
+    targetKind?: PromotionRemoteTarget;
+    minimumCoverage?: number;
+}
+export type MergeGateVerdict = 'approved' | 'blocked' | 'needs_review';
+export interface MergeGateReport {
+    verdict: MergeGateVerdict;
+    reasons: string[];
+    blocking_risks: string[];
+    pending_gates: Array<{
+        gate_id: string;
+        scope: string;
+        work_item_id: string | null;
+    }>;
+}
+export declare class MergeGateEvaluator {
+    evaluate(runResult: RunResult, manifest: VerificationManifest | null, riskLedger: ResidualRiskLedger | null, gates?: GateToken[], evidenceCoverage?: EvidenceCoverageSummary | null, minimumCoverage?: number): MergeGateReport;
+}
+export declare class PromotionPipeline {
+    private readonly projectRoot;
+    private readonly branchManager;
+    private readonly prManager;
+    private readonly gateEvaluator;
+    constructor(projectRoot: string, branchManager: BranchManager, prManager: PRManager, gateEvaluator?: MergeGateEvaluator);
+    private baseSummaryLines;
+    buildCommitSummary(runResult: RunResult, manifest: VerificationManifest | null, riskLedger: ResidualRiskLedger | null, commitMessage?: string | null): string;
+    buildPromotionSummary(runResult: RunResult, manifest: VerificationManifest | null, riskLedger: ResidualRiskLedger | null): string;
+    buildPRBody(runResult: RunResult, manifest: VerificationManifest | null, riskLedger: ResidualRiskLedger | null): string;
+    recordLocalCommit(runResult: RunResult, manifest: VerificationManifest | null, riskLedger: ResidualRiskLedger | null, options?: {
+        commitMessage?: string;
+        commitSha?: string | null;
+        summaryPath?: string | null;
+    }): CommitRecord;
+    promote(runResult: RunResult, manifest: VerificationManifest | null, riskLedger: ResidualRiskLedger | null, opts?: PromotionOptions, gates?: GateToken[], evidenceCoverage?: EvidenceCoverageSummary | null): Promise<PromotionRecord>;
+    loadCommitRecord(runId: string): CommitRecord | null;
+    loadPromotionRecord(runId: string): PromotionRecord | null;
+    savePRLink(runId: string, link: RunPRLink): void;
+    loadPRLink(runId: string): RunPRLink | null;
+    private asRunPRLink;
+    private safeCurrentCommit;
+}

package/lib/runtime/delivery/promotion-pipeline.js

@@ -0,0 +1,224 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromotionPipeline = exports.MergeGateEvaluator = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const delivery_records_1 = require("./delivery-records");
+class MergeGateEvaluator {
+    evaluate(runResult, manifest, riskLedger, gates = [], evidenceCoverage = null, minimumCoverage = 100) {
+        const reasons = [];
+        const blockingRisks = [];
+        const pendingGates = gates
+            .filter((gate) => gate.status === 'pending')
+            .map((gate) => ({
+            gate_id: gate.gate_id,
+            scope: gate.scope,
+            work_item_id: gate.work_item_id ?? null,
+        }));
+        if (runResult.failed.length > 0) {
+            reasons.push(`${runResult.failed.length} task(s) failed: ${runResult.failed.join(', ')}`);
+        }
+        if (runResult.blocked.length > 0) {
+            reasons.push(`${runResult.blocked.length} task(s) blocked: ${runResult.blocked.join(', ')}`);
+        }
+        if (manifest && !manifest.summary.all_passed) {
+            reasons.push(`Verification: ${manifest.summary.fail} check(s) failed, ${manifest.summary.error} error(s)`);
+        }
+        if (riskLedger) {
+            const critical = riskLedger.risks.filter((r) => r.severity === 'critical' || r.severity === 'high');
+            for (const risk of critical) {
+                blockingRisks.push(`[${risk.severity.toUpperCase()}] ${risk.description}`);
+            }
+        }
+        if (pendingGates.length > 0) {
+            reasons.push(`${pendingGates.length} pending gate(s)`);
+        }
+        if (evidenceCoverage && evidenceCoverage.coverage_percent < minimumCoverage) {
+            reasons.push(`Evidence coverage below threshold: ${evidenceCoverage.coverage_percent}%/${minimumCoverage}%`);
+        }
+        const hasBlockers = reasons.length > 0 || blockingRisks.length > 0;
+        const verdict = hasBlockers ? 'blocked' : 'approved';
+        return { verdict, reasons, blocking_risks: blockingRisks, pending_gates: pendingGates };
+    }
+}
+exports.MergeGateEvaluator = MergeGateEvaluator;
+class PromotionPipeline {
+    constructor(projectRoot, branchManager, prManager, gateEvaluator = new MergeGateEvaluator()) {
+        this.projectRoot = projectRoot;
+        this.branchManager = branchManager;
+        this.prManager = prManager;
+        this.gateEvaluator = gateEvaluator;
+    }
+    baseSummaryLines(runResult, manifest, riskLedger) {
+        const lines = [];
+        lines.push(`**Run ID:** \`${runResult.run_id}\``);
+        lines.push(`**Status:** ${runResult.status}`);
+        lines.push(`**Completed:** ${runResult.completed.length} tasks`);
+        if (runResult.failed.length > 0) {
+            lines.push(`**Failed:** ${runResult.failed.join(', ')}`);
+        }
+        if (runResult.blocked.length > 0) {
+            lines.push(`**Blocked:** ${runResult.blocked.join(', ')}`);
+        }
+        if (manifest) {
+            lines.push('');
+            lines.push('## Verification');
+            lines.push(`- Total: ${manifest.summary.total}`);
+            lines.push(`- Pass: ${manifest.summary.pass}`);
+            lines.push(`- Fail: ${manifest.summary.fail}`);
+            lines.push(`- Skip: ${manifest.summary.skip}`);
+        }
+        if (riskLedger && riskLedger.risks.length > 0) {
+            lines.push('');
+            lines.push('## Residual Risks');
+            for (const risk of riskLedger.risks) {
+                lines.push(`- [${risk.severity.toUpperCase()}] ${risk.description}`);
+                if (risk.mitigation)
+                    lines.push(`  - Mitigation: ${risk.mitigation}`);
+            }
+        }
+        lines.push('');
+        lines.push('---');
+        lines.push('*Generated by OXE Runtime*');
+        return lines;
+    }
+    buildCommitSummary(runResult, manifest, riskLedger, commitMessage = null) {
+        const lines = ['## OXE Commit Summary', ''];
+        if (commitMessage)
+            lines.push(`**Commit message:** \`${commitMessage}\``, '');
+        lines.push(...this.baseSummaryLines(runResult, manifest, riskLedger));
+        return lines.join('\n');
+    }
+    buildPromotionSummary(runResult, manifest, riskLedger) {
+        const lines = ['## OXE Promotion Summary', '', ...this.baseSummaryLines(runResult, manifest, riskLedger)];
+        return lines.join('\n');
+    }
+    buildPRBody(runResult, manifest, riskLedger) {
+        return this.buildPromotionSummary(runResult, manifest, riskLedger);
+    }
+    recordLocalCommit(runResult, manifest, riskLedger, options = {}) {
+        const blocked = runResult.failed.length > 0 || runResult.blocked.length > 0;
+        const record = {
+            run_id: runResult.run_id,
+            branch: this.branchManager.currentBranch(),
+            commit_sha: options.commitSha ?? this.safeCurrentCommit(),
+            status: blocked ? 'blocked' : 'committed',
+            created_at: new Date().toISOString(),
+            committed_at: blocked ? null : new Date().toISOString(),
+            message: options.commitMessage ?? null,
+            summary_path: options.summaryPath ?? null,
+        };
+        (0, delivery_records_1.saveCommitRecord)(this.projectRoot, runResult.run_id, record);
+        return record;
+    }
+    async promote(runResult, manifest, riskLedger, opts = {}, gates = [], evidenceCoverage = null) {
+        const gateReport = this.gateEvaluator.evaluate(runResult, manifest, riskLedger, gates, evidenceCoverage, opts.minimumCoverage ?? 100);
+        const targetKind = opts.targetKind ?? 'pr_draft';
+        const link = {
+            run_id: runResult.run_id,
+            target: 'remote_promotion',
+            target_kind: targetKind,
+            branch: this.branchManager.currentBranch(),
+            status: 'pending',
+            created_at: new Date().toISOString(),
+            promoted_at: null,
+            summary_path: null,
+            remote: opts.remote ?? 'origin',
+            target_ref: opts.targetRef ?? opts.baseBranch ?? 'main',
+            pr_url: null,
+            pr_number: null,
+            reasons: gateReport.reasons,
+            coverage_percent: evidenceCoverage ? evidenceCoverage.coverage_percent : null,
+        };
+        if (gateReport.verdict === 'blocked') {
+            link.status = 'blocked';
+            (0, delivery_records_1.savePromotionRecord)(this.projectRoot, runResult.run_id, link);
+            this.savePRLink(runResult.run_id, this.asRunPRLink(link));
+            return link;
+        }
+        if (targetKind === 'branch_push') {
+            try {
+                this.branchManager.push(opts.remote ?? 'origin', link.branch, false);
+                link.status = 'promoted';
+                link.promoted_at = new Date().toISOString();
+                (0, delivery_records_1.savePromotionRecord)(this.projectRoot, runResult.run_id, link);
+                this.savePRLink(runResult.run_id, this.asRunPRLink(link));
+                return link;
+            }
+            catch {
+                link.status = 'blocked';
+                (0, delivery_records_1.savePromotionRecord)(this.projectRoot, runResult.run_id, link);
+                this.savePRLink(runResult.run_id, this.asRunPRLink(link));
+                return link;
+            }
+        }
+        const body = this.buildPromotionSummary(runResult, manifest, riskLedger);
+        const title = `oxe: run ${runResult.run_id} — ${runResult.completed.length} tasks`;
+        const prResult = this.prManager.createDraft({
+            title,
+            body,
+            base: opts.baseBranch ?? 'main',
+            draft: opts.draftPR !== false,
+        });
+        if (!prResult.success || !prResult.url) {
+            link.status = 'blocked';
+            (0, delivery_records_1.savePromotionRecord)(this.projectRoot, runResult.run_id, link);
+            this.savePRLink(runResult.run_id, this.asRunPRLink(link));
+            return link;
+        }
+        link.pr_url = prResult.url;
+        link.status = 'open';
+        link.promoted_at = new Date().toISOString();
+        (0, delivery_records_1.savePromotionRecord)(this.projectRoot, runResult.run_id, link);
+        this.savePRLink(runResult.run_id, this.asRunPRLink(link));
+        return link;
+    }
+    loadCommitRecord(runId) {
+        return (0, delivery_records_1.loadCommitRecord)(this.projectRoot, runId);
+    }
+    loadPromotionRecord(runId) {
+        return (0, delivery_records_1.loadPromotionRecord)(this.projectRoot, runId);
+    }
+    savePRLink(runId, link) {
+        const p = path_1.default.join(this.projectRoot, '.oxe', 'runs', runId, 'pr-link.json');
+        fs_1.default.mkdirSync(path_1.default.dirname(p), { recursive: true });
+        fs_1.default.writeFileSync(p, JSON.stringify(link, null, 2), 'utf8');
+    }
+    loadPRLink(runId) {
+        const p = path_1.default.join(this.projectRoot, '.oxe', 'runs', runId, 'pr-link.json');
+        if (!fs_1.default.existsSync(p))
+            return null;
+        try {
+            return JSON.parse(fs_1.default.readFileSync(p, 'utf8'));
+        }
+        catch {
+            const promotion = (0, delivery_records_1.loadPromotionRecord)(this.projectRoot, runId);
+            return promotion ? this.asRunPRLink(promotion) : null;
+        }
+    }
+    asRunPRLink(record) {
+        return {
+            run_id: record.run_id,
+            branch: record.branch,
+            pr_url: record.pr_url,
+            pr_number: record.pr_number,
+            status: record.target_kind === 'branch_push'
+                ? (record.status === 'blocked' ? 'blocked' : 'open')
+                : (record.status === 'promoted' ? 'open' : record.status),
+            created_at: record.created_at,
+            merged_at: record.status === 'merged' ? record.promoted_at : null,
+        };
+    }
+    safeCurrentCommit() {
+        try {
+            return this.branchManager.currentCommit();
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.PromotionPipeline = PromotionPipeline;