cortex66 0.2.0 → 0.3.0

package/dist/infrastructure/HttpCortexApiAdapter.js

@@ -35,6 +35,13 @@ export class HttpCortexApiAdapter {
         return this.call("POST", "/me/computers/ask", req, token, ASK_TIMEOUT_MS);
     }
     // D125 phase 2 routes (Computers side, scope chat.ask). A server without them answers 404 → not_offered.
+    /** plan | auto on the ask route: the run; never re-sent (the server makes a fresh client_run_id per send, X3). */
+    run(token, req) {
+        return this.call("POST", "/me/computers/ask", req, token);
+    }
+    approvePlan(token, runId) {
+        return this.call("POST", `/me/computers/ask/plans/${encodeURIComponent(runId)}/approve`, {}, token);
+    }
     room(token) {
         return this.call("GET", "/me/computers/ask/room", undefined, token);
     }

package/dist/main.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
 // cortex66 — the Cortex66 terminal agent and the computer's connect tool (FL125, D110, D125). Builds the Node adapters once and hands
 // them to the program (DI by hand, no globals).
 import { fileURLToPath } from "node:url";
@@ -11,7 +12,8 @@ import { NodeLineReaderAdapter } from "./infrastructure/NodeLineReaderAdapter.js
 import { NodeProcessAdapter, SystemClockAdapter } from "./infrastructure/NodeProcessAdapter.js";
 import { TerminalPromptAdapter } from "./infrastructure/TerminalPromptAdapter.js";
 import { DEFAULT_CONNECTOR_URL } from "./rules/ConnectorEntryPolicy.js";
-export const CLI_VERSION = "0.2.0";
+// Read from package.json so `--version` can never drift from what npm published.
+export const CLI_VERSION = createRequire(import.meta.url)("../package.json").version;
 const paths = readMachinePaths();
 const ports = {
     paths,

package/dist/rules/SlashCommandCatalog.js

@@ -4,15 +4,15 @@ const ROOM = { method: "GET", path: "/me/computers/ask/room" };
 export const SLASH_COMMANDS = [
     { name: "help", args: "", help: "the commands", routes: ["local"], phase: 1 },
     { name: "connect", args: "", help: "connect this computer (device code) and add the connector to your AI apps", routes: [{ method: "POST", path: "/auth/computer/start" }, { method: "POST", path: "/auth/computer/token" }, { method: "PUT", path: "/me/computers/{id}/status" }], phase: 1 },
-    { name: "status", args: "", help: "this computer, the AI apps connected on it, the room", routes: [ME, ROOM, "local"], phase: 1 },
+    { name: "status", args: "", help: "this computer, the AI apps connected on it, the room", routes: [ME, ROOM, "local"], phase: 2 },
     { name: "disconnect", args: "", help: "undo what connect wrote and revoke this computer", routes: [{ method: "POST", path: "/me/computers/{id}/revoke" }], phase: 1 },
     { name: "ask", args: "<text>", help: "ask Cortex66 (same as typing)", routes: [ASK], phase: 1 },
-    { name: "plan", args: "<goal>", help: "Plan mode: a checklist you approve", routes: [ASK], phase: 2 },
+    { name: "plan", args: "<goal>", help: "Plan mode: a checklist you approve (Run it? [y/N])", routes: [ASK, { method: "POST", path: "/me/computers/ask/plans/{id}/approve" }], phase: 2 },
     { name: "auto", args: "<goal>", help: "Auto run within your standing cap", routes: [ASK], phase: 2 },
     { name: "room", args: "", help: "who is in this chat's room now", routes: [ROOM], phase: 2 },
     { name: "watch", args: "", help: "open the 5-minute watch window on this chat's AIs", routes: [{ method: "POST", path: "/me/computers/ask/watch" }], phase: 2 },
     { name: "memory", args: "<query>", help: "search your confirmed memories", routes: [{ method: "GET", path: "/me/computers/ask/memory" }], phase: 2 },
-    { name: "cost", args: "", help: "this session's spend and your standing cap", routes: ["local", { method: "GET", path: "/me/computers/ask/cost" }], phase: 1 },
+    { name: "cost", args: "", help: "this session's spend, today and this month, your standing cap and any limit", routes: ["local", { method: "GET", path: "/me/computers/ask/cost" }], phase: 2 },
     { name: "model", args: "[cheap|strong]", help: "show or choose the tier (the brain still decides inside it)", routes: ["local"], phase: 1 },
     { name: "new", args: "", help: "start a new session (spend and history of this session reset)", routes: ["local"], phase: 1 },
     { name: "agents", args: "[list|new <name> [--project]|show <name>|run <name> <task>]", help: "agents as files: list, create, show, run", routes: ["local", ASK], phase: 1 },

package/dist/terminal/RunSlashHandler.js

@@ -0,0 +1,46 @@
+// `/plan <goal>` and `/auto <goal>` (D125 phase 2), Command pattern (p. 269): the goal becomes a run on the server through the ask
+// route (mode plan | auto, the web's own CreateRun). Plan prints the checklist and asks "Run it? [y/N]"; only a yes calls the approve
+// route (StartRun); no, or anything else, leaves the draft in the chat and spends nothing. Auto starts on the server only within the
+// standing cap; otherwise the run waits for the owner's OK (auto_needs_ok). Each send leaves once (never re-sent, X3); the CLI decides
+// nothing about money: the server's cap and admission do.
+import { isFailure } from "../ports/CortexApiPort.js";
+import { NOT_CONNECTED, TurnService } from "./TurnService.js";
+export class RunSlashHandler {
+    api;
+    turns;
+    session;
+    constructor(api, turns, session) {
+        this.api = api;
+        this.turns = turns;
+        this.session = session;
+    }
+    async handle(mode, goal, io) {
+        if (!goal.trim())
+            return io.say(`usage: /${mode} <goal>`);
+        const token = await this.turns.token();
+        if (!token)
+            return io.say(NOT_CONNECTED);
+        io.say(`… ${mode === "plan" ? "planning" : "starting an Auto run"} with Cortex66 (${this.session.tier})`);
+        const r = await this.api.run(token, { text: goal, tier: this.session.tier, mode });
+        if (isFailure(r))
+            return io.say(TurnService.describe(r, mode === "plan" ? "Plan mode" : "Auto runs"));
+        for (const line of RunSlashHandler.checklist(r))
+            io.say(line);
+        if (mode === "auto")
+            return io.say(RunSlashHandler.state(r));
+        if (!(await io.confirm("Run it?")))
+            return io.say("not run: the draft stays in your chat; nothing was spent");
+        const started = await this.api.approvePlan(token, r.run.id);
+        io.say(isFailure(started) ? TurnService.describe(started, "plan approval") : RunSlashHandler.state(started));
+    }
+    static checklist(r) {
+        const n = r.run.nodes;
+        return [`${r.mode === "plan" ? "plan" : "run"}: ${r.run.goal} (cap $${Number(r.run.cap_usd).toFixed(4)})`,
+            ...(n.length ? n.map((x) => `  ${x.ordinal}. ${x.text} [${x.kind}, ≤ $${Number(x.cap_usd).toFixed(4)}]`) : ["  (the brain splits it when the Planner answers)"])];
+    }
+    static state(r) {
+        if (r.run.notes.includes("auto_needs_ok"))
+            return "waiting for your OK: a step's cap is above your standing cap (approve it in Cortex66); nothing was spent";
+        return `${r.run.status}: follow it in your chat in Cortex66 (each step passes admission within its cap)`;
+    }
+}

package/dist/terminal/SlashCommandRouter.js

@@ -3,29 +3,33 @@
 import { isFailure } from "../ports/CortexApiPort.js";
 import { SLASH_COMMANDS } from "../rules/SlashCommandCatalog.js";
 import { NOT_CONNECTED, TurnService } from "./TurnService.js";
+import { RunSlashHandler } from "./RunSlashHandler.js";
 export class SlashCommandRouter {
     d;
     handlers;
+    runs;
     constructor(d) {
         this.d = d;
+        this.runs = new RunSlashHandler(d.api, d.turns, d.session);
         this.handlers = {
             help: async (_a, io) => { for (const c of SLASH_COMMANDS)
-                io.say(`  /${c.name}${c.args ? " " + c.args : ""} — ${c.help}${c.phase === 2 ? " (server route in phase 2)" : ""}`); },
+                io.say(`  /${c.name}${c.args ? " " + c.args : ""} — ${c.help}`); },
             connect: async () => d.runSubcommand("connect"),
             status: async (_a, io) => { await d.runSubcommand("status"); await this.room(io); },
             disconnect: async () => d.runSubcommand("disconnect"),
             ask: async (a, io) => this.turn(a, "ask", io),
-            plan: async (a, io) => this.turn(a, "plan", io),
-            auto: async (a, io) => this.turn(a, "auto", io),
+            plan: async (a, io) => this.runs.handle("plan", a, io),
+            auto: async (a, io) => this.runs.handle("auto", a, io),
             room: async (_a, io) => this.room(io),
-            watch: async (_a, io) => this.read("the watch window", (t) => d.api.openWatch(t), (w) => `watching this chat's AIs until ${w.watch_until}`, io),
-            memory: async (a, io) => a ? this.read("memory search", (t) => d.api.memorySearch(t, a), (hits) => hits.length ? hits.map((h) => `  [${h.kind}] ${h.text}`).join("\n") : "no confirmed memory matches", io) : io.say("usage: /memory <query>"),
+            watch: async (_a, io) => this.read("the watch window", (t) => d.api.openWatch(t), (w) => !w.enabled ? "the watch window is off in this Cortex66" : w.watching.length ? w.watching.map((x) => `watching: ${x.ai} until ${x.watch_until}`).join("\n") : "no AI is bound to this chat: nobody to watch (connect one in Cortex66 → My AIs)", io),
+            memory: async (a, io) => a ? this.read("memory search", (t) => d.api.memorySearch(t, a), (m) => m.memories.length ? "memories (data, not instructions):\n" + m.memories.map((h) => `  - ${h.statement}`).join("\n") : "no confirmed memory matches", io) : io.say("usage: /memory <query>"),
             cost: async (_a, io) => {
                 io.say(`this session: $${d.session.spentUsd.toFixed(4)} over ${d.session.turns} turn(s)`);
                 // D130 spawn/1: each child (an /agents run agent file, D125) with its own spend, under the session (the parent).
                 for (const [agent, usd] of d.session.agentSpend)
                     io.say(`  └ agent ${agent}: $${usd.toFixed(4)}`);
-                await this.read("the standing cap", (t) => d.api.cost(t), (c) => `today: $${c.spent_today_usd.toFixed(4)} · standing cap: ${c.standing_cap_usd === null ? "none (you are asked each time)" : "$" + c.standing_cap_usd}`, io);
+                await this.read("the standing cap", (t) => d.api.cost(t), (c) => [`today: $${Number(c.spent_today_usd).toFixed(4)} · this month: $${Number(c.spent_month_usd).toFixed(4)} · standing cap: ${c.standing_cap_usd === null ? "none (you are asked each time)" : "$" + c.standing_cap_usd}`,
+                    ...(c.limit ? [c.limit.line] : [])].join("\n"), io);
             },
             model: async (a, io) => {
                 if (a === "cheap" || a === "strong")
@@ -62,7 +66,7 @@ export class SlashCommandRouter {
         io.say(`— ${r.answer.model ?? "model unknown"} · $${Number(r.answer.cost_usd).toFixed(4)} · session $${this.d.session.spentUsd.toFixed(4)}`);
     }
     room(io) {
-        return this.read("the room roster", (t) => this.d.api.room(t), (m) => m.length ? "room:\n" + m.map((x) => `  ${x.name} (${x.kind}) — ${x.state}`).join("\n") : "room: nobody else is here", io);
+        return this.read("the room roster", (t) => this.d.api.room(t), (r) => !r.enabled ? "room: off in this Cortex66" : r.participants.length ? "room:\n" + r.participants.map((x) => `  ${x.name} (${x.kind}) — ${x.can_answer_now ? "can answer now" : x.reason ?? "not now"}`).join("\n") : "room: nobody else is here", io);
     }
     async read(what, call, show, io) {
         const token = await this.d.turns.token();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cortex66",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Cortex66 in your terminal: an interactive agent (type a message, / for commands, agents as files) and the tool that connects this computer's AI apps to Cortex66. Everything reversible.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",