@praxis-ai/praxis 0.1.0 → 0.1.1

package/package.json

@@ -1,81 +1,168 @@
 {
   "name": "@praxis-ai/praxis",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "private": false,
   "type": "module",
-  "description": "Praxis agent framework and runtime for building OAO agents.",
+  "description": "Praxis agentCore architecture scaffold, tests, and engineering contracts.",
   "license": "AGPL-3.0-only",
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "bin/rax",
-    "dist/",
-    "README.md",
-    "CHANGELOG.md",
-    "LICENSE"
-  ],
   "bin": {
-    "rax": "./bin/rax"
+    "rax": "bin/rax",
+    "praxis-raxode": "raxode-tui/bin/raxode"
   },
   "exports": {
     ".": {
       "types": "./dist/agentCore/index.d.ts",
       "import": "./dist/agentCore/index.js"
     },
+    "./agentCore": {
+      "types": "./dist/agentCore/index.d.ts",
+      "import": "./dist/agentCore/index.js"
+    },
     "./agent-core": {
       "types": "./dist/agentCore/index.d.ts",
       "import": "./dist/agentCore/index.js"
     },
+    "./application": {
+      "types": "./dist/applicationLayer/index.d.ts",
+      "import": "./dist/applicationLayer/index.js"
+    },
     "./application-layer": {
       "types": "./dist/applicationLayer/index.d.ts",
       "import": "./dist/applicationLayer/index.js"
     },
+    "./basetool": {
+      "types": "./dist/basetool/index.d.ts",
+      "import": "./dist/basetool/index.js"
+    },
+    "./modelAdapter/*": {
+      "types": "./dist/modelAdapter/*.d.ts",
+      "import": "./dist/modelAdapter/*.js"
+    },
+    "./model-adapter/*": {
+      "types": "./dist/modelAdapter/*.d.ts",
+      "import": "./dist/modelAdapter/*.js"
+    },
+    "./provider/*": {
+      "types": "./dist/modelAdapter/*.d.ts",
+      "import": "./dist/modelAdapter/*.js"
+    },
+    "./memory": {
+      "types": "./dist/memory_managementPool/index.d.ts",
+      "import": "./dist/memory_managementPool/index.js"
+    },
+    "./modelAdapter": {
+      "types": "./dist/modelAdapter/index.d.ts",
+      "import": "./dist/modelAdapter/index.js"
+    },
+    "./model-adapter": {
+      "types": "./dist/modelAdapter/index.d.ts",
+      "import": "./dist/modelAdapter/index.js"
+    },
     "./rax": {
       "types": "./dist/rax_packageManager/index.d.ts",
       "import": "./dist/rax_packageManager/index.js"
     },
-    "./provider/*": {
-      "types": "./dist/agentCore/agent_modelAdapter/*.d.ts",
-      "import": "./dist/agentCore/agent_modelAdapter/*.js"
+    "./raxode": {
+      "types": "./raxode-tui/dist/raxode-cli/index.d.ts",
+      "import": "./raxode-tui/dist/raxode-cli/index.js"
+    },
+    "./raxode/backend": {
+      "types": "./raxode-tui/dist/raxode-cli/backend/raxodeBackend.d.ts",
+      "import": "./raxode-tui/dist/raxode-cli/backend/raxodeBackend.js"
+    },
+    "./raxode/contracts": {
+      "types": "./raxode-tui/dist/raxode-cli/contracts.d.ts",
+      "import": "./raxode-tui/dist/raxode-cli/contracts.js"
     },
     "./package.json": "./package.json"
   },
+  "files": [
+    "bin",
+    "dist",
+    "examples",
+    "raxode-tui/bin",
+    "raxode-tui/dist",
+    "raxode-tui/package.json",
+    "raxode-tui/tsconfig.json",
+    "!examples/scripts/agentcore_chat.ts",
+    "!examples/scripts/agentcore_tool_lab.ts",
+    "!examples/scripts/agentcore_all_tools_matrix.ts",
+    "!examples/scripts/agentcore_*_live_matrix.ts",
+    "!examples/scripts/agentcore_mcp_external_transport_smoke.ts",
+    "!examples/scripts/shellFullCapabilities.ts",
+    "!src/executionEngine/basic_toolLayer",
+    "!src/executionEngine/basic_toolLayer/**",
+    "!src/storagePool/baseToolStorage",
+    "!src/storagePool/baseToolStorage/**",
+    "!src/toolabilityPool",
+    "!src/toolabilityPool/**",
+    "!src/storagePool/tap_storagePool",
+    "!src/storagePool/tap_storagePool/**",
+    "LICENSE",
+    "tsconfig.json",
+    "!**/memory/generated",
+    "!**/memory/generated/**",
+    "!**/node_modules",
+    "!**/node_modules/**",
+    "!**/.devdoctor",
+    "!**/.devdoctor/**",
+    "!**/.raxode",
+    "!**/.raxode/**",
+    "!**/reports",
+    "!**/reports/**",
+    "!**/tests",
+    "!**/tests/**",
+    "!**/*.test.ts"
+  ],
   "engines": {
-    "node": ">=24.15.0"
+    "node": ">=22.22.3"
   },
   "scripts": {
-    "clean": "node scripts/clean-dist.mjs",
-    "build": "npm run clean && tsc -p tsconfig.build.json && node scripts/copy-dist-assets.mjs",
+    "clean": "node automations/clean-dist.mjs",
+    "build": "npm run clean && tsc -p tsconfig.build.json && tsc -p raxode-tui/tsconfig.build.json && node automations/copy-dist-assets.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "pack:dry": "npm pack --dry-run --json",
-    "chat:agentCore": "node --import tsx scripts/agentCore_Agent_Test/agentcore_chat.ts",
-    "chat:agentCore:live": "node --import tsx scripts/agentCore_Agent_Test/agentcore_chat.ts",
-    "chat:realtest:minimal": "node --import tsx scripts/agentCore_Agent_Test/agentcore_chat.ts --agent realtest/minimal",
-    "chat:realtest:fullstack": "node --import tsx scripts/agentCore_Agent_Test/agentcore_chat.ts --agent realtest/fullstack",
-    "test:agentCore:shell-dialogue": "AGENTCORE_LIVE_TEST=1 node --import tsx scripts/agentCore_Agent_Test/agentcore_shell_live_matrix.ts --dialogue",
-    "test:agentCore:shell-live": "AGENTCORE_LIVE_TEST=1 node --import tsx scripts/agentCore_Agent_Test/agentcore_shell_live_matrix.ts",
-    "test:agentCore:codebase-explore-dialogue": "AGENTCORE_LIVE_TEST=1 node --import tsx scripts/agentCore_Agent_Test/agentcore_codebase_explore_live_matrix.ts --dialogue",
-    "test:agentCore:codebase-explore-live": "AGENTCORE_LIVE_TEST=1 node --import tsx scripts/agentCore_Agent_Test/agentcore_codebase_explore_live_matrix.ts",
-    "test:agentCore:git-dialogue": "AGENTCORE_LIVE_TEST=1 node --import tsx scripts/agentCore_Agent_Test/agentcore_git_live_matrix.ts --dialogue",
-    "test:agentCore:git-live": "AGENTCORE_LIVE_TEST=1 node --import tsx scripts/agentCore_Agent_Test/agentcore_git_live_matrix.ts",
-    "test:agentCore:skill-dialogue": "AGENTCORE_LIVE_TEST=1 node --import tsx scripts/agentCore_Agent_Test/agentcore_skill_live_matrix.ts --dialogue",
-    "test:agentCore:skill-live": "AGENTCORE_LIVE_TEST=1 node --import tsx scripts/agentCore_Agent_Test/agentcore_skill_live_matrix.ts",
-    "test:agentCore:omni-dialogue": "AGENTCORE_LIVE_TEST=1 node --import tsx scripts/agentCore_Agent_Test/agentcore_omni_live_matrix.ts --dialogue",
-    "test:agentCore:omni-live": "AGENTCORE_LIVE_TEST=1 node --import tsx scripts/agentCore_Agent_Test/agentcore_omni_live_matrix.ts",
-    "test:agentCore:computeruse-dialogue": "AGENTCORE_LIVE_TEST=1 node --import tsx scripts/agentCore_Agent_Test/agentcore_computeruse_live_matrix.ts --dialogue",
-    "test:agentCore:computeruse-live": "AGENTCORE_LIVE_TEST=1 node --import tsx scripts/agentCore_Agent_Test/agentcore_computeruse_live_matrix.ts",
-    "test:agentCore:all-tools-matrix": "AGENTCORE_LIVE_TEST=1 node --import tsx scripts/agentCore_Agent_Test/agentcore_all_tools_matrix.ts",
-    "lab:agentCore:tools": "node --import tsx scripts/agentCore_Agent_Test/agentcore_tool_lab.ts",
-    "smoke:agentCore": "node --import tsx scripts/agentCore_Agent_Test/agentcore_smoke.ts",
+    "pack:dry-run": "npm pack --dry-run --json",
+    "pack:dist": "mkdir -p dist && npm pack --pack-destination dist",
+    "example:minimal": "node --import tsx examples/minimal/runRepoInspector.ts",
+    "example:fullstack": "node --import tsx examples/fullstack/runRepoInspector.ts",
+    "smoke:agentCore": "node --import tsx examples/scripts/agentcore_smoke.ts",
+    "smoke:modelAdapter": "node --import tsx examples/scripts/modelAdapter_smoke.ts",
+    "raxode:typecheck": "tsc -p raxode-tui/tsconfig.json --noEmit",
+    "raxode:test:backend": "cd raxode-tui && node --import tsx --test raxode-cli/frontend/bridge/*.test.ts raxode-cli/frontend/tui/cli/*.test.ts raxode-cli/frontend/tui/input/*.test.ts raxode-cli/backend/tests/*.test.ts",
+    "raxode:test:application": "npm run raxode:test:backend",
     "test:agentCore:live": "AGENTCORE_LIVE_TEST=1 node --import tsx --test test/agentCore/agentCoreLiveSmoke.test.ts",
-    "test:agentCore": "find test/agentCore -type f -name '*.test.ts' -print0 | xargs -0 node --import tsx --test",
-    "tasks:agentCore": "node tasks/scripts/agentcore_workflow.mjs",
-    "agentCore:workflow": "node tasks/scripts/agentcore_workflow.mjs"
+    "test:agentCore": "find test/agentCore \\( -path test/agentCore/agent_executionEngine/basic_toolLayer \\) -prune -o -type f -name '*.test.ts' -print0 | xargs -0 node --import tsx --test",
+    "test:unit": "npm run test:agentCore"
   },
   "devDependencies": {
-    "@types/node": "^24.12.0",
+    "@types/node": "^22.19.19"
+  },
+  "optionalDependencies": {
+    "@ffmpeg/core": "^0.12.10",
+    "@ffmpeg/ffmpeg": "^0.12.15",
+    "@ffmpeg/util": "^0.12.2",
+    "@huggingface/transformers": "^4.2.0"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.138",
+    "@anthropic-ai/sdk": "^0.78.0",
+    "@google/adk": "^0.5.0",
+    "@google/genai": "^1.52.0",
+    "@lancedb/lancedb": "^0.27.2",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@openai/agents": "^0.7.2",
+    "@types/react": "^18.3.28",
+    "apache-arrow": "^18.1.0",
+    "effect": "^3.21.2",
+    "ink": "^5.2.1",
+    "openai": "^6.37.0",
+    "react": "^18.3.1",
+    "string-width": "^7.2.0",
     "tsx": "^4.21.0",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "zod": "^4.4.3"
   }
 }

package/raxode-tui/bin/raxode

@@ -0,0 +1,45 @@
+#!/usr/bin/env sh
+PRG=$0
+while [ -h "$PRG" ]; do
+  LINK=$(ls -ld -- "$PRG")
+  LINK=$(expr "$LINK" : '.*-> \(.*\)$')
+  case "$LINK" in
+    /*) PRG=$LINK ;;
+    *) PRG=$(dirname -- "$PRG")/$LINK ;;
+  esac
+done
+SCRIPT_DIR=$(CDPATH= cd -- "$(dirname -- "$PRG")" && pwd)
+ORIGINAL_CWD=$(pwd)
+SOURCE_ENTRY="$SCRIPT_DIR/../raxode-cli/frontend/tui/cli/raxode-cli.ts"
+TSX_LOADER="$SCRIPT_DIR/../node_modules/tsx/dist/loader.mjs"
+if [ ! -f "$TSX_LOADER" ]; then
+  SEARCH_DIR="$SCRIPT_DIR"
+  while [ "$SEARCH_DIR" != "/" ]; do
+    CANDIDATE="$SEARCH_DIR/node_modules/tsx/dist/loader.mjs"
+    if [ -f "$CANDIDATE" ]; then
+      TSX_LOADER="$CANDIDATE"
+      break
+    fi
+    SEARCH_DIR=$(dirname -- "$SEARCH_DIR")
+  done
+fi
+if [ -f "$SOURCE_ENTRY" ] && [ -f "$TSX_LOADER" ]; then
+  if [ -z "$PRAXIS_WORKSPACE_ROOT" ]; then
+    export PRAXIS_WORKSPACE_ROOT="$ORIGINAL_CWD"
+  fi
+  if [ -z "$TSX_TSCONFIG_PATH" ]; then
+    export TSX_TSCONFIG_PATH="$SCRIPT_DIR/../tsconfig.json"
+  fi
+  cd "$SCRIPT_DIR/.." || exit 1
+  exec node --import "$TSX_LOADER" "$SOURCE_ENTRY" "$@"
+fi
+DIST_ENTRY="$SCRIPT_DIR/../dist/raxode-cli/frontend/tui/cli/raxode-cli.js"
+if [ -f "$DIST_ENTRY" ]; then
+  exec node "$DIST_ENTRY" "$@"
+fi
+if [ -f "$SOURCE_ENTRY" ]; then
+  echo "Raxode could not locate the bundled tsx loader. Please reinstall the package." >&2
+else
+  echo "Raxode could not locate the compiled entrypoint. Please run npm run build or reinstall the package." >&2
+fi
+  exit 1

package/raxode-tui/dist/raxode-cli/backend/agents/codingAgent/agent.d.ts

@@ -0,0 +1,20 @@
+import { praxis } from "@praxis-ai/praxis";
+import type { AgentIdentity, CapabilitySpec, DependencyDeclaration, BaseToolPolicyMatrixSpec, HarnessSpec, MainLoopSpec, ModelFleetSpec, ModelSpec, SandboxSpec, SessionSpec, StatePlaneSpec, StorageSpec } from "@praxis-ai/praxis";
+import type { RaxodeOptions } from "./config/raxodeOptions.js";
+import { RaxodeCodingPrompt } from "./prompts/codingPrompt.js";
+export default class RaxodeCodingAgent extends praxis.AgentArchetype {
+    identity: AgentIdentity;
+    model: ModelSpec;
+    modelFleet: ModelFleetSpec;
+    promptPack: RaxodeCodingPrompt;
+    mainLoop: MainLoopSpec;
+    sandbox: SandboxSpec;
+    toolPolicy: BaseToolPolicyMatrixSpec;
+    storage: StorageSpec;
+    session: SessionSpec;
+    statePlane: StatePlaneSpec;
+    harness: HarnessSpec;
+    capabilities: readonly CapabilitySpec[];
+    dependencies: readonly DependencyDeclaration[];
+    constructor(options?: RaxodeOptions);
+}

package/raxode-tui/dist/raxode-cli/backend/agents/codingAgent/agent.js

@@ -0,0 +1,121 @@
+import { praxis } from "@praxis-ai/praxis";
+import { createRaxodeIdentity } from "./config/identity.js";
+import { createRaxodeModel, createRaxodeModelFleet } from "./config/modelFleet.js";
+import { normalizeRaxodeOptions } from "./config/raxodeOptions.js";
+import { createRaxodeHarness } from "./harness/harness.js";
+import { createRaxodeMainLoop } from "./mainLoop/mainLoop.js";
+import { createRaxodeToolPolicy } from "./policies/toolPolicy.js";
+import { RaxodeCodingPrompt } from "./prompts/codingPrompt.js";
+import { createRaxodeSandbox } from "./sandbox/profile.js";
+import { createRaxodeStatePlane } from "./state/statePlane.js";
+import { createRaxodeSession, createRaxodeStorage } from "./storage/storagePolicy.js";
+export default class RaxodeCodingAgent extends praxis.AgentArchetype {
+    identity;
+    model;
+    modelFleet;
+    promptPack;
+    mainLoop;
+    sandbox;
+    toolPolicy;
+    storage;
+    session;
+    statePlane;
+    harness;
+    capabilities;
+    dependencies;
+    constructor(options = {}) {
+        super();
+        const normalized = normalizeRaxodeOptions(options);
+        this.identity = createRaxodeIdentity();
+        this.model = createRaxodeModel(normalized);
+        this.modelFleet = createRaxodeModelFleet(normalized);
+        this.promptPack = new RaxodeCodingPrompt({
+            memoryPromptGuide: normalized.memoryPromptGuide,
+        });
+        this.mainLoop = createRaxodeMainLoop(normalized);
+        this.sandbox = createRaxodeSandbox(normalized);
+        this.toolPolicy = createRaxodeToolPolicy(normalized.policyProfile);
+        this.storage = createRaxodeStorage(normalized);
+        this.session = createRaxodeSession(normalized);
+        this.statePlane = createRaxodeStatePlane();
+        this.harness = createRaxodeHarness(normalized);
+        const provision = createRaxodeProvisioning(normalized);
+        this.capabilities = provision.capabilities;
+        this.dependencies = provision.dependencies;
+    }
+}
+function createRaxodeProvisioning(options) {
+    const sandboxIsolation = options.sandboxProfile === "linuxBubblewrap"
+        ? "strong"
+        : options.sandboxProfile === "workspaceOnly"
+            ? "workspace"
+            : "none";
+    return praxis.capabilities([
+        praxis.capability.sandbox({
+            capabilityId: "capability.raxode.sandbox",
+            isolation: sandboxIsolation,
+            required: options.sandboxProfile === "linuxBubblewrap",
+            reason: "Prepare the Raxode backend for governed shell, filesystem, and tool execution.",
+            fallback: { allowWorkspaceRollback: true },
+            metadata: {
+                defaultPolicy: "permissive",
+                selectedProfile: options.sandboxProfile,
+                runtimeOwner: "praxis.applicationLayer",
+            },
+        }),
+        praxis.capability.codeIntelligence({
+            capabilityId: "capability.raxode.codeIntelligence",
+            languages: ["typescript", "javascript", "json", "markdown"],
+            required: false,
+            reason: "Expose optional LSP/code intelligence readiness for coding workflows.",
+            metadata: {
+                toolProfile: "agentCore",
+            },
+        }),
+        praxis.capability.mcp({
+            capabilityId: "capability.raxode.mcp",
+            required: false,
+            reason: "Reserve the MCP bridge for external tools without making it mandatory.",
+            metadata: {
+                bridge: "passive",
+            },
+        }),
+        praxis.dependency.binary("node", {
+            required: true,
+            acceptedVersions: [">=22.22.3"],
+            install: "manual",
+            reason: "Run Praxis, the application backend, and the Ink TUI.",
+            metadata: {
+                source: "raxode-backend",
+            },
+        }),
+        praxis.dependency.npm("tsx", {
+            required: true,
+            install: "auto",
+            reason: "Launch TypeScript backend/TUI entrypoints during development.",
+            metadata: {
+                source: "raxode-backend",
+            },
+        }),
+        praxis.dependency.binary("bwrap", {
+            required: options.sandboxProfile === "linuxBubblewrap",
+            install: "manual",
+            reason: "Prepare the Linux bubblewrap sandbox provider; Praxis degrades to workspace rollback when it is unavailable.",
+            metadata: {
+                source: "raxode-sandbox",
+                providerFamily: "linux-bubblewrap",
+                defaultWithSandbox: true,
+                installHint: "Install bubblewrap with the OS package manager, for example apt install bubblewrap.",
+            },
+        }),
+        praxis.dependency.secretRef("provider.core.main", {
+            required: false,
+            install: "disabled",
+            reason: "Allow the auth plane to resolve provider credentials for live model calls.",
+            metadata: {
+                roleId: "core.main",
+                secretOwner: "runtime.authPlane",
+            },
+        }),
+    ]);
+}

package/raxode-tui/dist/raxode-cli/backend/agents/codingAgent/config/identity.d.ts

@@ -0,0 +1,2 @@
+import type { AgentIdentity } from "@praxis-ai/praxis";
+export declare function createRaxodeIdentity(): AgentIdentity;

package/raxode-tui/dist/raxode-cli/backend/agents/codingAgent/config/identity.js

@@ -0,0 +1,8 @@
+export function createRaxodeIdentity() {
+    return {
+        id: "agent.raxode.coding",
+        name: "Raxode Coding Agent",
+        version: "0.1.0",
+        description: "The full-capability coding agent behind the Raxode TUI application.",
+    };
+}

package/raxode-tui/dist/raxode-cli/backend/agents/codingAgent/config/modelFleet.d.ts

@@ -0,0 +1,4 @@
+import type { ModelFleetSpec, ModelSpec } from "@praxis-ai/praxis";
+import type { NormalizedRaxodeOptions } from "./raxodeOptions.js";
+export declare function createRaxodeModel(options: NormalizedRaxodeOptions): ModelSpec;
+export declare function createRaxodeModelFleet(options: NormalizedRaxodeOptions): ModelFleetSpec;

package/raxode-tui/dist/raxode-cli/backend/agents/codingAgent/config/modelFleet.js

@@ -0,0 +1,81 @@
+import { praxis } from "@praxis-ai/praxis";
+import { createModelMetadataRecord } from "@praxis-ai/praxis/modelAdapter/providerAccessLayer/modelMetadataRegistry";
+function endpointPathFor(shape) {
+    if (shape === "messages")
+        return "/v1/messages";
+    if (shape === "chat_completions")
+        return "/v1/chat/completions";
+    return "/v1/responses";
+}
+function metadataFor(options) {
+    const metadata = createModelMetadataRecord({ provider: options.provider, model: options.model });
+    const routeMetadata = options.providerRoute
+        ? { providerRoute: options.providerRoute }
+        : {};
+    const outputMetadata = typeof options.maxOutputTokens === "number" && Number.isFinite(options.maxOutputTokens)
+        ? { maxOutputTokens: options.maxOutputTokens }
+        : {};
+    const baseMetadata = metadata ?? {};
+    return Object.keys(baseMetadata).length > 0 || Object.keys(routeMetadata).length > 0 || Object.keys(outputMetadata).length > 0
+        ? { ...baseMetadata, ...routeMetadata, ...outputMetadata }
+        : undefined;
+}
+export function createRaxodeModel(options) {
+    const metadata = metadataFor(options);
+    return praxis.model(options.model, {
+        provider: options.provider,
+        endpointShape: options.endpointShape,
+        carrierId: "carrier.raxode.coding.primary",
+        baseURL: options.baseURL,
+        reasoning: {
+            effort: options.reasoningEffort,
+            summary: "concise",
+        },
+        metadata,
+    });
+}
+export function createRaxodeModelFleet(options) {
+    const primaryMetadata = metadataFor(options);
+    return praxis.modelFleet.auto({
+        primary: praxis.endpoint(endpointPathFor(options.endpointShape), {
+            role: options.endpointShape === "messages" ? "reasoning" : "background",
+            provider: options.provider,
+            model: options.model,
+            carrierId: "carrier.raxode.coding.primary",
+            baseURL: options.baseURL,
+            capabilityMatrix: { text: true, reasoning: true, toolCalling: true, metadata: primaryMetadata },
+            failurePolicy: { onUnavailable: "degrade", maxRetries: 1, timeoutMs: 30_000 },
+            metadata: primaryMetadata,
+        }),
+        fast: praxis.endpoint("/v1/responses", {
+            role: "fast-path",
+            provider: "openai",
+            model: "gpt-5.4-mini",
+            capabilityMatrix: { text: true, toolCalling: true },
+            failurePolicy: { onUnavailable: "degrade", maxRetries: 1, timeoutMs: 15_000 },
+        }),
+        image: praxis.endpoint("/v1/images", {
+            role: "image-generation",
+            provider: "openai",
+            model: "gpt-image-style",
+            capabilityMatrix: { imageGeneration: true },
+            failurePolicy: { onUnavailable: "skip" },
+        }),
+        realtime: praxis.endpoint("/v1/realtime", {
+            role: "realtime",
+            provider: "openai",
+            model: "gpt-realtime-style",
+            capabilityMatrix: { realtime: true },
+            failurePolicy: { onUnavailable: "skip" },
+        }),
+    }, {
+        probeStrategy: "lazy",
+        primaryRef: "primary",
+        failurePolicy: {
+            onUnavailable: "degrade",
+            fallbackEndpointRef: "fast",
+            maxRetries: 1,
+            metadata: { optionalEndpointPolicy: "record-and-continue" },
+        },
+    });
+}

package/raxode-tui/dist/raxode-cli/backend/agents/codingAgent/config/raxodeOptions.d.ts

@@ -0,0 +1,27 @@
+export type RaxodePolicyProfile = "restricted" | "standard" | "permissive" | "yolo" | "bapr";
+export type RaxodeSandboxProfile = "hostObserved" | "workspaceOnly" | "linuxBubblewrap";
+export type RaxodeProvider = "openai" | "anthropic";
+export type RaxodeEndpointShape = "responses" | "chat_completions" | "messages";
+export type RaxodeMemoryProfile = "off" | "readonly" | "appendOnly" | "full";
+export type RaxodeProviderRoute = "chatgpt_codex_responses" | "openai_responses" | "openai_chat_completions" | "anthropic_messages";
+export type RaxodeOptions = {
+    policyProfile?: RaxodePolicyProfile;
+    sandboxProfile?: RaxodeSandboxProfile;
+    persistence?: "memory" | "sqlite";
+    includeAllCatalogTools?: boolean;
+    provider?: RaxodeProvider;
+    endpointShape?: RaxodeEndpointShape;
+    baseURL?: string;
+    providerRoute?: RaxodeProviderRoute;
+    model?: string;
+    reasoningEffort?: "low" | "medium" | "high" | "xhigh" | "none" | "minimal";
+    maxOutputTokens?: number;
+    memoryProfile?: RaxodeMemoryProfile;
+    memoryPromptGuide?: string;
+};
+export type NormalizedRaxodeOptions = Required<Omit<RaxodeOptions, "baseURL" | "providerRoute" | "maxOutputTokens">> & {
+    baseURL?: string;
+    providerRoute?: RaxodeProviderRoute;
+    maxOutputTokens?: number;
+};
+export declare function normalizeRaxodeOptions(options?: RaxodeOptions): NormalizedRaxodeOptions;

package/raxode-tui/dist/raxode-cli/backend/agents/codingAgent/config/raxodeOptions.js

@@ -0,0 +1,17 @@
+export function normalizeRaxodeOptions(options = {}) {
+    return {
+        policyProfile: options.policyProfile ?? "permissive",
+        sandboxProfile: options.sandboxProfile ?? "hostObserved",
+        persistence: options.persistence ?? "sqlite",
+        includeAllCatalogTools: options.includeAllCatalogTools ?? true,
+        provider: options.provider ?? (options.endpointShape === "messages" ? "anthropic" : "openai"),
+        endpointShape: options.endpointShape ?? "responses",
+        baseURL: options.baseURL,
+        providerRoute: options.providerRoute,
+        model: options.model ?? "gpt-5.5",
+        reasoningEffort: options.reasoningEffort ?? "low",
+        maxOutputTokens: options.maxOutputTokens,
+        memoryProfile: options.memoryProfile ?? "readonly",
+        memoryPromptGuide: options.memoryPromptGuide ?? "",
+    };
+}

package/raxode-tui/dist/raxode-cli/backend/agents/codingAgent/harness/harness.d.ts

@@ -0,0 +1,3 @@
+import type { HarnessSpec } from "@praxis-ai/praxis";
+import type { NormalizedRaxodeOptions } from "../config/raxodeOptions.js";
+export declare function createRaxodeHarness(options: NormalizedRaxodeOptions): HarnessSpec;

package/raxode-tui/dist/raxode-cli/backend/agents/codingAgent/harness/harness.js

@@ -0,0 +1,105 @@
+import { praxis } from "@praxis-ai/praxis";
+import { createRaxodeToolSet } from "../tools/toolSet.js";
+export function createRaxodeHarness(options) {
+    return praxis.harness({
+        modelRef: "model.raxode.coding.primary",
+        modelFleetRef: "modelFleet.raxode.auto",
+        promptPackRef: "prompt.raxode.coding",
+        toolPolicyRef: `toolPolicy.raxode.${options.policyProfile}`,
+        mainLoopRef: "mainLoop.raxode.coding",
+        sandboxRef: options.sandboxProfile === "hostObserved"
+            ? "sandbox.hostObserved"
+            : options.sandboxProfile === "workspaceOnly"
+                ? "sandbox.workspaceOnly"
+                : "sandbox.linuxBubblewrap",
+        storageRef: options.persistence === "sqlite" ? "storage.raxode.workspace" : "storage.raxode.memory",
+        sessionRef: options.persistence === "sqlite" ? "session.raxode.sqlite" : "session.raxode.memory",
+        statePlaneRef: "statePlane.raxode.control",
+        interfaceRefs: [
+            "interface.raxode.tui",
+            "interface.raxode.approval",
+            "interface.raxode.events",
+            "interface.raxode.management",
+            "interface.raxode.repair",
+        ],
+        contextRefs: [
+            "context.raxode.praxisContextBridge",
+            "context.raxode.workspace",
+            "context.praxis.passiveContext",
+        ],
+        context: {
+            refs: [
+                "context.raxode.workspace",
+                "context.praxis.passiveContext",
+                "context.praxis.promptPack",
+            ],
+            metadata: {
+                mode: "passive-first",
+                projectContext: "application-managed",
+                artifactBridge: "context.load",
+            },
+        },
+        memoryRefs: [
+            "memory.raxode.praxisMemoryBridge",
+            "memory.raxode.artifactIndex",
+            "memory.praxis.passiveMemory",
+        ],
+        memory: {
+            mode: "session",
+            pool: "memory.praxis.passiveMemory",
+            metadata: {
+                strategy: "passive-session-first",
+                longTermMemory: "optional",
+                artifactIndex: "application-managed",
+            },
+        },
+        tools: praxis.tools(createRaxodeToolSet(options)),
+        policy: praxis.policy({
+            allowProviderCall: true,
+            allowToolExecution: true,
+            scopes: [
+                "agent.invoke",
+                "manifest.inspect",
+                "promptPack.define",
+                "tool.execute",
+                "dependency.prepare",
+                "storage.init",
+                "session.persist",
+                "state.control",
+                "application.control",
+            ],
+        }),
+        loop: praxis.loop.standard({
+            maxModelTurns: 256,
+            maxToolCalls: 1024,
+        }),
+        modules: {
+            dependencyPlane: { mode: "prepare-declared-capabilities" },
+            authPlane: { mode: "provider-profile-resolver", roleId: "core.main" },
+            projectPlane: { mode: "application-project-runtime" },
+            sessionPlane: { mode: options.persistence === "sqlite" ? "durable" : "memory" },
+            contextPlane: { mode: "passive" },
+            memoryPlane: { mode: options.memoryProfile },
+            cachePlane: { mode: "prompt-pack-cache-xray" },
+            multiagentPlane: { mode: "contract-ready" },
+        },
+        runtimeRequirements: [
+            "praxis.applicationLayer",
+            "praxis.basetool.agentCore",
+            "praxis.promptPack.core123",
+            "praxis.authPlane.providerProfiles",
+            "praxis.projectSession.runtime",
+            "praxis.sandboxPlane.declaredCapabilities",
+            "praxis.cachePlane.promptPackXray",
+            "praxis.multiagent.contract",
+        ],
+        metadata: {
+            product: "raxode",
+            toolProfile: "agentCore",
+            policyProfile: options.policyProfile,
+            sandboxProfile: options.sandboxProfile,
+            applicationInstructions: "The backend is a Praxis application-layer harness, not a private runtime shortcut.",
+            harnessInstructions: "Preserve OAO declarations; keep provider auth, project/session, context/memory, sandbox, cache, and multiagent concerns routed through Praxis runtime surfaces.",
+        },
+    });
+}