@timurproko/a1 0.2.7-dev.754 → 0.2.7-dev.772

package/dist/integrations/pi/engine/runtime-integration.js

@@ -1,8 +1,63 @@
+import { closeSync, mkdirSync, openSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
 import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, resolveModelScopeWithDiagnostics, SessionManager, SettingsManager, } from "../startup-public.js";
 import { resolvePiProjectTrustPreflight, } from "./project-trust-preflight.js";
-import { openSelectedPiSession, resolveSessionArgumentPath } from "./session-selection.js";
+import { openSelectedPiSession, resolveSessionArgumentPath, takeSelectedSessionWriter } from "./session-selection.js";
 import { markStartupPhase } from "../../../foundation/startup/startup-runtime.js";
 import { createWindowsNulCleanupExtension } from "./windows-filesystem-hygiene.js";
+import { acquireSessionWriter, } from "../../../foundation/session-writer-lock/index.js";
+class SessionWriterCoordinator {
+    #current;
+    prepare(manager) {
+        const selected = takeSelectedSessionWriter(manager);
+        if (selected !== undefined)
+            return { handle: selected, alreadyCurrent: false };
+        const path = manager.getSessionFile();
+        if (path === undefined)
+            return undefined;
+        if (this.#current?.path === path)
+            return { handle: this.#current, alreadyCurrent: true };
+        const handle = acquireSessionWriter(path);
+        try {
+            if (!handle.bound) {
+                const header = manager.getHeader();
+                if (header === null)
+                    throw new Error("new session is missing its generated header");
+                mkdirSync(dirname(path), { recursive: true });
+                const descriptor = openSync(path, "wx", 0o600);
+                try {
+                    handle.bind(path);
+                    writeFileSync(descriptor, `${JSON.stringify(header)}\n`);
+                }
+                finally {
+                    closeSync(descriptor);
+                }
+                manager.setSessionFile(path);
+            }
+            return { handle, alreadyCurrent: false };
+        }
+        catch (error) {
+            handle.release();
+            throw error;
+        }
+    }
+    activate(pending) {
+        if (pending === undefined || pending.alreadyCurrent)
+            return;
+        const previous = this.#current;
+        this.#current = pending.handle;
+        previous?.release();
+    }
+    abandon(pending) {
+        if (pending !== undefined && !pending.alreadyCurrent)
+            pending.handle.release();
+    }
+    release() {
+        this.#current?.release();
+        this.#current = undefined;
+    }
+}
+const runtimeSessionWriters = new WeakMap();
 /**
  * Mirrors pinned Pi's CLI startup: resolve the `models` patterns from settings
  * into a scoped model list, keep the resolver's warnings (e.g. "No models match
@@ -69,40 +124,52 @@ export async function createPiRuntimeIntegration(options) {
             cwd: options.cwd, selection,
             ...(sessionDir === undefined ? {} : { sessionDir }),
             ...(options.sessionForkPrompt === undefined ? {} : { forkPrompt: options.sessionForkPrompt }),
+            guardWriter: true,
         });
+    const sessionWriters = new SessionWriterCoordinator();
     const createRuntime = async ({ cwd, sessionManager: targetSessionManager, sessionStartEvent, }) => {
-        const { services, trust } = await createPiRuntimeServicesAfterTrust({
-            cwd,
-            agentDir: options.agentDir,
-            ...(options.projectTrustPrompt === undefined ? {} : { projectTrustPrompt: options.projectTrustPrompt }),
-            ...(options.preflightDependencies === undefined ? {} : { preflightDependencies: options.preflightDependencies }),
-            ...(options.markStartupPhase === undefined ? {} : { markStartupPhase: options.markStartupPhase }),
-        });
-        const modelScope = await resolveConfiguredModelScope(services, options.signal);
-        const hasExistingSession = targetSessionManager.buildSessionContext().messages.length > 0;
-        const created = await createAgentSessionFromServices({
-            services,
-            sessionManager: targetSessionManager,
-            ...(sessionStartEvent ? { sessionStartEvent } : {}),
-            ...(modelScope.model && !hasExistingSession ? { model: modelScope.model } : {}),
-            ...(modelScope.thinkingLevel && !hasExistingSession ? { thinkingLevel: modelScope.thinkingLevel } : {}),
-            ...(modelScope.scopedModels.length > 0 ? { scopedModels: [...modelScope.scopedModels] } : {}),
-        });
-        await (options.markStartupPhase ?? defaultStartupPhaseMarker)("session-created");
-        return {
-            ...created,
-            services,
-            diagnostics: [
-                ...(trust.diagnostic === null ? [] : [{ type: "warning", code: "project-trust", message: trust.diagnostic }]),
-                ...modelScope.diagnostics,
-            ],
-        };
+        const pendingWriter = sessionWriters.prepare(targetSessionManager);
+        try {
+            const { services, trust } = await createPiRuntimeServicesAfterTrust({
+                cwd,
+                agentDir: options.agentDir,
+                ...(options.projectTrustPrompt === undefined ? {} : { projectTrustPrompt: options.projectTrustPrompt }),
+                ...(options.preflightDependencies === undefined ? {} : { preflightDependencies: options.preflightDependencies }),
+                ...(options.markStartupPhase === undefined ? {} : { markStartupPhase: options.markStartupPhase }),
+            });
+            const modelScope = await resolveConfiguredModelScope(services, options.signal);
+            const hasExistingSession = targetSessionManager.buildSessionContext().messages.length > 0;
+            const created = await createAgentSessionFromServices({
+                services,
+                sessionManager: targetSessionManager,
+                ...(sessionStartEvent ? { sessionStartEvent } : {}),
+                ...(modelScope.model && !hasExistingSession ? { model: modelScope.model } : {}),
+                ...(modelScope.thinkingLevel && !hasExistingSession ? { thinkingLevel: modelScope.thinkingLevel } : {}),
+                ...(modelScope.scopedModels.length > 0 ? { scopedModels: [...modelScope.scopedModels] } : {}),
+            });
+            sessionWriters.activate(pendingWriter);
+            await (options.markStartupPhase ?? defaultStartupPhaseMarker)("session-created");
+            return {
+                ...created,
+                services,
+                diagnostics: [
+                    ...(trust.diagnostic === null ? [] : [{ type: "warning", code: "project-trust", message: trust.diagnostic }]),
+                    ...modelScope.diagnostics,
+                ],
+            };
+        }
+        catch (error) {
+            sessionWriters.abandon(pendingWriter);
+            throw error;
+        }
     };
-    return createAgentSessionRuntime(createRuntime, {
+    const runtime = await createAgentSessionRuntime(createRuntime, {
         cwd: sessionManager.getCwd(),
         agentDir: options.agentDir,
         sessionManager,
     });
+    runtimeSessionWriters.set(runtime, sessionWriters);
+    return runtime;
 }
 function defaultStartupPhaseMarker(phase) {
     return markStartupPhase(process.env, phase);
@@ -119,5 +186,11 @@ export async function replacePiRuntimeSession(runtime, replacement) {
 export async function disposePiRuntimeIntegration(runtime) {
     runtime.setRebindSession(undefined);
     runtime.setBeforeSessionInvalidate(undefined);
-    await runtime.dispose();
+    try {
+        await runtime.dispose();
+    }
+    finally {
+        runtimeSessionWriters.get(runtime)?.release();
+        runtimeSessionWriters.delete(runtime);
+    }
 }

package/dist/integrations/pi/engine/session-runtime.d.ts

@@ -64,12 +64,6 @@ export interface PiEngineRuntimePorts {
     diagnostic(severity: OwnedUiDiagnostics["severity"], code: string, message: string, recoverable: boolean): void;
     emitView(): void;
 }
-/**
- * The pinned Pi runtime and the session bound to it: creation through the runtime factory, the
- * session generation that stamps and invalidates events, the subscription that forwards session
- * events, compaction progress observation, the queued-input integration, and disposal order. The
- * adapter derives its view state from the session it is handed and never touches these directly.
- */
 export declare class PiEngineRuntime {
     #private;
     constructor(options: PiEngineRuntimeOptions, ports: PiEngineRuntimePorts);

package/dist/integrations/pi/engine/session-runtime.js

@@ -18,6 +18,9 @@ const GIT_BRANCH_MAX_BUFFER_BYTES = 4 * 1024;
  * events, compaction progress observation, the queued-input integration, and disposal order. The
  * adapter derives its view state from the session it is handed and never touches these directly.
  */
+function hasSessionContent(path, session) {
+    return path !== null && existsSync(path) && session.messages.length > 0;
+}
 export class PiEngineRuntime {
     #options;
     #ports;
@@ -154,14 +157,16 @@ export class PiEngineRuntime {
         return typeof value === "string" && value.length > 0 ? value : null;
     }
     currentSessionResumeMetadata() {
-        const manager = this.#session?.sessionManager;
-        if (manager === undefined
+        const session = this.#session;
+        const manager = session?.sessionManager;
+        if (session === undefined
+            || manager === undefined
             || typeof manager.isPersisted !== "function"
             || typeof manager.getSessionId !== "function"
             || typeof manager.getSessionDir !== "function"
             || typeof manager.usesDefaultSessionDir !== "function"
             || manager.isPersisted() !== true
-            || !existsSync(this.currentSessionFile() ?? ""))
+            || !hasSessionContent(this.currentSessionFile(), session))
             return null;
         const sessionId = manager.getSessionId();
         const sessionDir = manager.getSessionDir();

package/dist/integrations/pi/engine/session-selection.d.ts

@@ -1,4 +1,5 @@
 import { SessionManager, type SessionInfo } from "../startup-public.js";
+import { type SessionWriterHandle } from "../../../foundation/session-writer-lock/index.js";
 export interface PiSessionSelection {
     readonly target: string;
     readonly sessionDir?: string;
@@ -16,11 +17,13 @@ interface SessionSelectionOptions {
     readonly selection: PiSessionSelection;
     readonly sessionDir?: string;
     readonly forkPrompt?: PiSessionForkPrompt;
+    readonly guardWriter?: boolean;
     /** Public API seam for deterministic lookup/open race and listing-order evidence. */
     readonly sessions?: Pick<typeof SessionManager, "list" | "open" | "forkFrom"> & {
         readonly listAll: (sessionDir?: string) => Promise<SessionInfo[]>;
     };
 }
+export declare function takeSelectedSessionWriter(manager: SessionManager): SessionWriterHandle | undefined;
 /** Pinned Pi 0.84.2 main.ts policy, using SDK APIs rather than importing the CLI. */
 export declare function openSelectedPiSession(options: SessionSelectionOptions): Promise<SessionManager>;
 /** Resolve before switching effective cwd, including quoted home-relative paths. */

package/dist/integrations/pi/engine/session-selection.js

@@ -2,6 +2,7 @@ import { accessSync, constants, existsSync, realpathSync, statSync } from "node:
 import { homedir } from "node:os";
 import { resolve } from "node:path";
 import { SessionManager } from "../startup-public.js";
+import { acquireExisting, acquireSessionWriter, SessionWriterConflict, } from "../../../foundation/session-writer-lock/index.js";
 /** Expected resume outcomes are concise CLI diagnostics, not engine crashes. */
 export class PiSessionSelectionError extends Error {
     exitCode;
@@ -11,13 +12,23 @@ export class PiSessionSelectionError extends Error {
         this.name = "PiSessionSelectionError";
     }
 }
+const selectedSessionWriters = new WeakMap();
+export function takeSelectedSessionWriter(manager) {
+    const writer = selectedSessionWriters.get(manager);
+    selectedSessionWriters.delete(manager);
+    return writer;
+}
+function holdSelectedWriter(manager, writer) {
+    selectedSessionWriters.set(manager, writer);
+    return manager;
+}
 /** Pinned Pi 0.84.2 main.ts policy, using SDK APIs rather than importing the CLI. */
 export async function openSelectedPiSession(options) {
+    const sessions = options.sessions ?? SessionManager;
+    const cwd = resolve(options.cwd);
+    const directory = options.selection.sessionDir ?? options.sessionDir ?? process.env.PI_CODING_AGENT_SESSION_DIR;
+    const sessionDir = directory === undefined ? undefined : resolveSessionArgumentPath(directory, cwd);
     try {
-        const sessions = options.sessions ?? SessionManager;
-        const cwd = resolve(options.cwd);
-        const directory = options.selection.sessionDir ?? options.sessionDir ?? process.env.PI_CODING_AGENT_SESSION_DIR;
-        const sessionDir = directory === undefined ? undefined : resolveSessionArgumentPath(directory, cwd);
         const target = options.selection.target;
         let path;
         let global;
@@ -43,18 +54,43 @@ export async function openSelectedPiSession(options) {
             }
             assertResumeFile(path);
             assertCwd(cwd);
-            return sessions.forkFrom(path, cwd, sessionDir);
+            const manager = sessions.forkFrom(path, cwd, sessionDir);
+            if (!options.guardWriter)
+                return manager;
+            const target = manager.getSessionFile();
+            if (target === undefined)
+                throw new PiSessionSelectionError("Fork did not create a session file");
+            return holdSelectedWriter(manager, acquireSessionWriter(target));
         }
         // Invariant: no await between the final guard and SDK open. A disappeared target
         // can otherwise produce a new in-memory header instead of an existing session.
-        const manager = sessions.open(path, sessionDir);
-        assertResumeFile(path);
-        assertCwd(manager.getCwd());
-        return manager;
+        const writer = options.guardWriter ? acquireExisting(path) : undefined;
+        try {
+            const manager = sessions.open(path, sessionDir);
+            assertResumeFile(path);
+            assertCwd(manager.getCwd());
+            return writer === undefined ? manager : holdSelectedWriter(manager, writer);
+        }
+        catch (error) {
+            writer?.release();
+            throw error;
+        }
     }
     catch (error) {
         if (error instanceof PiSessionSelectionError)
             throw error;
+        if (error instanceof SessionWriterConflict) {
+            if (options.forkPrompt && await options.forkPrompt({ sourceCwd: cwd })) {
+                const manager = sessions.forkFrom(error.path, cwd, sessionDir);
+                if (!options.guardWriter)
+                    return manager;
+                const target = manager.getSessionFile();
+                if (target === undefined)
+                    throw new PiSessionSelectionError("Fork did not create a session file");
+                return holdSelectedWriter(manager, acquireSessionWriter(target));
+            }
+            throw new PiSessionSelectionError("session is open in another A1 process");
+        }
         throw new PiSessionSelectionError(`Could not resume session: ${error instanceof Error ? error.message : String(error)}`);
     }
 }

package/dist/integrations/pi/engine/workflow-contexts.js

@@ -3,6 +3,7 @@ import { dirname, resolve } from "node:path";
 import { dynamicObject, isRecord, requireCapability, stringProperty } from "./message-values.js";
 import { ProjectTrustStore, SessionManager } from "../startup-public.js";
 import { resolveConfiguredModelIds, scopedModelRecords, scopedModelReference, workflowOptions } from "./workflow-support.js";
+import { acquireExisting } from "../../../foundation/session-writer-lock/index.js";
 /**
  * The selector contexts and option lists the owned UI's workflow dialogs read from pinned Pi:
  * model, scoped-model, session, tree, fork, project-trust, and provider-authentication state,
@@ -102,7 +103,15 @@ export class PiWorkflowContexts {
                 const next = (nextName ?? "").trim();
                 if (!next)
                     return;
-                SessionManager.open(sessionFilePath).appendSessionInfo(next);
+                const isCurrent = typeof currentSessionFilePath === "string"
+                    && resolve(currentSessionFilePath) === resolve(sessionFilePath);
+                const writer = isCurrent ? undefined : acquireExisting(sessionFilePath);
+                try {
+                    SessionManager.open(sessionFilePath).appendSessionInfo(next);
+                }
+                finally {
+                    writer?.release();
+                }
             },
         };
     }