@orion-agents/orion-code 0.3.1 → 0.3.4

package/dist/runtime/orion-session-runner.d.ts

@@ -5,6 +5,8 @@ import type { OrionRuntimeDiagnosticsV1, OrionRuntimeV1 } from './orion-runtime-
 import { type ThreadUiModeResolverV1 } from './thread-ui-adapter';
 import type { UiEventSink } from './ui-events';
 import type { ThreadSessionRuntimeActivationV1 } from './thread-session-view';
+import { resolvePlanReviewV1 } from './plan-review';
+import type { PlanReviewProjectionV1 } from './thread-projection';
 export interface OrionSessionRunnerOptionsV1 {
     readonly eventSink: UiEventSink;
     readonly getSessionId: () => string;
@@ -25,6 +27,7 @@ export declare class OrionSessionRunnerV1 implements AgentRuntimeRunnerV1 {
     private transition;
     private readonly backgroundDrains;
     private closed;
+    private closeFlight?;
     constructor(options: OrionSessionRunnerOptionsV1);
     runInput(input: string, options?: AgentRuntimeRunInputOptionsV1): Promise<void>;
     runRequest(request: AgentTurnRequest, options?: AgentRuntimeRunInputOptionsV1): Promise<void>;
@@ -32,8 +35,11 @@ export declare class OrionSessionRunnerV1 implements AgentRuntimeRunnerV1 {
     controlGoal(control: GoalRuntimeControlV2): Promise<GoalRuntimeControlResultV2>;
     compact(input?: AgentRuntimeCompactInputV1): Promise<AgentRuntimeCompactResultV1>;
     diagnostics(): Promise<OrionRuntimeDiagnosticsV1>;
+    planReviewState(): Promise<PlanReviewProjectionV1 | undefined>;
+    reviewPlan(input: Parameters<typeof resolvePlanReviewV1>[1]): Promise<ReturnType<typeof resolvePlanReviewV1>>;
     interrupt(reason?: string): void;
     close(reason?: string): Promise<void>;
+    private performClose;
     private ensureActive;
     private switchTo;
     private closeActive;

package/dist/runtime/orion-session-runner.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OrionSessionRunnerV1 = void 0;
 const thread_ui_adapter_1 = require("./thread-ui-adapter");
+const plan_review_1 = require("./plan-review");
 /**
  * Session-aware product runner. A session switch drains and closes the old
  * OrionRuntime before constructing the next sole Thread owner.
@@ -81,13 +82,31 @@ class OrionSessionRunnerV1 {
         const active = await this.ensureActive();
         return active.runtime.diagnostics();
     }
+    async planReviewState() {
+        const active = await this.ensureActive();
+        return active.runtime.thread.getProjection().planReview;
+    }
+    async reviewPlan(input) {
+        const active = await this.ensureActive();
+        const receipt = (0, plan_review_1.resolvePlanReviewV1)(active.runtime, input);
+        if (receipt.admission.status === 'started' || receipt.admission.status === 'queued') {
+            this.startBackgroundDrain(active);
+        }
+        if (this.active === active)
+            active.adapter.flush();
+        return receipt;
+    }
     interrupt(reason = 'user interrupted') {
         this.active?.adapter.interrupt(reason);
     }
-    async close(reason = 'session runner closed') {
-        if (this.closed)
-            return;
+    close(reason = 'session runner closed') {
+        if (this.closeFlight)
+            return this.closeFlight;
         this.closed = true;
+        this.closeFlight = this.performClose(reason);
+        return this.closeFlight;
+    }
+    async performClose(reason) {
         const transitioning = this.transition;
         if (transitioning) {
             try {
@@ -146,7 +165,11 @@ class OrionSessionRunnerV1 {
             return;
         active.disposeObserver?.();
         active.adapter.close(reason);
-        await active.runtime.close(reason);
+        const report = await active.runtime.close(reason);
+        if (report.timedOut || report.leaseTimedOut || report.errors.length > 0) {
+            throw new Error(`Orion Session Runtime cleanup was incomplete (${report.errors.length} error(s), ` +
+                `timedOut=${report.timedOut}, leaseTimedOut=${report.leaseTimedOut}).`);
+        }
     }
     async drainUntilIdle(active) {
         let idle = false;

package/dist/runtime/plan-review.d.ts

@@ -0,0 +1,38 @@
+import type { OrionRuntimeV1 } from './orion-runtime-v1';
+import type { ThreadEventStore } from './thread-event-store';
+import type { PlanReviewProjectionV1, ThreadProjectionV1 } from './thread-projection';
+import { type PlanReceiptV1 } from './turn-commit';
+export type PlanReviewActionV1 = 'approve' | 'continue' | 'cancel';
+export interface PlanReviewResolutionReceiptV1 {
+    readonly receiptId: string;
+    readonly state: PlanReviewProjectionV1;
+    readonly admission: {
+        readonly status: 'started';
+        readonly turnId: string;
+    } | {
+        readonly status: 'queued';
+        readonly queueId: string;
+    } | {
+        readonly status: 'already_admitted' | 'cancelled';
+    } | {
+        readonly status: 'pending';
+        readonly reason: string;
+    };
+    readonly digest: string;
+}
+export declare class PlanReviewControlError extends Error {
+    readonly code: 'runtime_busy' | 'plan_review_stale' | 'plan_review_invalid';
+    constructor(code: 'runtime_busy' | 'plan_review_stale' | 'plan_review_invalid', message: string);
+}
+/** Persist an awaiting-review authority for a newly committed PlanReceipt. */
+export declare function ensurePlanReviewRequestedV1(store: ThreadEventStore, receipt: PlanReceiptV1, createdModel: string): PlanReviewProjectionV1;
+/** Resolve the exact pending plan and admit any follow-on request separately. */
+export declare function resolvePlanReviewV1(runtime: OrionRuntimeV1, input: {
+    readonly planDigest: string;
+    readonly action: PlanReviewActionV1;
+    readonly feedback?: string;
+}): PlanReviewResolutionReceiptV1;
+/** Recover the crash gap between a durable resolution and its turn admission. */
+export declare function recoverResolvedPlanReviewV1(runtime: OrionRuntimeV1): PlanReviewResolutionReceiptV1['admission'];
+export declare function findPlanReceiptForReviewV1(projection: ThreadProjectionV1, review: PlanReviewProjectionV1): PlanReceiptV1;
+//# sourceMappingURL=plan-review.d.ts.map

package/dist/runtime/plan-review.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlanReviewControlError = void 0;
+exports.ensurePlanReviewRequestedV1 = ensurePlanReviewRequestedV1;
+exports.resolvePlanReviewV1 = resolvePlanReviewV1;
+exports.recoverResolvedPlanReviewV1 = recoverResolvedPlanReviewV1;
+exports.findPlanReceiptForReviewV1 = findPlanReceiptForReviewV1;
+const crypto_1 = require("crypto");
+const canonical_1 = require("./protocol/canonical");
+const turn_commit_1 = require("./turn-commit");
+class PlanReviewControlError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'PlanReviewControlError';
+    }
+}
+exports.PlanReviewControlError = PlanReviewControlError;
+/** Persist an awaiting-review authority for a newly committed PlanReceipt. */
+function ensurePlanReviewRequestedV1(store, receipt, createdModel) {
+    const projection = store.loadProjection();
+    const current = projection.planReview;
+    if (current?.planDigest === receipt.planDigest && current.planReceiptDigest === receipt.digest) {
+        return current;
+    }
+    if (current?.status === 'awaiting_review') {
+        throw new PlanReviewControlError('plan_review_invalid', 'Another durable plan is already awaiting review.');
+    }
+    const reviewId = (0, crypto_1.randomUUID)();
+    const revision = (0, crypto_1.randomUUID)();
+    store.appendDurable({
+        turnId: receipt.turnId,
+        payload: {
+            type: 'plan.review_requested',
+            data: {
+                reviewId,
+                revision,
+                planDigest: receipt.planDigest,
+                planReceiptDigest: receipt.digest,
+                createdAt: receipt.createdAt,
+                createdModel: createdModel.trim() || 'unknown-model',
+                returnMode: receipt.returnMode,
+            },
+        },
+    });
+    const requested = store.loadProjection().planReview;
+    if (!requested || requested.reviewId !== reviewId) {
+        throw new PlanReviewControlError('plan_review_invalid', 'Durable plan review request was not projected.');
+    }
+    return requested;
+}
+/** Resolve the exact pending plan and admit any follow-on request separately. */
+function resolvePlanReviewV1(runtime, input) {
+    const projection = runtime.thread.getProjection();
+    if (projection.activeTurnId) {
+        throw new PlanReviewControlError('runtime_busy', 'The active logical request must finish before reviewing its plan.');
+    }
+    const current = projection.planReview;
+    if (!current || current.status !== 'awaiting_review' || current.planDigest !== input.planDigest) {
+        throw new PlanReviewControlError('plan_review_stale', 'The plan review no longer matches the latest awaiting plan.');
+    }
+    const feedback = input.feedback?.trim();
+    if (input.action === 'continue' && !feedback) {
+        throw new PlanReviewControlError('plan_review_invalid', 'Continue planning requires non-empty feedback.');
+    }
+    if (input.action !== 'continue' && feedback) {
+        throw new PlanReviewControlError('plan_review_invalid', 'Feedback is accepted only when continuing planning.');
+    }
+    requireBoundPlanReceipt(projection, current);
+    const revision = (0, crypto_1.randomUUID)();
+    runtime.graph.eventStore.appendDurable({
+        payload: {
+            type: 'plan.review_resolved',
+            data: {
+                reviewId: current.reviewId,
+                previousRevision: current.revision,
+                revision,
+                planDigest: current.planDigest,
+                action: input.action,
+                resolvedAt: Date.now(),
+                ...(feedback ? { feedback, feedbackDigest: (0, canonical_1.digestRuntimeValue)(feedback) } : {}),
+            },
+        },
+    });
+    const resolved = runtime.thread.getProjection().planReview;
+    if (!resolved || resolved.revision !== revision) {
+        throw new PlanReviewControlError('plan_review_invalid', 'Durable plan review resolution was not projected.');
+    }
+    const admission = admitResolvedPlanReviewV1(runtime, resolved);
+    const content = {
+        version: 1,
+        receiptId: (0, crypto_1.randomUUID)(),
+        state: resolved,
+        admission,
+    };
+    return Object.freeze({ ...content, digest: (0, canonical_1.digestRuntimeValue)(content) });
+}
+/** Recover the crash gap between a durable resolution and its turn admission. */
+function recoverResolvedPlanReviewV1(runtime) {
+    const review = runtime.thread.getProjection().planReview;
+    if (!review || review.status === 'awaiting_review') {
+        return { status: 'pending', reason: 'awaiting_review' };
+    }
+    return admitResolvedPlanReviewV1(runtime, review);
+}
+function findPlanReceiptForReviewV1(projection, review) {
+    return requireBoundPlanReceipt(projection, review);
+}
+function admitResolvedPlanReviewV1(runtime, review) {
+    if (review.status === 'cancelled')
+        return { status: 'cancelled' };
+    if (review.status !== 'approved' && review.status !== 'continued') {
+        return { status: 'pending', reason: 'awaiting_review' };
+    }
+    const input = planReviewTurnInput(review);
+    const projection = runtime.thread.getProjection();
+    if (Object.values(projection.turns).some(turn => turn.input === input) ||
+        projection.queue.some(item => item.input === input)) {
+        return { status: 'already_admitted' };
+    }
+    const result = runtime.thread.dispatch({
+        type: 'turn.start',
+        data: {
+            input,
+            mode: review.status === 'approved' ? 'build' : 'plan',
+        },
+    });
+    if (result.status === 'started')
+        return { status: 'started', turnId: result.turnId };
+    if (result.status === 'queued')
+        return { status: 'queued', queueId: result.queueId };
+    return {
+        status: 'pending',
+        reason: result.status === 'rejected' ? result.reason : `unexpected_${result.status}`,
+    };
+}
+function planReviewTurnInput(review) {
+    const authority = [
+        '[Orion Plan Review V1]',
+        `reviewId=${review.reviewId}`,
+        `planDigest=${review.planDigest}`,
+    ];
+    if (review.status === 'approved') {
+        return [
+            ...authority,
+            'action=approve',
+            'Execute the approved durable plan in BUILD mode. Verify the implementation before finishing.',
+        ].join('\n');
+    }
+    return [
+        ...authority,
+        'action=continue',
+        'Revise the durable plan using this review feedback:',
+        review.feedback ?? '',
+    ].join('\n');
+}
+function requireBoundPlanReceipt(projection, review) {
+    for (const turn of Object.values(projection.turns)) {
+        if (!turn.commit)
+            continue;
+        const commit = (0, turn_commit_1.parseTurnCommitV1)(turn.commit.receipt);
+        if (!commit.planReceipt)
+            continue;
+        const receipt = (0, turn_commit_1.parsePlanReceiptV1)(commit.planReceipt);
+        if (receipt.planDigest === review.planDigest &&
+            receipt.digest === review.planReceiptDigest &&
+            commit.planReceiptDigest === receipt.digest) {
+            return receipt;
+        }
+    }
+    throw new PlanReviewControlError('plan_review_invalid', 'The awaiting review is not bound to a valid durable PlanReceipt.');
+}
+//# sourceMappingURL=plan-review.js.map

package/dist/runtime/product-bootstrap.d.ts

@@ -3,6 +3,8 @@ import { type SettingsInvalidationV1 } from '../services/settings-coordinator';
 import type { OrionRuntimeV1 } from './orion-runtime-v1';
 import type { ThreadSessionRuntimeActivationV1 } from './thread-session-view';
 import type { OrionCodeUiRuntime } from './ui-events';
+import type { WorkspaceMutationCoordinatorV1 } from './step-snapshot';
+import { WorkspaceRuntimeKernelV1 } from './workspace-runtime-kernel';
 export interface ProductUiRuntimeBootstrapOptions {
     readonly cwd: string;
     readonly uiRenderer?: UIRenderer;
@@ -11,6 +13,10 @@ export interface ProductUiRuntimeBootstrapOptions {
     readonly onActiveSessionRuntime?: (runtime: OrionRuntimeV1, sessionId: string, activation?: ThreadSessionRuntimeActivationV1) => void | (() => void);
     /** Secret-free Settings invalidations projected by the renderer-owned host. */
     readonly onSettingsInvalidated?: (event: SettingsInvalidationV1) => void;
+    /** Optional Web-hosted FIFO for side effects shared by concurrent Session actors. */
+    readonly workspaceMutationCoordinator?: WorkspaceMutationCoordinatorV1;
+    /** Workspace-owned resources reused by Web Session actors. */
+    readonly workspaceRuntimeKernel?: WorkspaceRuntimeKernelV1;
 }
 /**
  * Shared product composition root for TUI, terminal, print and Web surfaces.