@celestea/studio 2.7.1

package/dist/store/session-meta.js

@@ -0,0 +1,66 @@
+/**
+ * `<session-dir>/session.json` — the optional Studio session metadata
+ * (`contracts/data-files/session.schema.json`).
+ *
+ * The engine NEVER reads this file; only `POST /api/sessions` writes it (and
+ * only when `title` and/or `model` and/or `prompt` and/or `mode` is non-empty),
+ * `rename`/`branch` re-write it (see W779 below), and `activate`/`compact` honor
+ * its `model` override. Missing or corrupt files are tolerated (`None`), never
+ * repaired.
+ *
+ * W779 T2: `title` joins them — the ORIGINAL, un-sanitized session title (CJK,
+ * spaces and all), so the GUI can show `我的 会话` instead of the directory name
+ * `我的_会话-1700000000.0`. `POST /api/sessions` always has a title, so every
+ * session created from now on carries one; the field is optional on read, and a
+ * session without it falls back to the de-suffixed directory name.
+ *
+ * W729 (P0): `mode` joins `model`/`prompt` as a creation-time session property.
+ * K8: the default mode is *not* written — the KEY never appears for a session
+ * that did not ask for one. W779 T2 adds `title`, so the file itself now always
+ * exists; K8's guarantee is per-key (no `mode` key), not per-file.
+ */
+import { parseMode } from "./mode.js";
+import { readJsonIfExists, writeTextPlain } from "./fs-json.js";
+export const SESSION_META = "session.json";
+/**
+ * Read the metadata; a corrupt file behaves exactly like a missing one, and a
+ * `mode` that is not a declared literal is dropped (never repaired on disk).
+ */
+export function readSessionMeta(dir) {
+    const out = readJsonIfExists(`${dir}/${SESSION_META}`);
+    if (!out.exists || out.error !== undefined)
+        return null;
+    if (typeof out.value !== "object" || out.value === null || Array.isArray(out.value))
+        return null;
+    const rec = out.value;
+    const meta = {};
+    if (typeof rec["title"] === "string")
+        meta.title = rec["title"];
+    if (typeof rec["model"] === "string")
+        meta.model = rec["model"];
+    if (typeof rec["prompt"] === "string")
+        meta.prompt = rec["prompt"];
+    const mode = parseMode(rec["mode"]);
+    if (mode !== null)
+        meta.mode = mode;
+    return meta;
+}
+/** Any of `title`/`model`/`prompt`/`mode` non-empty -> write; all empty -> no file. */
+export function writeSessionMeta(dir, meta) {
+    const title = meta.title ?? "";
+    const model = meta.model ?? "";
+    const prompt = meta.prompt ?? "";
+    const mode = meta.mode ?? "";
+    if (title === "" && model === "" && prompt === "" && mode === "")
+        return;
+    const body = {};
+    if (title !== "")
+        body["title"] = title;
+    if (model !== "")
+        body["model"] = model;
+    if (prompt !== "")
+        body["prompt"] = prompt;
+    if (mode !== "")
+        body["mode"] = mode;
+    writeTextPlain(`${dir}/${SESSION_META}`, `${JSON.stringify(body, null, 2)}\n`);
+}

package/dist/store/session-ops.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Session directory moves: rename / branch / archive / trash
+ * (`src/workspaces.rs:1228-1311,1506-1650`).
+ *
+ * All four are plain filesystem moves: archiving is the canonical
+ * `<CELESTEA_HOME>/workspaces/<ws>/archive/<name>` (W880; id-preserving and
+ * reversible) while deleting moves to `<CELESTEA_HOME>/workspaces/<ws>/trash/<name>-<ts>`
+ * (NOT addressable by id afterwards). The legacy `<ws>/.celestea-archived` /
+ * `<ws>/.celestea-trash` siblings stay READABLE. The archive state needs no
+ * field in `workspaces.json` because the default scanner never lists it.
+ *
+ * W791: "invisible to the scanner" is about the DEFAULT listing only. An
+ * archived session keeps its id, so the three operations that address a session
+ * BY ID must agree on where it can be: `unarchive` always did, `trash` now looks
+ * in the archive too (B3), and the scanner answers the `?archived=1` listing
+ * (`SessionsStore.listArchived`, B1).
+ *
+ * W794 (裁决: "active 只是状态标记，不是保护理由"): the ACTIVE session is no
+ * longer refused by `archive` / `trash` — both move it like any other session.
+ * The active MARKER is a view preference, not a lock, so the operation owns the
+ * consequence: once the active session has moved away, `active_session` is set
+ * to `null` and persisted (it must never keep pointing at an id this call just
+ * removed). Cutting the session's in-flight model response and releasing its
+ * engine instance is the engine's half of the same removal and happens BEFORE
+ * these functions run (see `handlers/session-move.ts`).
+ */
+import { type StoreResult } from "./result.js";
+import { type WorkspacesStore } from "./workspaces.js";
+import { type SessionsStore } from "./sessions.js";
+export interface BatchOutcome {
+    count: number;
+    failed: Array<{
+        id: string;
+        error: string;
+    }>;
+}
+export declare class SessionOps {
+    private readonly ws;
+    private readonly sessions;
+    private readonly now;
+    constructor(ws: WorkspacesStore, sessions: SessionsStore, now?: () => number);
+    /** POST /api/sessions/{id}/rename — same name is a no-op success. */
+    rename(id: string, newTitle: string): StoreResult<string>;
+    /**
+     * W779 T2: `session.json.title` <- [title], keeping every other key. A session
+     * that never had a meta file gets a `{title}` one (the title belongs to the
+     * session, not to the model/prompt/mode trio).
+     */
+    private writeTitle;
+    /** POST /api/sessions/{id}/branch — copy the log into a sibling dir. */
+    branch(id: string, title?: string): StoreResult<string>;
+    private move;
+    /**
+     * POST /api/sessions/{id}/archive — id-preserving move into the archive.
+     *
+     * W794: the active session is archived like any other; the active MARKER is
+     * cleared afterwards (the archived row is not part of the default listing, so a
+     * marker still pointing at it would contradict `GET /api/sessions`).
+     */
+    archive(id: string): StoreResult<void>;
+    unarchive(id: string): StoreResult<void>;
+    /** POST /api/sessions/batch-archive — per-id, always 200. */
+    batchArchive(ids: readonly string[]): {
+        archived: number;
+        failed: Array<{
+            id: string;
+            error: string;
+        }>;
+    };
+    /** POST /api/sessions/batch-delete — per-id move to `.celestea-trash`. */
+    batchDelete(ids: readonly string[]): {
+        deleted: number;
+        failed: Array<{
+            id: string;
+            error: string;
+        }>;
+    };
+    private batch;
+    /**
+     * The session's directory wherever it currently IS: the live location first,
+     * else the archive (W791 B3).
+     *
+     * Deleting an ARCHIVED session used to answer `unknown session '<id>'`: the
+     * operation only ever looked at `<ws>/<session>`, which is exactly where an
+     * archived session is NOT. The id is unchanged by archiving, so the archive is
+     * the only other place it can be — and both a live and an archived copy is
+     * impossible (`unarchive` refuses to overwrite a live session).
+     */
+    private locate;
+    /**
+     * One session into `<ws>/.celestea-trash/<session>-<ts>`.
+     *
+     * W794: no active-session guard. Deleting the focused session is a normal
+     * operation — the marker is cleared instead, in the same atomic write the
+     * registry uses for every other `active_session` change.
+     */
+    private trash;
+    /**
+     * W794: `active_session` must not survive the session it names.
+     *
+     * Called only AFTER the directory has actually moved (a failure to move leaves
+     * the registry untouched — the session is still there and still active). The
+     * value becomes `null`: no other session is silently promoted, so the UI shows
+     * what is true (nothing is focused) instead of a session the user never chose.
+     * A failed persist is a 500 — the caller's `failed[]` / error then says the
+     * registry could not be updated, rather than pretending the id is gone.
+     */
+    private clearActiveIf;
+}

package/dist/store/session-ops.js

@@ -0,0 +1,264 @@
+/**
+ * Session directory moves: rename / branch / archive / trash
+ * (`src/workspaces.rs:1228-1311,1506-1650`).
+ *
+ * All four are plain filesystem moves: archiving is the canonical
+ * `<CELESTEA_HOME>/workspaces/<ws>/archive/<name>` (W880; id-preserving and
+ * reversible) while deleting moves to `<CELESTEA_HOME>/workspaces/<ws>/trash/<name>-<ts>`
+ * (NOT addressable by id afterwards). The legacy `<ws>/.celestea-archived` /
+ * `<ws>/.celestea-trash` siblings stay READABLE. The archive state needs no
+ * field in `workspaces.json` because the default scanner never lists it.
+ *
+ * W791: "invisible to the scanner" is about the DEFAULT listing only. An
+ * archived session keeps its id, so the three operations that address a session
+ * BY ID must agree on where it can be: `unarchive` always did, `trash` now looks
+ * in the archive too (B3), and the scanner answers the `?archived=1` listing
+ * (`SessionsStore.listArchived`, B1).
+ *
+ * W794 (裁决: "active 只是状态标记，不是保护理由"): the ACTIVE session is no
+ * longer refused by `archive` / `trash` — both move it like any other session.
+ * The active MARKER is a view preference, not a lock, so the operation owns the
+ * consequence: once the active session has moved away, `active_session` is set
+ * to `null` and persisted (it must never keep pointing at an id this call just
+ * removed). Cutting the session's in-flight model response and releasing its
+ * engine instance is the engine's half of the same removal and happens BEFORE
+ * these functions run (see `handlers/session-move.ts`).
+ */
+import { copyFileSync, renameSync, mkdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { isDirectory, isFile, removeDir } from "./fs-json.js";
+import { badRequest, conflict, errText, fail, notFound, ok } from "./result.js";
+import { archiveDirCandidates, archiveRoots, baseName, parentDir, sanitizeComponent, timestampSuffix, trashRoots } from "./session-id.js";
+import { readSessionMeta, writeSessionMeta } from "./session-meta.js";
+import { SESSION_FILE } from "./workspaces.js";
+import { displayTitle } from "./sessions.js";
+/** W885: platform-aware parent (the pre-W885 hardcoded `/` broke on win32). */
+function parentOf(path) {
+    return parentDir(path);
+}
+/** W885: platform-aware basename (`dir.slice(lastIndexOf("/") + 1)` before). */
+function baseOf(path) {
+    return baseName(path);
+}
+export class SessionOps {
+    ws;
+    sessions;
+    now;
+    constructor(ws, sessions, now = Date.now) {
+        this.ws = ws;
+        this.sessions = sessions;
+        this.now = now;
+    }
+    /** POST /api/sessions/{id}/rename — same name is a no-op success. */
+    rename(id, newTitle) {
+        const found = this.sessions.require(id);
+        if (!found.ok)
+            return found;
+        const res = found.value;
+        const title = newTitle.trim();
+        const base = sanitizeComponent(title);
+        if (base === "" || base === "." || base === "..")
+            return badRequest("new title must not be empty");
+        if (base.startsWith("."))
+            return badRequest(`title '${title}' sanitizes to the hidden name '${base}'`);
+        if (base === res.session)
+            return ok(res.id);
+        const newDir = this.sessions.uniqueDir(res.wsPath, base, parentOf(res.dir));
+        try {
+            renameSync(res.dir, newDir);
+        }
+        catch (e) {
+            return fail(500, `move failed: ${errText(e)}`);
+        }
+        // W779 T2: the directory name is the sanitized title, so the DISPLAY name
+        // lives in session.json — an update that fails reports 500 rather than
+        // leaving the session labelled with its old title.
+        const titled = this.writeTitle(newDir, title);
+        if (!titled.ok) {
+            // N1 (W815): a failed meta write must not leave the directory moved — the
+            // caller (and `active_session`) still addresses the OLD id, so undo it.
+            try {
+                renameSync(newDir, res.dir);
+            }
+            catch (e) {
+                return fail(500, `${titled.error}; rollback failed: ${errText(e)}`);
+            }
+            return titled;
+        }
+        return ok(`${res.workspace}/${baseOf(newDir)}`);
+    }
+    /**
+     * W779 T2: `session.json.title` <- [title], keeping every other key. A session
+     * that never had a meta file gets a `{title}` one (the title belongs to the
+     * session, not to the model/prompt/mode trio).
+     */
+    writeTitle(dir, title) {
+        try {
+            writeSessionMeta(dir, { ...(readSessionMeta(dir) ?? {}), title });
+            return ok(undefined);
+        }
+        catch (e) {
+            return fail(500, `meta write failed: ${errText(e)}`);
+        }
+    }
+    /** POST /api/sessions/{id}/branch — copy the log into a sibling dir. */
+    branch(id, title) {
+        const found = this.sessions.require(id);
+        if (!found.ok)
+            return found;
+        const res = found.value;
+        const parent = readSessionMeta(res.dir);
+        const asked = (title ?? "").trim();
+        // W779 T2: the default name is derived from the PARENT'S DISPLAY NAME, not
+        // from its directory (`alpha-1700000000.0-分支` was the old leak).
+        const display = asked === "" ? `${displayTitle(parent, res.session)}-分支` : asked;
+        const base = sanitizeComponent(display);
+        if (base === "" || base === "." || base === "..")
+            return badRequest("title must not be empty");
+        if (base.startsWith("."))
+            return badRequest(`title sanitizes to the hidden name '${base}'`);
+        const newDir = this.sessions.uniqueDir(res.wsPath, `${base}-${timestampSuffix(this.now())}`, parentOf(res.dir));
+        try {
+            mkdirSync(newDir, { recursive: false });
+        }
+        catch (e) {
+            return fail(500, `create failed: ${errText(e)}`);
+        }
+        try {
+            copyFileSync(`${res.dir}/${SESSION_FILE}`, `${newDir}/${SESSION_FILE}`);
+        }
+        catch (e) {
+            removeDir(newDir);
+            return fail(500, `copy failed: ${errText(e)}`);
+        }
+        // The branch INHERITS model/prompt/mode and carries its OWN title (the asked
+        // one, or `<parent display>-分支`); the log copy above never touches meta.
+        try {
+            writeSessionMeta(newDir, { ...(parent ?? {}), title: display });
+        }
+        catch (e) {
+            removeDir(newDir);
+            return fail(500, `meta write failed: ${errText(e)}`);
+        }
+        return ok(`${res.workspace}/${baseOf(newDir)}`);
+    }
+    move(res, from, to) {
+        try {
+            mkdirSync(parentOf(to), { recursive: true });
+            renameSync(from, to);
+            return ok(undefined);
+        }
+        catch (e) {
+            return fail(500, `move failed: ${errText(e)}`);
+        }
+    }
+    /**
+     * POST /api/sessions/{id}/archive — id-preserving move into the archive.
+     *
+     * W794: the active session is archived like any other; the active MARKER is
+     * cleared afterwards (the archived row is not part of the default listing, so a
+     * marker still pointing at it would contradict `GET /api/sessions`).
+     */
+    archive(id) {
+        const resolved = this.sessions.resolve(id);
+        if (!resolved.ok)
+            return resolved;
+        const res = resolved.value;
+        if (!isDirectory(res.dir) || !isFile(`${res.dir}/${SESSION_FILE}`))
+            return notFound(`unknown session '${id}'`);
+        const dst = join(archiveRoots(res.wsPath)[0] ?? res.wsPath, res.session);
+        if (archiveDirCandidates(res.wsPath, res.session).some((c) => existsSync(c))) {
+            return conflict(`session '${id}' is already archived`);
+        }
+        const moved = this.move(res, res.dir, dst);
+        if (!moved.ok)
+            return moved;
+        return this.clearActiveIf(id);
+    }
+    unarchive(id) {
+        const resolved = this.sessions.resolve(id);
+        if (!resolved.ok)
+            return resolved;
+        const res = resolved.value;
+        const src = archiveDirCandidates(res.wsPath, res.session).find((c) => isDirectory(c));
+        if (src === undefined)
+            return notFound(`session '${id}' is not archived`);
+        if (existsSync(res.dir))
+            return conflict(`a live session already exists at '${id}'`);
+        return this.move(res, src, res.dir);
+    }
+    /** POST /api/sessions/batch-archive — per-id, always 200. */
+    batchArchive(ids) {
+        const out = this.batch(ids, (id) => this.archive(id));
+        return { archived: out.count, failed: out.failed };
+    }
+    /** POST /api/sessions/batch-delete — per-id move to `.celestea-trash`. */
+    batchDelete(ids) {
+        const out = this.batch(ids, (id) => this.trash(id));
+        return { deleted: out.count, failed: out.failed };
+    }
+    batch(ids, op) {
+        let count = 0;
+        const failed = [];
+        for (const id of ids) {
+            const res = op(id);
+            if (res.ok)
+                count += 1;
+            else
+                failed.push({ id, error: res.error });
+        }
+        return { count, failed };
+    }
+    /**
+     * The session's directory wherever it currently IS: the live location first,
+     * else the archive (W791 B3).
+     *
+     * Deleting an ARCHIVED session used to answer `unknown session '<id>'`: the
+     * operation only ever looked at `<ws>/<session>`, which is exactly where an
+     * archived session is NOT. The id is unchanged by archiving, so the archive is
+     * the only other place it can be — and both a live and an archived copy is
+     * impossible (`unarchive` refuses to overwrite a live session).
+     */
+    locate(res) {
+        if (isDirectory(res.dir) && isFile(`${res.dir}/${SESSION_FILE}`))
+            return res.dir;
+        const archived = archiveDirCandidates(res.wsPath, res.session).find((c) => isDirectory(c) && isFile(`${c}/${SESSION_FILE}`));
+        return archived ?? null;
+    }
+    /**
+     * One session into `<ws>/.celestea-trash/<session>-<ts>`.
+     *
+     * W794: no active-session guard. Deleting the focused session is a normal
+     * operation — the marker is cleared instead, in the same atomic write the
+     * registry uses for every other `active_session` change.
+     */
+    trash(id) {
+        const resolved = this.sessions.resolve(id);
+        if (!resolved.ok)
+            return resolved;
+        const res = resolved.value;
+        const from = this.locate(res);
+        if (from === null)
+            return notFound(`unknown session '${id}'`);
+        const dst = join(trashRoots(res.wsPath)[0] ?? res.wsPath, `${res.session}-${timestampSuffix(this.now())}`);
+        const moved = this.move(res, from, dst);
+        if (!moved.ok)
+            return moved;
+        return this.clearActiveIf(id);
+    }
+    /**
+     * W794: `active_session` must not survive the session it names.
+     *
+     * Called only AFTER the directory has actually moved (a failure to move leaves
+     * the registry untouched — the session is still there and still active). The
+     * value becomes `null`: no other session is silently promoted, so the UI shows
+     * what is true (nothing is focused) instead of a session the user never chose.
+     * A failed persist is a 500 — the caller's `failed[]` / error then says the
+     * registry could not be updated, rather than pretending the id is gone.
+     */
+    clearActiveIf(id) {
+        if (this.ws.activeSession() !== id.trim())
+            return ok(undefined);
+        return this.ws.setActiveSession(null);
+    }
+}

package/dist/store/session-tools.d.ts

@@ -0,0 +1,42 @@
+/**
+ * W860: session-level TOOL SWITCHES — the pure SUBTRACTIVE layer beside the W9
+ * permission baseline.
+ *
+ * A session may DISABLE tools by name (`<session dir>/tools.json`). The list is
+ * a DENY set ONLY: `engine-grants.ts` unions it with the preset's `toolDeny`
+ * (preset first, session second) into the session's effective deny, so the engine
+ * can never turn a blocked name back on — including the names the `execution`
+ * mode folded away. Nothing here ever ADDS a tool (grants' `tool_extra` is the
+ * only additive path, and it is unaffected by this file).
+ *
+ * Same discipline as permission.json: whitelist + validate every field, atomic
+ * 0600 write, and a corrupt / foreign file means "run as if nothing were
+ * disabled" — never "repair it". That is deliberately fail-closed for the DENY
+ * side: an unreadable list must never silently WIDEN the tool face.
+ */
+export declare const SESSION_TOOLS_FILE = "tools.json";
+export interface SessionToolsRead {
+    /** The normalized disabled list; empty whenever the file is absent or void. */
+    disabled: string[];
+    /**
+     * Why the file was ignored. At most one entry, and it always says the session
+     * runs with nothing disabled (the same "degrade + say so" contract as
+     * `readSessionPermission`).
+     */
+    warnings: string[];
+}
+/**
+ * Read + validate; NEVER throws. A missing file is `{disabled: []}` with no
+ * warning (the pre-W860 bytes); a broken one is the empty deny set plus ONE
+ * warning that states the session runs with no tools disabled.
+ */
+export declare function readSessionTools(dir: string, expectedSession: string): SessionToolsRead;
+/**
+ * The ONE normalizer: trim, drop blanks, dedupe, keep first-occurrence order.
+ * The PUT endpoint validates the raw array first (any non-string or blank is a
+ * 422); a hand-written file goes through the same function on read, where a
+ * blank entry is merely dropped.
+ */
+export declare function normalizeDisabledTools(disabled: readonly string[]): string[];
+/** Normalize + atomic 0600 write; returns the list that was persisted. */
+export declare function writeSessionTools(dir: string, session: string, disabled: readonly string[], now: number): string[];

package/dist/store/session-tools.js

@@ -0,0 +1,69 @@
+/**
+ * W860: session-level TOOL SWITCHES — the pure SUBTRACTIVE layer beside the W9
+ * permission baseline.
+ *
+ * A session may DISABLE tools by name (`<session dir>/tools.json`). The list is
+ * a DENY set ONLY: `engine-grants.ts` unions it with the preset's `toolDeny`
+ * (preset first, session second) into the session's effective deny, so the engine
+ * can never turn a blocked name back on — including the names the `execution`
+ * mode folded away. Nothing here ever ADDS a tool (grants' `tool_extra` is the
+ * only additive path, and it is unaffected by this file).
+ *
+ * Same discipline as permission.json: whitelist + validate every field, atomic
+ * 0600 write, and a corrupt / foreign file means "run as if nothing were
+ * disabled" — never "repair it". That is deliberately fail-closed for the DENY
+ * side: an unreadable list must never silently WIDEN the tool face.
+ */
+import { join } from "node:path";
+import { readJsonIfExists, writeJsonAtomic } from "./fs-json.js";
+export const SESSION_TOOLS_FILE = "tools.json";
+/**
+ * Read + validate; NEVER throws. A missing file is `{disabled: []}` with no
+ * warning (the pre-W860 bytes); a broken one is the empty deny set plus ONE
+ * warning that states the session runs with no tools disabled.
+ */
+export function readSessionTools(dir, expectedSession) {
+    const out = readJsonIfExists(join(dir, SESSION_TOOLS_FILE));
+    if (!out.exists)
+        return { disabled: [], warnings: [] };
+    const voided = (reason) => ({
+        disabled: [],
+        warnings: ["tools_unreadable: " + reason + " — the session runs with no tools disabled"],
+    });
+    if (out.error !== undefined)
+        return voided("unparsable tools.json: " + out.error);
+    const value = out.value;
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return voided("tools.json is not an object");
+    const rec = value;
+    if (rec["version"] !== 1)
+        return voided("unknown tools.json version " + JSON.stringify(rec["version"]));
+    if (rec["session"] !== expectedSession)
+        return voided("tools.json belongs to " + JSON.stringify(rec["session"]));
+    const raw = rec["disabled"];
+    if (!Array.isArray(raw) || raw.some((name) => typeof name !== "string"))
+        return voided("tools.json has no \`disabled\` array of strings");
+    return { disabled: normalizeDisabledTools(raw), warnings: [] };
+}
+/**
+ * The ONE normalizer: trim, drop blanks, dedupe, keep first-occurrence order.
+ * The PUT endpoint validates the raw array first (any non-string or blank is a
+ * 422); a hand-written file goes through the same function on read, where a
+ * blank entry is merely dropped.
+ */
+export function normalizeDisabledTools(disabled) {
+    const out = [];
+    for (const value of disabled) {
+        const name = value.trim();
+        if (name === "" || out.includes(name))
+            continue;
+        out.push(name);
+    }
+    return out;
+}
+/** Normalize + atomic 0600 write; returns the list that was persisted. */
+export function writeSessionTools(dir, session, disabled, now) {
+    const normalized = normalizeDisabledTools(disabled);
+    writeJsonAtomic(join(dir, SESSION_TOOLS_FILE), { version: 1, session, disabled: normalized, updated_at: now }, { mode: 0o600 });
+    return normalized;
+}