praxis-agent 0.30.0 → 0.32.0

package/dist/application/subagent-service.js

@@ -1318,6 +1318,11 @@ export class ClaudeSubagentExecutor {
                 hooks: scopedHooks,
                 session: hookSession,
                 recordOutcome: recordHookOutcome,
+                ...(this.options.eventSink
+                    ? {
+                        warn: (message) => this.options.eventSink?.({ type: 'warning', message }),
+                    }
+                    : {}),
             })
             : agentTools;
         const runtimePermissions = scopedHooks
@@ -1515,6 +1520,7 @@ export class ClaudeSubagentExecutor {
             const configuredEffort = typeof customAgent?.effort === 'string' ? customAgent.effort : undefined;
             const effectiveEffort = options.effort ?? configuredEffort;
             const result = await runtime.run({
+                sessionId: String(options.root.sessionId),
                 messages: await assembleMessages(),
                 collectMetrics: true,
                 reloadMessages: assembleMessages,

package/dist/cli/interactive.d.ts

@@ -42,6 +42,7 @@ interface InteractiveSessionCommands {
     rewindFiles?(sessionId: string, userMessageId: string): Promise<void>;
     rewindPoints?(sessionId: string): Promise<RewindPoint[]>;
     changeCwd?(sessionId: string | undefined, cwd: string): Promise<string>;
+    notify?(sessionId: string | undefined, message: string, notificationType: string, title?: string): void;
     recordCdUsage?(sessionId: string): Promise<void>;
     approveRecentlyDenied?(sessionId: string, display: string): Promise<void>;
     retryRecentlyDenied?(sessionId: string, display: string, signal?: AbortSignal): Promise<SessionRunResult>;
@@ -189,11 +190,12 @@ interface InteractiveAppProps {
     runtimeSettings?: PraxisRuntimeSettings;
     runtimeSettingsTarget?: ConfigSettingsTarget;
     notificationWriter?: TuiNotificationWriter;
+    notificationDelayMs?: number;
     elicitationUrlOpener?: (url: string) => void | Promise<void>;
     releaseNotesLoader?: (configRoot: string) => Promise<string>;
     settingSources?: readonly ClaudeResourceScope[];
 }
-export declare function InteractiveApp({ dataPlane, configRoot: suppliedConfigRoot, statePath: suppliedStatePath, factory, initialSessions, initialPrompt, initialHistory, initialSessionColor, signal, onCancel, onTurnChange, onCleanup, onRendererChange, onBackground, axScreenReader, allowNewSession, resume, display, terminalWidth, slashCommands, agents, allowDangerouslySkipPermissions, additionalDirectories, diffLoader, doctorLoader, fileLoader, externalEditor, keybindingsConfigRoot, keybindingsFile, keybindingsLoader, keybindingsEditor, memoryFilesLoader, memoryEditor, memoryFolderOpener, suspendProcess, clipboardReader, clipboardWriter, sideQuestionClipboardWriter, exportWriter, permissionRuleStore, sandboxStore: suppliedSandboxStore, recentlyDeniedStore: suppliedRecentlyDeniedStore, terminalSetup: terminalSetupOverride, themeStore, initialThemeSettings, initialThemeLoadError, workspaceDirectoryResolver, workspaceDirectoryCompleter, runtimeSettings: suppliedRuntimeSettings, runtimeSettingsTarget, notificationWriter, elicitationUrlOpener, releaseNotesLoader, settingSources, }: InteractiveAppProps): import("react").JSX.Element;
+export declare function InteractiveApp({ dataPlane, configRoot: suppliedConfigRoot, statePath: suppliedStatePath, factory, initialSessions, initialPrompt, initialHistory, initialSessionColor, signal, onCancel, onTurnChange, onCleanup, onRendererChange, onBackground, axScreenReader, allowNewSession, resume, display, terminalWidth, slashCommands, agents, allowDangerouslySkipPermissions, additionalDirectories, diffLoader, doctorLoader, fileLoader, externalEditor, keybindingsConfigRoot, keybindingsFile, keybindingsLoader, keybindingsEditor, memoryFilesLoader, memoryEditor, memoryFolderOpener, suspendProcess, clipboardReader, clipboardWriter, sideQuestionClipboardWriter, exportWriter, permissionRuleStore, sandboxStore: suppliedSandboxStore, recentlyDeniedStore: suppliedRecentlyDeniedStore, terminalSetup: terminalSetupOverride, themeStore, initialThemeSettings, initialThemeLoadError, workspaceDirectoryResolver, workspaceDirectoryCompleter, runtimeSettings: suppliedRuntimeSettings, runtimeSettingsTarget, notificationWriter, notificationDelayMs, elicitationUrlOpener, releaseNotesLoader, settingSources, }: InteractiveAppProps): import("react").JSX.Element;
 export declare function runInteractive(options: {
     dataPlane?: DataPlane;
     configRoot?: string;

package/dist/cli/interactive.js

@@ -267,7 +267,7 @@ const HIDDEN_TUI_SLASH_COMMANDS = new Set([
     'update',
     'usage',
 ]);
-export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: suppliedConfigRoot, statePath: suppliedStatePath, factory, initialSessions, initialPrompt, initialHistory = [], initialSessionColor, signal, onCancel, onTurnChange, onCleanup, onRendererChange, onBackground, axScreenReader = false, allowNewSession = true, resume, display = { version: 'dev', cwd: process.cwd() }, terminalWidth, slashCommands = EMPTY_SLASH_COMMANDS, agents = EMPTY_AGENTS, allowDangerouslySkipPermissions = false, additionalDirectories = [], diffLoader, doctorLoader, fileLoader, externalEditor = editTuiPrompt, keybindingsConfigRoot, keybindingsFile = ensureTuiKeybindingsFile, keybindingsLoader = loadTuiKeybindings, keybindingsEditor = openTuiEditorFile, memoryFilesLoader, memoryEditor = openTuiEditorFile, memoryFolderOpener = openTuiMemoryFolder, suspendProcess = suspendTuiProcess, clipboardReader = readTuiClipboard, clipboardWriter = writeTuiClipboard, sideQuestionClipboardWriter = writeTuiOsc52Clipboard, exportWriter = writeConversationExport, permissionRuleStore, sandboxStore: suppliedSandboxStore, recentlyDeniedStore: suppliedRecentlyDeniedStore, terminalSetup: terminalSetupOverride, themeStore, initialThemeSettings, initialThemeLoadError, workspaceDirectoryResolver = resolveTuiWorkspaceDirectory, workspaceDirectoryCompleter = completeTuiWorkspaceDirectory, runtimeSettings: suppliedRuntimeSettings, runtimeSettingsTarget, notificationWriter, elicitationUrlOpener = openTuiUrl, releaseNotesLoader = (configRoot) => loadClaudeReleaseNotes({ configRoot }), settingSources, }) {
+export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: suppliedConfigRoot, statePath: suppliedStatePath, factory, initialSessions, initialPrompt, initialHistory = [], initialSessionColor, signal, onCancel, onTurnChange, onCleanup, onRendererChange, onBackground, axScreenReader = false, allowNewSession = true, resume, display = { version: 'dev', cwd: process.cwd() }, terminalWidth, slashCommands = EMPTY_SLASH_COMMANDS, agents = EMPTY_AGENTS, allowDangerouslySkipPermissions = false, additionalDirectories = [], diffLoader, doctorLoader, fileLoader, externalEditor = editTuiPrompt, keybindingsConfigRoot, keybindingsFile = ensureTuiKeybindingsFile, keybindingsLoader = loadTuiKeybindings, keybindingsEditor = openTuiEditorFile, memoryFilesLoader, memoryEditor = openTuiEditorFile, memoryFolderOpener = openTuiMemoryFolder, suspendProcess = suspendTuiProcess, clipboardReader = readTuiClipboard, clipboardWriter = writeTuiClipboard, sideQuestionClipboardWriter = writeTuiOsc52Clipboard, exportWriter = writeConversationExport, permissionRuleStore, sandboxStore: suppliedSandboxStore, recentlyDeniedStore: suppliedRecentlyDeniedStore, terminalSetup: terminalSetupOverride, themeStore, initialThemeSettings, initialThemeLoadError, workspaceDirectoryResolver = resolveTuiWorkspaceDirectory, workspaceDirectoryCompleter = completeTuiWorkspaceDirectory, runtimeSettings: suppliedRuntimeSettings, runtimeSettingsTarget, notificationWriter, notificationDelayMs = 6_000, elicitationUrlOpener = openTuiUrl, releaseNotesLoader = (configRoot) => loadClaudeReleaseNotes({ configRoot }), settingSources, }) {
     const { exit, suspendTerminal, waitUntilRenderFlush } = useApp();
     const width = useTerminalWidth(terminalWidth);
     const rows = useTerminalRows();
@@ -449,6 +449,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
     const [costUsd, setCostUsd] = useState();
     const [contextWindowTokens, setContextWindowTokens] = useState(display.contextWindowTokens);
     const [history, setHistory] = useState([...initialHistory]);
+    const activeAttemptThinkingItemsRef = useRef([]);
     const [transcriptScrollOffset, setTranscriptScrollOffset] = useState(0);
     // The pure TUI view model classifies the session identity (fresh/resumed/
     // started) and projects the rendered transcript. Startup diagnostics are
@@ -1183,28 +1184,45 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                 // Signatures authenticate a thinking block for provider replay; they are
                 // intentionally not part of the user-visible reasoning summary.
                 break;
-            case 'thinking-stop':
+            case 'thinking-stop': {
                 // append flushes pending thinking deltas before the retained boundary
                 // item, keeping streaming order correct; the effective thinking getter
                 // already includes any deltas not yet published.
-                append({
+                const thinkingItem = {
                     kind: 'thinking',
                     text: event.block.type === 'thinking'
                         ? redactSensitiveText(event.block.thinking, sensitiveValues)
                         : (streamingFrameRef.current?.thinking ?? ''),
-                });
+                };
+                activeAttemptThinkingItemsRef.current.push(thinkingItem);
+                append(thinkingItem);
                 streamingFrameRef.current?.resetThinking();
                 streamingFrameRef.current?.flush();
                 break;
+            }
             case 'user-message':
                 append({ kind: 'assistant', text: event.message });
                 break;
             case 'state':
+                if (event.state === 'awaiting-model') {
+                    activeAttemptThinkingItemsRef.current = [];
+                }
                 setStatus(event.state);
                 break;
             case 'usage':
                 setUsage(event.usage);
                 break;
+            case 'model-attempt-discarded':
+                streamingFrameRef.current?.resetText();
+                streamingFrameRef.current?.resetThinking();
+                streamingFrameRef.current?.flush();
+                setUsage({ inputTokens: 0, outputTokens: 0 });
+                if (activeAttemptThinkingItemsRef.current.length > 0) {
+                    const discarded = new Set(activeAttemptThinkingItemsRef.current);
+                    setHistory((current) => current.filter((item) => !discarded.has(item)));
+                    activeAttemptThinkingItemsRef.current = [];
+                }
+                break;
             case 'tool-call':
                 if (['Edit', 'Write', 'NotebookEdit'].includes(event.call.name))
                     turnMutatedFilesRef.current = true;
@@ -1301,6 +1319,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                     kind: 'notice',
                     text: `MCP elicitation completed · ${event.mcpServerName}`,
                 });
+                serviceRef.current?.notify?.(sessionIdRef.current ?? undefined, `MCP elicitation completed · ${event.mcpServerName}`, 'elicitation_complete', 'Praxis');
                 if (elicitationUrlWaitingRef.current?.request.serverName ===
                     event.mcpServerName &&
                     elicitationUrlWaitingRef.current.request.elicitationId ===
@@ -1346,6 +1365,11 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
             : null;
         const editableRule = projected?.options.find((option) => option.editableRule)?.editableRule;
         let settled = false;
+        const notificationTimer = setTimeout(() => {
+            if (settled)
+                return;
+            serviceRef.current?.notify?.(sessionIdRef.current ?? undefined, `Approval required for ${call.name}`, 'permission_prompt', 'Praxis');
+        }, notificationDelayMs);
         const pending = {
             kind,
             call,
@@ -1354,6 +1378,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                 if (settled)
                     return;
                 settled = true;
+                clearTimeout(notificationTimer);
                 if (permissionRef.current === pending)
                     permissionRef.current = null;
                 setPermission((current) => (current === pending ? null : current));
@@ -1370,12 +1395,20 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
     const approveTool = (call, _originalCall, decision) => requestApproval(call, 'tool', decision);
     const requestElicitation = (request) => new Promise((resolveResult) => {
         let settled = false;
+        const notificationTimer = setTimeout(() => {
+            if (settled)
+                return;
+            serviceRef.current?.notify?.(sessionIdRef.current ?? undefined, 'Praxis needs your input', request.mode === 'url'
+                ? 'elicitation_url_dialog'
+                : 'elicitation_dialog', 'Praxis');
+        }, notificationDelayMs);
         const pending = {
             request,
             resolve: (result, options) => {
                 if (settled)
                     return;
                 settled = true;
+                clearTimeout(notificationTimer);
                 if (elicitationRef.current === pending)
                     elicitationRef.current = null;
                 if (!options?.keepUrlDialog) {

package/dist/cli/protocol.d.ts

@@ -277,6 +277,7 @@ export declare class StreamJsonOutput {
     private onEvent;
     private writeSessionState;
     private ensureTurn;
+    private discardTurn;
     private startTurn;
     private partialText;
     private finishPartial;

package/dist/cli/protocol.js

@@ -1753,6 +1753,10 @@ export class StreamJsonOutput {
         this.modelTurns = 0;
     }
     onEvent(event) {
+        if (event.type === 'model-attempt-discarded') {
+            this.discardTurn(event.reason);
+            return;
+        }
         if (event.type === 'state') {
             if (this.compacting && event.state !== 'compacting') {
                 this.compacting = false;
@@ -2109,6 +2113,26 @@ export class StreamJsonOutput {
         if (!this.turnActive)
             this.startTurn();
     }
+    discardTurn(reason) {
+        this.write({
+            type: 'system',
+            subtype: 'model_attempt_discarded',
+            reason,
+            uuid: randomUUID(),
+            session_id: this.sessionId,
+        });
+        this.turnText = '';
+        this.turnThinking = [];
+        this.turnCalls = [];
+        this.turnUsage = emptyUsage();
+        this.turnTerminalReason = undefined;
+        this.turnActive = false;
+        this.assistantFlushed = true;
+        this.contentStarted = false;
+        this.textContentIndex = undefined;
+        this.activeThinkingIndex = undefined;
+        this.nextContentIndex = 0;
+    }
     startTurn() {
         if (this.turnActive)
             this.finishTurn();

package/dist/cli/tui/hook-settings.js

@@ -110,7 +110,20 @@ const TUI_HOOK_EVENT_DEFINITIONS = [
         detail: [],
     },
 ];
-export const TUI_HOOK_EVENTS = TUI_HOOK_EVENT_DEFINITIONS.filter((definition) => HOOK_EVENTS.includes(definition.name));
+const OBSERVED_TUI_EVENTS_2_1_208 = new Set([
+    'PreToolUse',
+    'PostToolUse',
+    'PostToolUseFailure',
+    'UserPromptSubmit',
+    'SessionStart',
+    'Stop',
+    'SubagentStart',
+    'SubagentStop',
+    'SessionEnd',
+    'PermissionRequest',
+]);
+export const TUI_HOOK_EVENTS = TUI_HOOK_EVENT_DEFINITIONS.filter((definition) => OBSERVED_TUI_EVENTS_2_1_208.has(definition.name) &&
+    HOOK_EVENTS.includes(definition.name));
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }

package/dist/cli/tui/memory-files.d.ts

@@ -18,9 +18,10 @@ export interface LoadTuiMemoryFilesOptions {
     cwd: string;
     homeDirectory?: string;
     dataPlane?: DataPlane;
+    environment?: Readonly<Record<string, string | undefined>>;
 }
 export declare function displayTuiMemoryPath(path: string, cwd: string, homeDirectory?: string): string;
-export declare function loadTuiMemoryFiles({ configRoot, cwd, homeDirectory, dataPlane, }: LoadTuiMemoryFilesOptions): Promise<TuiMemoryFiles>;
+export declare function loadTuiMemoryFiles({ configRoot, cwd, homeDirectory, dataPlane, environment, }: LoadTuiMemoryFilesOptions): Promise<TuiMemoryFiles>;
 type TuiMemoryFolderLauncher = (command: string, args: readonly string[]) => Promise<void>;
 export declare function openTuiMemoryFolder(path: string, launcher?: TuiMemoryFolderLauncher): Promise<void>;
 export {};

package/dist/cli/tui/memory-files.js

@@ -2,9 +2,10 @@ import { spawn } from 'node:child_process';
 import { mkdir, realpath } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { basename, isAbsolute, relative, resolve } from 'node:path';
-import { loadClaudeContextResources, loadClaudeSettings, resolveClaudeProjectMemoryDirectory, } from '../../compatibility/claude/shared-resources.js';
-import { sanitizeClaudeProjectPath } from '../../compatibility/claude/paths.js';
-import { loadNativeContextResources, loadNativeSharedResources, } from '../../persistence/native-resources.js';
+import { loadClaudeContextResources, loadClaudeSettings, } from '../../compatibility/claude/shared-resources.js';
+import { resolveProjectMemoryPolicy } from '../../core/project-memory.js';
+import { resolveProjectMemoryDirectory } from '../../platform/project-memory-paths.js';
+import { loadNativeContextResources, loadNativeSettings, } from '../../persistence/native-resources.js';
 function isWithin(root, path) {
     const value = relative(root, path);
     return value === '' || (!value.startsWith('..') && !isAbsolute(value));
@@ -41,40 +42,39 @@ function importedEntries(resource, instructions, cwd, homeDirectory, sourceDispl
         imported: true,
     }));
 }
-function autoMemorySetting(settings) {
-    let enabled = true;
-    for (const resource of settings) {
-        if (typeof resource.value === 'object' &&
-            resource.value !== null &&
-            !Array.isArray(resource.value)) {
-            const value = resource.value
-                .autoMemoryEnabled;
-            if (typeof value === 'boolean')
-                enabled = value;
-        }
-    }
-    return enabled;
-}
-export async function loadTuiMemoryFiles({ configRoot, cwd, homeDirectory = homedir(), dataPlane = 'claude', }) {
+export async function loadTuiMemoryFiles({ configRoot, cwd, homeDirectory = homedir(), dataPlane = 'claude', environment = process.env, }) {
     const [canonicalCwd, canonicalHome] = await Promise.all([
         realpath(cwd),
         realpath(homeDirectory).catch(() => resolve(homeDirectory)),
     ]);
-    const [context, settings, autoMemoryDirectory] = dataPlane === 'native'
-        ? await Promise.all([
-            loadNativeContextResources({ root: configRoot, cwd }),
-            loadNativeSharedResources({ root: configRoot, cwd }).then((resources) => resources.settings),
-            Promise.resolve(resolve(configRoot, 'memory', sanitizeClaudeProjectPath(cwd))),
-        ])
-        : await Promise.all([
-            loadClaudeContextResources({ configRoot, cwd, homeDirectory }),
-            loadClaudeSettings({ configRoot, cwd }),
-            resolveClaudeProjectMemoryDirectory({
+    const settings = dataPlane === 'native'
+        ? await loadNativeSettings({ root: configRoot, cwd })
+        : await loadClaudeSettings({ configRoot, cwd });
+    const memoryPolicy = resolveProjectMemoryPolicy({
+        dataPlane,
+        settings,
+        environment,
+    });
+    const [context, autoMemoryDirectory] = await Promise.all([
+        dataPlane === 'native'
+            ? loadNativeContextResources({
+                root: configRoot,
+                cwd,
+                environment,
+                includeProjectMemory: memoryPolicy.enabled,
+            })
+            : loadClaudeContextResources({
                 configRoot,
                 cwd,
                 homeDirectory,
+                includeProjectMemory: memoryPolicy.enabled,
             }),
-        ]);
+        resolveProjectMemoryDirectory({
+            dataPlane,
+            configRoot,
+            cwd,
+        }),
+    ]);
     const instructionName = dataPlane === 'native' ? 'PRAXIS.md' : 'CLAUDE.md';
     const userPath = resolve(configRoot, instructionName);
     const projectResources = context.instructions.filter((resource) => resource.importedFrom === undefined &&
@@ -129,7 +129,7 @@ export async function loadTuiMemoryFiles({ configRoot, cwd, homeDirectory = home
         });
         entries.push(...importedEntries(resource, context.instructions, canonicalCwd, canonicalHome, displayPath));
     }
-    const autoMemoryEnabled = autoMemorySetting(settings);
+    const autoMemoryEnabled = memoryPolicy.enabled;
     if (autoMemoryEnabled) {
         entries.push({
             kind: 'folder',

package/dist/cli-runtime.d.ts

@@ -39,6 +39,7 @@ interface SessionCommands {
     rewindFiles?(sessionId: string, userMessageId: string): Promise<void>;
     rewindPoints?(sessionId: string): Promise<RewindPoint[]>;
     changeCwd?(sessionId: string | undefined, cwd: string): Promise<string>;
+    notify?(sessionId: string | undefined, message: string, notificationType: string, title?: string): void;
     recordCdUsage?(sessionId: string): Promise<void>;
     approveRecentlyDenied?(sessionId: string, display: string): Promise<void>;
     retryRecentlyDenied?(sessionId: string, display: string, signal?: AbortSignal): Promise<SessionRunResult>;

package/dist/cli-runtime.js

@@ -7,6 +7,9 @@ import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { randomUUID } from 'node:crypto';
 import { ClaudeSessionService, } from './application/session-service.js';
+import { ProjectMemoryAgentExtractor, ProjectMemoryExtractionController, ProjectMemoryModelSelector, ProjectMemoryRecallController, } from './application/project-memory.js';
+import { resolveProjectMemoryPolicy } from './core/project-memory.js';
+import { resolveProjectMemoryDirectory, resolveProjectMemoryStatePath, } from './platform/project-memory-paths.js';
 import { ClaudeCostStateStore } from './persistence/claude-cost-state-store.js';
 import { agentColorMessage, parseAgentColorInput, } from './compatibility/claude/agent-color.js';
 import { ClaudeConditionalRuleResolver, ClaudeContextAssembler, } from './compatibility/claude/context.js';
@@ -16,7 +19,7 @@ import { isClaudeSessionId, resolveClaudePaths, } from './compatibility/claude/p
 import { resolveDataPlane, resolveDataPlaneRoot, resolveDataPlanePaths, } from './persistence/data-plane.js';
 import { loadNativeContextResources, loadNativeSettings, loadNativeSharedResources, } from './persistence/native-resources.js';
 import { migrateClaudeData } from './persistence/claude-migration.js';
-import { loadClaudeContextResources, loadClaudeSettings, loadClaudeSharedResources, resolveClaudeProjectIdentity, resolveClaudeProjectMemoryDirectory, } from './compatibility/claude/shared-resources.js';
+import { loadClaudeContextResources, loadClaudeSettings, loadClaudeSharedResources, resolveClaudeProjectIdentity, } from './compatibility/claude/shared-resources.js';
 import { AgentRunCancelledError, } from './core/runtime.js';
 import { persistTuiPermissionUpdates } from './cli/tui/permission-settings.js';
 import { loadClaudeReleaseNotes } from './cli/tui/release-notes.js';
@@ -30,6 +33,7 @@ import { createClaudeModelAutoClassifier, defaultClaudeAutoModeConfig, loadClaud
 import { ClaudeExtensionPermissionResolver, ClaudeExtensionToolRegistry, } from './extensions/claude-extension-tools.js';
 import { ClaudeExtensionCatalog } from './extensions/claude-extensions.js';
 import { ClaudeHookRunner } from './hooks/claude-hooks.js';
+import { ClaudeSessionEnvironment } from './hooks/claude-session-environment.js';
 import { ClaudeMcpToolRegistry, } from './mcp/claude-mcp-tools.js';
 import { ClaudeMcpManagement, filterDisabledMcpResources, mcpScope, } from './mcp/claude-mcp-management.js';
 import { authenticateMcpServer, ClaudeMcpOAuthStore, mcpOAuthServerIdentity, readMcpClientSecret, } from './mcp/claude-mcp-oauth.js';
@@ -1011,9 +1015,47 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
         : toolProvider;
     const automaticSettingSources = cli.safeMode || simpleMode ? [] : cli.settingSources;
     const nativeSharedResourcesEnabled = !cli.safeMode && !simpleMode;
+    const baseSettings = dataPlane === 'native'
+        ? nativeSharedResourcesEnabled
+            ? await loadNativeSettings({ root: configRoot, cwd })
+            : []
+        : await loadClaudeSettings({
+            configRoot,
+            cwd,
+            ...(automaticSettingSources === undefined
+                ? {}
+                : { settingSources: automaticSettingSources }),
+        });
+    const pluginResources = await loadClaudePlugins({
+        configRoot,
+        dataPlane,
+        cwd,
+        pluginDirectories: cli.pluginDirectories,
+        pluginUrls: cli.pluginUrls,
+        strictPluginDirectories: cli.pluginDirectories.length + cli.pluginUrls.length > 0,
+        loadInstalled: !cli.safeMode && !simpleMode,
+        environment: runtimeEnvironment,
+    });
+    const projectMemoryPolicy = cli.safeMode || simpleMode
+        ? { enabled: false, extraction: false, recall: false }
+        : resolveProjectMemoryPolicy({
+            dataPlane,
+            settings: [
+                ...baseSettings,
+                ...pluginResources.settings,
+                ...(cli.additionalSettings ? [cli.additionalSettings] : []),
+            ],
+            environment: runtimeEnvironment,
+        });
+    const includeProjectMemory = projectMemoryPolicy.enabled && !projectMemoryPolicy.recall;
     const loadedResources = dataPlane === 'native'
         ? nativeSharedResourcesEnabled
-            ? await loadNativeSharedResources({ root: configRoot, cwd })
+            ? await loadNativeSharedResources({
+                root: configRoot,
+                cwd,
+                environment: runtimeEnvironment,
+                includeProjectMemory,
+            })
             : {
                 instructions: [],
                 memory: [],
@@ -1027,20 +1069,11 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             configRoot,
             cwd,
             claudeStatePath,
+            includeProjectMemory,
             ...(automaticSettingSources === undefined
                 ? {}
                 : { settingSources: automaticSettingSources }),
         });
-    const pluginResources = await loadClaudePlugins({
-        configRoot,
-        dataPlane,
-        cwd,
-        pluginDirectories: cli.pluginDirectories,
-        pluginUrls: cli.pluginUrls,
-        strictPluginDirectories: cli.pluginDirectories.length + cli.pluginUrls.length > 0,
-        loadInstalled: !cli.safeMode && !simpleMode,
-        environment: runtimeEnvironment,
-    });
     const settings = [
         ...loadedResources.settings,
         ...pluginResources.settings,
@@ -1081,21 +1114,53 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
         disableSlashCommands: cli.disableSlashCommands,
         dataPlane,
     });
-    const memoryDirectory = cli.safeMode || simpleMode
+    const memoryDirectory = !projectMemoryPolicy.enabled
         ? undefined
-        : dataPlane === 'native'
-            ? resolveDataPlanePaths({
-                dataPlane,
-                root: configRoot,
-                cwd,
-                sessionId: randomUUID(),
-            }).memoryRoot
-            : await resolveClaudeProjectMemoryDirectory({ configRoot, cwd });
+        : await resolveProjectMemoryDirectory({
+            dataPlane,
+            configRoot,
+            cwd,
+        });
     if (memoryDirectory)
         await mkdir(memoryDirectory, { recursive: true });
+    const projectMemoryProviderFactory = providerForMainModel && model
+        ? () => providerForMainModel(model)
+        : undefined;
+    const projectMemoryRecall = projectMemoryPolicy.recall &&
+        memoryDirectory &&
+        projectMemoryProviderFactory
+        ? new ProjectMemoryRecallController({
+            directory: memoryDirectory,
+            selector: new ProjectMemoryModelSelector({
+                directory: memoryDirectory,
+                providerFactory: projectMemoryProviderFactory,
+            }),
+        })
+        : undefined;
+    const projectMemoryExtraction = projectMemoryPolicy.extraction &&
+        memoryDirectory &&
+        projectMemoryProviderFactory
+        ? new ProjectMemoryExtractionController({
+            directory: memoryDirectory,
+            cursorPath: resolveProjectMemoryStatePath({
+                dataPlane,
+                configRoot,
+                memoryDirectory,
+            }),
+            extractor: new ProjectMemoryAgentExtractor({
+                providerFactory: projectMemoryProviderFactory,
+            }),
+            onWarning: (message) => runtimeEventSink({ type: 'warning', message }),
+        })
+        : undefined;
     const loadContextResources = (runtimeCwd = workspace.cwd()) => dataPlane === 'native'
         ? nativeSharedResourcesEnabled
-            ? loadNativeContextResources({ root: configRoot, cwd: runtimeCwd })
+            ? loadNativeContextResources({
+                root: configRoot,
+                cwd: runtimeCwd,
+                environment: runtimeEnvironment,
+                includeProjectMemory,
+            })
             : Promise.resolve({
                 instructions: [],
                 conditionalRules: [],
@@ -1104,6 +1169,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
         : loadClaudeContextResources({
             configRoot,
             cwd: runtimeCwd,
+            includeProjectMemory,
             ...(automaticSettingSources === undefined
                 ? {}
                 : { settingSources: automaticSettingSources }),
@@ -1161,6 +1227,15 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             : {}),
     }), extensions);
     const permissions = permissionResolverForMode(cli.dangerouslySkipPermissions ? 'bypassPermissions' : cli.permissionMode);
+    const hookSessionEnvironment = new ClaudeSessionEnvironment({
+        stateRoot: resolveDataPlanePaths({
+            dataPlane,
+            root: configRoot,
+            cwd,
+            sessionId: '00000000-0000-4000-8000-000000000000',
+        }).stateRoot,
+        warn: (message) => runtimeEventSink({ type: 'warning', message }),
+    });
     const localTools = new LocalToolRegistry({
         cwd,
         cwdProvider: () => workspace.cwd(),
@@ -1172,6 +1247,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
         homeDirectory: sandboxEnvironment.HOME ?? sandboxEnvironment.USERPROFILE ?? homedir(),
         configRoot,
         dataPlane,
+        sessionEnvironment: (sessionId) => hookSessionEnvironment.environment(sessionId),
         ...(environment ? { environment } : {}),
     });
     const runtimeMcpResources = async (candidates) => {
@@ -1200,6 +1276,8 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                     ? await loadNativeSharedResources({
                         root: configRoot,
                         cwd: workspace.cwd(),
+                        environment: runtimeEnvironment,
+                        includeProjectMemory,
                     })
                     : {
                         instructions: [],
@@ -1214,6 +1292,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                     configRoot,
                     cwd: workspace.cwd(),
                     claudeStatePath,
+                    includeProjectMemory,
                     ...(automaticSettingSources === undefined
                         ? {}
                         : { settingSources: automaticSettingSources }),
@@ -1369,6 +1448,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                 settings,
                 cwd,
                 onEvent: (event) => runtimeEventSink({ type: 'hook', event }),
+                sessionEnvironment: hookSessionEnvironment,
             });
         const interactiveTools = selectedInteractiveTools.length > 0 && askUser && approvePlan
             ? new ClaudeInteractiveToolManager({
@@ -1386,6 +1466,11 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             : undefined;
         contextAssembler = new ClaudeContextAssembler({
             loadResources: loadContextResources,
+            onInstructionsLoaded: async (instructions, context) => {
+                if (!context.lifecycleId)
+                    return;
+                await service.instructionsLoaded(context.lifecycleId, instructions, context.reason);
+            },
             loadDynamicContext: (runtimeCwd = workspace.cwd()) => loadClaudeDynamicContext({
                 cwd: runtimeCwd,
                 ...(memoryDirectory ? { memoryDirectory } : {}),
@@ -1467,6 +1552,9 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             ...(interactiveTools ? { interactiveTools } : {}),
             ...(hooks ? { hooks } : {}),
             ...(selectedMainAgent ? { agent: selectedMainAgent } : {}),
+            ...(memoryDirectory ? { projectMemoryDirectory: memoryDirectory } : {}),
+            ...(projectMemoryRecall ? { projectMemoryRecall } : {}),
+            ...(projectMemoryExtraction ? { projectMemoryExtraction } : {}),
             contextAssembler,
             conditionalRuleResolver: new ClaudeConditionalRuleResolver({
                 loadResources: loadContextResources,
@@ -1553,6 +1641,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             rewindFiles: (sessionId, userMessageId) => service.rewindFiles(sessionId, userMessageId),
             rewindPoints: (sessionId) => service.rewindPoints(sessionId),
             changeCwd: (sessionId, cwd) => service.changeCwd(sessionId, cwd),
+            notify: (sessionId, message, notificationType, title) => service.notifyDetached(sessionId, message, notificationType, title),
             recordCdUsage: (sessionId) => service.recordCdUsage(sessionId),
             approveRecentlyDenied: (sessionId, display) => service.approveRecentlyDenied(sessionId, display),
             retryRecentlyDenied: (sessionId, display, retrySignal) => service.retryRecentlyDenied(sessionId, display, retrySignal),
@@ -3544,9 +3633,40 @@ function eventSink(io, outputFormat, legacyJson = false) {
     }
     if (outputFormat !== 'text')
         return () => undefined;
+    let turnBuffered = false;
+    let bufferedText = '';
+    const flushBufferedText = () => {
+        if (bufferedText.length > 0)
+            io.stdout(bufferedText);
+        bufferedText = '';
+    };
     return (event) => {
-        if (event.type === 'text-delta')
-            io.stdout(event.delta);
+        if (event.type === 'state' && event.state === 'awaiting-model') {
+            turnBuffered = true;
+            bufferedText = '';
+        }
+        if (event.type === 'text-delta') {
+            if (turnBuffered)
+                bufferedText += event.delta;
+            else
+                io.stdout(event.delta);
+        }
+        if (event.type === 'model-attempt-discarded')
+            bufferedText = '';
+        if (event.type === 'terminal' &&
+            event.reason !== 'prompt_too_long' &&
+            turnBuffered) {
+            flushBufferedText();
+            turnBuffered = false;
+        }
+        if (event.type === 'state' && event.state === 'completed' && turnBuffered) {
+            flushBufferedText();
+            turnBuffered = false;
+        }
+        if (event.type === 'failed') {
+            bufferedText = '';
+            turnBuffered = false;
+        }
         if (event.type === 'user-message')
             io.stdout(`\n${event.message}\n`);
         if (event.type === 'warning') {

package/dist/compatibility/claude/context.d.ts

@@ -1,8 +1,13 @@
 import type { AssembledContext, ContextAssembler, ContextAssemblyOptions, ContextInvalidationOptions } from '../../core/context.js';
 import { type ClaudeDynamicContextSections } from './dynamic-context.js';
-import type { ClaudeContextResources, ClaudeConditionalRule } from './shared-resources.js';
+import type { ClaudeContextResources, ClaudeConditionalRule, ClaudeTextResource } from './shared-resources.js';
 export interface ClaudeContextAssemblerOptions {
     loadResources(cwd?: string): Promise<ClaudeContextResources>;
+    onInstructionsLoaded?(resources: readonly ClaudeTextResource[], context: {
+        lifecycleId?: string;
+        cwd?: string;
+        reason: 'session_start' | 'compact' | 'resource_reload';
+    }): Promise<void>;
     loadDynamicContext?(cwd?: string): Promise<ClaudeDynamicContextSections>;
     loadMcpInstructions?(): Promise<readonly ClaudeMcpInstruction[]>;
     loadSessionGuidance?(): Promise<string | undefined>;