praxis-agent 0.67.0 → 0.67.2

package/dist/application/session-service.d.ts

@@ -378,7 +378,6 @@ export declare class ClaudeSessionService {
     private toolCapabilities;
     private capabilityToolNames;
     private teamRegistry;
-    private logicalTailUuid;
 }
 export {};
 //# sourceMappingURL=session-service.d.ts.map

package/dist/application/session-service.js

@@ -33,7 +33,7 @@ import { lastUserPrompt, projectTranscriptDisplay, unresolvedActiveToolCallIds,
 import { InMemoryTranscriptStore } from '../persistence/in-memory-transcript-store.js';
 import { NativeTranscriptStore, } from '../persistence/native-transcript-store.js';
 import { NativeSessionTranscript, } from './native-session-transcript.js';
-import { TurnPersistence } from './turn-persistence.js';
+import { deriveTurnProjectionCursor, TurnPersistence, } from './turn-persistence.js';
 import { TurnAccounting } from './turn-accounting.js';
 import { CompactionAccounting } from './compaction-accounting.js';
 import { classifyCompactionError } from './compaction-errors.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);
@@ -2636,7 +2637,7 @@ export class ClaudeSessionService {
                     const view = persistence.view();
                     return {
                         entries: [...view.projectionEntries],
-                        tail: view.projectionTail,
+                        cursor: view.projectionCursor,
                     };
                 };
                 const commitProjection = async (entries) => {
@@ -2797,7 +2798,7 @@ export class ClaudeSessionService {
                 const flushRecoveryHookOutcomes = async () => {
                     const entries = [];
                     let history = projectionSnapshot().entries;
-                    let parentUuid = this.logicalTailUuid(projectionSnapshot().tail);
+                    let parentUuid = projectionSnapshot().cursor.lastEntryId;
                     for (const outcome of pendingRecoveryHookOutcomes) {
                         const outcomeEntries = createClaudeHookAttachmentEntries(outcome, {
                             ...this.translationContext(sessionId, projectionSnapshot()),
@@ -2806,9 +2807,8 @@ export class ClaudeSessionService {
                         });
                         entries.push(...outcomeEntries);
                         history = [...history, ...outcomeEntries];
-                        const lastEntry = outcomeEntries.at(-1);
-                        if (typeof lastEntry?.uuid === 'string')
-                            parentUuid = lastEntry.uuid;
+                        const batchCursor = deriveTurnProjectionCursor(outcomeEntries);
+                        parentUuid = batchCursor.lastEntryId ?? parentUuid;
                     }
                     if (entries.length === 0) {
                         pendingRecoveryHookOutcomes.length = 0;
@@ -4479,7 +4479,7 @@ export class ClaudeSessionService {
     translationContext(sessionId, snapshot) {
         return {
             sessionId,
-            parentUuid: this.logicalTailUuid(snapshot.tail),
+            parentUuid: snapshot.cursor.lastEntryId,
             cwd: this.activeCwd(),
             claudeVersion: this.options.claudeVersion,
             gitBranch: null,
@@ -5254,8 +5254,5 @@ export class ClaudeSessionService {
         }
         return factory(base, operations, sessionId, enabledTools);
     }
-    logicalTailUuid(tail) {
-        return tail.branchParentId ?? tail.lastEventId;
-    }
 }
 //# sourceMappingURL=session-service.js.map

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/application/turn-persistence.d.ts

@@ -2,10 +2,13 @@ import type { ModelMessage } from '../core/runtime.js';
 import type { TranscriptEvent } from '../core/transcript-event.js';
 import type { NativeTranscriptEntry } from '../native/schema.js';
 import type { NativeCompactionAppend, NativeInterruption, NativeMessageAppend, NativeSessionTranscriptLease } from './native-session-transcript.js';
-import type { NativeTranscriptTail } from '../persistence/native-transcript-store.js';
+export interface TurnProjectionCursor {
+    readonly lastEntryId: string | null;
+    readonly entryCount: number;
+}
 export interface TurnPersistenceView {
     readonly projectionEntries: readonly NativeTranscriptEntry[];
-    readonly projectionTail: NativeTranscriptTail;
+    readonly projectionCursor: TurnProjectionCursor;
     readonly activeEvents: readonly TranscriptEvent[];
     readonly activeMessages: readonly ModelMessage[];
     readonly interruption: NativeInterruption;
@@ -47,7 +50,7 @@ export type TurnPersistenceReceipt = {
 export declare class TurnPersistence {
     private readonly input;
     private projectionEntries;
-    private projectionTail;
+    private projectionCursor;
     private commitQueue;
     constructor(input: {
         readonly native: NativeSessionTranscriptLease;
@@ -58,5 +61,7 @@ export declare class TurnPersistence {
     commit(command: TurnPersistenceCommand): Promise<TurnPersistenceReceipt>;
     private commitCommand;
     private stageProjection;
+    private replaceProjection;
 }
+export declare const deriveTurnProjectionCursor: (entries: readonly NativeTranscriptEntry[]) => TurnProjectionCursor;
 //# sourceMappingURL=turn-persistence.d.ts.map

package/dist/application/turn-persistence.js

@@ -1,32 +1,28 @@
 import { projectNativeSessionEntries } from './native-session-projection.js';
-const emptyProjectionTail = () => ({
-    byteLength: 0,
-    lastLineHash: null,
-    lastEventId: null,
-    newlineTerminated: true,
-});
 export class TurnPersistence {
     input;
     projectionEntries;
-    projectionTail = emptyProjectionTail();
+    projectionCursor;
     commitQueue = Promise.resolve();
     constructor(input) {
         this.input = input;
         this.projectionEntries = structuredClone(input.initialProjectionEntries
             ? [...input.initialProjectionEntries]
             : projectNativeSessionEntries(input.native.activeEvents()));
+        this.projectionCursor = deriveTurnProjectionCursor(this.projectionEntries);
     }
     view() {
         return {
             projectionEntries: structuredClone(this.projectionEntries),
-            projectionTail: structuredClone(this.projectionTail),
+            projectionCursor: structuredClone(this.projectionCursor),
             activeEvents: structuredClone(this.input.native.activeEvents()),
             activeMessages: structuredClone(this.input.native.activeMessages()),
             interruption: structuredClone(this.input.native.interruption()),
         };
     }
     refresh() {
-        this.projectionEntries = structuredClone(projectNativeSessionEntries(this.input.native.activeEvents()));
+        const entries = projectNativeSessionEntries(this.input.native.activeEvents());
+        this.replaceProjection(entries);
         return this.view();
     }
     commit(command) {
@@ -49,14 +45,10 @@ export class TurnPersistence {
         switch (command.kind) {
             case 'projection': {
                 const staged = this.stageProjection(command.entries);
-                this.projectionEntries = staged.entries;
-                this.projectionTail = staged.tail;
-                const lastProjectionId = [...command.entries]
-                    .reverse()
-                    .find((entry) => typeof entry.uuid === 'string')?.uuid;
+                this.replaceProjection(staged.entries, staged.cursor);
                 return {
                     kind: 'projection',
-                    lastProjectionId: typeof lastProjectionId === 'string' ? lastProjectionId : null,
+                    lastProjectionId: staged.cursor.lastEntryId,
                 };
             }
             case 'messages': {
@@ -67,8 +59,7 @@ export class TurnPersistence {
                     : this.stageProjection(command.projectionEntries);
                 const eventId = await this.input.native.appendMessages(command.input);
                 if (staged) {
-                    this.projectionEntries = staged.entries;
-                    this.projectionTail = staged.tail;
+                    this.replaceProjection(staged.entries, staged.cursor);
                 }
                 return { kind: 'messages', eventId };
             }
@@ -90,25 +81,22 @@ export class TurnPersistence {
         if (entries.length === 0)
             throw new Error('Cannot append an empty projection');
         const stagedEntries = [...this.projectionEntries, ...entries];
-        const lastUuidValue = [...entries]
-            .reverse()
-            .find((entry) => typeof entry.uuid === 'string')?.uuid;
-        const lastUuid = typeof lastUuidValue === 'string' ? lastUuidValue : undefined;
-        const byteLength = this.projectionTail.byteLength + entries.length;
         return {
             entries: stagedEntries,
-            tail: {
-                ...this.projectionTail,
-                byteLength,
-                lastLineHash: `projection:${byteLength}`,
-                lastEventId: typeof lastUuid === 'string'
-                    ? lastUuid
-                    : this.projectionTail.lastEventId,
-                ...(this.projectionTail.branchParentId === undefined
-                    ? {}
-                    : { branchParentId: null }),
-            },
+            cursor: deriveTurnProjectionCursor(stagedEntries),
         };
     }
+    replaceProjection(entries, cursor = deriveTurnProjectionCursor(entries)) {
+        this.projectionEntries = structuredClone([...entries]);
+        this.projectionCursor = structuredClone(cursor);
+    }
 }
+export const deriveTurnProjectionCursor = (entries) => {
+    let lastEntryId = null;
+    for (const entry of entries) {
+        if (typeof entry.uuid === 'string' && entry.uuid.length > 0)
+            lastEntryId = entry.uuid;
+    }
+    return { lastEntryId, entryCount: entries.length };
+};
 //# sourceMappingURL=turn-persistence.js.map

package/dist/build-identity.json

@@ -1 +1 @@
-{"schema_version":"1.0","source_revision":"git:044ea290901a55dd5e343e78bdcd6a63d0455a00","source_dirty":false,"artifact_sha256":"sha256:272099586a6fe68b899e7ec80e182b404afe590341a24cb90196eebe90d3ce29"}
+{"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.0",
+  "version": "0.67.2",
   "description": "Local-first, single-user general agent for the command line.",
   "license": "MIT",
   "author": "wuqisen",