praxis-agent 0.30.0 → 0.31.0

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';
@@ -1011,9 +1014,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 +1068,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 +1113,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 +1168,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
         : loadClaudeContextResources({
             configRoot,
             cwd: runtimeCwd,
+            includeProjectMemory,
             ...(automaticSettingSources === undefined
                 ? {}
                 : { settingSources: automaticSettingSources }),
@@ -1200,6 +1265,8 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                     ? await loadNativeSharedResources({
                         root: configRoot,
                         cwd: workspace.cwd(),
+                        environment: runtimeEnvironment,
+                        includeProjectMemory,
                     })
                     : {
                         instructions: [],
@@ -1214,6 +1281,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                     configRoot,
                     cwd: workspace.cwd(),
                     claudeStatePath,
+                    includeProjectMemory,
                     ...(automaticSettingSources === undefined
                         ? {}
                         : { settingSources: automaticSettingSources }),
@@ -1467,6 +1535,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,
@@ -3544,9 +3615,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.js

@@ -1,5 +1,6 @@
 import { isAbsolute, matchesGlob, relative, resolve, sep } from 'node:path';
 import { PromptComposer, } from '../../core/prompt-composer.js';
+import { boundProjectMemoryIndex } from '../../core/project-memory.js';
 import { renderClaudeDynamicSystemContext, renderClaudeDynamicUserContext, } from './dynamic-context.js';
 function renderResources(title, resources) {
     const rendered = resources
@@ -12,7 +13,7 @@ function renderResources(title, resources) {
 function limitMemoryIndex(resource) {
     return {
         ...resource,
-        content: resource.content.split('\n').slice(0, 200).join('\n'),
+        content: boundProjectMemoryIndex(resource.content),
     };
 }
 export class ClaudeConditionalRuleResolver {

package/dist/compatibility/claude/dynamic-context.js

@@ -145,7 +145,8 @@ export async function loadClaudeDynamicContext(options) {
         ? [
             '# Memory',
             `Persistent project memory is stored at \`${options.memoryDirectory}\`.`,
-            'Use MEMORY.md as its concise index. Keep detailed durable facts in linked Markdown files, update existing entries instead of duplicating them, and do not store transient conversation state.',
+            'Use MEMORY.md as a concise index of one-line links. Keep detailed durable facts in linked Markdown topic files with name, description, and a type of user, feedback, project, or reference. Update existing entries instead of duplicating them.',
+            'Do not store codebase architecture, implementation patterns, git history, fix recipes, transient task or conversation state, or duplicates of repository instructions.',
         ].join('\n')
         : undefined;
     return {

package/dist/compatibility/claude/paths.js

@@ -1,26 +1,15 @@
 import { lstat, readdir } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { extname, resolve } from 'node:path';
+import { sanitizeProjectPath } from '../../platform/project-path-key.js';
 import { getDataOwnership } from './ownership.js';
 const MAX_SANITIZED_LENGTH = 200;
 const SESSION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 export function isClaudeSessionId(value) {
     return SESSION_ID_PATTERN.test(value);
 }
-function stablePathHash(value) {
-    let hash = 0;
-    for (let index = 0; index < value.length; index += 1) {
-        hash = Math.imul(hash, 31) + value.charCodeAt(index);
-        hash |= 0;
-    }
-    return Math.abs(hash);
-}
 export function sanitizeClaudeProjectPath(path) {
-    const sanitized = path.replace(/[^a-zA-Z0-9]/g, '-');
-    if (sanitized.length <= MAX_SANITIZED_LENGTH) {
-        return sanitized;
-    }
-    return `${sanitized.slice(0, MAX_SANITIZED_LENGTH)}-${stablePathHash(path).toString(36)}`;
+    return sanitizeProjectPath(path);
 }
 async function isDirectory(path) {
     try {

package/dist/compatibility/claude/shared-resources.d.ts

@@ -42,17 +42,17 @@ export interface LoadClaudeSharedResourcesOptions {
     homeDirectory?: string;
     claudeStatePath?: string;
     settingSources?: readonly ClaudeResourceScope[];
+    includeProjectMemory?: boolean;
 }
 export declare function resolveClaudeInstructionImports(resources: readonly ClaudeTextResource[], { homeDirectory }?: {
     homeDirectory?: string;
 }): Promise<ClaudeTextResource[]>;
-export declare function resolveClaudeProjectIdentity({ cwd, homeDirectory, }: {
+export declare function resolveClaudeProjectIdentity({ cwd, }: {
     cwd: string;
-    homeDirectory?: string;
 }): Promise<string>;
 export declare function loadClaudeSettings({ configRoot, cwd, settingSources, }: LoadClaudeSharedResourcesOptions): Promise<ClaudeJsonResource[]>;
 export declare function resolveClaudeProjectMemoryDirectory({ configRoot, cwd, homeDirectory, }: LoadClaudeSharedResourcesOptions): Promise<string>;
 export declare function loadClaudeMcpResources({ configRoot, cwd, homeDirectory, claudeStatePath, settingSources, }: LoadClaudeSharedResourcesOptions): Promise<ClaudeJsonResource[]>;
-export declare function loadClaudeContextResources({ configRoot, cwd, homeDirectory, settingSources, }: LoadClaudeSharedResourcesOptions): Promise<ClaudeContextResources>;
-export declare function loadClaudeSharedResources({ configRoot, cwd, homeDirectory, claudeStatePath, settingSources, }: LoadClaudeSharedResourcesOptions): Promise<ClaudeSharedResources>;
+export declare function loadClaudeContextResources({ configRoot, cwd, homeDirectory, settingSources, includeProjectMemory, }: LoadClaudeSharedResourcesOptions): Promise<ClaudeContextResources>;
+export declare function loadClaudeSharedResources({ configRoot, cwd, homeDirectory, claudeStatePath, settingSources, includeProjectMemory, }: LoadClaudeSharedResourcesOptions): Promise<ClaudeSharedResources>;
 //# sourceMappingURL=shared-resources.d.ts.map

package/dist/compatibility/claude/shared-resources.js

@@ -2,6 +2,7 @@ import { readdir, readFile, realpath, stat } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { parse as parseYaml } from 'yaml';
+import { resolveProjectIdentity } from '../../platform/project-identity.js';
 import { sanitizeClaudeProjectPath } from './paths.js';
 function selectedScope(scope, settingSources) {
     return settingSources === undefined || settingSources.includes(scope);
@@ -255,32 +256,6 @@ async function findGitRoot(cwd) {
     }
     return current;
 }
-async function readOptionalRaw(path) {
-    try {
-        return await readFile(path, 'utf8');
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return null;
-        throw error;
-    }
-}
-async function findMemoryIdentityRoot(gitRoot) {
-    const gitMarker = join(gitRoot, '.git');
-    const marker = await stat(gitMarker);
-    if (!marker.isFile())
-        return gitRoot;
-    const gitFile = await readFile(gitMarker, 'utf8');
-    const match = /^gitdir:\s*(.+)\s*$/m.exec(gitFile);
-    if (!match?.[1])
-        return gitRoot;
-    const gitDirectory = resolve(gitRoot, match[1]);
-    const commonDirectory = await readOptionalRaw(join(gitDirectory, 'commondir'));
-    if (!commonDirectory)
-        return gitRoot;
-    const commonGitDirectory = await canonicalPath(resolve(gitDirectory, commonDirectory.trim()));
-    return dirname(commonGitDirectory);
-}
 async function resolveProjectContext(cwd, homeDirectory) {
     const canonicalCwd = await canonicalPath(cwd);
     const gitRoot = await findGitRoot(canonicalCwd);
@@ -289,7 +264,7 @@ async function resolveProjectContext(cwd, homeDirectory) {
             directories: directoriesFromRoot(gitRoot, canonicalCwd),
             extensionDirectories: directoriesFromRoot(gitRoot, canonicalCwd),
             homeBoundary: null,
-            memoryIdentityRoot: await findMemoryIdentityRoot(gitRoot),
+            memoryIdentityRoot: await resolveProjectIdentity(gitRoot),
         };
     }
     const canonicalHome = await canonicalPath(homeDirectory);
@@ -303,8 +278,8 @@ async function resolveProjectContext(cwd, homeDirectory) {
         memoryIdentityRoot: canonicalCwd,
     };
 }
-export async function resolveClaudeProjectIdentity({ cwd, homeDirectory = homedir(), }) {
-    return (await resolveProjectContext(cwd, homeDirectory)).memoryIdentityRoot;
+export async function resolveClaudeProjectIdentity({ cwd, }) {
+    return resolveProjectIdentity(cwd);
 }
 async function loadProjectSettings(configRoot, cwd) {
     const userSettings = await readOptionalJson(join(configRoot, 'settings.json'), 'user');
@@ -411,13 +386,15 @@ async function loadProjectContextResources(projectDirectories, homeBoundary) {
 function present(value) {
     return value !== null;
 }
-async function loadResolvedClaudeContext(configRoot, projectDirectories, homeBoundary, memoryIdentityRoot) {
+async function loadResolvedClaudeContext(configRoot, projectDirectories, homeBoundary, memoryIdentityRoot, includeProjectMemory) {
     const projectMemoryDirectory = join(configRoot, 'projects', sanitizeClaudeProjectPath(memoryIdentityRoot), 'memory');
     const [globalInstruction, globalRules, projectContext, memoryIndex] = await Promise.all([
         readOptionalText(join(configRoot, 'CLAUDE.md'), 'user'),
         loadRuleResources(join(configRoot, 'rules'), 'user', projectDirectories.at(-1) ?? memoryIdentityRoot),
         loadProjectContextResources(projectDirectories, homeBoundary),
-        readOptionalText(join(projectMemoryDirectory, 'MEMORY.md'), 'project'),
+        includeProjectMemory
+            ? readOptionalText(join(projectMemoryDirectory, 'MEMORY.md'), 'project')
+            : Promise.resolve(null),
     ]);
     return {
         instructions: [
@@ -432,9 +409,9 @@ async function loadResolvedClaudeContext(configRoot, projectDirectories, homeBou
         memoryIndex,
     };
 }
-export async function loadClaudeContextResources({ configRoot, cwd, homeDirectory = homedir(), settingSources, }) {
+export async function loadClaudeContextResources({ configRoot, cwd, homeDirectory = homedir(), settingSources, includeProjectMemory = true, }) {
     const { directories, homeBoundary, memoryIdentityRoot } = await resolveProjectContext(cwd, homeDirectory);
-    const resources = await loadResolvedClaudeContext(configRoot, directories, homeBoundary, memoryIdentityRoot);
+    const resources = await loadResolvedClaudeContext(configRoot, directories, homeBoundary, memoryIdentityRoot, includeProjectMemory);
     const instructions = resources.instructions.filter((resource) => selectedScope(resource.scope, settingSources));
     return {
         instructions: await resolveClaudeInstructionImports(instructions, {
@@ -447,14 +424,16 @@ export async function loadClaudeContextResources({ configRoot, cwd, homeDirector
             : null,
     };
 }
-export async function loadClaudeSharedResources({ configRoot, cwd, homeDirectory = homedir(), claudeStatePath = join(configRoot, '.claude.json'), settingSources, }) {
+export async function loadClaudeSharedResources({ configRoot, cwd, homeDirectory = homedir(), claudeStatePath = join(configRoot, '.claude.json'), settingSources, includeProjectMemory = true, }) {
     const { directories: projectDirectories, extensionDirectories, homeBoundary, memoryIdentityRoot, } = await resolveProjectContext(cwd, homeDirectory);
     const projectMemoryDirectory = join(configRoot, 'projects', sanitizeClaudeProjectPath(memoryIdentityRoot), 'memory');
     const [globalInstruction, globalRules, projectInstructions, memory, skills, commands, agents, settings, mcp,] = await Promise.all([
         readOptionalText(join(configRoot, 'CLAUDE.md'), 'user'),
         loadAllRules(join(configRoot, 'rules'), 'user'),
         loadProjectInstructions(projectDirectories, homeBoundary),
-        findFiles(projectMemoryDirectory, (name) => name.endsWith('.md')).then((paths) => loadFiles(paths, 'project')),
+        includeProjectMemory
+            ? findFiles(projectMemoryDirectory, (name) => name.endsWith('.md')).then((paths) => loadFiles(paths, 'project'))
+            : Promise.resolve([]),
         loadScopedFiles(join(configRoot, 'skills'), extensionDirectories.map((path) => join(path, '.claude', 'skills')), (name) => name === 'SKILL.md'),
         loadScopedFiles(join(configRoot, 'commands'), extensionDirectories.map((path) => join(path, '.claude', 'commands')), (name) => name.endsWith('.md')),
         loadScopedFiles(join(configRoot, 'agents'), extensionDirectories.map((path) => join(path, '.claude', 'agents')), (name) => name.endsWith('.md')),

package/dist/core/context-budget.d.ts

@@ -1,4 +1,5 @@
 import type { ModelMessage, ModelToolDefinition, ModelUsage } from './runtime.js';
+import { ModelProviderError } from './runtime.js';
 export interface ContextBudgetOptions {
     contextWindowTokens: number;
     reserveTokens?: number;
@@ -76,15 +77,16 @@ export type ContextRecoveryStage = 'preflight' | 'microcompact' | 'auto-compact'
 export interface ContextRecoveryPlannerOptions {
     /** Number of reactive retries allowed before the planner reports `blocked`. */
     maxReactiveRetries?: number;
-    /** Consecutive failures that trip the circuit breaker to `blocked`. */
-    consecutiveFailureThreshold?: number;
 }
+export interface ContextRecoveryProgress {
+    beforeOccupancyTokens: number;
+    afterOccupancyTokens: number;
+}
+export declare function contextRecoveryMadeProgress(progress: ContextRecoveryProgress): boolean;
 export declare class ContextRecoveryPlanner {
     private readonly maxReactiveRetries;
-    private readonly consecutiveFailureThreshold;
     private currentStage;
     private reactiveRetriesUsed;
-    private consecutiveFailures;
     constructor(options?: ContextRecoveryPlannerOptions);
     get stage(): ContextRecoveryStage;
     get reactiveRetriesRemaining(): number;
@@ -93,14 +95,13 @@ export declare class ContextRecoveryPlanner {
     advance(): ContextRecoveryStage;
     /** Consume one reactive retry decision; reports `blocked` once the maximum
      *  reactive retries have been consumed. */
-    consumeReactiveRetry(): ContextRecoveryStage;
-    /** Record a failed recovery attempt; trips the circuit breaker to `blocked`
-     *  after `consecutiveFailureThreshold` consecutive failures. */
+    consumeReactiveRetry(progress: ContextRecoveryProgress): ContextRecoveryStage;
+    /** A failed reactive attempt exhausts the only selected context transition. */
     recordFailure(): ContextRecoveryStage;
     /** Record a successful recovery/model attempt; resets the planner. */
     recordSuccess(): ContextRecoveryStage;
 }
 /** True when a provider error signals that the request exceeded the model's
  *  context window and a reactive compaction retry is the relevant recovery. */
-export declare function isPromptTooLongError(error: unknown): boolean;
+export declare function isPromptTooLongError(error: unknown): error is ModelProviderError;
 //# sourceMappingURL=context-budget.d.ts.map

package/dist/core/context-budget.js

@@ -203,26 +203,24 @@ export class ContextBudget {
     }
 }
 const DEFAULT_MAX_REACTIVE_RETRIES = 1;
-const DEFAULT_CONSECUTIVE_FAILURE_THRESHOLD = 3;
+export function contextRecoveryMadeProgress(progress) {
+    for (const [name, value] of Object.entries(progress)) {
+        if (!Number.isSafeInteger(value) || value < 0) {
+            throw new Error(`${name} must be a nonnegative safe integer`);
+        }
+    }
+    return progress.afterOccupancyTokens < progress.beforeOccupancyTokens;
+}
 export class ContextRecoveryPlanner {
     maxReactiveRetries;
-    consecutiveFailureThreshold;
     currentStage = 'preflight';
     reactiveRetriesUsed = 0;
-    consecutiveFailures = 0;
     constructor(options = {}) {
         const maxReactiveRetries = options.maxReactiveRetries ?? DEFAULT_MAX_REACTIVE_RETRIES;
-        const consecutiveFailureThreshold = options.consecutiveFailureThreshold ??
-            DEFAULT_CONSECUTIVE_FAILURE_THRESHOLD;
         if (!Number.isInteger(maxReactiveRetries) || maxReactiveRetries < 0) {
             throw new Error('maxReactiveRetries must be a nonnegative integer');
         }
-        if (!Number.isInteger(consecutiveFailureThreshold) ||
-            consecutiveFailureThreshold < 1) {
-            throw new Error('consecutiveFailureThreshold must be a positive integer');
-        }
         this.maxReactiveRetries = maxReactiveRetries;
-        this.consecutiveFailureThreshold = consecutiveFailureThreshold;
     }
     get stage() {
         return this.currentStage;
@@ -253,7 +251,11 @@ export class ContextRecoveryPlanner {
     }
     /** Consume one reactive retry decision; reports `blocked` once the maximum
      *  reactive retries have been consumed. */
-    consumeReactiveRetry() {
+    consumeReactiveRetry(progress) {
+        if (!contextRecoveryMadeProgress(progress)) {
+            this.currentStage = 'blocked';
+            return this.currentStage;
+        }
         this.reactiveRetriesUsed += 1;
         this.currentStage =
             this.reactiveRetriesUsed <= this.maxReactiveRetries
@@ -261,28 +263,21 @@ export class ContextRecoveryPlanner {
                 : 'blocked';
         return this.currentStage;
     }
-    /** Record a failed recovery attempt; trips the circuit breaker to `blocked`
-     *  after `consecutiveFailureThreshold` consecutive failures. */
+    /** A failed reactive attempt exhausts the only selected context transition. */
     recordFailure() {
-        this.consecutiveFailures += 1;
-        if (this.consecutiveFailures >= this.consecutiveFailureThreshold) {
-            this.currentStage = 'blocked';
-        }
+        this.currentStage = 'blocked';
         return this.currentStage;
     }
     /** Record a successful recovery/model attempt; resets the planner. */
     recordSuccess() {
-        this.consecutiveFailures = 0;
         this.reactiveRetriesUsed = 0;
         this.currentStage = 'preflight';
         return this.currentStage;
     }
 }
-const PROMPT_TOO_LONG_PATTERN = /context(?:[_\s-]?length|[_\s-]?window)|prompt(?:[_\s-]?is)?[_\s-]?too[_\s-]?long|too[_\s-]?many[_\s-]?tokens|maximum[_\s-]?context/iu;
 /** True when a provider error signals that the request exceeded the model's
  *  context window and a reactive compaction retry is the relevant recovery. */
 export function isPromptTooLongError(error) {
-    return (error instanceof ModelProviderError &&
-        PROMPT_TOO_LONG_PATTERN.test(error.message));
+    return error instanceof ModelProviderError && error.kind === 'prompt_too_long';
 }
 //# sourceMappingURL=context-budget.js.map

package/dist/core/project-memory.d.ts

@@ -0,0 +1,19 @@
+export declare const PROJECT_MEMORY_INDEX_MAX_LINES = 200;
+export declare const PROJECT_MEMORY_INDEX_MAX_BYTES: number;
+export type ProjectMemoryDataPlane = 'native' | 'claude';
+export interface ProjectMemoryPolicy {
+    enabled: boolean;
+    extraction: boolean;
+    recall: boolean;
+}
+export interface ResolveProjectMemoryPolicyOptions {
+    dataPlane: ProjectMemoryDataPlane;
+    settings: readonly {
+        value: unknown;
+    }[];
+    environment: Readonly<Record<string, string | undefined>>;
+}
+export declare function boundProjectMemoryText(source: string, maxLines: number, maxBytes: number): string;
+export declare function boundProjectMemoryIndex(source: string): string;
+export declare function resolveProjectMemoryPolicy({ dataPlane, settings, environment, }: ResolveProjectMemoryPolicyOptions): ProjectMemoryPolicy;
+//# sourceMappingURL=project-memory.d.ts.map

package/dist/core/project-memory.js

@@ -0,0 +1,58 @@
+export const PROJECT_MEMORY_INDEX_MAX_LINES = 200;
+export const PROJECT_MEMORY_INDEX_MAX_BYTES = 25 * 1024;
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function utf8Prefix(source, maxBytes) {
+    const buffer = Buffer.from(source, 'utf8');
+    if (buffer.byteLength <= maxBytes)
+        return source;
+    for (let end = maxBytes; end >= Math.max(0, maxBytes - 4); end -= 1) {
+        try {
+            return new TextDecoder('utf-8', { fatal: true }).decode(buffer.subarray(0, end));
+        }
+        catch {
+            // Try the previous Unicode boundary.
+        }
+    }
+    return '';
+}
+export function boundProjectMemoryText(source, maxLines, maxBytes) {
+    return utf8Prefix(source.split(/\r?\n/u).slice(0, maxLines).join('\n'), maxBytes);
+}
+export function boundProjectMemoryIndex(source) {
+    return boundProjectMemoryText(source, PROJECT_MEMORY_INDEX_MAX_LINES, PROJECT_MEMORY_INDEX_MAX_BYTES);
+}
+function settingBoolean(settings, path) {
+    let selected;
+    for (const resource of settings) {
+        let value = resource.value;
+        for (const key of path)
+            value = record(value)?.[key];
+        if (typeof value === 'boolean')
+            selected = value;
+    }
+    return selected;
+}
+function enabledEnvironmentValue(value) {
+    return value === '1' || value?.toLowerCase() === 'true';
+}
+export function resolveProjectMemoryPolicy({ dataPlane, settings, environment, }) {
+    const disabledByEnvironment = enabledEnvironmentValue(dataPlane === 'claude'
+        ? environment.CLAUDE_CODE_DISABLE_AUTO_MEMORY
+        : environment.PRAXIS_DISABLE_AUTO_MEMORY);
+    const enabled = !disabledByEnvironment &&
+        (settingBoolean(settings, ['autoMemoryEnabled']) ?? true);
+    if (!enabled)
+        return { enabled: false, extraction: false, recall: false };
+    return {
+        enabled: true,
+        extraction: settingBoolean(settings, ['projectMemory', 'backgroundExtraction']) ??
+            enabledEnvironmentValue(environment.PRAXIS_PROJECT_MEMORY_EXTRACTION),
+        recall: settingBoolean(settings, ['projectMemory', 'selectiveRecall']) ??
+            enabledEnvironmentValue(environment.PRAXIS_PROJECT_MEMORY_RECALL),
+    };
+}
+//# sourceMappingURL=project-memory.js.map

package/dist/core/runtime.d.ts

@@ -181,6 +181,9 @@ export type RuntimeEvent = {
 } | {
     type: 'terminal';
     reason: ModelTerminalReason;
+} | {
+    type: 'model-attempt-discarded';
+    reason: ProviderErrorKind;
 } | {
     type: 'tool-call';
     call: ModelToolCall;
@@ -472,6 +475,9 @@ export interface AgentRunRequest {
     effort?: string;
     thinking?: ModelThinkingConfig;
     collectMetrics?: boolean;
+    /** Provider failures whose presentation is owned by a caller recovery
+     *  boundary. `true` defers every typed provider failure for an owned retry. */
+    deferFailureKinds?: true | readonly ProviderErrorKind[];
     maxModelTurns?: number;
     betas?: readonly string[];
 }