praxis-agent 0.21.6 → 0.22.0

package/README.md

@@ -161,16 +161,16 @@ not in this entry-point README.
 
 ## Claude Code interoperability
 
-Praxis and Claude Code use one local data plane by default:
+Praxis uses an independent local data plane by default:
 
 ```text
-Claude Code ─┐
-             ├── ~/.claude (or CLAUDE_CONFIG_DIR)
-Praxis ──────┘
+Praxis ─── ~/.praxis (or PRAXIS_HOME)
 ```
 
-Praxis can resume Claude Code sessions, and Claude Code can resume compatible
-sessions written by Praxis. Every semver-like Claude Code producer version is
+Use `praxis --data-plane claude` when you need the legacy shared Claude Code
+layout (`~/.claude` or `CLAUDE_CONFIG_DIR`). Praxis can resume Claude Code
+sessions in that mode, and Claude Code can resume compatible sessions written
+there. Every semver-like Claude Code producer version is
 structurally validated and is read/write compatible when its entry shape is
 supported; schema adapters are selected from transcript entry structure rather
 than an installed or fixed producer version, and malformed or unsupported

package/dist/application/claude-project-purge.d.ts

@@ -1,4 +1,5 @@
-export type ClaudeProjectPurgeItemKind = 'project' | 'tasks' | 'debug' | 'file-history' | 'prompt-history' | 'config-key';
+import type { DataPlane } from '../persistence/data-plane.js';
+export type ClaudeProjectPurgeItemKind = 'project' | 'memory' | 'scheduled' | 'tasks' | 'debug' | 'file-history' | 'prompt-history' | 'config-key';
 type ClaudeProjectPurgeOperation = 'remove-path' | 'filter-history' | 'remove-project-config' | 'clear-project-config';
 export interface ClaudeProjectPurgeItem {
     id: string;
@@ -14,6 +15,7 @@ export interface ClaudeProjectPurgePlan {
     mode: 'project' | 'all';
     configRoot: string;
     statePath: string;
+    allowStateOutsideConfigRoot?: boolean;
     targetPath?: string;
     projectIdentity?: string;
     projectRootPaths: string[];
@@ -21,6 +23,7 @@ export interface ClaudeProjectPurgePlan {
     items: ClaudeProjectPurgeItem[];
 }
 export interface PlanClaudeProjectPurgeOptions {
+    dataPlane?: DataPlane;
     cwd: string;
     path?: string;
     all?: boolean;

package/dist/application/claude-project-purge.js

@@ -1,6 +1,6 @@
 import { lstat, readFile, readdir, realpath, rm } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { basename, dirname, isAbsolute, join, relative, resolve, sep, } from 'node:path';
 import { isClaudeSessionId, sanitizeClaudeProjectPath, } from '../compatibility/claude/paths.js';
 import { resolveClaudeProjectIdentity } from '../compatibility/claude/shared-resources.js';
 import { writeFileAtomically } from '../platform/atomic-write.js';
@@ -74,7 +74,8 @@ async function assertSafePurgePath(configRoot, candidate) {
     const canonical = await realpath(absolute);
     assertLexicallyContained(configRoot, canonical);
 }
-async function assertMutableRegularFile(path) {
+async function assertMutableRegularFile(path, boundary) {
+    const canonicalBoundary = await canonicalPath(boundary);
     let current = resolve(path);
     while (true) {
         try {
@@ -87,6 +88,14 @@ async function assertMutableRegularFile(path) {
             if (errorCode(error) !== 'ENOENT')
                 throw error;
         }
+        try {
+            if ((await realpath(current)) === canonicalBoundary)
+                break;
+        }
+        catch (error) {
+            if (errorCode(error) !== 'ENOENT')
+                throw error;
+        }
         const parent = dirname(current);
         if (parent === current)
             break;
@@ -182,8 +191,8 @@ async function discoverSessionIds(projectRoot) {
     }
     return [...sessionIds].sort();
 }
-async function discoverProjectRoots(configRoot, targetPaths) {
-    const projectsRoot = join(configRoot, 'projects');
+async function discoverProjectRoots(configRoot, targetPaths, dataPlane) {
+    const projectsRoot = join(configRoot, dataPlane === 'native' ? 'sessions' : 'projects');
     if (!(await pathExists(projectsRoot)))
         return [];
     await assertSafePurgePath(configRoot, projectsRoot);
@@ -198,9 +207,10 @@ async function discoverProjectRoots(configRoot, targetPaths) {
         throw error;
     }
     const targetKeys = targetPaths.map(sanitizeClaudeProjectPath);
+    const worktreeSegment = dataPlane === 'native' ? '--praxis-worktrees-' : '--claude-worktrees-';
     return entries
         .filter((entry) => targetKeys.some((targetKey) => entry.name === targetKey ||
-        entry.name.startsWith(`${targetKey}--worktrees-`)))
+        entry.name.startsWith(`${targetKey}${worktreeSegment}`)))
         .map((entry) => join(projectsRoot, entry.name))
         .sort();
 }
@@ -227,11 +237,26 @@ export async function planClaudeProjectPurge(options) {
     const configuredRoot = options.configRoot ??
         (process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude'));
     const configRoot = await canonicalPath(configuredRoot);
-    const defaultStatePath = options.configRoot !== undefined || Boolean(process.env.CLAUDE_CONFIG_DIR)
-        ? join(configRoot, '.claude.json')
-        : resolve(homedir(), '.claude.json');
-    const statePath = await canonicalPath(options.statePath ?? defaultStatePath);
-    await assertMutableRegularFile(statePath);
+    const dataPlane = options.dataPlane ?? 'claude';
+    const homeDirectory = options.homeDirectory ?? homedir();
+    const legacyClaudeStatePath = resolve(homeDirectory, '.claude.json');
+    const legacyClaudeConfigRoot = await canonicalPath(resolve(homeDirectory, '.claude'));
+    const defaultStatePath = dataPlane === 'native'
+        ? join(configRoot, 'state.json')
+        : options.configRoot !== undefined ||
+            Boolean(process.env.CLAUDE_CONFIG_DIR)
+            ? join(configRoot, '.claude.json')
+            : legacyClaudeStatePath;
+    const statePath = resolve(options.statePath ?? defaultStatePath);
+    const usesLegacyDefaultClaudeState = dataPlane === 'claude' &&
+        !process.env.CLAUDE_CONFIG_DIR &&
+        configRoot === legacyClaudeConfigRoot &&
+        statePath === legacyClaudeStatePath;
+    const canonicalStateParent = await canonicalPath(dirname(statePath));
+    if (!usesLegacyDefaultClaudeState) {
+        assertLexicallyContained(configRoot, join(canonicalStateParent, basename(statePath)));
+    }
+    await assertMutableRegularFile(statePath, usesLegacyDefaultClaudeState ? canonicalStateParent : configRoot);
     const state = parseState(await readOptionalFile(statePath), statePath);
     const projects = stateProjects(state);
     const items = [];
@@ -239,9 +264,25 @@ export async function planClaudeProjectPurge(options) {
         const roots = [
             {
                 kind: 'project',
-                name: 'projects',
-                description: 'all project transcripts and memory',
+                name: dataPlane === 'native' ? 'sessions' : 'projects',
+                description: dataPlane === 'native'
+                    ? 'all project transcripts'
+                    : 'all project transcripts and memory',
             },
+            ...(dataPlane === 'native'
+                ? [
+                    {
+                        kind: 'memory',
+                        name: 'memory',
+                        description: 'all project memory',
+                    },
+                    {
+                        kind: 'scheduled',
+                        name: 'scheduled',
+                        description: 'all project scheduled prompts',
+                    },
+                ]
+                : []),
             {
                 kind: 'tasks',
                 name: 'tasks',
@@ -282,6 +323,9 @@ export async function planClaudeProjectPurge(options) {
             mode: 'all',
             configRoot,
             statePath,
+            ...(usesLegacyDefaultClaudeState
+                ? { allowStateOutsideConfigRoot: true }
+                : {}),
             projectRootPaths: [],
             sessionIds: [],
             items,
@@ -294,7 +338,7 @@ export async function planClaudeProjectPurge(options) {
         cwd: targetPath,
         homeDirectory: options.homeDirectory ?? homedir(),
     });
-    const projectRootPaths = await discoverProjectRoots(configRoot, targetPaths);
+    const projectRootPaths = await discoverProjectRoots(configRoot, targetPaths, dataPlane);
     const sessionIdSet = new Set();
     for (const projectRoot of projectRootPaths) {
         await assertSafePurgePath(configRoot, projectRoot);
@@ -308,8 +352,20 @@ export async function planClaudeProjectPurge(options) {
         await addExistingPath(items, configRoot, removePathItem('debug', join(configRoot, 'debug', `${sessionId}.txt`), `debug log for session ${sessionId}`));
         await addExistingPath(items, configRoot, removePathItem('file-history', join(configRoot, 'file-history', sessionId), `file edit history for session ${sessionId}`));
     }
+    if (dataPlane === 'native') {
+        const projectKeys = new Set([
+            ...targetPaths.map(sanitizeClaudeProjectPath),
+            ...projectRootPaths.map((path) => basename(path)),
+        ]);
+        for (const projectKey of projectKeys) {
+            await addExistingPath(items, configRoot, removePathItem('memory', join(configRoot, 'memory', projectKey), `memory for project ${projectKey}`));
+            await addExistingPath(items, configRoot, removePathItem('scheduled', join(configRoot, 'scheduled', `${projectKey}.json`), `scheduled prompts for project ${projectKey}`));
+        }
+    }
     for (const projectRoot of projectRootPaths) {
-        await addExistingPath(items, configRoot, removePathItem('project', projectRoot, 'project transcripts and memory'));
+        await addExistingPath(items, configRoot, removePathItem('project', projectRoot, dataPlane === 'native'
+            ? 'project transcripts'
+            : 'project transcripts and memory'));
     }
     const historyPath = join(configRoot, 'history.jsonl');
     const historyExists = await pathExists(historyPath);
@@ -351,6 +407,9 @@ export async function planClaudeProjectPurge(options) {
         mode: 'project',
         configRoot,
         statePath,
+        ...(usesLegacyDefaultClaudeState
+            ? { allowStateOutsideConfigRoot: true }
+            : {}),
         targetPath,
         projectIdentity,
         projectRootPaths,
@@ -358,8 +417,8 @@ export async function planClaudeProjectPurge(options) {
         items,
     };
 }
-async function atomicallyUpdate(path, update) {
-    await assertMutableRegularFile(path);
+async function atomicallyUpdate(path, update, boundary) {
+    await assertMutableRegularFile(path, boundary);
     for (let attempt = 0; attempt < MAX_ATOMIC_UPDATE_RETRIES; attempt += 1) {
         const source = await readOptionalFile(path);
         const content = update(source);
@@ -389,9 +448,17 @@ async function executeItem(plan, item) {
             if (source === null)
                 return null;
             return filterProjectHistory(source, projectPaths).content;
-        });
+        }, plan.configRoot);
         return;
     }
+    const stateParent = await canonicalPath(dirname(item.path));
+    let stateBoundary;
+    if (plan.allowStateOutsideConfigRoot)
+        stateBoundary = stateParent;
+    else {
+        assertLexicallyContained(plan.configRoot, join(stateParent, basename(item.path)));
+        stateBoundary = plan.configRoot;
+    }
     await atomicallyUpdate(item.path, (source) => {
         if (source === null)
             return null;
@@ -412,7 +479,7 @@ async function executeItem(plan, item) {
         }
         state.projects = projects;
         return `${JSON.stringify(state, null, 2)}\n`;
-    });
+    }, stateBoundary);
 }
 export async function executeClaudeProjectPurge(plan, options = {}) {
     if (options.dryRun) {

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

@@ -22,6 +22,7 @@ export declare function createFreshSessionMemoryState(): SessionMemoryState;
 export interface SessionMemoryStoreOptions {
     configRoot: string;
     sessionId: string;
+    sidecarRoot?: string;
 }
 /**
  * Durable sidecar for one session's extracted memory under

package/dist/application/session-memory.js

@@ -94,7 +94,7 @@ export class SessionMemoryStore {
         if (!isClaudeSessionId(options.sessionId)) {
             throw new SessionMemoryStateError(`Invalid session memory session ID: ${options.sessionId}`);
         }
-        this.directory = resolve(options.configRoot, 'praxis', 'session-memory', options.sessionId);
+        this.directory = resolve(options.sidecarRoot ?? resolve(options.configRoot, 'praxis'), 'session-memory', options.sessionId);
         this.stateFile = join(this.directory, 'state.json');
         this.summaryFile = join(this.directory, 'summary.md');
     }

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

@@ -1,5 +1,6 @@
 import { type AgentColorName, type AgentColorSelection } from '../compatibility/claude/agent-color.js';
 import type { ClaudeConditionalRuleResolver } from '../compatibility/claude/context.js';
+import { type DataPlane } from '../persistence/data-plane.js';
 import { type ClaudeFileResource, type ClaudeFileResourceConfig } from '../compatibility/claude/file-resources.js';
 import { type ClaudeDisplayTranscriptItem } from '../compatibility/claude/projection.js';
 import { type ModelDocument, type ModelImage, type ModelToolCall, type ModelProvider, type ModelUsage, type PermissionApproval, type PermissionDecision, type PermissionResolver, type PermissionUpdate, type RuntimeEventSink, type ToolRegistry } from '../core/runtime.js';
@@ -23,6 +24,8 @@ import type { ClaudePermissionMode } from '../permissions/claude-permission-reso
 import type { ClaudeMcpRuntime, ClaudeMcpServerStatus, ClaudeMcpToolInspection } from '../mcp/claude-mcp-tools.js';
 export interface ClaudeSessionServiceOptions {
     configRoot: string;
+    /** `claude` preserves the legacy shared layout; the CLI selects `native` by default. */
+    dataPlane?: DataPlane;
     cwd: string;
     claudeVersion: string;
     provider?: ModelProvider;
@@ -246,6 +249,7 @@ export declare class ClaudeSessionService {
     private restoreWorktree;
     private paths;
     private discoverProjectRoot;
+    private pathsForCwd;
     private appendCdCommand;
     private appendAgentColorUsage;
     private appendSystemLocalCommand;

package/dist/application/session-service.js

@@ -5,6 +5,7 @@ import { basename, extname, isAbsolute, join, relative, resolve, } from 'node:pa
 import { AGENT_COLOR_DEFAULT, agentColorMessage, getClaudeEffectiveAgentColor, } from '../compatibility/claude/agent-color.js';
 import { createClaudeCompactEntries, formatClaudeCompactSummary, getCumulativeDroppedTokens, } from '../compatibility/claude/compaction.js';
 import { discoverClaudeProjectRoot, isClaudeSessionId, resolveClaudePaths, resolveClaudeScheduledTaskFile, } from '../compatibility/claude/paths.js';
+import { resolveDataPlanePaths, resolveScheduledTaskFile, } from '../persistence/data-plane.js';
 import { downloadClaudeFileResources, } from '../compatibility/claude/file-resources.js';
 import { createClaudeNativeFork } from '../compatibility/claude/fork.js';
 import { selectClaudeActiveTranscript, selectClaudeTranscriptAtMessage, } from '../compatibility/claude/history.js';
@@ -347,15 +348,28 @@ export class ClaudeSessionService {
         this.scheduledPrompts =
             options.tools && (options.scheduledToolNames?.length ?? 0) > 0
                 ? new ScheduledPromptManager({
-                    filePath: resolveClaudeScheduledTaskFile(options.cwd),
-                    lockFile: join(options.configRoot, 'praxis', 'locks', 'scheduled-tasks.lock'),
+                    filePath: options.dataPlane === 'native'
+                        ? resolveScheduledTaskFile({
+                            dataPlane: 'native',
+                            cwd: options.cwd,
+                            root: options.configRoot,
+                        })
+                        : resolveClaudeScheduledTaskFile(options.cwd),
+                    lockFile: join(options.dataPlane === 'native'
+                        ? resolveDataPlanePaths({
+                            dataPlane: 'native',
+                            root: options.configRoot,
+                            cwd: options.cwd,
+                            sessionId: '00000000-0000-4000-8000-000000000000',
+                        }).praxisRoot
+                        : resolve(options.configRoot, 'praxis'), 'locks', 'scheduled-tasks.lock'),
                     ...(options.enableDynamicWakeups === undefined
                         ? {}
                         : { dynamicWakeupsEnabled: options.enableDynamicWakeups }),
                 })
                 : null;
         this.workflowManager = options.enableWorkflows
-            ? new WorkflowManager(options.configRoot, options.cwd, () => this.activeCwd())
+            ? new WorkflowManager(options.configRoot, options.cwd, () => this.activeCwd(), options.dataPlane)
             : null;
         this.backgroundTasks = new BackgroundTaskRuntime(this.workflowManager);
         this.worktreeManager =
@@ -363,6 +377,7 @@ export class ClaudeSessionService {
                 ? new SessionWorktreeManager({
                     workspace: options.workspace,
                     sessionId: '',
+                    dataPlane: options.dataPlane ?? 'claude',
                     ...(options.worktreeBaseRef
                         ? { baseRef: options.worktreeBaseRef }
                         : {}),
@@ -509,6 +524,7 @@ export class ClaudeSessionService {
                 manager: this.scheduledPrompts,
                 sessionId,
                 enabledTools: scheduledToolNames,
+                dataPlane: this.options.dataPlane ?? 'claude',
             })
             : null;
         const wrappedBase = scheduledTools ?? taskTools ?? baseTools;
@@ -516,6 +532,7 @@ export class ClaudeSessionService {
             this.options.permissions
             ? new ClaudeSubagentExecutor({
                 configRoot: this.options.configRoot,
+                dataPlane: this.options.dataPlane ?? 'claude',
                 cwd: this.activeCwd(),
                 cwdProvider: () => this.activeCwd(),
                 claudeVersion: this.options.claudeVersion,
@@ -592,6 +609,7 @@ export class ClaudeSessionService {
                 defaultModel: this.options.provider?.model ?? 'praxis/provider',
                 tokenBudget: null,
                 enabled: capabilities.has('Workflow'),
+                dataPlane: this.options.dataPlane ?? 'claude',
             })
             : agentTools;
         if (this.worktreeManager)
@@ -601,6 +619,7 @@ export class ClaudeSessionService {
                 base: workflowTools,
                 manager: this.worktreeManager,
                 workspace: this.options.workspace,
+                dataPlane: this.options.dataPlane ?? 'claude',
                 ...(this.options.worktreeToolNames
                     ? { enabledTools: this.options.worktreeToolNames }
                     : {}),
@@ -1051,16 +1070,8 @@ export class ClaudeSessionService {
             throw new Error(`Not a directory: ${requestedCwd}`);
         }
         if (sessionId && this.options.sessionPersistence !== false) {
-            const sourcePaths = resolveClaudePaths({
-                configDir: this.options.configRoot,
-                cwd: this.sessionCwds.get(sessionId) ?? previousCwd,
-                sessionId,
-            });
-            const targetPaths = resolveClaudePaths({
-                configDir: this.options.configRoot,
-                cwd,
-                sessionId,
-            });
+            const sourcePaths = this.pathsForCwd(sessionId, this.sessionCwds.get(sessionId) ?? previousCwd);
+            const targetPaths = this.pathsForCwd(sessionId, cwd);
             if (sourcePaths.sessionFile !== targetPaths.sessionFile) {
                 try {
                     await lstat(targetPaths.sessionFile);
@@ -1909,6 +1920,7 @@ export class ClaudeSessionService {
                     manager: this.scheduledPrompts,
                     sessionId,
                     enabledTools: scheduledToolNames,
+                    dataPlane: this.options.dataPlane ?? 'claude',
                 })
                 : null;
             const baseTools = scheduledTools ?? taskTools ?? this.options.tools;
@@ -1919,6 +1931,7 @@ export class ClaudeSessionService {
                 turnPermissions
                 ? new ClaudeSubagentExecutor({
                     configRoot: this.options.configRoot,
+                    dataPlane: this.options.dataPlane ?? 'claude',
                     cwd: this.activeCwd(),
                     cwdProvider: () => this.activeCwd(),
                     claudeVersion: this.options.claudeVersion,
@@ -1996,6 +2009,7 @@ export class ClaudeSessionService {
                     defaultModel: provider.model ?? 'praxis/provider',
                     tokenBudget: workflowTokenTarget(effectivePrompt),
                     enabled: capabilities.has('Workflow'),
+                    dataPlane: this.options.dataPlane ?? 'claude',
                 })
                 : agentTools;
             const workspaceTools = this.worktreeManager &&
@@ -2007,6 +2021,7 @@ export class ClaudeSessionService {
                     manager: this.worktreeManager,
                     workspace: this.options.workspace,
                     enabledTools: this.options.worktreeToolNames ?? [],
+                    dataPlane: this.options.dataPlane ?? 'claude',
                 })
                 : turnTools;
             const messageTools = this.options.brief && workspaceTools
@@ -3277,11 +3292,9 @@ export class ClaudeSessionService {
         this.worktreeManager.restore(state);
     }
     paths(sessionId) {
-        const exact = resolveClaudePaths({
-            configDir: this.options.configRoot,
-            cwd: this.sessionCwds.get(sessionId) ?? this.activeCwd(),
-            sessionId,
-        });
+        const exact = this.pathsForCwd(sessionId, this.sessionCwds.get(sessionId) ?? this.activeCwd());
+        if (this.options.dataPlane === 'native')
+            return exact;
         const discovered = this.discoveredProjectRoots.get(sessionId);
         if (discovered === undefined)
             return exact;
@@ -3292,6 +3305,8 @@ export class ClaudeSessionService {
         };
     }
     async discoverProjectRoot(sessionId) {
+        if (this.options.dataPlane === 'native')
+            return;
         if (this.discoveredProjectRoots.has(sessionId))
             return;
         const discovered = await discoverClaudeProjectRoot({
@@ -3303,6 +3318,21 @@ export class ClaudeSessionService {
             this.discoveredProjectRoots.set(sessionId, discovered);
         }
     }
+    pathsForCwd(sessionId, cwd) {
+        if (this.options.dataPlane === 'native') {
+            return resolveDataPlanePaths({
+                dataPlane: 'native',
+                root: this.options.configRoot,
+                cwd,
+                sessionId,
+            });
+        }
+        return resolveClaudePaths({
+            configDir: this.options.configRoot,
+            cwd,
+            sessionId,
+        });
+    }
     async appendCdCommand(sessionId, cwd) {
         const result = await this.store(sessionId).withLease(async (lease) => {
             const snapshot = await lease.load();
@@ -3724,7 +3754,7 @@ export class ClaudeSessionService {
                 !this.options.agentSystemPromptOverridesExplicit)) {
             return null;
         }
-        const memory = await agentMemoryPrompt(this.options.configRoot, this.activeCwd(), agent);
+        const memory = await agentMemoryPrompt(this.options.configRoot, this.activeCwd(), agent, this.options.dataPlane ?? 'claude');
         const system = memory ? `${agent.body}\n\n${memory}` : agent.body;
         return system.trim() ? system : null;
     }
@@ -3766,6 +3796,7 @@ export class ClaudeSessionService {
                 store: new SessionMemoryStore({
                     configRoot: this.options.configRoot,
                     sessionId,
+                    sidecarRoot: this.paths(sessionId).praxisRoot,
                 }),
                 extractor: (input) => this.extractSessionMemory(sessionId, input),
             });

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

@@ -1,5 +1,8 @@
+import type { DataPlane } from '../persistence/data-plane.js';
 export interface WorktreeSessionState {
     originalCwd: string;
+    /** Repository root used to validate the persisted worktree path on restore. */
+    repositoryRoot?: string;
     preEnterOriginalCwd: string;
     worktreePath: string;
     worktreeName: string;
@@ -29,7 +32,10 @@ export declare class SessionWorktreeManager {
         workspace: WorkspaceContext;
         sessionId: string;
         baseRef?: 'fresh' | 'head';
+        /** Claude compatibility retains its established project worktree path. */
+        dataPlane?: DataPlane;
     });
+    private worktreeRoot;
     bindSession(sessionId: string): void;
     current(): WorktreeSessionState | null;
     ensureInitial(name?: string): Promise<void>;

package/dist/application/session-worktree.js

@@ -64,6 +64,9 @@ export class SessionWorktreeManager {
     constructor(options) {
         this.options = options;
     }
+    worktreeRoot(repositoryRoot) {
+        return join(repositoryRoot, this.options.dataPlane === 'native' ? '.praxis' : '.claude', 'worktrees');
+    }
     bindSession(sessionId) {
         if (this.active && this.active.sessionId !== sessionId) {
             throw new Error(`Cannot switch to session ${sessionId} while worktree session ${this.active.sessionId} is active`);
@@ -86,7 +89,7 @@ export class SessionWorktreeManager {
         if (state.sessionId !== this.options.sessionId)
             return;
         const worktreePath = resolve(state.worktreePath);
-        const allowedRoot = resolve(state.originalCwd, '.claude', 'worktrees');
+        const allowedRoot = this.worktreeRoot(state.repositoryRoot ?? state.originalCwd);
         if (!isWithin(allowedRoot, worktreePath))
             return;
         // A crashed session can leave the directory behind after Git has
@@ -141,13 +144,14 @@ export class SessionWorktreeManager {
             if (invalidName(name)) {
                 throw new Error('Worktree name must use slash-separated letters, digits, dots, underscores, or dashes and be at most 64 characters');
             }
-            const worktreePath = join(root, '.claude', 'worktrees', name);
+            const worktreeRoot = this.worktreeRoot(root);
+            const worktreePath = join(worktreeRoot, name);
             const branch = `worktree-${nameFromPath(name)}`;
             const baseCommit = this.options.baseRef === 'head'
                 ? originalHeadCommit
                 : ((await gitOptional(root, ['merge-base', 'HEAD', '@{upstream}'])) ??
                     originalHeadCommit);
-            await mkdir(join(root, '.claude', 'worktrees'), { recursive: true });
+            await mkdir(worktreeRoot, { recursive: true });
             try {
                 await git(root, [
                     'worktree',
@@ -174,6 +178,7 @@ export class SessionWorktreeManager {
             }
             const state = {
                 originalCwd,
+                repositoryRoot: root,
                 preEnterOriginalCwd: originalCwd,
                 worktreePath,
                 worktreeName: name,
@@ -283,9 +288,9 @@ export class SessionWorktreeManager {
     }
     async enterExisting(root, originalCwd, originalBranch, originalHeadCommit, requestedPath) {
         const worktreePath = await realpath(resolve(originalCwd, requestedPath));
-        const allowedRoot = resolve(root, '.claude', 'worktrees');
+        const allowedRoot = this.worktreeRoot(root);
         if (!isWithin(allowedRoot, worktreePath)) {
-            throw new Error('Worktree path must be inside .claude/worktrees');
+            throw new Error(`Worktree path must be inside ${this.options.dataPlane === 'native' ? '.praxis' : '.claude'}/worktrees`);
         }
         const worktrees = parseWorktrees(await git(root, ['worktree', 'list', '--porcelain']));
         const entry = worktrees.find((candidate) => candidate.path === worktreePath);
@@ -296,6 +301,7 @@ export class SessionWorktreeManager {
             throw new Error('Worktree path has an invalid name');
         return {
             originalCwd,
+            repositoryRoot: root,
             preEnterOriginalCwd: originalCwd,
             worktreePath,
             worktreeName: name,

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

@@ -4,6 +4,7 @@ import { type ModelProvider, type ModelToolCall, type ModelToolDefinition, type
 import { type ClaudeAgentRuntimeDefinition, type ClaudeExtensionCatalog } from '../extensions/claude-extensions.js';
 import type { ClaudeHookRunner } from '../hooks/claude-hooks.js';
 import type { ClaudeMcpRuntime } from '../mcp/claude-mcp-tools.js';
+import { type DataPlane } from '../persistence/data-plane.js';
 import { type BackgroundAgentSnapshot } from './background-agent-manager.js';
 export interface WorkflowAgentRunOptions {
     sessionId: string;
@@ -47,9 +48,10 @@ export declare class StructuredOutputRegistry implements ToolRegistry {
     prepare(call: ModelToolCall, context: ToolExecutionContext): Promise<ModelToolCall>;
     execute(call: ModelToolCall, context: ToolExecutionContext): Promise<ToolExecutionResult>;
 }
-export declare function agentMemoryPrompt(configRoot: string, cwd: string, definition: ClaudeAgentRuntimeDefinition | null): Promise<string | null>;
+export declare function agentMemoryPrompt(configRoot: string, cwd: string, definition: ClaudeAgentRuntimeDefinition | null, dataPlane: DataPlane): Promise<string | null>;
 export interface ClaudeSubagentExecutorOptions {
     configRoot: string;
+    dataPlane: DataPlane;
     cwd: string;
     cwdProvider?: () => string;
     claudeVersion: string;
@@ -99,6 +101,7 @@ export declare class ClaudeSubagentExecutor {
     prepare(call: ModelToolCall, depth: number): ModelToolCall;
     execute(call: ModelToolCall, sessionId: string, depth: number, promptId: string, context: ToolExecutionContext): Promise<ToolExecutionResult>;
     private sidechainStore;
+    private sessionPaths;
     private createAgentWorktree;
     private createBackgroundAgentRun;
     runWorkflowAgent(options: WorkflowAgentRunOptions): Promise<WorkflowAgentRunResult>;