praxis-agent 0.67.1 → 0.67.2

package/dist/application/session-service.js

@@ -901,7 +901,7 @@ export class ClaudeSessionService {
     }
     async close() {
         this.closing = true;
-        this.turnCoordinator.close();
+        await this.turnCoordinator.close();
         await this.fileChangeWatcher?.close(5_000);
         await this.hookLifecycle.close();
         await this.drainDetachedHookRuns(5_000);
@@ -2590,7 +2590,7 @@ export class ClaudeSessionService {
         return tracker.snapshot();
     }
     async executeTurn(request) {
-        const { activation, submission, signal } = request;
+        const { activation, submission } = request;
         const sessionId = activation.sessionId;
         const requireExisting = activation.kind === 'resume';
         const name = activation.name;
@@ -2604,7 +2604,8 @@ export class ClaudeSessionService {
         const documents = submission.kind === 'prompt' ? (submission.documents ?? []) : [];
         const shellCommand = submission.kind === 'shell' ? submission.command : undefined;
         const skipUserPrompt = submission.kind === 'retry';
-        return this.turnCoordinator.run(request, async ({ emit, steering }) => {
+        return this.turnCoordinator.run(request, async (scope) => {
+            const { emit, signal, steering } = scope;
             this.assertTurnWritable();
             await this.activateSessionCostTracker(sessionId);
             await this.ensureFileResources(sessionId, signal);

package/dist/application/turn-lifecycle.d.ts

@@ -29,6 +29,7 @@ export interface TurnRequest {
 }
 export interface TurnScope {
     readonly emit: RuntimeEventSink;
+    readonly signal: AbortSignal;
     readonly steering?: ActiveTurnInputPort;
 }
 export interface TurnCoordinatorOptions {
@@ -39,11 +40,13 @@ export interface TurnCoordinatorOptions {
 export declare class TurnCoordinator {
     private readonly options;
     private readonly activeTurns;
+    private closing;
+    private closePromise;
     constructor(options: TurnCoordinatorOptions);
     run<T>(request: TurnRequest, work: (scope: TurnScope) => Promise<T>): Promise<T>;
     steer(sessionId: string, content: string): ActiveTurnInputCommandResult;
     withdrawSteering(sessionId: string, id: string): ActiveTurnInputCommandResult;
-    close(): void;
+    close(): Promise<void>;
     private validateRequest;
     private terminalState;
     private transition;

package/dist/application/turn-lifecycle.js

@@ -4,6 +4,8 @@ import { ActiveTurnInputMailbox, } from '../core/active-turn-input.js';
 export class TurnCoordinator {
     options;
     activeTurns = new Map();
+    closing = false;
+    closePromise;
     constructor(options) {
         this.options = options;
     }
@@ -12,13 +14,23 @@ export class TurnCoordinator {
         const mailbox = request.submission.kind === 'shell'
             ? undefined
             : new ActiveTurnInputMailbox(this.options.createSteeringId);
+        let settle;
+        const settled = new Promise((resolve) => {
+            settle = resolve;
+        });
+        const controller = new AbortController();
         const record = {
             ...(mailbox ? { mailbox } : {}),
+            controller,
+            settled,
+            settle,
             terminal: false,
         };
         let terminalState = 'failed';
         let pendingFailure;
+        let callerAbort;
         const scope = {
+            signal: controller.signal,
             emit: (event) => {
                 if (event.type === 'state' &&
                     (event.state === 'completed' ||
@@ -31,19 +43,29 @@ export class TurnCoordinator {
             ...(mailbox ? { steering: mailbox } : {}),
         };
         try {
+            if (request.signal?.aborted)
+                controller.abort(request.signal.reason);
             this.validateRequest(request);
             if (this.activeTurns.has(sessionId)) {
                 throw new Error(`conflict: locked (session ${sessionId} already has an active turn)`);
             }
+            if (this.closing)
+                throw new Error('turn coordinator is closed');
             this.activeTurns.set(sessionId, record);
+            if (request.signal && !request.signal.aborted) {
+                callerAbort = () => controller.abort(request.signal?.reason);
+                request.signal.addEventListener('abort', callerAbort, { once: true });
+            }
             const result = await work(scope);
+            if (controller.signal.aborted)
+                throw new AgentRunCancelledError();
             terminalState = 'completed';
             this.transition(record, 'completed');
             return result;
         }
         catch (error) {
             if (!record.terminal) {
-                terminalState = this.terminalState(error, request.signal);
+                terminalState = this.terminalState(error, controller.signal);
                 this.transition(record, terminalState);
             }
             throw error;
@@ -55,10 +77,14 @@ export class TurnCoordinator {
                 }
             }
             finally {
+                if (callerAbort && request.signal) {
+                    request.signal.removeEventListener('abort', callerAbort);
+                }
                 if (this.activeTurns.get(sessionId) === record) {
                     this.activeTurns.delete(sessionId);
                 }
             }
+            record.settle();
             if (pendingFailure) {
                 // A rejected-input sink failure intentionally retains its prior precedence.
                 // eslint-disable-next-line no-unsafe-finally -- compatibility is covered by the sink-error regression
@@ -86,16 +112,33 @@ export class TurnCoordinator {
         const result = active.mailbox.withdraw(id);
         return result.kind === 'withdrawn' ? result : { kind: 'not-pending' };
     }
-    close() {
+    async close() {
+        if (this.closePromise)
+            return this.closePromise;
+        this.closing = true;
+        const snapshot = [...this.activeTurns.values()];
         let firstFailure;
-        for (const active of this.activeTurns.values()) {
-            if (!active.mailbox)
-                continue;
-            const failure = this.rejectPending(active.mailbox.close(), 'closed');
-            firstFailure ??= failure;
-        }
-        if (firstFailure)
-            throw firstFailure.error;
+        let resolveClose;
+        let rejectClose;
+        this.closePromise = new Promise((resolve, reject) => {
+            resolveClose = resolve;
+            rejectClose = reject;
+        });
+        void (async () => {
+            for (const active of snapshot) {
+                if (active.mailbox) {
+                    const failure = this.rejectPending(active.mailbox.close(), 'closed');
+                    firstFailure ??= failure;
+                }
+                active.controller.abort();
+            }
+            await Promise.allSettled(snapshot.map((active) => active.settled));
+            if (firstFailure)
+                rejectClose(firstFailure.error);
+            else
+                resolveClose();
+        })();
+        return this.closePromise;
     }
     validateRequest(request) {
         const { activation, submission } = request;

package/dist/build-identity.json

@@ -1 +1 @@
-{"schema_version":"1.0","source_revision":"git:dc131bb8a371077329b97b3da87c4af7c15301f2","source_dirty":false,"artifact_sha256":"sha256:ea1838f9bf68da8966f2b3dbc5a994e2719c55bc511f3b064e71fdd64cc82f7f"}
+{"schema_version":"1.0","source_revision":"git:cdfb04df03516521ee1f366319665ef07c41fdb7","source_dirty":false,"artifact_sha256":"sha256:506df1f26b80d8092b1748de2a1130ad9b4b9fa423776d31f911d81cd5976610"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praxis-agent",
-  "version": "0.67.1",
+  "version": "0.67.2",
   "description": "Local-first, single-user general agent for the command line.",
   "license": "MIT",
   "author": "wuqisen",