@nt-ai-lab/deterministic-agent-workflow-pi 0.5.3 → 0.5.5-issue-526.ce3247e.0

package/dist/features/pi-extension/entrypoint/pi-workflow-extension.d.ts

@@ -1,6 +1,6 @@
 import type { BaseWorkflowState, RehydratableWorkflow, TransitionContext } from '@nt-ai-lab/deterministic-agent-workflow-engine';
 import type { PiWorkflowExtension, PiWorkflowExtensionConfig } from '../../../platform/domain/pi-workflow-extension-types';
-export declare const PI_IDLE_RECOVERY_MESSAGE = "You have stopped. You should never stop until the workflow is complete unless your current state permits stopping.";
+export declare const PI_IDLE_RECOVERY_MESSAGE: string;
 export declare const PI_SESSION_BRANCH_BLOCK_MESSAGE = "Pi session tree navigation and forks are disabled while a workflow is active.";
 /** @riviere-role cli-entrypoint */
 export declare function createPiWorkflowExtension<TWorkflow extends RehydratableWorkflow<TState>, TState extends BaseWorkflowState<TStateName>, TDeps, TStateName extends string = string, TOperation extends string = string, TTransitionContext extends TransitionContext<TState, TStateName> = TransitionContext<TState, TStateName>>(config: PiWorkflowExtensionConfig<TWorkflow, TState, TDeps, TStateName, TOperation, TTransitionContext>): PiWorkflowExtension;

package/dist/features/pi-extension/entrypoint/pi-workflow-extension.js

@@ -1,18 +1,19 @@
 import { join } from 'node:path';
 import { WorkflowEngine } from '@nt-ai-lab/deterministic-agent-workflow-engine';
-import { createPreToolUseHandler, createWorkflowRunner, getRepositoryName, } from '@nt-ai-lab/deterministic-agent-workflow-cli';
+import { createPreToolUseHandler, createWorkflowRunner, formatStopPreventionMessage, getRepositoryName, } from '@nt-ai-lab/deterministic-agent-workflow-cli';
 import { createStore } from '@nt-ai-lab/deterministic-agent-workflow-event-store';
 import { Type } from 'typebox';
 import { parsePiCommandArguments } from '../../../platform/domain/pi-command-arguments.js';
-import { hasPiWorkflowMarker, PI_WORKFLOW_MARKER_CUSTOM_TYPE, readPiSessionMetadata, } from '../../../platform/infra/external-clients/pi/pi-session-file.js';
+import { hasPiWorkflowMarker, PI_WORKFLOW_MARKER_CUSTOM_TYPE, } from '../../../platform/infra/external-clients/pi/pi-session-file.js';
 import { getLatestPiAssistantSettlement, PiTranscriptReader, } from '../../../platform/infra/external-clients/pi/pi-transcript-reader.js';
 import { notifyRouteResult, readSessionId, readWorkflowInstruction, requireSessionFile, resolveDatabasePath, translationNote, } from './pi-workflow-extension-platform.js';
+import { createPiWorkflowSessionOwnership } from './pi-workflow-session-ownership.js';
 const PI_QUESTION_TOOL = 'question';
 const DEFAULT_COMMAND_NAME = 'workflow';
 const DEFAULT_TOOL_NAME = 'workflow';
 const INITIALIZATION_PENDING_REASON = 'Pi workflow initialization has not completed safely. Tool execution is blocked.';
 const INACTIVE_WORKFLOW_REASON = 'Pi workflow is inactive. Run the workflow init command before using workflow operations.';
-export const PI_IDLE_RECOVERY_MESSAGE = 'You have stopped. You should never stop until the workflow is complete unless your current state permits stopping.';
+export const PI_IDLE_RECOVERY_MESSAGE = formatStopPreventionMessage();
 export const PI_SESSION_BRANCH_BLOCK_MESSAGE = 'Pi session tree navigation and forks are disabled while a workflow is active.';
 const workflowToolParameters = Type.Object({
     operation: Type.String({ description: 'Workflow operation, for example init or transition' }),
@@ -23,6 +24,7 @@ export function createPiWorkflowExtension(config) {
     const databasePath = resolveDatabasePath(config.databasePath);
     const commandName = config.commandName ?? DEFAULT_COMMAND_NAME;
     const toolName = config.toolName ?? DEFAULT_TOOL_NAME;
+    const ownership = createPiWorkflowSessionOwnership(databasePath);
     const initializationBySession = new Map();
     const sessionStartsById = new Map();
     const recoveredAssistantBySession = new Map();
@@ -35,6 +37,7 @@ export function createPiWorkflowExtension(config) {
     const runner = createWorkflowRunner({
         workflowDefinition: config.workflowDefinition,
         routes: config.routes,
+        unknownCommandMessage: config.unknownCommandMessage,
         bashForbidden: config.bashForbidden,
         isWriteAllowed: config.isWriteAllowed,
         questionToolName: PI_QUESTION_TOOL,
@@ -53,7 +56,7 @@ export function createPiWorkflowExtension(config) {
             appendToFile: () => undefined,
             now,
             transcriptReader: new PiTranscriptReader(() => ctx.sessionManager.getBranch()),
-            sessionContext: { getMainSessionId: () => sessionId },
+            sessionContext: { getMainSessionId: () => ownership.delegatedParent(sessionId, store) ?? sessionId, },
         };
     }
     function useEngine(ctx, operation) {
@@ -62,6 +65,7 @@ export function createPiWorkflowExtension(config) {
             const engineDeps = buildEngineDeps(ctx, store);
             const now = engineDeps.now;
             const sessionId = ctx.sessionManager.getSessionId();
+            ownership.requireAccess(store, sessionId);
             const platform = {
                 getPluginRoot: () => config.pluginRoot,
                 now,
@@ -76,15 +80,6 @@ export function createPiWorkflowExtension(config) {
             store.db.close();
         }
     }
-    function hasPersistedWorkflowState(sessionId) {
-        const store = createStore(databasePath);
-        try {
-            return store.hasSessionStarted(sessionId);
-        }
-        finally {
-            store.db.close();
-        }
-    }
     function markInitializationFailed(ctx, sessionId, detail) {
         return failSession(ctx, sessionId, `Pi workflow initialization failed: ${detail}`);
     }
@@ -113,23 +108,9 @@ export function createPiWorkflowExtension(config) {
     }
     function isInactive(ctx) {
         const session = readSessionId(ctx);
-        return session.ok && initializationBySession.get(session.sessionId)?.type === 'inactive';
-    }
-    function parentSafetyFailure(event, ctx) {
-        const parentSessionFile = ctx.sessionManager.getHeader()?.parentSession;
-        if (parentSessionFile === undefined) {
-            return event.reason === 'fork' ? 'Forked Pi session has no verifiable parent session file.' : undefined;
-        }
-        const parent = readPiSessionMetadata(parentSessionFile);
-        const store = createStore(databasePath);
-        try {
-            return store.hasSessionStarted(parent.id) || parent.hasWorkflowMarker
-                ? `Cannot fork Pi session ${parent.id}: its workflow is active.`
-                : undefined;
-        }
-        finally {
-            store.db.close();
-        }
+        if (!session.ok)
+            return false;
+        return initializationBySession.get(session.sessionId)?.type === 'inactive';
     }
     function initializeSession(event, ctx, pi, sessionId) {
         try {
@@ -139,22 +120,29 @@ export function createPiWorkflowExtension(config) {
                 return 'Pi session header does not match the active session UUID.';
             const activeBranchHasWorkflowMarker = hasPiWorkflowMarker(ctx.sessionManager.getBranch());
             const sessionHasWorkflowMarker = hasPiWorkflowMarker(ctx.sessionManager.getEntries());
+            const inheritedWorkflowState = ownership.usesInheritedWorkflow(sessionId);
+            const delegatedParent = ownership.delegatedParent(sessionId);
             const result = useEngine(ctx, (engine) => {
                 const sqliteHasWorkflowState = engine.hasSessionStarted(sessionId);
                 if (!sqliteHasWorkflowState) {
-                    const parentFailure = parentSafetyFailure(event, ctx);
+                    const parentFailure = ownership.parentSafetyFailure(event, ctx);
                     if (parentFailure !== undefined)
                         return {
                             type: 'error',
                             output: parentFailure,
                         };
                 }
-                if (sessionHasWorkflowMarker && !activeBranchHasWorkflowMarker)
+                if (delegatedParent !== undefined && !sqliteHasWorkflowState)
+                    return {
+                        type: 'error',
+                        output: `Pi parent session ${delegatedParent} has no persisted workflow.`,
+                    };
+                if (!inheritedWorkflowState && sessionHasWorkflowMarker && !activeBranchHasWorkflowMarker)
                     return {
                         type: 'error',
                         output: `The active Pi branch does not contain this session's ${PI_WORKFLOW_MARKER_CUSTOM_TYPE} marker.`,
                     };
-                if (activeBranchHasWorkflowMarker !== sqliteHasWorkflowState)
+                if (!inheritedWorkflowState && activeBranchHasWorkflowMarker !== sqliteHasWorkflowState)
                     return {
                         type: 'error',
                         output: `Pi transcript and SQLite workflow state disagree for session ${sessionId}.`,
@@ -243,7 +231,7 @@ export function createPiWorkflowExtension(config) {
             }
             sessionStartsById.set(session.sessionId, event);
             try {
-                const hasPersistedWorkflow = hasPersistedWorkflowState(session.sessionId);
+                const hasPersistedWorkflow = ownership.hasPersistedWorkflow(session.sessionId);
                 const hasTranscriptWorkflow = hasPiWorkflowMarker(ctx.sessionManager.getEntries());
                 if (!hasPersistedWorkflow && !hasTranscriptWorkflow) {
                     initializationBySession.set(session.sessionId, { type: 'inactive' });
@@ -317,7 +305,7 @@ export function createPiWorkflowExtension(config) {
                 const result = useEngine(ctx, (engine) => engine.checkStopping(session.sessionId, 'stop'));
                 if (result.type === 'blocked' && ctx.isIdle() && !ctx.hasPendingMessages()) {
                     recoveredAssistantBySession.set(session.sessionId, settlement.id);
-                    pi.sendUserMessage(PI_IDLE_RECOVERY_MESSAGE);
+                    pi.sendUserMessage(formatStopPreventionMessage(result.output, config.stopPreventionMessage));
                 }
             }
             catch (error) {

package/dist/features/pi-extension/entrypoint/pi-workflow-session-ownership.d.ts

@@ -0,0 +1,12 @@
+import type { ExtensionContext, SessionStartEvent } from '@earendil-works/pi-coding-agent';
+import { type SqliteEventStore } from '@nt-ai-lab/deterministic-agent-workflow-event-store';
+interface PiWorkflowSessionOwnership {
+    delegatedParent(sessionId: string, store?: SqliteEventStore): string | undefined;
+    hasPersistedWorkflow(sessionId: string): boolean;
+    usesInheritedWorkflow(sessionId: string): boolean;
+    parentSafetyFailure(event: SessionStartEvent, ctx: ExtensionContext): string | undefined;
+    requireAccess(store: SqliteEventStore, sessionId: string): void;
+}
+/** @riviere-role cli-entrypoint */
+export declare function createPiWorkflowSessionOwnership(databasePath: string): PiWorkflowSessionOwnership;
+export {};

package/dist/features/pi-extension/entrypoint/pi-workflow-session-ownership.js

@@ -0,0 +1,72 @@
+import { createStore, } from '@nt-ai-lab/deterministic-agent-workflow-event-store';
+import { resolvePiMainSessionId } from '../../../platform/domain/pi-main-session.js';
+import { readPiSessionMetadata } from '../../../platform/infra/external-clients/pi/pi-session-file.js';
+/** @riviere-role cli-entrypoint */
+export function createPiWorkflowSessionOwnership(databasePath) {
+    const delegatedParent = (sessionId, existingStore) => {
+        const store = existingStore ?? createStore(databasePath);
+        try {
+            if (store.hasSessionStarted(sessionId))
+                return undefined;
+            const mainSessionId = resolvePiMainSessionId(sessionId);
+            return mainSessionId === sessionId ? undefined : mainSessionId;
+        }
+        finally {
+            if (existingStore === undefined)
+                store.db.close();
+        }
+    };
+    const requireParent = (store, parentSessionId) => {
+        if (!store.hasSessionStarted(parentSessionId)) {
+            throw new TypeError(`Pi parent session ${parentSessionId} has no persisted workflow.`);
+        }
+    };
+    return {
+        delegatedParent,
+        hasPersistedWorkflow(sessionId) {
+            const store = createStore(databasePath);
+            try {
+                const parentSessionId = delegatedParent(sessionId, store);
+                if (parentSessionId !== undefined) {
+                    requireParent(store, parentSessionId);
+                    return true;
+                }
+                return store.hasSessionStarted(sessionId);
+            }
+            finally {
+                store.db.close();
+            }
+        },
+        usesInheritedWorkflow(sessionId) {
+            const store = createStore(databasePath);
+            try {
+                return delegatedParent(sessionId, store) !== undefined;
+            }
+            finally {
+                store.db.close();
+            }
+        },
+        parentSafetyFailure(event, ctx) {
+            const parentSessionFile = ctx.sessionManager.getHeader()?.parentSession;
+            if (parentSessionFile === undefined) {
+                return event.reason === 'fork' ? 'Forked Pi session has no verifiable parent session file.' : undefined;
+            }
+            const parent = readPiSessionMetadata(parentSessionFile);
+            const store = createStore(databasePath);
+            try {
+                return store.hasSessionStarted(parent.id) || parent.hasWorkflowMarker
+                    ? `Cannot fork Pi session ${parent.id}: its workflow is active.`
+                    : undefined;
+            }
+            finally {
+                store.db.close();
+            }
+        },
+        requireAccess(store, sessionId) {
+            const parentSessionId = delegatedParent(sessionId, store);
+            if (parentSessionId !== undefined) {
+                requireParent(store, parentSessionId);
+            }
+        },
+    };
+}

package/dist/index.d.ts

@@ -1,3 +1,5 @@
 export { createPiWorkflowExtension, PI_IDLE_RECOVERY_MESSAGE, PI_SESSION_BRANCH_BLOCK_MESSAGE, } from './features/pi-extension/entrypoint/pi-workflow-extension';
 export type { PiWorkflowExtension, PiWorkflowExtensionConfig, } from './platform/domain/pi-workflow-extension-types';
+export { resolvePiMainSessionId } from './platform/domain/pi-main-session';
+export { refreshPiContextWindow } from './platform/infra/external-clients/pi/pi-context-window';
 export { PiTranscriptReader } from './platform/infra/external-clients/pi/pi-transcript-reader';

package/dist/index.js

@@ -1,2 +1,4 @@
 export { createPiWorkflowExtension, PI_IDLE_RECOVERY_MESSAGE, PI_SESSION_BRANCH_BLOCK_MESSAGE, } from './features/pi-extension/entrypoint/pi-workflow-extension.js';
+export { resolvePiMainSessionId } from './platform/domain/pi-main-session.js';
+export { refreshPiContextWindow } from './platform/infra/external-clients/pi/pi-context-window.js';
 export { PiTranscriptReader } from './platform/infra/external-clients/pi/pi-transcript-reader.js';

package/dist/platform/domain/pi-main-session.d.ts

@@ -0,0 +1,2 @@
+/** @riviere-role domain-service */
+export declare function resolvePiMainSessionId(currentSessionId: string, environment?: Readonly<Record<string, string | undefined>>): string;

package/dist/platform/domain/pi-main-session.js

@@ -0,0 +1,15 @@
+const PI_SUBAGENT_PARENT_SESSION = 'PI_SUBAGENT_PARENT_SESSION';
+/** @riviere-role domain-service */
+export function resolvePiMainSessionId(currentSessionId, environment = process.env) {
+    const current = currentSessionId.trim();
+    if (current.length === 0)
+        throw new TypeError('Pi returned an empty session UUID.');
+    const rawParent = environment[PI_SUBAGENT_PARENT_SESSION];
+    if (rawParent === undefined)
+        return current;
+    const parent = rawParent.trim();
+    if (parent.length === 0) {
+        throw new TypeError(`${PI_SUBAGENT_PARENT_SESSION} must contain a non-empty session UUID.`);
+    }
+    return parent;
+}

package/dist/platform/domain/pi-workflow-extension-types.d.ts

@@ -26,9 +26,11 @@ export type PiSessionIdResult = {
 export type PiWorkflowExtensionConfig<TWorkflow extends RehydratableWorkflow<TState>, TState extends BaseWorkflowState<TStateName>, TDeps, TStateName extends string = string, TOperation extends string = string, TTransitionContext extends TransitionContext<TState, TStateName> = TransitionContext<TState, TStateName>> = Omit<PreToolUseHandlerConfig<TWorkflow, TState, TStateName>, 'questionToolName'> & {
     readonly workflowDefinition: WorkflowDefinition<TWorkflow, TState, TDeps, TStateName, TOperation, TTransitionContext>;
     readonly routes: RouteMap<TWorkflow, TState>;
+    readonly unknownCommandMessage: string;
     readonly buildWorkflowDeps: (platform: PlatformContext) => TDeps;
     readonly pluginRoot: string;
     readonly databasePath?: string;
     readonly commandName?: string;
     readonly toolName?: string;
+    readonly stopPreventionMessage?: string;
 };

package/dist/platform/infra/external-clients/pi/pi-context-window.d.ts

@@ -0,0 +1,3 @@
+import { type AgentSession } from '@earendil-works/pi-coding-agent';
+/** @riviere-role external-client-service */
+export declare function refreshPiContextWindow(session: AgentSession, stateInstructions: string): void;

package/dist/platform/infra/external-clients/pi/pi-context-window.js

@@ -0,0 +1,17 @@
+import { estimateTokens, } from '@earendil-works/pi-coding-agent';
+/** @riviere-role external-client-service */
+export function refreshPiContextWindow(session, stateInstructions) {
+    if (stateInstructions.trim().length === 0) {
+        throw new TypeError('Pi context state instructions must not be empty.');
+    }
+    if (!session.isIdle) {
+        throw new TypeError('Cannot refresh Pi context until the session is idle.');
+    }
+    if (!session.sessionManager.isPersisted()) {
+        throw new TypeError('Cannot refresh Pi context without a persisted session.');
+    }
+    const tokensBefore = session.messages.reduce((total, message) => total + estimateTokens(message), 0);
+    const boundary = session.sessionManager.appendCustomEntry('pi-context-window-boundary');
+    session.sessionManager.appendCompaction(stateInstructions, boundary, tokensBefore);
+    session.agent.state.messages = session.sessionManager.buildSessionContext().messages;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nt-ai-lab/deterministic-agent-workflow-pi",
-  "version": "0.5.3",
+  "version": "0.5.5-issue-526.ce3247e.0",
   "private": false,
   "type": "module",
   "engines": {
@@ -23,9 +23,9 @@
   },
   "dependencies": {
     "typebox": "^1.3.7",
-    "@nt-ai-lab/deterministic-agent-workflow-cli": "0.4.6",
-    "@nt-ai-lab/deterministic-agent-workflow-event-store": "0.4.6",
-    "@nt-ai-lab/deterministic-agent-workflow-engine": "0.4.6"
+    "@nt-ai-lab/deterministic-agent-workflow-event-store": "0.4.8-issue-526.ce3247e.0",
+    "@nt-ai-lab/deterministic-agent-workflow-cli": "0.4.8-issue-526.ce3247e.0",
+    "@nt-ai-lab/deterministic-agent-workflow-engine": "0.4.8-issue-526.ce3247e.0"
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.4",