@illuminis/comprism 0.1.3 → 0.1.4

package/out/commands/report.d.ts

@@ -0,0 +1,39 @@
+export interface Bucket {
+    key: string;
+    calls: number;
+    inputTokens: number;
+    outputTokens: number;
+    costUsd: number;
+    unpriced: number;
+    /**
+     * The weakest provenance among the rows in this bucket, in words.
+     *
+     * Derived, never asserted. The report used to print "observed, first party"
+     * on every line regardless of what the rows actually said, which meant the
+     * desktop connector's inferred, unpriced turns were displayed as measured
+     * spend. A product whose whole claim is "you can see where this number came
+     * from" cannot print a provenance it did not read off the rows.
+     */
+    provenance: string;
+}
+export interface Report {
+    since: Date | null;
+    rows: number;
+    totalCostUsd: number;
+    unpricedCalls: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    byModel: Bucket[];
+    byTier: Bucket[];
+    bySurface: Bucket[];
+    sessions: number;
+    /** Calls at attempt_index > 0: work that had to be done twice. */
+    remediationCalls: number;
+    remediationCostUsd: number;
+    /** Repeat attempts the provider never priced. Counted, never summed as zero. */
+    remediationUnpriced: number;
+    firstTs: string | null;
+    lastTs: string | null;
+}
+export declare function parseSince(spec: string | undefined): Date | null;
+export declare function buildReport(since: Date | null): Report;

package/out/commands/report.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSince = parseSince;
+exports.buildReport = buildReport;
+/**
+ * Spend reporting, computed from the ledger and nothing else.
+ *
+ * Every figure below is a sum over rows that were written once and never edited,
+ * so `report` can be reconciled against the provider's own invoice line by line.
+ * That reconciliation is the acceptance test for this file, and it is also the
+ * first thing a finance team will ask for.
+ *
+ * Rows the provider never priced are counted on their own line rather than
+ * folded into the total. A total that quietly includes zeros for calls of
+ * unknown cost is exactly the kind of figure this product exists to replace.
+ */
+const store_1 = require("../lib/store");
+function parseSince(spec) {
+    if (!spec)
+        return null;
+    const m = /^(\d+)([dhw])$/.exec(spec.trim());
+    if (!m)
+        return null;
+    const n = Number(m[1]);
+    const unit = m[2];
+    const ms = unit === 'h' ? 3_600_000 : unit === 'w' ? 604_800_000 : 86_400_000;
+    return new Date(Date.now() - n * ms);
+}
+function bucketise(rows, keyOf) {
+    const map = new Map();
+    const derivations = new Map();
+    const provenances = new Map();
+    for (const r of rows) {
+        const key = keyOf(r);
+        const b = map.get(key) || {
+            key,
+            calls: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            costUsd: 0,
+            unpriced: 0,
+            provenance: '',
+        };
+        b.calls += 1;
+        b.inputTokens += r.input_tokens ?? 0;
+        b.outputTokens += r.output_tokens ?? 0;
+        if (r.cost_usd === null)
+            b.unpriced += 1;
+        else
+            b.costUsd += r.cost_usd;
+        map.set(key, b);
+        const seen = derivations.get(key) || new Set();
+        seen.add(r.meta?.derivation || 'observed');
+        derivations.set(key, seen);
+        const sources = provenances.get(key) || new Set();
+        sources.add(r.meta?.provenance || 'first_party');
+        provenances.set(key, sources);
+    }
+    for (const b of map.values()) {
+        b.provenance = describe(derivations.get(b.key) || new Set(), provenances.get(b.key) || new Set(), b.unpriced, b.calls);
+    }
+    return [...map.values()].sort((a, b) => b.costUsd - a.costUsd);
+}
+/**
+ * Say what a bucket's figures actually rest on.
+ *
+ * A displayed figure inherits the WEAKEST provenance among its inputs, so a
+ * bucket mixing observed and inferred rows is described as mixed, not as
+ * observed. And a bucket where nothing was priced says so in place of a cost,
+ * because "$0.00" and "we could not price this" are different facts that look
+ * identical on a screen.
+ */
+function describe(derivations, provenances, unpriced, calls) {
+    const source = provenances.has('imported')
+        ? provenances.size > 1
+            ? 'mixed source'
+            : 'imported'
+        : 'first party';
+    let strength;
+    if (derivations.size > 1)
+        strength = 'mixed';
+    else if (derivations.has('estimated'))
+        strength = 'estimated';
+    else if (derivations.has('inferred'))
+        strength = 'inferred';
+    else
+        strength = 'observed';
+    if (unpriced === calls && calls > 0)
+        return `${strength}, ${source}, none priced`;
+    if (unpriced > 0)
+        return `${strength}, ${source}, ${unpriced} unpriced`;
+    return `${strength}, ${source}`;
+}
+function buildReport(since) {
+    const all = (0, store_1.readRows)(store_1.LEDGER_FILE);
+    const rows = since ? all.filter((r) => new Date(r.ts) >= since) : all;
+    const remediation = rows.filter((r) => r.attempt_index > 0);
+    return {
+        since,
+        rows: rows.length,
+        totalCostUsd: rows.reduce((s, r) => s + (r.cost_usd ?? 0), 0),
+        unpricedCalls: rows.filter((r) => r.cost_usd === null).length,
+        totalInputTokens: rows.reduce((s, r) => s + (r.input_tokens ?? 0), 0),
+        totalOutputTokens: rows.reduce((s, r) => s + (r.output_tokens ?? 0), 0),
+        byModel: bucketise(rows, (r) => r.model_dispatched),
+        byTier: bucketise(rows, (r) => r.task_tier),
+        bySurface: bucketise(rows, (r) => r.source_system),
+        sessions: new Set(rows.map((r) => r.session_id)).size,
+        remediationCalls: remediation.length,
+        remediationCostUsd: remediation.reduce((s, r) => s + (r.cost_usd ?? 0), 0),
+        remediationUnpriced: remediation.filter((r) => r.cost_usd === null).length,
+        firstTs: rows[0]?.ts ?? null,
+        lastTs: rows[rows.length - 1]?.ts ?? null,
+    };
+}

package/out/commands/review.d.ts

@@ -0,0 +1,5 @@
+export declare function review(op: string, payload: Record<string, unknown>, cwd?: string): Promise<import("../lib/gateway").GatewayReply>;
+export declare function cmdChanges(args: string[]): Promise<number>;
+export declare function cmdDiff(args: string[]): Promise<number>;
+/** `confirmWith`: a session's own keyboard, so two readers never share it. */
+export declare function cmdRewind(args: string[], confirmWith?: (question: string) => Promise<boolean>): Promise<number>;

package/out/commands/review.js

@@ -0,0 +1,223 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.review = review;
+exports.cmdChanges = cmdChanges;
+exports.cmdDiff = cmdDiff;
+exports.cmdRewind = cmdRewind;
+/**
+ * `comprism changes`, `comprism diff` and `comprism rewind` (manual 7.1 to 7.4,
+ * 7.7).
+ *
+ * The service knows what the agent changed, from the job's own records and its
+ * checkpoints, and decides what putting a file back means: restore, delete or
+ * rename back, and what cannot be undone. This file prints its words, and does
+ * the physical part of a rewind: before writing each file it checks the file
+ * still holds what the agent left, and skips it otherwise unless `--force`.
+ */
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ui = __importStar(require("../lib/ui"));
+const gateway_1 = require("../lib/gateway");
+const project_1 = require("../lib/project");
+const project_2 = require("../lib/project");
+const out = (s = "") => process.stdout.write(`${s}\n`);
+const err = (s = "") => process.stderr.write(`${s}\n`);
+async function review(op, payload, cwd = process.cwd()) {
+    const project = (0, project_1.resolveProject)(cwd);
+    return (0, gateway_1.ask)({ intent: "review", prompt: "", op, payload: { ...(0, project_2.asWire)(project), ...payload } });
+}
+function refused(reply) {
+    if (!reply.ok)
+        return reply.message || "Your workspace could not be reached.";
+    if (reply.served === false)
+        return "Your workspace is running an older build that does not answer this yet.";
+    if (reply.granted === false)
+        return reply.message || "Refused.";
+    return null;
+}
+function words(args, valueFlags) {
+    return args.filter((a, i) => !a.startsWith("--") && !valueFlags.includes(String(args[i - 1])));
+}
+async function cmdChanges(args) {
+    const [job] = words(args, []);
+    const reply = await review("changes", { job: job ?? "" });
+    const why = refused(reply);
+    if (why) {
+        err(ui.fail(why));
+        return 1;
+    }
+    out();
+    for (const line of reply.lines ?? [])
+        out(`  ${line}`);
+    out();
+    return 0;
+}
+async function cmdDiff(args) {
+    const [first, second] = words(args, []);
+    // `diff calc.py` is a file of the latest job; `diff j_7c21 calc.py` names both.
+    const isJob = first && !second && !first.includes(".") && !first.includes("/") ? true : Boolean(second);
+    const reply = await review("diff", { job: isJob ? first : "", file: isJob ? (second ?? "") : (first ?? "") });
+    const why = refused(reply);
+    if (why) {
+        err(ui.fail(why));
+        return 1;
+    }
+    out();
+    for (const line of reply.lines ?? []) {
+        const shown = line.startsWith("+") && !line.startsWith("+++") ? ui.c.green(line)
+            : line.startsWith("-") && !line.startsWith("---") ? ui.c.red(line) : line;
+        out(`  ${shown}`);
+    }
+    out();
+    return 0;
+}
+function sha(file) {
+    try {
+        return { exists: true, sha: crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex") };
+    }
+    catch {
+        return { exists: false, sha: null };
+    }
+}
+function inside(root, rel) {
+    const base = fs.realpathSync(root);
+    const where = path.resolve(base, rel);
+    return where.startsWith(base + path.sep) ? where : null;
+}
+async function confirm(question) {
+    if (!process.stdin.isTTY)
+        return false;
+    const { ask: prompt, closePrompt } = await Promise.resolve().then(() => __importStar(require("../lib/prompt")));
+    const answer = await prompt(`  ${question} `);
+    closePrompt();
+    return /^y(es)?$/i.test(answer.trim());
+}
+/** `confirmWith`: a session's own keyboard, so two readers never share it. */
+async function cmdRewind(args, confirmWith) {
+    const force = args.includes("--force");
+    const yes = args.includes("--yes");
+    const stepAt = args.indexOf("--to-step");
+    const toStep = stepAt === -1 ? null : Number(args[stepAt + 1]);
+    if (stepAt !== -1 && (!Number.isInteger(toStep) || (toStep ?? -1) < 0)) {
+        err(ui.fail("--to-step takes a step number, for example --to-step 2."));
+        return 2;
+    }
+    const [job, file] = words(args, ["--to-step"]);
+    const project = (0, project_1.resolveProject)(process.cwd());
+    const reply = await review("rewind_plan", { job: job ?? "", to_step: toStep, file: file ?? "" });
+    const why = refused(reply);
+    if (why) {
+        err(ui.fail(why));
+        return 1;
+    }
+    const data = (reply.data ?? {});
+    const items = data.items ?? [];
+    out();
+    for (const line of reply.lines ?? [])
+        out(`  ${line}`);
+    if (!items.length) {
+        out();
+        return 0;
+    }
+    if (!yes && !(await (confirmWith ?? confirm)("Go ahead? [y/N]"))) {
+        out(ui.c.dim("  Nothing was changed."));
+        out();
+        return process.stdin.isTTY ? 0 : 4;
+    }
+    const results = [];
+    for (const item of items) {
+        const where = inside(project.root, item.path);
+        if (!where) {
+            results.push({ path: item.path, result: "outside this project, not restored" });
+            continue;
+        }
+        // Your later changes are never overwritten (7.4): the file must still be
+        // what the agent left, or it is skipped unless --force.
+        const now = sha(where);
+        const agentLeft = item.expected_exists === false ? { exists: false, sha: null }
+            : { exists: true, sha: item.expected_sha ?? null };
+        const same = now.exists === agentLeft.exists && (!now.exists || !agentLeft.sha || now.sha === agentLeft.sha);
+        if (!same && !force) {
+            results.push({ path: item.path, result: "changed since the job, not restored (--force restores it)" });
+            continue;
+        }
+        if (!same && force && now.exists) {
+            out(ui.c.amber(`  --force: ${item.path} was changed since the job; those changes are lost:`));
+            const current = fs.readFileSync(where, "utf8").split("\n").slice(0, 20);
+            for (const l of current)
+                out(ui.c.dim(`      ${l}`));
+        }
+        try {
+            if (item.action === "delete") {
+                if (now.exists)
+                    fs.rmSync(where);
+                results.push({ path: item.path, result: "deleted (created by the agent)" });
+            }
+            else if (item.action === "rename_back" && item.to) {
+                const from = inside(project.root, item.to);
+                if (!from)
+                    throw new Error("the new name is outside this project");
+                fs.mkdirSync(path.dirname(where), { recursive: true });
+                if (fs.existsSync(from))
+                    fs.renameSync(from, where);
+                if (typeof item.content === "string")
+                    fs.writeFileSync(where, item.content);
+                results.push({ path: item.path, result: `renamed back from ${item.to}` });
+            }
+            else {
+                if (typeof item.content !== "string")
+                    throw new Error("no copy was kept");
+                fs.mkdirSync(path.dirname(where), { recursive: true });
+                fs.writeFileSync(where, item.content);
+                results.push({ path: item.path, result: "restored" });
+            }
+        }
+        catch (e) {
+            results.push({ path: item.path, result: `not restored: ${e.message}` });
+        }
+    }
+    const ok = results.filter((r) => /^(restored|deleted|renamed back)/.test(r.result));
+    out();
+    for (const r of results)
+        out(`  ${ok.includes(r) ? ui.c.green("done") : ui.c.amber("left")}  ${r.path}  ${r.result}`);
+    out(ok.length === results.length
+        ? ui.ok(`Rewound ${ok.length} file${ok.length === 1 ? "" : "s"}.`)
+        : ui.warn(`Rewound ${ok.length} of ${results.length} files. The others were left as they are.`));
+    out();
+    await review("rewound", { job_id: data.job_id, to_step: toStep, results });
+    return ok.length === results.length ? 0 : 1;
+}

package/out/commands/sessions.d.ts

@@ -0,0 +1,23 @@
+import type { Message, PersistedTurn, Provider, Session, SourceSurface } from '../lib/types';
+export declare function listSessions(): Session[];
+export declare function getSession(sessionId: string): Session | undefined;
+export declare function newSession(title?: string, surface?: SourceSurface): Session;
+/** Context size in tokens, from what has already been persisted. */
+export declare function contextTokens(session: Session): number;
+export declare function isFresh(session: Session): boolean;
+export declare function appendTurn(sessionId: string, role: 'user' | 'assistant', content: string, meta?: {
+    model?: string;
+    provider?: Provider;
+}): PersistedTurn;
+/**
+ * Rebuild the message history a provider needs.
+ *
+ * Only possible when text storage is on. Otherwise the honest answer is an
+ * empty history and a caller that says so - being content-blind has a cost, and
+ * paying it visibly beats storing the text and calling the product
+ * content-blind anyway.
+ */
+export declare function replayableHistory(session: Session): {
+    messages: Message[];
+    replayable: boolean;
+};

package/out/commands/sessions.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listSessions = listSessions;
+exports.getSession = getSession;
+exports.newSession = newSession;
+exports.contextTokens = contextTokens;
+exports.isFresh = isFresh;
+exports.appendTurn = appendTurn;
+exports.replayableHistory = replayableHistory;
+/**
+ * Work sessions: a person's working conversation, recorded content-blind.
+ *
+ * `sessions.json` is the one store here that is rewritten rather than appended.
+ * That is deliberate and it is not a hole in the append-only rule: a session is
+ * current state (a title, a turn count, a context size), not evidence. Every
+ * evidentiary claim - what was dispatched, what it cost, what was decided -
+ * lives in the ledger and the decision records, which are never rewritten.
+ *
+ * What is persisted per turn is the SHAPE of the turn: role, fingerprint, size,
+ * and which model answered. Not its words, unless the tenant has explicitly
+ * turned text storage on.
+ */
+const node_fs_1 = __importDefault(require("node:fs"));
+const config_1 = require("../lib/config");
+const fingerprint_1 = require("../lib/fingerprint");
+const store_1 = require("../lib/store");
+function readAll() {
+    const p = (0, store_1.storePath)(store_1.SESSIONS_FILE);
+    if (!node_fs_1.default.existsSync(p))
+        return {};
+    try {
+        return JSON.parse(node_fs_1.default.readFileSync(p, 'utf8'));
+    }
+    catch {
+        // A corrupt session index must not stop someone working. Start clean; the
+        // ledger and the decision records are the parts that matter and they are
+        // append-only, so nothing evidentiary is lost here.
+        return {};
+    }
+}
+function writeAll(map) {
+    (0, config_1.ensureHome)();
+    node_fs_1.default.writeFileSync((0, store_1.storePath)(store_1.SESSIONS_FILE), `${JSON.stringify(map, null, 2)}\n`, { mode: 0o600 });
+}
+function listSessions() {
+    return Object.values(readAll()).sort((a, b) => b.updated.localeCompare(a.updated));
+}
+function getSession(sessionId) {
+    return readAll()[sessionId];
+}
+function newSession(title, surface = 'sdk') {
+    const now = new Date().toISOString();
+    const session = {
+        session_id: (0, fingerprint_1.newId)('ses'),
+        title: title || 'Untitled session',
+        created: now,
+        updated: now,
+        source_surface: surface,
+        turns: [],
+    };
+    const map = readAll();
+    map[session.session_id] = session;
+    writeAll(map);
+    return session;
+}
+/** Context size in tokens, from what has already been persisted. */
+function contextTokens(session) {
+    return session.turns.reduce((sum, t) => sum + t.approx_tokens, 0);
+}
+function isFresh(session) {
+    return session.turns.length === 0;
+}
+function appendTurn(sessionId, role, content, meta = {}) {
+    const cfg = (0, config_1.loadConfig)();
+    const turn = {
+        role,
+        ts: new Date().toISOString(),
+        fingerprint: (0, fingerprint_1.fingerprint)(content),
+        chars: content.length,
+        approx_tokens: (0, fingerprint_1.approxTokens)(content),
+        ...(meta.model ? { model: meta.model } : {}),
+        ...(meta.provider ? { provider: meta.provider } : {}),
+        // Off by default. The whole product is built to work without it.
+        ...(cfg.contentPolicy.storeText ? { content } : {}),
+    };
+    const map = readAll();
+    const session = map[sessionId];
+    if (!session)
+        throw new Error(`unknown session: ${sessionId}`);
+    session.turns.push(turn);
+    session.updated = turn.ts;
+    writeAll(map);
+    return turn;
+}
+/**
+ * Rebuild the message history a provider needs.
+ *
+ * Only possible when text storage is on. Otherwise the honest answer is an
+ * empty history and a caller that says so - being content-blind has a cost, and
+ * paying it visibly beats storing the text and calling the product
+ * content-blind anyway.
+ */
+function replayableHistory(session) {
+    const withText = session.turns.filter((t) => typeof t.content === 'string');
+    if (session.turns.length > 0 && withText.length !== session.turns.length) {
+        return { messages: [], replayable: false };
+    }
+    return {
+        messages: withText.map((t) => ({ role: t.role, content: t.content })),
+        replayable: true,
+    };
+}

package/out/commands/settings.d.ts

@@ -18,4 +18,6 @@ export declare function cmdProviders(): Promise<void>;
  * have used, which is the only thing a saving can honestly be measured against.
  */
 export declare function cmdModel(args: string[]): Promise<void>;
-export declare function cmdWorkspace(args: string[]): Promise<void>;
+export declare function cmdProject(args: string[]): Promise<void>;
+/** The older name, kept so nothing that calls it breaks. */
+export declare const cmdWorkspace: typeof cmdProject;

package/out/commands/settings.js

@@ -36,10 +36,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdWorkspace = void 0;
 exports.currentWorkspace = currentWorkspace;
 exports.cmdProviders = cmdProviders;
 exports.cmdModel = cmdModel;
-exports.cmdWorkspace = cmdWorkspace;
+exports.cmdProject = cmdProject;
 /**
  * The three things a person sets once and then forgets: which model they are
  * compared against, which vendors they can reach, and which folder they work in.
@@ -62,6 +63,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const prompt_1 = require("../lib/prompt");
 const gateway_1 = require("../lib/gateway");
 const config_1 = require("../lib/config");
+const project_1 = require("../lib/project");
 const ui = __importStar(require("../lib/ui"));
 const out = (s = '') => process.stdout.write(s + '\n');
 /** Where the chosen folder is remembered. Beside the rest of the settings. */
@@ -193,10 +195,10 @@ async function cmdModel(args) {
     out(`      ${ui.c.dim('every receipt from now on prices your work against this model')}`);
     out();
 }
-async function cmdWorkspace(args) {
+async function cmdProject(args) {
     const named = args.find((a) => !a.startsWith('--'));
     const current = currentWorkspace();
-    out(ui.banner('Working folder'));
+    out(ui.banner('Project folder'));
     out();
     out(`  ${ui.c.bold(current.path)}`);
     out(`      ${ui.c.dim(current.source === 'cwd'
@@ -212,8 +214,12 @@ async function cmdWorkspace(args) {
         out();
         return;
     }
+    // `comprism project` on its own shows the folder (manual 2.1). Asking only
+    // when a person is at the keyboard and typed nothing, as before.
     let target = named;
     if (!target) {
+        if (!process.stdin.isTTY)
+            return;
         const answer = await (0, prompt_1.ask)('  new folder, or enter to keep it: ');
         (0, prompt_1.closePrompt)();
         if (!answer) {
@@ -223,22 +229,18 @@ async function cmdWorkspace(args) {
         }
         target = answer;
     }
-    const resolved = node_path_1.default.resolve(target.replace(/^~/, process.env.HOME || '~'));
-    if (!node_fs_1.default.existsSync(resolved)) {
-        out(ui.fail(`There is no folder at ${resolved}.`));
-        out();
-        process.exitCode = 1;
-        return;
-    }
-    if (!node_fs_1.default.statSync(resolved).isDirectory()) {
-        out(ui.fail(`${resolved} is a file, not a folder.`));
+    const found = (0, project_1.checkFolder)(target);
+    if (!found.ok) {
+        out(ui.fail(found.why));
         out();
-        process.exitCode = 1;
+        process.exitCode = 2;
         return;
     }
     node_fs_1.default.mkdirSync((0, config_1.homeDir)(), { recursive: true });
-    node_fs_1.default.writeFileSync(workspaceFile(), JSON.stringify({ path: resolved }, null, 2), { mode: 0o600 });
-    out(ui.ok(`Working folder set to ${ui.c.bold(resolved)}.`));
-    out(`      ${ui.c.dim('clear it with')} ${ui.c.bold('comprism workspace --clear')}`);
+    node_fs_1.default.writeFileSync(workspaceFile(), JSON.stringify({ path: found.path }, null, 2), { mode: 0o600 });
+    out(ui.ok(`Project folder set to ${ui.c.bold(found.path)}.`));
+    out(`      ${ui.c.dim('clear it with')} ${ui.c.bold('comprism project --clear')}`);
     out();
 }
+/** The older name, kept so nothing that calls it breaks. */
+exports.cmdWorkspace = cmdProject;

package/out/commands/skills.d.ts

@@ -0,0 +1,21 @@
+type Row = {
+    name: string;
+    description: string;
+    where: string;
+    active: boolean;
+    note?: string | null;
+};
+type Checked = {
+    level: string;
+    name: string;
+    line: string;
+};
+export declare function skillRows(folder: string, op?: "list" | "check"): Promise<{
+    rows: Row[];
+    checked?: Checked[];
+    empty?: string | null;
+    error?: string;
+}>;
+export declare const SKILLS_HELP = "  comprism skills                          the skills here and where each came from\n  comprism skills add --personal <folder>  keep a skill folder on your account\n  comprism skills remove --personal <name> remove one of your own skills\n  comprism skills check                    what will not load, and how to fix it\n  In a session, /name followed by anything runs that skill with it.";
+export declare function cmdSkills(args: string[]): Promise<number>;
+export {};