akemon 0.3.4 → 0.3.6

package/dist/cli.js

@@ -6,6 +6,10 @@ import { getOrCreateRelayCredentials } from "./config.js";
 import { connectRelay } from "./relay-client.js";
 import { listAgents } from "./list.js";
 import { connect } from "./connect.js";
+import { PrivacyFilterUnavailableError, sanitizeText, } from "./privacy-filter.js";
+import { SoftwareAgentStreamCliRenderer } from "./software-agent-stream-cli.js";
+import { appendWorkMemoryNote, buildWorkMemoryContext, } from "./work-memory.js";
+import { renderSoftwareAgentRunResult } from "./software-agent-result-cli.js";
 import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
@@ -24,6 +28,43 @@ function clampPositiveInt(value, fallback, max) {
         return fallback;
     return Math.min(parsed, max);
 }
+function parsePrivacyFilterMode(value) {
+    if (value === "fast" || value === "pii" || value === "strict")
+        return value;
+    console.error("--mode must be one of: fast, pii, strict");
+    process.exit(1);
+}
+function parsePrivacyFilterBackend(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === "fast" || value === "opf")
+        return value;
+    console.error("--backend must be one of: fast, opf");
+    process.exit(1);
+}
+function parseSoftwareAgentEnvPolicy(value) {
+    const normalized = (value || "inherit").trim().toLowerCase();
+    if (normalized === "inherit" || normalized === "allowlist")
+        return normalized;
+    console.error("--software-agent-env must be one of: inherit, allowlist");
+    process.exit(1);
+}
+function parseCommaSeparatedCliOption(value) {
+    if (!value)
+        return undefined;
+    const items = value.split(",").map((item) => item.trim()).filter(Boolean);
+    return items.length ? items : undefined;
+}
+function parsePositiveIntCliOption(value, optionName) {
+    if (value === undefined)
+        return undefined;
+    const parsed = typeof value === "number" ? value : Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        console.error(`${optionName} must be a positive integer`);
+        process.exit(1);
+    }
+    return parsed;
+}
 function printSoftwareAgentTaskList(tasks) {
     if (!tasks.length) {
         console.log("No software-agent tasks found.");
@@ -37,10 +78,36 @@ function printSoftwareAgentTaskList(tasks) {
             : "no-git";
         const goal = truncateOneLine(task.envelope?.goal || "", 90);
         console.log(`${task.taskId}  ${task.status}/${result}  ${duration}  ${git}  ${task.updatedAt || task.startedAt}`);
+        if (task.contextSession?.sessionId)
+            console.log(`  session: ${task.contextSession.sessionId}`);
+        const workMemoryDir = task.envelope?.workMemoryDir || task.result?.workMemoryDir;
+        if (workMemoryDir)
+            console.log(`  work memory: ${workMemoryDir}`);
         if (goal)
             console.log(`  ${goal}`);
     }
 }
+function printSoftwareAgentSessionList(sessions) {
+    if (!sessions.length) {
+        console.log("No software-agent context sessions found.");
+        return;
+    }
+    for (const session of sessions) {
+        const result = session.lastResult?.success === true ? "ok" : session.lastResult?.success === false ? "error" : "pending";
+        const duration = typeof session.lastResult?.durationMs === "number" ? `${session.lastResult.durationMs}ms` : "-";
+        const updatedAt = session.updatedAt || "-";
+        const goal = truncateOneLine(session.lastGoal || "", 90);
+        console.log(`${session.sessionId}  ${result}  ${duration}  ${updatedAt}`);
+        if (session.lastTaskId)
+            console.log(`  last task: ${session.lastTaskId}`);
+        if (goal)
+            console.log(`  ${goal}`);
+        if (session.packetPath)
+            console.log(`  context: ${session.packetPath}`);
+        if (session.workMemoryDir)
+            console.log(`  work memory: ${session.workMemoryDir}`);
+    }
+}
 function truncateOneLine(value, max) {
     const oneLine = value.replace(/\s+/g, " ").trim();
     if (oneLine.length <= max)
@@ -117,6 +184,7 @@ async function streamLocalOwnerEndpoint(path, opts, body) {
     const decoder = new TextDecoder();
     let buffer = "";
     let failed = false;
+    const streamRenderer = new SoftwareAgentStreamCliRenderer();
     const reader = res.body.getReader();
     while (true) {
         const { done, value } = await reader.read();
@@ -126,57 +194,74 @@ async function streamLocalOwnerEndpoint(path, opts, body) {
         const lines = buffer.split(/\r?\n/);
         buffer = lines.pop() || "";
         for (const line of lines) {
-            if (handleSoftwareAgentStreamLine(line))
+            if (streamRenderer.handleLine(line))
                 failed = true;
         }
     }
     buffer += decoder.decode();
-    if (buffer.trim() && handleSoftwareAgentStreamLine(buffer))
+    if (buffer.trim() && streamRenderer.handleLine(buffer))
         failed = true;
     if (failed)
         process.exit(1);
 }
-function handleSoftwareAgentStreamLine(line) {
-    const trimmed = line.trim();
-    if (!trimmed)
-        return false;
-    let event;
+async function runSoftwareAgentCli(goalParts, opts, forcedSessionId) {
+    const body = {
+        goal: goalParts.join(" "),
+        roleScope: opts.roleScope,
+        memoryScope: opts.memoryScope,
+        riskLevel: opts.risk,
+    };
+    if (opts.workdir)
+        body.workdir = opts.workdir;
+    if (opts.allowOutsideWorkdir)
+        body.allowOutsideWorkdir = true;
+    if (opts.memorySummary)
+        body.memorySummary = opts.memorySummary;
+    const workContextBudget = parsePositiveIntCliOption(opts.workContextBudget, "--work-context-budget");
+    if (opts.workContext || workContextBudget !== undefined)
+        body.includeWorkMemoryContext = true;
+    if (workContextBudget !== undefined)
+        body.workMemoryContextBudget = workContextBudget;
+    const sessionId = forcedSessionId || opts.session;
+    if (sessionId)
+        body.contextSessionId = sessionId;
+    if (opts.deliverable)
+        body.deliverable = opts.deliverable;
+    if (opts.timeoutMs) {
+        const timeoutMs = Number(opts.timeoutMs);
+        if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) {
+            console.error("--timeout-ms must be a positive integer");
+            process.exit(1);
+        }
+        body.timeoutMs = timeoutMs;
+    }
+    if (opts.stream !== false) {
+        await streamLocalOwnerEndpoint("/self/software-agent/run-stream", opts, body);
+        return;
+    }
+    const res = await fetchLocalOwnerEndpoint("/self/software-agent/run", opts, {
+        method: "POST",
+        body: JSON.stringify(body),
+    });
+    const text = await res.text();
+    let data;
     try {
-        event = JSON.parse(trimmed);
+        data = text ? JSON.parse(text) : {};
     }
     catch {
-        process.stderr.write(`${trimmed}\n`);
-        return true;
-    }
-    if (event.type === "start" && event.taskId) {
-        process.stderr.write(`[software-agent] started ${event.taskId}\n`);
-        return false;
-    }
-    if (event.type === "stdout" && typeof event.chunk === "string") {
-        process.stdout.write(event.chunk);
-        return false;
-    }
-    if (event.type === "stderr" && typeof event.chunk === "string") {
-        process.stderr.write(event.chunk);
-        return false;
-    }
-    if (event.type === "end") {
-        const result = event.result;
-        if (result?.success === false && result.error) {
-            process.stderr.write(`${result.error}\n`);
-            return true;
-        }
-        return false;
+        data = { output: text };
     }
-    if (event.type === "error") {
-        process.stderr.write(`${event.error || "Software-agent stream failed"}\n`);
-        return true;
+    if (!res.ok) {
+        console.error(data.error || text || `Request failed with HTTP ${res.status}`);
+        process.exit(1);
     }
-    return false;
+    const failed = renderSoftwareAgentRunResult(data);
+    if (failed)
+        process.exit(1);
 }
 program
     .name("akemon")
-    .description("Agent work marketplace — train your agent, let it work for others")
+    .description("Local AI companion runtime with memory, modules, relay sync, and software-agent control")
     .version(pkg.version);
 program
     .command("serve")
@@ -202,6 +287,8 @@ program
     .option("--without <modules>", "Disable specific modules (comma-separated: biostate,memory)")
     .option("--script <name>", "Script to load for ScriptModule (default: daily-life)", "daily-life")
     .option("--terminal", "Enable remote terminal access (PTY)")
+    .option("--software-agent-env <policy>", "Software-agent child environment policy: inherit or allowlist", process.env.AKEMON_SOFTWARE_AGENT_ENV_POLICY || "inherit")
+    .option("--software-agent-env-allow <vars>", "Comma-separated extra env vars for software-agent allowlist")
     .option("--relay <url>", "Relay WebSocket URL", RELAY_WS)
     .action(async (opts) => {
     const port = parseInt(opts.port);
@@ -237,6 +324,8 @@ program
         notifyUrl: opts.notify,
         enabledModules,
         scriptName: opts.script,
+        softwareAgentEnvPolicy: parseSoftwareAgentEnvPolicy(opts.softwareAgentEnv),
+        softwareAgentEnvAllowlist: parseCommaSeparatedCliOption(opts.softwareAgentEnvAllow),
     });
     console.log(`\nakemon v${pkg.version}`);
     if (!opts.public) {
@@ -303,44 +392,34 @@ program
     .option("--memory-scope <scope>", "Memory scope: none|public|task|owner", "owner")
     .option("--risk <level>", "Risk level: low|medium|high", "medium")
     .option("--memory-summary <text>", "Pre-filtered memory/context text to include")
+    .option("--work-context", "Embed a bounded work-memory context packet in the task envelope")
+    .option("--work-context-budget <chars>", "Maximum embedded work-memory context size; also enables --work-context")
+    .option("--session <id>", "Akemon-side context session id for explicit software-agent continuity")
     .option("--deliverable <text>", "Expected output shape")
     .option("--timeout-ms <ms>", "Task timeout in milliseconds")
     .option("--no-stream", "Disable local streaming and wait for the final response")
     .action(async (goalParts, opts) => {
-    const body = {
-        goal: goalParts.join(" "),
-        roleScope: opts.roleScope,
-        memoryScope: opts.memoryScope,
-        riskLevel: opts.risk,
-    };
-    if (opts.workdir)
-        body.workdir = opts.workdir;
-    if (opts.allowOutsideWorkdir)
-        body.allowOutsideWorkdir = true;
-    if (opts.memorySummary)
-        body.memorySummary = opts.memorySummary;
-    if (opts.deliverable)
-        body.deliverable = opts.deliverable;
-    if (opts.timeoutMs) {
-        const timeoutMs = Number(opts.timeoutMs);
-        if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) {
-            console.error("--timeout-ms must be a positive integer");
-            process.exit(1);
-        }
-        body.timeoutMs = timeoutMs;
-    }
-    if (opts.stream !== false) {
-        await streamLocalOwnerEndpoint("/self/software-agent/run-stream", opts, body);
-        return;
-    }
-    const data = await callLocalOwnerEndpoint("/self/software-agent/run", opts, {
-        method: "POST",
-        body: JSON.stringify(body),
-    });
-    if (data.output)
-        console.log(data.output);
-    else
-        console.log(JSON.stringify(data, null, 2));
+    await runSoftwareAgentCli(goalParts, opts);
+});
+program
+    .command("software-agent-continue")
+    .description("Continue an Akemon-side software-agent context session")
+    .argument("<sessionId>", "Akemon-side context session id to continue")
+    .argument("<goal...>", "Task goal to send to the software agent")
+    .option("-p, --port <port>", "Local akemon serve port", "3000")
+    .option("-w, --workdir <path>", "Workdir for the software agent (default: serve workdir)")
+    .option("--allow-outside-workdir", "Allow the software agent workdir to be outside the serve workdir")
+    .option("--role-scope <scope>", "Role scope: owner|public|order|agent|system", "owner")
+    .option("--memory-scope <scope>", "Memory scope: none|public|task|owner", "owner")
+    .option("--risk <level>", "Risk level: low|medium|high", "medium")
+    .option("--memory-summary <text>", "Pre-filtered memory/context text to include")
+    .option("--work-context", "Embed a bounded work-memory context packet in the task envelope")
+    .option("--work-context-budget <chars>", "Maximum embedded work-memory context size; also enables --work-context")
+    .option("--deliverable <text>", "Expected output shape")
+    .option("--timeout-ms <ms>", "Task timeout in milliseconds")
+    .option("--no-stream", "Disable local streaming and wait for the final response")
+    .action(async (sessionId, goalParts, opts) => {
+    await runSoftwareAgentCli(goalParts, opts, sessionId);
 });
 program
     .command("software-agent-status")
@@ -358,20 +437,78 @@ program
     .argument("[taskId]", "Task id to inspect")
     .option("-p, --port <port>", "Local akemon serve port", "3000")
     .option("-l, --limit <n>", "Maximum recent tasks to list", "20")
+    .option("--session <id>", "Filter listed tasks by Akemon-side context session id")
+    .option("--context", "Print the task's Akemon TASK_CONTEXT.md content when inspecting one task")
     .option("--json", "Print raw JSON")
     .action(async (taskId, opts) => {
+    if (!taskId && opts.context) {
+        console.error("--context requires a taskId");
+        process.exit(1);
+    }
+    if (taskId && opts.session) {
+        console.error("--session cannot be used when inspecting a single taskId");
+        process.exit(1);
+    }
     const path = taskId
-        ? `/self/software-agent/tasks/${encodeURIComponent(taskId)}`
-        : `/self/software-agent/tasks?limit=${clampPositiveInt(opts.limit, 20, 100)}`;
+        ? `/self/software-agent/tasks/${encodeURIComponent(taskId)}${opts.context ? "?includeContext=1" : ""}`
+        : `/self/software-agent/tasks?limit=${clampPositiveInt(opts.limit, 20, 100)}${opts.session ? `&session=${encodeURIComponent(opts.session)}` : ""}`;
     const data = await callLocalOwnerEndpoint(path, opts, {
         method: "GET",
     });
+    if (taskId && opts.context) {
+        const contextPacket = data.contextSession?.contextPacket;
+        if (typeof contextPacket === "string" && contextPacket.length > 0) {
+            process.stdout.write(contextPacket);
+            if (!contextPacket.endsWith("\n"))
+                process.stdout.write("\n");
+            return;
+        }
+        console.error("No TASK_CONTEXT.md content found for this task.");
+        process.exit(1);
+    }
     if (opts.json || taskId) {
         console.log(JSON.stringify(taskId ? data.task : data, null, 2));
         return;
     }
     printSoftwareAgentTaskList(Array.isArray(data.tasks) ? data.tasks : []);
 });
+program
+    .command("software-agent-sessions")
+    .description("List or inspect owner-only Akemon-side software-agent context sessions")
+    .argument("[sessionId]", "Context session id to inspect")
+    .option("-p, --port <port>", "Local akemon serve port", "3000")
+    .option("-l, --limit <n>", "Maximum recent sessions to list", "20")
+    .option("--context", "Print the session TASK_CONTEXT.md content")
+    .option("--json", "Print raw JSON")
+    .action(async (sessionId, opts) => {
+    const query = sessionId && opts.context ? "?includeContext=1" : "";
+    const path = sessionId
+        ? `/self/software-agent/sessions/${encodeURIComponent(sessionId)}${query}`
+        : `/self/software-agent/sessions?limit=${clampPositiveInt(opts.limit, 20, 100)}`;
+    const data = await callLocalOwnerEndpoint(path, opts, {
+        method: "GET",
+    });
+    if (sessionId) {
+        if (opts.context) {
+            const contextPacket = data.session?.contextPacket;
+            if (typeof contextPacket === "string" && contextPacket.length > 0) {
+                process.stdout.write(contextPacket);
+                if (!contextPacket.endsWith("\n"))
+                    process.stdout.write("\n");
+                return;
+            }
+            console.error("No TASK_CONTEXT.md content found for this session.");
+            process.exit(1);
+        }
+        console.log(JSON.stringify(data.session, null, 2));
+        return;
+    }
+    if (opts.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    printSoftwareAgentSessionList(Array.isArray(data.sessions) ? data.sessions : []);
+});
 program
     .command("software-agent-reset")
     .description("Reset the owner-only local software-agent peripheral session")
@@ -382,6 +519,109 @@ program
     });
     console.log(JSON.stringify(data, null, 2));
 });
+program
+    .command("privacy-filter")
+    .description("Sanitize text with built-in redaction and optional OpenAI Privacy Filter")
+    .argument("<text...>", "Text to sanitize")
+    .option("--mode <mode>", "Mode: fast, pii, or strict", "fast")
+    .option("--backend <backend>", "Backend: fast or opf")
+    .option("--command <command>", "OPF command (default: opf)")
+    .option("--device <device>", "OPF device, e.g. cpu or cuda")
+    .option("--checkpoint <path>", "OPF checkpoint directory")
+    .option("--timeout-ms <ms>", "OPF timeout in milliseconds")
+    .option("--max-input-chars <n>", "Maximum text length to pass to OPF")
+    .option("--json", "Print result metadata as JSON")
+    .action(async (textParts, opts) => {
+    try {
+        const result = await sanitizeText(textParts.join(" "), {
+            mode: parsePrivacyFilterMode(opts.mode),
+            backend: parsePrivacyFilterBackend(opts.backend),
+            command: opts.command,
+            device: opts.device,
+            checkpoint: opts.checkpoint,
+            timeoutMs: parsePositiveIntCliOption(opts.timeoutMs, "--timeout-ms"),
+            maxInputChars: parsePositiveIntCliOption(opts.maxInputChars, "--max-input-chars"),
+        });
+        if (opts.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(result.text);
+        for (const warning of result.warnings) {
+            console.error(`[privacy-filter] ${warning}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof PrivacyFilterUnavailableError || error instanceof TypeError) {
+            console.error(error.message);
+            process.exit(1);
+        }
+        throw error;
+    }
+});
+program
+    .command("work-context")
+    .description("Print a work-memory context packet for external software agents")
+    .option("-w, --workdir <path>", "Akemon workdir (default: cwd)")
+    .option("-n, --name <name>", "Agent name", "my-agent")
+    .option("--purpose <text>", "Purpose of this context packet", "external software-agent work context")
+    .option("--budget <chars>", "Maximum packet size in characters", "12000")
+    .option("--json", "Print raw JSON")
+    .action(async (opts) => {
+    try {
+        const packet = await buildWorkMemoryContext({
+            workdir: opts.workdir || process.cwd(),
+            agentName: opts.name,
+            purpose: opts.purpose,
+            budget: parsePositiveIntCliOption(opts.budget, "--budget"),
+        });
+        if (opts.json) {
+            console.log(JSON.stringify(packet, null, 2));
+            return;
+        }
+        process.stdout.write(packet.text);
+        if (!packet.text.endsWith("\n"))
+            process.stdout.write("\n");
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+program
+    .command("work-note")
+    .description("Append a note to Akemon work memory")
+    .argument("<text...>", "Durable work-memory note")
+    .option("-w, --workdir <path>", "Akemon workdir (default: cwd)")
+    .option("-n, --name <name>", "Agent name", "my-agent")
+    .option("--source <source>", "Note source, e.g. user, codex, or claude-code", "user")
+    .option("--session <id>", "External or Akemon-side session id")
+    .option("--kind <kind>", "Work-memory kind, e.g. note, decision, command, project", "note")
+    .option("--target <path>", "Optional target file under the work memory directory")
+    .option("--json", "Print raw JSON")
+    .action(async (textParts, opts) => {
+    try {
+        const result = await appendWorkMemoryNote({
+            workdir: opts.workdir || process.cwd(),
+            agentName: opts.name,
+            text: textParts.join(" "),
+            source: opts.source,
+            sessionId: opts.session,
+            kind: opts.kind,
+            target: opts.target,
+        });
+        if (opts.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`Work memory note appended: ${result.note.id}`);
+        console.log(`Path: ${result.path}`);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
 program
     .command("dashboard")
     .description("Open your agent dashboard in the browser")

package/dist/engine-peripheral.js

@@ -17,7 +17,7 @@ import { callAgent, sendTaskEnd, sendTaskStart, sendTaskStream } from "./relay-c
 import { SIG, sig } from "./types.js";
 import { updateMetrics, pushExecMs } from "./metrics.js";
 import { sendFailureEvent } from "./relay-client.js";
-import { resolveEngineConfig, } from "./engine-routing.js";
+import { resolveEngineRoute, } from "./engine-routing.js";
 export const LLM_ENGINES = new Set(["claude", "codex", "opencode", "gemini", "raw"]);
 const defaultTaskRelay = {
     sendTaskStart,
@@ -100,11 +100,12 @@ export class EnginePeripheral {
     // ---------------------------------------------------------------------------
     // Unified engine runner
     // ---------------------------------------------------------------------------
-    async runEngine(task, allowAll, extraAllowedTools, signal, origin, routing, taskId) {
-        const entry = resolveEngineConfig(routing, origin);
+    async runEngine(task, allowAll, extraAllowedTools, signal, origin, routing, taskId, routeRequest) {
+        const resolution = resolveEngineRoute(routing, { origin, ...routeRequest });
+        const entry = resolution.entry;
         const cfg = entry ? applyRoutingEntry(this.config, entry) : this.config;
         if (origin && entry) {
-            console.log(`[engine] using ${cfg.engine}${cfg.model ? `/${cfg.model}` : ""} (origin=${origin})`);
+            console.log(`[engine] using ${cfg.engine}${cfg.model ? `/${cfg.model}` : ""} (origin=${origin}, source=${resolution.source})`);
         }
         const t0 = Date.now();
         try {

package/dist/engine-routing.js

@@ -6,6 +6,15 @@
  *   deriveChildOrigin    — returns the origin a child/sub-task should carry
  *   downgradeForRetry    — downgrades any origin to "retry" when a task retries
  */
+export class EngineRegistry {
+    routing;
+    constructor(routing) {
+        this.routing = routing;
+    }
+    resolve(request = {}) {
+        return resolveEngineRoute(this.routing, request);
+    }
+}
 /**
  * Resolve which engine routing entry to use for a given origin.
  *
@@ -27,6 +36,34 @@ export function resolveEngineConfig(routing, origin) {
     }
     return routing.default ?? null;
 }
+export function resolveEngineRoute(routing, request = {}) {
+    if (!routing) {
+        return { entry: null, source: "none", reason: "no routing configured" };
+    }
+    const route = selectRoute(routing.routes, request);
+    if (route) {
+        return {
+            entry: stripRouteMetadata(route),
+            source: "route",
+            reason: "matched registry route",
+        };
+    }
+    if (request.origin && routing[request.origin]) {
+        return {
+            entry: routing[request.origin],
+            source: "origin",
+            reason: `matched legacy origin route ${request.origin}`,
+        };
+    }
+    if (routing.default) {
+        return {
+            entry: routing.default,
+            source: "default",
+            reason: "matched legacy default route",
+        };
+    }
+    return { entry: null, source: "none", reason: "no matching route" };
+}
 /**
  * Derive the origin that a child task should carry.
  *
@@ -50,3 +87,65 @@ export function deriveChildOrigin(_parentOrigin) {
 export function downgradeForRetry(_origin) {
     return "retry";
 }
+function selectRoute(routes, request) {
+    if (!routes?.length)
+        return null;
+    let best = null;
+    for (let index = 0; index < routes.length; index++) {
+        const route = routes[index];
+        if (!routeMatches(route, request))
+            continue;
+        const score = scoreRoute(route, request);
+        if (!best || score > best.score || (score === best.score && index < best.index)) {
+            best = { route, score, index };
+        }
+    }
+    return best?.route ?? null;
+}
+function routeMatches(route, request) {
+    if (request.origin && route.origins?.length && !route.origins.includes(request.origin))
+        return false;
+    if (!hasRequiredCapabilities(route.capabilities, request.requiredCapabilities))
+        return false;
+    if (request.privacy && route.privacy && route.privacy !== request.privacy)
+        return false;
+    if (request.maxCost && route.cost && tierRank(route.cost) > tierRank(request.maxCost))
+        return false;
+    if (request.maxLatency && route.latency && tierRank(route.latency) > tierRank(request.maxLatency))
+        return false;
+    return true;
+}
+function hasRequiredCapabilities(available, required) {
+    if (!required?.length)
+        return true;
+    if (!available?.length)
+        return false;
+    return required.every((capability) => available.includes(capability));
+}
+function scoreRoute(route, request) {
+    let score = route.priority ?? 0;
+    if (request.origin && route.origins?.includes(request.origin))
+        score += 100;
+    if (request.origin && !route.origins?.length)
+        score += 10;
+    if (request.requiredCapabilities?.length)
+        score += (route.capabilities?.length || 0) * 2;
+    if (request.privacy && route.privacy === request.privacy)
+        score += 20;
+    if (route.cost)
+        score += 6 - tierRank(route.cost);
+    if (route.latency)
+        score += 6 - tierRank(route.latency);
+    return score;
+}
+function stripRouteMetadata(route) {
+    const { origins: _origins, priority: _priority, ...entry } = route;
+    return entry;
+}
+function tierRank(tier) {
+    switch (tier) {
+        case "low": return 1;
+        case "medium": return 2;
+        case "high": return 3;
+    }
+}