@chibitek/chibi 0.1.155 → 0.1.157

package/dist-server/server/personal-goals.js

@@ -0,0 +1,195 @@
+import { redactSecretsInText } from "./redact.js";
+import { existsSync, readFileSync } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { z } from "zod";
+import { writeFileAtomic } from "./atomic.js";
+import { parseGroupGoalDecision } from "./group-goal-run.js";
+const goalSchema = z.object({
+    id: z.string(), botId: z.string(), threadId: z.string(), objective: z.string(),
+    criteria: z.array(z.string()), maxTurns: z.number().int().positive().max(1000),
+    tokenBudget: z.number().int().positive().optional(), tokensUsed: z.number().nonnegative(),
+    turnCount: z.number().int().nonnegative(),
+    status: z.enum(["working", "paused", "completed", "needs-input", "blocked", "limit-reached", "stopped", "failed"]),
+    detail: z.string(), createdAt: z.number(), updatedAt: z.number(),
+    trigger: z.union([z.object({ kind: z.literal("owner") }), z.object({ kind: z.literal("user"), email: z.string().optional(), label: z.string().optional() })]).optional(),
+    receiptMessageId: z.string().optional(), missing: z.number(), noProgress: z.number(),
+    repeated: z.number(), lastReply: z.string(), lastBlocker: z.string(), blockers: z.number(),
+});
+const terminal = (goal) => goal.status === "completed" || goal.status === "stopped";
+/** A single durable objective per conversation. No provider, timer or authority lives here. */
+export class PersonalGoals {
+    records;
+    loadError;
+    path;
+    changed;
+    constructor(path, changed = () => { }) {
+        this.path = path;
+        this.changed = changed;
+        this.records = [];
+        try {
+            this.records = existsSync(path) ? z.array(goalSchema).parse(JSON.parse(readFileSync(path, "utf8"))) : [];
+        }
+        catch {
+            this.loadError = "Saved goal state could not be read. It has been preserved for recovery; goals are paused.";
+        }
+        for (const goal of this.records)
+            if (goal.status === "working") {
+                goal.status = "paused";
+                goal.detail = "Atomic restarted. Use /goal resume to continue.";
+                goal.updatedAt = Date.now();
+            }
+        if (this.records.length) {
+            this.save();
+            this.records.forEach(this.changed);
+        }
+    }
+    save() { writeFileAtomic(this.path, JSON.stringify(this.records), { mode: 0o600 }); }
+    touch(goal) { goal.updatedAt = Date.now(); goal.detail = redactSecretsInText(goal.detail); this.changed(goal); this.save(); }
+    get(threadId) { return this.records.findLast((goal) => goal.threadId === threadId); }
+    byId(id) { return this.records.find((goal) => goal.id === id); }
+    start(botId, threadId, input) {
+        if (this.loadError)
+            throw new Error(this.loadError);
+        const previous = this.get(threadId);
+        if (previous && !terminal(previous))
+            throw new Error("This conversation already has a goal. Resume it or stop it first.");
+        const goal = goalSchema.parse({ ...input, objective: redactSecretsInText(input.objective), criteria: input.criteria.map(redactSecretsInText), id: randomUUID(), botId, threadId,
+            tokensUsed: 0, turnCount: 0, status: "working", detail: "Starting goal.",
+            createdAt: Date.now(), updatedAt: Date.now(), missing: 0, noProgress: 0, repeated: 0, lastReply: "", lastBlocker: "", blockers: 0 });
+        this.records.push(goal);
+        this.touch(goal);
+        return goal;
+    }
+    control(threadId, action) {
+        const goal = this.get(threadId);
+        if (!goal)
+            throw new Error("This conversation has no goal.");
+        if (!terminal(goal)) {
+            goal.status = action === "pause" ? "paused" : "stopped";
+            goal.detail = action === "pause" ? "Paused by you." : "Stopped by you.";
+            this.touch(goal);
+        }
+        return goal;
+    }
+    resume(threadId, budgets = {}) {
+        const goal = this.get(threadId);
+        if (!goal || terminal(goal))
+            throw new Error("There is no unfinished goal to resume.");
+        if (goal.status === "working")
+            throw new Error("This goal is already working.");
+        const maxTurns = budgets.maxTurns ?? goal.maxTurns;
+        const tokenBudget = budgets.tokenBudget ?? goal.tokenBudget;
+        if (goal.turnCount >= maxTurns || (tokenBudget !== undefined && goal.tokensUsed >= tokenBudget)) {
+            throw new Error("The goal has reached its budget. Resume with a higher --turns or --tokens total.");
+        }
+        goal.maxTurns = maxTurns;
+        goal.tokenBudget = tokenBudget;
+        goal.status = "working";
+        goal.detail = "Resuming. Inspect current state before continuing.";
+        goal.missing = goal.noProgress = goal.repeated = goal.blockers = 0;
+        goal.lastReply = goal.lastBlocker = "";
+        this.touch(goal);
+        return goal;
+    }
+    begin(id) {
+        const goal = this.byId(id);
+        if (!goal || goal.status !== "working")
+            return false;
+        if (goal.turnCount >= goal.maxTurns || (goal.tokenBudget !== undefined && goal.tokensUsed >= goal.tokenBudget)) {
+            goal.status = "limit-reached";
+            goal.detail = "Goal budget reached.";
+            this.touch(goal);
+            return false;
+        }
+        goal.turnCount++;
+        this.touch(goal);
+        return true;
+    }
+    settle(id, result) {
+        const goal = this.byId(id);
+        if (!goal)
+            return;
+        if (result.tokens !== undefined && Number.isFinite(result.tokens))
+            goal.tokensUsed += Math.max(0, result.tokens);
+        if (goal.status !== "working") {
+            this.touch(goal);
+            return;
+        }
+        const parsed = parseGroupGoalDecision(result.text);
+        const decision = parsed.decision;
+        const reply = createHash("sha256").update(parsed.visibleText.trim()).digest("hex");
+        if (decision?.status !== "blocked") {
+            goal.blockers = 0;
+            goal.lastBlocker = "";
+        }
+        goal.repeated = reply && reply === goal.lastReply ? goal.repeated + 1 : 1;
+        goal.lastReply = reply;
+        goal.noProgress = result.tools ? 0 : goal.noProgress + 1;
+        goal.missing = decision ? 0 : goal.missing + 1;
+        if (!result.ok) {
+            goal.status = "paused";
+            goal.detail = "The turn did not finish successfully. Resume when ready.";
+        }
+        else if (goal.tokenBudget !== undefined && result.tokens === undefined) {
+            goal.status = "paused";
+            goal.detail = "The engine did not report token usage. The token budget cannot be verified.";
+        }
+        else if (decision?.status === "completed") {
+            // Evidence is reported by the worker, never presented as an independent verification.
+            const close = result.text.lastIndexOf("</openmaus-goal>");
+            const open = result.text.lastIndexOf("<openmaus-goal>", close);
+            const payload = open < 0 ? "{}" : result.text.slice(open + "<openmaus-goal>".length, close);
+            let evidence;
+            try {
+                evidence = JSON.parse(payload ?? "{}").evidence;
+            }
+            catch { /* malformed evidence cannot complete */ }
+            if (goal.criteria.length && (!Array.isArray(evidence) || evidence.length !== goal.criteria.length || evidence.some((item) => typeof item !== "string" || !item.trim()))) {
+                goal.detail = "Completion needs evidence for every criterion. Verify the remaining criteria.";
+            }
+            else {
+                goal.status = "completed";
+                goal.detail = decision.detail;
+            }
+        }
+        else if (decision?.status === "needs-input") {
+            goal.status = "needs-input";
+            goal.detail = decision.detail;
+        }
+        else if (decision?.status === "blocked") {
+            const blocker = createHash("sha256").update(decision.detail.trim().toLowerCase()).digest("hex");
+            goal.blockers = blocker === goal.lastBlocker ? goal.blockers + 1 : 1;
+            goal.lastBlocker = blocker;
+            goal.detail = goal.blockers >= 3 ? decision.detail : `Try an alternative and verify the blocker: ${decision.detail}`;
+            if (goal.blockers >= 3)
+                goal.status = "blocked";
+        }
+        else {
+            goal.detail = decision?.detail ?? "Continue the objective and report a valid goal status.";
+        }
+        if (goal.status === "working") {
+            if (goal.turnCount >= goal.maxTurns || (goal.tokenBudget !== undefined && goal.tokensUsed >= goal.tokenBudget)) {
+                goal.status = "limit-reached";
+                goal.detail = "Goal budget reached. Resume with a higher total to continue.";
+            }
+            else if (goal.missing >= 3 || goal.noProgress >= 3 || goal.repeated >= 3) {
+                goal.status = "paused";
+                goal.detail = "No measurable progress across three turns. Resume with more direction.";
+            }
+        }
+        this.touch(goal);
+    }
+}
+export function personalGoalInstructions(goal) {
+    return [
+        "You are pursuing this conversation's durable goal. Complete authorized work; ordinary turn completion does not end the goal.",
+        `Objective: ${goal.objective}`,
+        `Completion criteria: ${JSON.stringify(goal.criteria)}. Supply one non-empty evidence string per criterion when completed.`,
+        `Turn ${goal.turnCount}/${goal.maxTurns}. Tokens used: ${goal.tokensUsed}; budget: ${goal.tokenBudget ?? "not set"}.`,
+        `Progress: ${goal.detail}`,
+        "Existing permissions and approval requirements still apply. Never claim completion from intent alone. Ask for required human input using needs-input.",
+        'End with a private envelope: <openmaus-goal>{"status":"continue","next":"self","instruction":"next concrete step","detail":"progress"}</openmaus-goal>',
+        'Or status completed, needs-input or blocked with detail and no next/instruction. For completed include "evidence":["verification for criterion 1", ...].',
+        "Write useful visible results before the envelope. Never show or explain the envelope. On resume inspect current state before acting.",
+    ].join("\n");
+}

package/dist-server/server/routes/local-models.js

@@ -9,6 +9,7 @@ import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { delimiter, join } from "node:path";
 import { isOllamaCloudModel, validLocalModelTag } from "../../shared/local-models.js";
+import { ollamaBinaryHere } from "../app-installers.js";
 import { PASS } from "./table.js";
 export const OLLAMA_LOCAL_URL = "http://127.0.0.1:11434";
 export const OLLAMA_DOWNLOAD_URL = "https://ollama.com/download";
@@ -77,9 +78,9 @@ export function installedModelsFromTags(payload, bots, engines) {
     }
     return out.sort((a, b) => a.name.localeCompare(b.name));
 }
-/** The Ollama app, or the `ollama` command on PATH. */
+/** The Ollama app, Atomic's own install of it, or the `ollama` command on PATH. */
 export function ollamaInstalledHere(env = process.env) {
-    const apps = process.platform === "darwin" ? ["/Applications/Ollama.app", join(homedir(), "Applications", "Ollama.app")] : [];
+    const apps = process.platform === "darwin" ? ["/Applications/Ollama.app", join(homedir(), "Applications", "Ollama.app")] : [ollamaBinaryHere()].filter((path) => Boolean(path));
     if (apps.some((path) => existsSync(path)))
         return true;
     const names = process.platform === "win32" ? ["ollama.exe"] : ["ollama"];

package/dist-server/server/skill-fetch.js

@@ -11,6 +11,20 @@ import { z } from "zod";
 const MAX_FILES = 30;
 const MAX_FILE_BYTES = 256 * 1024;
 const API = "https://api.github.com";
+// Upload bytes, never a client-supplied path on the server's filesystem.
+export const skillImportSchema = z.union([
+    z.object({ source: z.string().min(1).max(2000) }).strict(),
+    z.object({ file: z.object({
+            name: z.string().min(1).max(255).regex(/^[^/\\]+\.md$/i, "Choose a Markdown (.md) skill file")
+                .refine(name => [...name].every(char => char.charCodeAt(0) >= 32 && char.charCodeAt(0) !== 127), "Invalid filename"),
+            text: z.string().min(1).refine(text => Buffer.byteLength(text, "utf8") <= MAX_FILE_BYTES, "Skill exceeds 256 KiB"),
+        }).strict() }).strict(),
+]);
+export async function resolveSkillImport(input) {
+    if ("source" in input)
+        return fetchSkillFromSource(input.source);
+    return { skills: [{ source: `file:${input.file.name}`, files: [{ path: "SKILL.md", content: input.file.text }] }] };
+}
 class ImportLimitError extends Error {
 }
 // One budget for the entire import, including directory discovery. Read the

package/dist-server/shared/engine-choices.js

@@ -295,6 +295,21 @@ export function choiceFor(choices, engine, instanceId, model) {
     }
     return mine.find((choice) => !choice.host) ?? mine[0];
 }
+/** Back to "any account of this provider": the rung names the driver again
+ * (a ladder rung may name a driver kind), keeping the rung's model when the
+ * driver still offers it. When that exact route is already on the ladder,
+ * the driver's first model no rung uses takes its place; undefined when no
+ * free route is left, which leaves the rung unchanged. */
+export function anyAccountEntry(entry, engine, others) {
+    if (!engine)
+        return undefined;
+    const used = (model) => others.some((other) => other.engine === engine.driverKind && other.model === model);
+    const keep = entry.model && engine.models.some((model) => model.id === entry.model) ? entry.model : undefined;
+    if (!used(keep))
+        return keep ? { engine: engine.driverKind, model: keep } : { engine: engine.driverKind };
+    const alternate = engine.models.map((model) => model.id).find((id) => !used(id));
+    return alternate ? { engine: engine.driverKind, model: alternate } : undefined;
+}
 /** Providers with accounts the person should name: brand and how many accounts it has. */
 export function accountsToName(choices) {
     const out = new Map();

package/dist-server/shared/engine-tiers.js

@@ -29,6 +29,77 @@ export function toModelClass(value) {
 /** The class one below, or undefined for Añejo. */
 export const classBelow = (modelClass) => MODEL_CLASSES[MODEL_CLASSES.indexOf(modelClass) + 1];
 export const DEFAULT_CLASS_BANDS = { Mezcal: 50, Plata: 44, Reposado: 38 };
+/** Hand-written ladders, used only when no model has a class yet (the
+ * server always has the bundled baseline, so in practice the generated
+ * ladders below apply). Pay-per-token engines need no rung: they form the
+ * automatic last band of every ladder (resolveLadder).
+ *
+ * Erick's own ladders (2026-10-25), each per-install instance id
+ * ("claude-<uuid>") reduced to its driver kind so a fresh install matches
+ * whatever account it has (matchesEngine); the exact engine+model
+ * duplicates that collapse created are dropped. */
+export const DEFAULT_LADDERS = {
+    orchestrator: [
+        { engine: "claudeAgent", model: "claude-opus-5-5", modelClass: "Plata" },
+        { engine: "codex", model: "gpt-6-sol" },
+        { engine: "opencodeGo", model: "opencode-go/gemini-4-argon" },
+        { engine: "hermes", model: "nous:x-ai/grok-4.6" },
+        { engine: "ollamaCloud", model: "glm-5.3" },
+        { engine: "museCode", model: "muse-spark-1.2" },
+        { engine: "hermesAgent", model: "openai-codex:gpt-6-sol", modelClass: "Plata" },
+        { engine: "antigravity", model: "gemini-3.8-flash-medium" },
+        { engine: "cursorAgent", model: "auto" },
+        { engine: "hermesAgent", model: "huggingface:deepseek-ai/DeepSeek-R1-0528", modelClass: "Plata" },
+        { engine: "hermesAgent", model: "opencode-go:deepseek-v4-flash", modelClass: "Plata" },
+        { engine: "hermesAgent", model: "deepinfra:anthropic/claude-opus-5", modelClass: "Plata" },
+        { engine: "hermesAgent", model: "nous:meta/muse-spark-1.3", modelClass: "Plata" },
+        { engine: "hermesAgent", model: "openrouter:openai/gpt-6-sol", modelClass: "Plata" },
+        { engine: "hermesAgent", model: "openai-codex:gpt-6.1-sol", modelClass: "Plata" },
+    ],
+    engineering: [
+        { engine: "codex", model: "gpt-6-astra", modelClass: "Mezcal" },
+        { engine: "claude", model: "claude-opus-5-5" },
+        { engine: "claudeAgent", model: "claude-opus-5-5" },
+        { engine: "opencodeGo", model: "opencode-go/gemini-4-argon" },
+        { engine: "ollamaCloud", model: "kimi-k3" },
+        { engine: "hermesAgent", model: "openai-codex:gpt-6-astra", modelClass: "Mezcal" },
+        { engine: "grok", model: "grok-4.7" },
+        { engine: "grokAgent", model: "grok-4.7" },
+        { engine: "kimi", model: "kimi-code/k3" },
+        { engine: "openai-compat", model: "qwen3.7-plus" },
+        { engine: "hermesAgent", model: "nous:anthropic/claude-opus-5.5" },
+        { engine: "hermesAgent", model: "opencode-zen:claude-fable-5-1", modelClass: "Mezcal" },
+        { engine: "cursorAgent", model: "auto" },
+    ],
+    research: [
+        { engine: "openai-compat", model: "MiniMax-M2.5" },
+        { engine: "vibe", model: "mistral-medium-3.5" },
+        { engine: "antigravityAgent", model: "gemini-3.8-flash-low" },
+        { engine: "cursorAgent", model: "auto" },
+        { engine: "hermesAgent", model: "openrouter:x-ai/grok-4.7", modelClass: "Plata" },
+        { engine: "hermesAgent", model: "custom:local-(localhost:11434):deepseek-v4-pro:cloud" },
+        { engine: "hermesAgent", model: "openrouter:meta/muse-spark-1.3", modelClass: "Plata" },
+        { engine: "hermesAgent", model: "opencode-zen:muse-spark-1.3", modelClass: "Plata" },
+        { engine: "claudeAgent", model: "claude-opus-5", modelClass: "Plata" },
+        { engine: "cursorAgent", model: "claude-opus-5-high", modelClass: "Plata" },
+        { engine: "opencodeGo", model: "opencode/claude-opus-5", modelClass: "Plata" },
+    ],
+    writing: [
+        { engine: "claudeAgent", model: "claude-sonnet-5-5" },
+        { engine: "claude", model: "claude-sonnet-5-5" },
+        { engine: "codex", model: "gpt-5.6-luna" },
+        { engine: "antigravity", model: "gemini-3.8-flash-high" },
+        { engine: "antigravityAgent", model: "gemini-3.8-flash-high" },
+        { engine: "hermes", model: "nous:moonshotai/kimi-k3" },
+    ],
+    routine: [
+        { engine: "antigravityAgent", model: "gemini-3.8-flash-low" },
+        { engine: "antigravity", model: "gemini-3.8-flash-low" },
+        { engine: "openai-compat", model: "MiniMax-M2.5" },
+        { engine: "cursor", model: "auto" },
+        { engine: "mistral", model: "mistral-medium", modelClass: "Añejo" },
+    ],
+};
 export function classForScore(score, bands = DEFAULT_CLASS_BANDS) {
     if (score >= bands.Mezcal)
         return "Mezcal";
@@ -45,9 +116,10 @@ export const DEFAULT_TIER_CLASSES = {
     // puts Claude's rungs first in its ladder.
     orchestrator: "Plata",
     engineering: "Mezcal",
-    research: "Plata",
+    // Research and Routine ask for the cheapest class (Erick, 2026-10-25).
+    research: "Añejo",
     writing: "Plata",
-    routine: "Reposado",
+    routine: "Añejo",
 };
 /** A person's class choice at an API boundary: a class, or null for
  * "Automatic (by tier)"; undefined when the value is neither. */

package/dist-server/shared/local-models.js

@@ -53,9 +53,7 @@ export const LIGHT_LOCAL_MODEL = "gemma4:e2b-it-qat";
 const SIXTEEN_GB = 15.5 * GB;
 const EIGHT_GB = 7.5 * GB;
 export function recommendLocalModel(machine) {
-    if (machine.platform !== "darwin")
-        return { kind: "none", reason: "notMac" };
-    if (machine.arch !== "arm64")
+    if (machine.platform === "darwin" && machine.arch !== "arm64")
         return { kind: "none", reason: "intel" };
     const model = (tag) => SUGGESTED_LOCAL_MODELS.find((entry) => entry.tag === tag);
     if (machine.memoryBytes >= SIXTEEN_GB)

package/dist-server/shared/personal-goal.js

@@ -0,0 +1,43 @@
+export function parseGoalCommand(text) {
+    const match = /^\/goal(?:\s+([\s\S]*))?$/i.exec(text.trim());
+    if (!match)
+        return null;
+    let rest = (match[1] ?? "").trim();
+    const action = /^(status|pause|resume|stop|help)(?:\s|$)/i.exec(rest);
+    if (action)
+        rest = rest.slice(action[0].length).trim();
+    let maxTurns;
+    let tokenBudget;
+    const criteria = [];
+    while (rest.startsWith("--")) {
+        const flag = /^--(turns|tokens|done)\s+(?:"([^"\n]+)"|'([^'\n]+)'|(\S+))(?:\s|$)/.exec(rest);
+        if (!flag)
+            throw new Error('Use --turns N, --tokens N, or --done "completion criterion" before the objective.');
+        const value = flag[2] ?? flag[3] ?? flag[4];
+        if (flag[1] === "done")
+            criteria.push(value);
+        else {
+            const number = Number(value);
+            if (!/^\d+$/.test(value) || !Number.isSafeInteger(number) || number < 1 || (flag[1] === "turns" && number > 1000)) {
+                throw new Error("Budgets must be positive whole numbers; the turn limit cannot exceed 1000.");
+            }
+            if (flag[1] === "turns")
+                maxTurns = number;
+            else
+                tokenBudget = number;
+        }
+        rest = rest.slice(flag[0].length).trim();
+    }
+    if (action) {
+        if (rest || criteria.length || (action[1].toLowerCase() !== "resume" && (maxTurns || tokenBudget))) {
+            throw new Error("Only /goal resume accepts --turns and --tokens; other controls take no arguments.");
+        }
+        return { action: action[1].toLowerCase(), maxTurns, tokenBudget };
+    }
+    if (!rest)
+        return { action: "help" };
+    if (rest.length > 20_000 || criteria.length > 20 || criteria.some((item) => item.length > 2000))
+        throw new Error("Goal or completion criteria are too long.");
+    return { action: "start", objective: rest, maxTurns: maxTurns ?? 20, tokenBudget, criteria };
+}
+export const GOAL_HELP = 'Start: /goal [--turns 20] [--tokens N] [--done "criterion"] objective\nControls: /goal status, /goal pause, /goal resume [--turns N] [--tokens N], /goal stop. Resume budgets are total ceilings, not additional allowances. Token limits are checked between turns; a running turn can exceed the limit.';