praxis-agent 0.34.0 → 0.35.0

package/dist/persistence/data-plane.js

@@ -1,6 +1,10 @@
-import { homedir } from 'node:os';
-import { resolve } from 'node:path';
-import { isClaudeSessionId, sanitizeClaudeProjectPath, } from '../compatibility/claude/paths.js';
+import { claudeDataPlaneAdapter } from '../compatibility/claude/data-plane-adapter.js';
+import { nativeDataPlaneAdapter } from './native-data-plane-adapter.js';
+function adapterFor(dataPlane) {
+    return dataPlane === 'native'
+        ? nativeDataPlaneAdapter
+        : claudeDataPlaneAdapter;
+}
 export function resolveDataPlane(environment = process.env) {
     const value = environment.PRAXIS_DATA_PLANE?.trim();
     if (value === undefined || value === '')
@@ -12,55 +16,14 @@ export function resolveDataPlane(environment = process.env) {
 export function resolveDataPlaneRoot(options = {}) {
     const environment = options.environment ?? process.env;
     const dataPlane = options.dataPlane ?? resolveDataPlane(environment);
-    const homeDirectory = options.homeDirectory ?? homedir();
-    if (options.root?.trim())
-        return resolve(options.root);
-    if (dataPlane === 'native') {
-        const configuredRoot = environment.PRAXIS_HOME;
-        return resolve(configuredRoot?.trim()
-            ? configuredRoot
-            : resolve(homeDirectory, '.praxis'));
-    }
-    const configuredRoot = environment.CLAUDE_CONFIG_DIR;
-    return resolve(configuredRoot?.trim() ? configuredRoot : resolve(homeDirectory, '.claude'));
+    return adapterFor(dataPlane).resolveRoot(options);
 }
 export function resolveDataPlanePaths(options) {
-    if (!isClaudeSessionId(options.sessionId)) {
-        throw new Error(`Invalid session ID: ${options.sessionId}`);
-    }
     const environment = options.environment ?? process.env;
     const dataPlane = options.dataPlane ?? resolveDataPlane(environment);
-    const root = resolveDataPlaneRoot({
-        dataPlane,
-        environment,
-        ...(options.root === undefined ? {} : { root: options.root }),
-        ...(options.homeDirectory === undefined
-            ? {}
-            : { homeDirectory: options.homeDirectory }),
-    });
-    const projectKey = sanitizeClaudeProjectPath(options.cwd);
-    const projectRoot = dataPlane === 'native'
-        ? resolve(root, 'sessions', projectKey)
-        : resolve(root, 'projects', projectKey);
-    const stateRoot = dataPlane === 'native' ? resolve(root, 'state') : resolve(root, 'praxis');
-    return {
-        dataPlane,
-        root,
-        projectRoot,
-        sessionFile: resolve(projectRoot, `${options.sessionId}.jsonl`),
-        taskRoot: dataPlane === 'native'
-            ? resolve(root, 'tasks', options.sessionId)
-            : resolve(root, 'tasks', options.sessionId),
-        stateRoot,
-        praxisRoot: stateRoot,
-        memoryRoot: dataPlane === 'native'
-            ? resolve(root, 'memory', projectKey)
-            : resolve(root, 'projects', projectKey, 'memory'),
-    };
+    return adapterFor(dataPlane).resolvePaths(options);
 }
 export function resolveScheduledTaskFile(options) {
-    return options.dataPlane === 'native'
-        ? resolve(options.root, 'scheduled', `${sanitizeClaudeProjectPath(options.cwd)}.json`)
-        : resolve(options.cwd, '.claude', 'scheduled_tasks.json');
+    return adapterFor(options.dataPlane).resolveScheduledTaskFile(options);
 }
 //# sourceMappingURL=data-plane.js.map

package/dist/persistence/native-data-plane-adapter.d.ts

@@ -0,0 +1,9 @@
+import type { DataPlaneAdapter, DataPlaneAdapterOptions, DataPlanePaths, DataPlaneRootOptions, ScheduledTaskFileOptions } from './data-plane-adapter.js';
+export declare class NativeDataPlaneAdapter implements DataPlaneAdapter {
+    readonly dataPlane: "native";
+    resolveRoot(options: DataPlaneRootOptions): string;
+    resolvePaths(options: DataPlaneAdapterOptions): DataPlanePaths;
+    resolveScheduledTaskFile(options: ScheduledTaskFileOptions): string;
+}
+export declare const nativeDataPlaneAdapter: NativeDataPlaneAdapter;
+//# sourceMappingURL=native-data-plane-adapter.d.ts.map

package/dist/persistence/native-data-plane-adapter.js

@@ -0,0 +1,39 @@
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { isSessionId } from '../core/session.js';
+import { sanitizeProjectPath } from '../platform/project-path-key.js';
+export class NativeDataPlaneAdapter {
+    dataPlane = 'native';
+    resolveRoot(options) {
+        const environment = options.environment ?? process.env;
+        if (options.root?.trim())
+            return resolve(options.root);
+        const configuredRoot = environment.PRAXIS_HOME;
+        return resolve(configuredRoot?.trim()
+            ? configuredRoot
+            : resolve(options.homeDirectory ?? homedir(), '.praxis'));
+    }
+    resolvePaths(options) {
+        if (!isSessionId(options.sessionId)) {
+            throw new Error(`Invalid session ID: ${options.sessionId}`);
+        }
+        const root = this.resolveRoot(options);
+        const projectKey = sanitizeProjectPath(options.cwd);
+        const projectRoot = resolve(root, 'sessions', projectKey);
+        return {
+            dataPlane: 'native',
+            root,
+            projectRoot,
+            sessionFile: resolve(projectRoot, `${options.sessionId}.jsonl`),
+            taskRoot: resolve(root, 'tasks', options.sessionId),
+            stateRoot: resolve(root, 'state'),
+            praxisRoot: resolve(root, 'state'),
+            memoryRoot: resolve(root, 'memory', projectKey),
+        };
+    }
+    resolveScheduledTaskFile(options) {
+        return resolve(options.root, 'scheduled', `${sanitizeProjectPath(options.cwd)}.json`);
+    }
+}
+export const nativeDataPlaneAdapter = new NativeDataPlaneAdapter();
+//# sourceMappingURL=native-data-plane-adapter.js.map

package/dist/persistence/native-resources.d.ts

@@ -1,11 +1,11 @@
-import type { ClaudeContextResources, ClaudeJsonResource, ClaudeSharedResources } from '../compatibility/claude/shared-resources.js';
+import type { ContextResources, JsonResource, SharedResources } from '../core/resources.js';
 export interface LoadNativeResourcesOptions {
     root: string;
     cwd: string;
     environment?: Readonly<Record<string, string | undefined>>;
     includeProjectMemory?: boolean;
 }
-export declare function loadNativeSettings({ root, cwd, }: LoadNativeResourcesOptions): Promise<ClaudeJsonResource[]>;
-export declare function loadNativeSharedResources({ root, cwd, environment, includeProjectMemory, }: LoadNativeResourcesOptions): Promise<ClaudeSharedResources>;
-export declare function loadNativeContextResources(options: LoadNativeResourcesOptions): Promise<ClaudeContextResources>;
+export declare function loadNativeSettings({ root, cwd, }: LoadNativeResourcesOptions): Promise<JsonResource[]>;
+export declare function loadNativeSharedResources({ root, cwd, environment, includeProjectMemory, }: LoadNativeResourcesOptions): Promise<SharedResources>;
+export declare function loadNativeContextResources(options: LoadNativeResourcesOptions): Promise<ContextResources>;
 //# sourceMappingURL=native-resources.d.ts.map

package/dist/persistence/native-transcript-codec.d.ts

@@ -0,0 +1,13 @@
+import { type TranscriptEvent } from '../core/transcript-event.js';
+import { type OpaquePreservationToken, type TranscriptCodec, type TranscriptDocumentResult, type TranscriptEncodeResult, type TranscriptLineResult } from '../core/transcript-codec.js';
+export declare class NativeTranscriptCodec implements TranscriptCodec {
+    readonly id = "praxis.transcript";
+    readonly version: number;
+    readonly writeMode: 'read-only' | 'read-write';
+    constructor(version?: number);
+    decodeLine(line: string, lineNumber?: number, byteOffset?: number): TranscriptLineResult;
+    encodeLine(event: TranscriptEvent, preservation?: OpaquePreservationToken): TranscriptEncodeResult;
+    decodeDocument(source: string | Uint8Array): TranscriptDocumentResult;
+}
+export declare function createNativeTranscriptCodec(version?: number): NativeTranscriptCodec;
+//# sourceMappingURL=native-transcript-codec.d.ts.map

package/dist/persistence/native-transcript-codec.js

@@ -0,0 +1,102 @@
+import { isTranscriptEvent, } from '../core/transcript-event.js';
+import { createPreservationToken, readPreservationToken, decodeDocumentWith, diagnostic, } from '../core/transcript-codec.js';
+const TOKEN_ID = Symbol('praxis.native.transcript.v1');
+export class NativeTranscriptCodec {
+    id = 'praxis.transcript';
+    version;
+    writeMode;
+    constructor(version = 1) {
+        this.version = version;
+        this.writeMode = version === 1 ? 'read-write' : 'read-only';
+    }
+    decodeLine(line, lineNumber = 1, byteOffset = 0) {
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch {
+            return {
+                ok: false,
+                issue: diagnostic('corrupt-line', 'Invalid JSON transcript line', byteOffset, lineNumber, { schemaVersion: this.version }),
+            };
+        }
+        if (typeof value !== 'object' || value === null || Array.isArray(value))
+            return {
+                ok: false,
+                issue: diagnostic('corrupt-line', 'Transcript line must be an object', byteOffset, lineNumber, { schemaVersion: this.version }),
+            };
+        const object = value;
+        if (object.schema !== this.id ||
+            (typeof object.version !== 'number' && typeof object.version !== 'string'))
+            return {
+                ok: false,
+                issue: diagnostic('corrupt-line', 'Invalid native transcript envelope', byteOffset, lineNumber, { schemaVersion: this.version }),
+            };
+        if (object.version !== 1)
+            return {
+                ok: false,
+                issue: diagnostic('unsupported-version', `Unsupported native transcript version ${String(object.version)}`, byteOffset, lineNumber, { schemaVersion: object.version }),
+            };
+        if (!isTranscriptEvent(object.event))
+            return {
+                ok: false,
+                issue: diagnostic('unsupported-event', 'Invalid or unsupported TranscriptEvent', byteOffset, lineNumber, typeof object.event === 'object' && object.event !== null
+                    ? {
+                        eventKind: String(object.event.kind ?? ''),
+                    }
+                    : {}),
+            };
+        return {
+            ok: true,
+            record: {
+                event: object.event,
+                preservation: createPreservationToken(TOKEN_ID, {
+                    owner: TOKEN_ID,
+                    raw: line,
+                    event: object.event,
+                }),
+            },
+        };
+    }
+    encodeLine(event, preservation) {
+        if (this.writeMode === 'read-only')
+            return {
+                ok: false,
+                issue: diagnostic('unsupported-version', 'Native codec is read-only', 0, null, { schemaVersion: this.version }),
+            };
+        if (!isTranscriptEvent(event))
+            return {
+                ok: false,
+                issue: diagnostic('unsupported-event', 'Invalid TranscriptEvent', 0, null, typeof event === 'object' && event !== null
+                    ? {
+                        eventKind: String(event.kind ?? ''),
+                    }
+                    : {}),
+            };
+        if (preservation) {
+            const token = readPreservationToken(preservation, TOKEN_ID);
+            if (!token)
+                return {
+                    ok: false,
+                    issue: diagnostic('unsupported-event', 'Preservation token belongs to another codec', 0, null),
+                };
+            return {
+                ok: true,
+                line: token.eventFingerprint === JSON.stringify(event)
+                    ? token.raw
+                    : JSON.stringify({ schema: this.id, version: 1, event }),
+            };
+        }
+        return {
+            ok: true,
+            line: JSON.stringify({ schema: this.id, version: 1, event }),
+        };
+    }
+    decodeDocument(source) {
+        return decodeDocumentWith(this, source);
+    }
+}
+export function createNativeTranscriptCodec(version = 1) {
+    return new NativeTranscriptCodec(version);
+}
+//# sourceMappingURL=native-transcript-codec.js.map

package/dist/tools/claude-user-message.d.ts

@@ -4,7 +4,6 @@ export interface UserMessage {
     attachments: readonly string[];
     status: 'normal' | 'proactive';
 }
-export declare const CLAUDE_USER_MESSAGE_PROMPT = "When brief mode is enabled, SendUserMessage is the primary user-visible reply channel. Use it for the answer, progress checkpoints, and blockers. Set status to normal for a direct reply and proactive for an unsolicited update.";
 export declare class ClaudeUserMessageToolRegistry implements ToolRegistry {
     private readonly base;
     private readonly onMessage;

package/dist/tools/claude-user-message.js

@@ -1,7 +1,6 @@
 import { stat } from 'node:fs/promises';
 import { extname, resolve } from 'node:path';
 import { resolveToolSchedulingPolicy } from '../core/tool-scheduling-policy.js';
-export const CLAUDE_USER_MESSAGE_PROMPT = 'When brief mode is enabled, SendUserMessage is the primary user-visible reply channel. Use it for the answer, progress checkpoints, and blockers. Set status to normal for a direct reply and proactive for an unsolicited update.';
 const DEFINITION = {
     name: 'SendUserMessage',
     description: 'Send a visible message to the user. Use this for progress updates, blockers, or completion notices when brief mode is enabled.',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praxis-agent",
-  "version": "0.34.0",
+  "version": "0.35.0",
   "description": "Local-first, single-user general agent for the command line.",
   "license": "MIT",
   "author": "wuqisen",
@@ -30,12 +30,15 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
-    "check": "npm run format:check && npm run lint && npm run test:docs && npm run verify:release-automation && npm run check:boundaries && npm run typecheck && npm test && npm run build",
+    "check": "npm run format:check && npm run lint && npm run test:docs && npm run verify:release-automation && npm run check:boundaries && npm run typecheck && npm run build:native && npm test && npm run build",
     "check:boundaries": "node scripts/check-boundaries.mjs",
     "dev": "tsx src/cli.ts",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "lint": "eslint .",
+    "clean:native": "node -e \"require('node:fs').rmSync('dist-native',{recursive:true,force:true})\"",
+    "prebuild:native": "npm run clean:native",
+    "build:native": "tsc -p tsconfig.native.json",
     "prebuild": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
     "prepack": "npm run build",
     "release:artifacts": "node scripts/build-release-artifacts.mjs",
@@ -63,6 +66,7 @@
     "test:mcp-resource-compat": "npm run build && node scripts/verify-mcp-resource-compatibility.mjs",
     "test:notebook-compat": "npm run build && node scripts/verify-notebook-compatibility.mjs",
     "test:context-compat": "npm run build && node scripts/verify-context-runtime.mjs",
+    "test:core-design-drift": "npm run build && node scripts/verify-core-design-drift.mjs",
     "test:cross-version-session-compat": "npm run build && node scripts/verify-cross-version-session-compatibility.mjs",
     "test:cross-version-resume-at-compat": "npm run build && node scripts/verify-cross-version-resume-at-compatibility.mjs",
     "test:cross-version-fork-compat": "npm run build && node scripts/verify-cross-version-fork-compatibility.mjs",