@chibitek/chibi 0.1.155 → 0.1.158

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

@@ -0,0 +1,86 @@
+import { GOAL_HELP } from "../shared/personal-goal.js";
+import { PersonalGoals } from "./personal-goals.js";
+/** Serial continuation per goal; every provider turn still passes normal admission. */
+export class PersonalGoalRuntime {
+    goals;
+    running = new Set();
+    scheduled = new Map();
+    host;
+    constructor(path, host) {
+        this.host = host;
+        this.goals = new PersonalGoals(path, (goal) => host.changed(goal));
+    }
+    async command(botId, threadId, command, trigger) {
+        if (command.action === "help")
+            return GOAL_HELP;
+        if (this.goals.loadError)
+            return this.goals.loadError;
+        let goal = this.goals.get(threadId);
+        if (command.action === "status")
+            return goal ? this.describe(goal) : "This conversation has no goal. " + GOAL_HELP;
+        if (command.action === "start" || command.action === "resume") {
+            if (this.host.busy(botId, threadId) || (goal && this.running.has(goal.id)))
+                throw new Error("This conversation is still working. Wait for its turn to settle.");
+            goal = command.action === "start" ? this.goals.start(botId, threadId, { ...command, ...(trigger?.kind === "user" || trigger?.kind === "owner" ? { trigger } : {}) }) : this.goals.resume(threadId, command);
+            // Persist the human command before provider setup reads the conversation.
+            this.running.add(goal.id);
+            this.scheduled.set(goal.id, setImmediate(() => { this.scheduled.delete(goal.id); void this.run(goal); }));
+        }
+        else {
+            goal = this.goals.control(threadId, command.action);
+            const pending = this.scheduled.get(goal.id);
+            if (pending) {
+                clearImmediate(pending);
+                this.scheduled.delete(goal.id);
+                this.running.delete(goal.id);
+            }
+            if (this.running.has(goal.id))
+                await this.host.interrupt(botId, threadId, goal.id);
+        }
+        return this.describe(goal);
+    }
+    describe(goal) {
+        return `${goal.status}: ${goal.objective}\n${goal.detail}\nTurns: ${goal.turnCount}/${goal.maxTurns}. Tokens: ${goal.tokensUsed}${goal.tokenBudget === undefined ? "" : `/${goal.tokenBudget}`}.`;
+    }
+    steer(threadId) {
+        const goal = this.goals.get(threadId);
+        if (goal?.status === "working") {
+            goal.status = "paused";
+            goal.detail = "You sent a message. Use /goal resume when ready to continue.";
+            this.goals.touch(goal);
+        }
+    }
+    async run(goal) {
+        this.running.add(goal.id);
+        try {
+            while (this.goals.begin(goal.id)) {
+                const result = await this.host.run(goal);
+                this.goals.settle(goal.id, result);
+                // Give queued human input priority before reserving another turn.
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            }
+        }
+        catch {
+            if (goal.status === "working") {
+                goal.status = "paused";
+                goal.detail = "The next turn could not start. Check the conversation and use /goal resume.";
+                this.goals.touch(goal);
+            }
+        }
+        finally {
+            this.running.delete(goal.id);
+        }
+    }
+}
+export async function receiveGoalCommand(runtime, store, botId, threadId, command, text, sendId, sender, trigger) {
+    let result;
+    try {
+        result = await runtime.command(botId, threadId, command, trigger);
+    }
+    catch (error) {
+        throw Object.assign(error instanceof Error ? error : new Error(String(error)), { status: 409 });
+    }
+    const message = store.appendMessage(threadId, { role: "user", kind: "text", text, sendId, sender });
+    store.appendMessage(threadId, { role: "bot", kind: "text", text: result });
+    return { ok: true, threadId, message, goalSummary: result };
+}

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

@@ -0,0 +1,125 @@
+export function updatePersonalGoalReceipt(goal, store) {
+    if (!store.taskByThread(goal.botId, goal.threadId))
+        return;
+    const goalRun = { runId: goal.id, goal: goal.objective, status: goal.status,
+        coordinatorBotId: goal.botId, coordinatorName: store.bot(goal.botId)?.name ?? "Bot",
+        turnCount: goal.turnCount, maxTurns: goal.maxTurns, detail: `${goal.detail} Tokens: ${goal.tokensUsed}${goal.tokenBudget === undefined ? "" : `/${goal.tokenBudget}`}.`, startedAt: goal.createdAt };
+    if (goal.receiptMessageId)
+        store.patchMessage(goal.threadId, goal.receiptMessageId, { goalRun });
+    else
+        goal.receiptMessageId = store.appendMessage(goal.threadId, { role: "bot", kind: "goal.run", goalRun }).id;
+}
+export async function runPersonalGoalTurn(goal, host) {
+    const guard = { token: Symbol("personal-goal"), personalGoalId: goal.id, assistantItems: [], discard: false };
+    let ok = false, tools = 0, measured = false, completed = false;
+    let tokens;
+    const before = host.store.taskByThread(goal.botId, goal.threadId)?.usage;
+    const beforeTokens = (before?.input ?? 0) + (before?.output ?? 0);
+    host.addGuard(goal.threadId, guard);
+    const unsub = host.subscribe((event) => {
+        if (event.threadId !== goal.threadId || host.ignore(event))
+            return;
+        if (guard.turnId && event.turnId && guard.turnId !== event.turnId)
+            return;
+        if (event.type === "item.completed" && event.itemType === "tool")
+            tools++;
+        if (event.type === "thread.token-usage.updated")
+            measured = true;
+        if (event.type === "turn.completed") {
+            completed = true;
+            ok = event.ok;
+            measured ||= event.usage !== undefined;
+            const usage = host.store.taskByThread(goal.botId, goal.threadId)?.usage;
+            if (measured)
+                tokens = Math.max(0, (usage?.input ?? 0) + (usage?.output ?? 0) - beforeTokens);
+        }
+    });
+    try {
+        await new Promise((resolve, reject) => {
+            void host.start(goal.botId, goal.turnCount === 1 ? goal.objective : "Continue the active goal.", {
+                threadId: goal.threadId, cardContinuation: true, trigger: goal.trigger,
+                onTurnSettled: () => setImmediate(resolve), onDispatchError: reject,
+            }).catch(reject);
+        });
+        // The terminal event precedes digest/screen resource release. Never overlap those claims.
+        const deadline = Date.now() + 30_000;
+        while (host.busy(goal.botId, goal.threadId) && Date.now() < deadline)
+            await new Promise(resolve => setTimeout(resolve, 25));
+        if (host.busy(goal.botId, goal.threadId))
+            throw new Error("Turn is still settling");
+        return { ok, text: guard.assistantItems.join("\n"), tools, tokens };
+    }
+    finally {
+        unsub();
+        // Before a provider id exists, direct-turn admission owns late setup events.
+        // Keeping an unbound guard here would swallow an unrelated later turn.
+        if (completed || !guard.turnId)
+            host.removeGuard(goal.threadId, guard);
+        else {
+            guard.discard = true;
+            guard.cleanupTimer = setTimeout(() => host.removeGuard(goal.threadId, guard), 5 * 60_000);
+            guard.cleanupTimer.unref();
+        }
+    }
+}
+export function addGoalGuard(groupGoalCoordinatorTurns, threadId, turn) {
+    const turns = groupGoalCoordinatorTurns.get(threadId) ?? new Set();
+    turns.add(turn);
+    groupGoalCoordinatorTurns.set(threadId, turns);
+}
+export function removeGoalGuard(groupGoalCoordinatorTurns, threadId, turn) {
+    if (turn.cleanupTimer)
+        clearTimeout(turn.cleanupTimer);
+    const turns = groupGoalCoordinatorTurns.get(threadId);
+    turns?.delete(turn);
+    if (turns?.size === 0)
+        groupGoalCoordinatorTurns.delete(threadId);
+}
+export function hasUnboundGoalGuard(groupGoalCoordinatorTurns, threadId) {
+    return [...(groupGoalCoordinatorTurns.get(threadId) ?? [])]
+        .some((turn) => turn.discard && !turn.turnId);
+}
+/** Match private coordinator output to one provider turn, never merely to a
+ * reusable room thread. Most adapters emit turn.started before sendTurn
+ * resolves, so the first stable event may bind an otherwise pending guard. */
+export function goalGuardForEvent(groupGoalCoordinatorTurns, retireProviderTurn, event) {
+    const turns = groupGoalCoordinatorTurns.get(event.threadId);
+    if (!turns?.size)
+        return undefined;
+    const candidates = [...turns];
+    if (event.turnId) {
+        const exact = candidates.find((turn) => turn.turnId === event.turnId);
+        if (exact)
+            return exact;
+        // Until an interrupted handshake returns its own id, no new id can be
+        // attributed safely. The stall fallback keeps this thread unavailable in
+        // that narrow window; private text is suppressed below until sendTurn's
+        // result binds the old guard or its bounded expiry releases ownership.
+        const unboundDiscarded = candidates.filter((turn) => turn.discard && !turn.turnId);
+        if (unboundDiscarded.length > 0) {
+            // The ownership fallback below keeps a lone abandoned handshake's
+            // thread closed, so its first eventual id can safely bind here. More
+            // than one unbound candidate is genuinely ambiguous and stays gated.
+            if (candidates.length === 1) {
+                unboundDiscarded[0].turnId = event.turnId;
+                // This event is the first stable identity for an already-abandoned
+                // provider turn. Tombstone it immediately so this event and every
+                // later completion/request cannot settle a replacement on the same
+                // room thread.
+                retireProviderTurn(event.turnId);
+                return unboundDiscarded[0];
+            }
+            return undefined;
+        }
+        const pending = candidates.findLast((turn) => !turn.turnId && !turn.discard);
+        if (pending && !pending.turnId) {
+            pending.turnId = event.turnId;
+            return pending;
+        }
+        return undefined;
+    }
+    // Turn-scoped events normally carry an id. If an adapter omits it, fail
+    // closed for private text; with multiple overlapping guards there is no
+    // safe way to attribute a completion, so leave cleanup to the bounded timer.
+    return candidates.length === 1 ? candidates[0] : undefined;
+}

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/port-in-use.js

@@ -0,0 +1,21 @@
+import { connect } from "node:net";
+/** True when anything accepts TCP on 127.0.0.1:port, not just an Atomic server. */
+export function portInUse(port) {
+    return new Promise((done) => {
+        const socket = connect({ host: "127.0.0.1", port });
+        socket.setTimeout(1000);
+        socket.once("connect", () => { socket.destroy(); done(true); });
+        socket.once("timeout", () => { socket.destroy(); done(false); });
+        socket.once("error", () => done(false));
+    });
+}
+/** The server binds port and port + 1 (webhooks); report the first busy one. */
+export async function reportBusyPort(port, dataDirFlag) {
+    for (const candidate of [port, Number(process.env.OMB_WEBHOOK_PORT || port + 1)]) {
+        if (!(await portInUse(candidate)))
+            continue;
+        console.error(`Port ${candidate} is already in use by another app. Choose a free port, for example: chibi start --port ${port + 20}${dataDirFlag}`);
+        return true;
+    }
+    return false;
+}

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/session-fallback.js

@@ -0,0 +1,76 @@
+// Session fallback for company subscription bots (docs/chibitek/engine-tiers.md,
+// "Subscription bots: the one failover exception"). When no account of the
+// bot's own provider can take a turn, one conversation may run on the same
+// class from another provider's subscription for up to SESSION_FALLBACK_TURNS
+// turns. The bot's own default never changes; the next turn tries its own
+// provider first again.
+import { SESSION_FALLBACK_TURNS } from "../shared/subscription-bots.js";
+export { SESSION_FALLBACK_TURNS };
+// ponytail: in memory, so a restart gives a conversation its 50 turns again;
+// persist on the task record if that matters.
+const fallbacks = new Map();
+/** The thread's own provider took this turn: it leaves the fallback (its count stays). */
+export function leaveSessionFallback(threadId) {
+    const entry = fallbacks.get(threadId);
+    if (entry)
+        entry.active = false;
+}
+/** Enter (or stay on) the fallback for this thread. A new turn counts one;
+ * a failover within a turn already on it counts nothing. False once the
+ * conversation has used its turns. */
+export function enterSessionFallback(threadId, newTurn) {
+    const entry = fallbacks.get(threadId) ?? { turns: 0, active: false };
+    if (entry.active && !newTurn)
+        return true;
+    if (entry.turns >= SESSION_FALLBACK_TURNS) {
+        entry.active = false;
+        fallbacks.set(threadId, entry);
+        return false;
+    }
+    entry.turns += 1;
+    entry.active = true;
+    fallbacks.set(threadId, entry);
+    return true;
+}
+/** Turn start for a subscription bot: its own provider's engine (which
+ * leaves the fallback), else, on its stop, the fallback's, counted as a
+ * turn. No fallback keeps the stop; past the limit, `spent` of it. */
+export function ownOrFallback(threadId, own, fallback, isStop, spent) {
+    try {
+        const choice = own();
+        leaveSessionFallback(threadId);
+        return choice;
+    }
+    catch (stop) {
+        if (!isStop(stop))
+            throw stop;
+        let choice;
+        try {
+            choice = fallback();
+        }
+        catch {
+            choice = undefined;
+        }
+        if (choice === undefined)
+            throw stop;
+        if (!enterSessionFallback(threadId, true))
+            throw spent(stop);
+        return choice;
+    }
+}
+export function onSessionFallback(threadId) {
+    return fallbacks.get(threadId)?.active === true;
+}
+export function sessionFallbackTurns(threadId) {
+    return fallbacks.get(threadId)?.turns ?? 0;
+}
+/** The bot as a fallback turn runs it: an ordinary company bot, so the
+ * ladder and every gate read it without the provider lock. */
+export function withoutSubscription(bot) {
+    const { subscription: _subscription, ...rest } = bot;
+    return rest;
+}
+/** The line a company subscription bot stops with once its fallback turns are used. */
+export function sessionFallbackSpentLine(line) {
+    return `${line} This conversation already used its ${SESSION_FALLBACK_TURNS} turns on another provider; download a handoff or hand it to another bot.`;
+}

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/server/vault/routes.js

@@ -0,0 +1,43 @@
+import { PASS } from "../routes/table.js";
+import { VaultError } from "./store.js";
+/** The owner is supplied by the authenticated host, never from request JSON.
+ * Authorization runs on reads too, and is checked again after reading a body. */
+export function createVaultRoutes(deps) {
+    return async ({ req, res, path, method, auth, json, readBody }) => {
+        if (path !== "/api/vault" && !path.startsWith("/api/vault/"))
+            return PASS;
+        res.setHeader("cache-control", "no-store");
+        const ownerId = deps.owner(req, auth);
+        if (!ownerId)
+            return json(res, 403, { error: "Only the Vault owner can manage saved items." });
+        const store = deps.store();
+        if (!store)
+            return json(res, 503, { error: "Vault encryption is unavailable. Unlock the secure store and try again." });
+        const item = /^\/api\/vault\/([0-9a-f-]{36})$/.exec(path);
+        if (path !== "/api/vault" && !item)
+            return json(res, 404, { error: "Vault item is unavailable." });
+        if (!(path === "/api/vault" ? ["GET", "POST"] : ["PUT", "DELETE"]).includes(method))
+            return json(res, 405, { error: "Method not allowed." });
+        try {
+            if (method === "GET")
+                return json(res, 200, { items: store.list(ownerId) });
+            const body = method === "DELETE" ? undefined : await readBody(req).catch(() => null);
+            if (deps.owner(req, auth) !== ownerId || deps.store() !== store)
+                return json(res, 403, { error: "Vault access changed. Try again." });
+            if (method === "POST")
+                return json(res, 201, { item: store.create(ownerId, body) });
+            if (method === "PUT" && item)
+                return json(res, 200, { item: store.update(ownerId, item[1], body) });
+            if (method === "DELETE" && item) {
+                store.remove(ownerId, item[1]);
+                return json(res, 200, { removed: true });
+            }
+        }
+        catch (error) {
+            // No raw parser, filesystem, crypto or browser error crosses this route.
+            if (error instanceof VaultError)
+                return json(res, 400, { error: error.message });
+            return json(res, 503, { error: "Vault could not complete the request." });
+        }
+    };
+}

package/dist-server/server/vault/runtime.js

@@ -0,0 +1,48 @@
+import { timingSafeEqual } from "node:crypto";
+import { z } from "zod";
+import { VaultStore } from "./store.js";
+import { join } from "node:path";
+import { ROUTES } from "../routes/table.js";
+import { createVaultRoutes } from "./routes.js";
+const keyMessage = z.object({ type: z.literal("atomic:native-vault-key"), ownerId: z.string().uuid(), key: z.string().regex(/^[0-9a-f]{64}$/) }).strict();
+/** Constructed by the server, bootstrapped only on Electron's private port.
+ * No HTTP endpoint can unlock the vault or replace its owner. */
+export class NativeVaultRuntime {
+    #directory;
+    #store = null;
+    #ownerId = null;
+    constructor(directory) { this.#directory = directory; }
+    receive(raw) {
+        if (!raw || typeof raw !== "object" || !("type" in raw) || raw.type !== "atomic:native-vault-key")
+            return false;
+        const parsed = keyMessage.safeParse(raw);
+        if (!parsed.success || this.#store)
+            return true;
+        const key = Buffer.from(parsed.data.key, "hex");
+        try {
+            this.#store = new VaultStore(this.#directory, key);
+            this.#ownerId = parsed.data.ownerId;
+        }
+        finally {
+            key.fill(0);
+        }
+        return true;
+    }
+    store() { return this.#store; }
+    /** Until paired owner identity is established, remote clients fail closed.
+     * GET needs the desktop capability too; loopback alone is not authority. */
+    owner(req, auth, desktopToken) {
+        if (!desktopToken || auth.kind !== "loopback" || auth.trust === "service" || !auth.scopes.includes("admin"))
+            return null;
+        const supplied = req.headers["x-chibi-desktop-owner"];
+        if (typeof supplied !== "string" || !/^[A-Za-z0-9_-]{43}$/.test(supplied) || supplied.length !== desktopToken.length || !timingSafeEqual(Buffer.from(supplied), Buffer.from(desktopToken)))
+            return null;
+        return this.#ownerId ?? "pending";
+    }
+}
+/** Keep bootstrapping and route registration together, outside index.ts. */
+export function installNativeVault(dataDir, port, desktopToken, fromBot) {
+    const runtime = new NativeVaultRuntime(join(dataDir, "providers", "native-vault"));
+    port?.on("message", (event) => { runtime.receive(event?.data); });
+    ROUTES.push(createVaultRoutes({ store: () => runtime.store(), owner: (req, auth) => fromBot(req) ? null : runtime.owner(req, auth, desktopToken()) }));
+}