@datename/fastcode-termux 0.1.6-beta → 0.1.8-beta.0

package/dist/skills/manager.js

@@ -5,21 +5,122 @@
  * a SKILL.md file plus optional resource files. FastCode supports three
  * install sources:
  *
- *   1. skills.sh / skillshub.wtf API (default registry)
- *      `/skills install pdf`               → resolves via the registry
- *      `/skills install owner/repo/skill`  → fetches raw SKILL.md
- *   2. Direct https URLs ending in SKILL.md.
+ *   1. A registry configured via FASTCODE_SKILLS_REGISTRY or skillsRegistry
+ *      `/skills install pdf`               → resolves via the configured registry
+ *      `/skills install owner/repo/skill`  → fetches raw SKILL.md from the registry
+ *   2. Direct https URLs ending in SKILL.md (no registry required).
  *   3. Local paths (just symlinks into ~/.fastcode/skills/).
  *
  * Installed skills can be enabled per-session and are then stitched into
  * the system prompt at chat time, exactly like Claude does internally.
  */
+import { createHash } from "node:crypto";
 import { readFileSync, writeFileSync, existsSync, readdirSync, rmSync, mkdirSync, } from "node:fs";
 import { join } from "node:path";
 import { getPaths } from "../config/paths.js";
+import { invalidateConfigCache } from "../config/store.js";
 import { fetchJson } from "../lib/http.js";
 import { parseSkill } from "./parser.js";
-const DEFAULT_REGISTRY = "https://skillshub.wtf";
+const SOURCE_FILE = ".fastcode-source";
+const INTEGRITY_VERSION = 1;
+const REGISTRY_REQUIRED = "No skills registry configured. Set one with `/skills registry <url>` or FASTCODE_SKILLS_REGISTRY.";
+/**
+ * Pick the skills registry without treating an empty environment variable as
+ * "configured". `??` would keep `""` and make env overrides silently break;
+ * explicit null/empty checks keep `""` and `" "` on the config path. There is
+ * intentionally no built-in default registry.
+ */
+export function resolveRegistry(envValue, configValue) {
+    const env = typeof envValue === "string" && envValue.trim() ? envValue.trim() : "";
+    const configured = typeof configValue === "string" && configValue.trim() ? configValue.trim() : "";
+    return (env || configured).replace(/\/+$/, "");
+}
+function requireRegistry(registry) {
+    if (!registry)
+        throw new Error(REGISTRY_REQUIRED);
+    return registry;
+}
+export function hashSkillDirectory(folder) {
+    const entries = skillFiles(folder).sort();
+    return createHash("sha256").update(entries.join("\n")).digest("hex");
+}
+function skillFiles(folder, prefix = "") {
+    const out = [];
+    let items;
+    try {
+        items = readdirSync(folder, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const item of items) {
+        if (item.name === SOURCE_FILE)
+            continue;
+        const full = join(folder, item.name);
+        const rel = prefix ? prefix + "/" + item.name : item.name;
+        if (item.isDirectory()) {
+            out.push(...skillFiles(full, rel));
+            continue;
+        }
+        if (!item.isFile())
+            continue;
+        const digest = createHash("sha256").update(readFileSync(full)).digest("hex");
+        out.push(rel + "\0" + digest);
+    }
+    return out;
+}
+function readSourceMeta(folder) {
+    const sourcePath = join(folder, SOURCE_FILE);
+    if (!existsSync(sourcePath))
+        return { source: "local", legacy: true };
+    const raw = readFileSync(sourcePath, "utf8").trim();
+    if (raw.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(raw);
+            return {
+                source: typeof parsed.source === "string" ? parsed.source : "local",
+                sha256: typeof parsed.sha256 === "string" ? parsed.sha256 : undefined,
+                legacy: typeof parsed.sha256 !== "string",
+            };
+        }
+        catch {
+            // Fall through and treat the file as a legacy plain-text source.
+        }
+    }
+    return { source: raw || "local", legacy: true };
+}
+function writeSourceMeta(folder, source) {
+    const sha256 = hashSkillDirectory(folder);
+    const payload = {
+        version: INTEGRITY_VERSION,
+        algorithm: "sha256",
+        source,
+        sha256,
+    };
+    writeFileSync(join(folder, SOURCE_FILE), JSON.stringify(payload, null, 2));
+    return sha256;
+}
+export function rebaselineSkills(names) {
+    const installed = listInstalledSkills();
+    const wanted = names && names.length > 0 ? new Set(names) : undefined;
+    const results = [];
+    let changed = false;
+    for (const skill of installed) {
+        if (wanted && !wanted.has(skill.name) && !wanted.has(basename(skill.path)))
+            continue;
+        try {
+            writeSourceMeta(skill.path, skill.source === "local" ? "local" : skill.source);
+            results.push({ name: skill.name, ok: true });
+            changed = true;
+        }
+        catch (err) {
+            results.push({ name: skill.name, ok: false, warning: err?.message ?? String(err) });
+        }
+    }
+    if (changed)
+        invalidateConfigCache();
+    return results;
+}
 /** List skills currently installed under ~/.fastcode/skills. */
 export function listInstalledSkills() {
     const { skills } = getPaths();
@@ -35,16 +136,20 @@ export function listInstalledSkills() {
             continue;
         const raw = readFileSync(md, "utf8");
         const parsed = parseSkill(raw, dir.name);
-        const sourcePath = join(folder, ".fastcode-source");
-        const source = existsSync(sourcePath)
-            ? readFileSync(sourcePath, "utf8").trim()
-            : "local";
+        const meta = readSourceMeta(folder);
+        const actualHash = hashSkillDirectory(folder);
+        const integrity = !meta.sha256
+            ? "unverified"
+            : actualHash === meta.sha256 ? "ok" : "drift";
         out.push({
             name: parsed.name || dir.name,
             description: parsed.description,
-            source,
+            source: meta.source,
             path: folder,
             body: parsed.body,
+            integrity,
+            sha256: actualHash,
+            lockedHash: meta.sha256,
         });
     }
     return out.sort((a, b) => a.name.localeCompare(b.name));
@@ -56,7 +161,7 @@ export function getSkill(name) {
 /** Install a skill. Returns the parsed manifest on success. */
 export async function installSkill(spec, opts = {}) {
     const { skills } = getPaths();
-    const registry = (opts.registry ?? DEFAULT_REGISTRY).replace(/\/+$/, "");
+    const registry = resolveRegistry(process.env["FASTCODE_SKILLS_REGISTRY"], opts.registry);
     let parsed;
     let source;
     let folderName;
@@ -68,7 +173,8 @@ export async function installSkill(spec, opts = {}) {
     }
     else if (looksLikeRepoPath(spec)) {
         // owner/repo or owner/repo/skill — fetch via registry's raw endpoint.
-        const url = `${registry}/${spec}?format=md`;
+        const base = requireRegistry(registry);
+        const url = `${base}/${spec}?format=md`;
         const body = await fetchText(url);
         parsed = parseSkill(body, parts(spec).pop() ?? spec);
         source = url;
@@ -76,11 +182,12 @@ export async function installSkill(spec, opts = {}) {
     }
     else {
         // Single-token name → search the registry.
-        const hits = await searchRegistry(spec, registry);
+        const base = requireRegistry(registry);
+        const hits = await searchRegistry(spec, base);
         const hit = hits[0];
         if (!hit)
-            throw new Error(`No skill found for "${spec}" in ${registry}`);
-        const url = hit.fetchUrl ?? `${registry}/${hit.slug}?format=md`;
+            throw new Error(`No skill found for "${spec}" in ${base}`);
+        const url = hit.fetchUrl ?? `${base}/${hit.slug}?format=md`;
         const body = await fetchText(url);
         parsed = parseSkill(body, hit.name);
         source = url;
@@ -94,13 +201,14 @@ export async function installSkill(spec, opts = {}) {
         rmSync(targetDir, { recursive: true, force: true });
     mkdirSync(targetDir, { recursive: true });
     writeFileSync(join(targetDir, "SKILL.md"), reassemble(parsed));
-    writeFileSync(join(targetDir, ".fastcode-source"), source);
+    writeSourceMeta(targetDir, source);
     return {
         name: parsed.name || folderName,
         description: parsed.description,
         source,
         path: targetDir,
         body: parsed.body,
+        integrity: "ok",
     };
 }
 /** Remove an installed skill by name or folder. */
@@ -125,8 +233,10 @@ export function uninstallSkill(name) {
     return false;
 }
 /** Search the registry for skills matching a query. */
-export async function searchRegistry(query, registry = DEFAULT_REGISTRY) {
-    const base = registry.replace(/\/+$/, "");
+export async function searchRegistry(query, registry) {
+    const base = resolveRegistry(process.env["FASTCODE_SKILLS_REGISTRY"], registry);
+    if (!base)
+        return [];
     try {
         const json = await fetchJson(`${base}/api/v1/skills/search?q=${encodeURIComponent(query)}`);
         return json.data ?? [];
@@ -145,6 +255,13 @@ export function buildSkillsPrompt(enabled) {
         const skill = installed.find((s) => s.name === name || basename(s.path) === name);
         if (!skill)
             continue;
+        if (skill.integrity !== "ok") {
+            const reason = skill.integrity === "drift"
+                ? "content drift detected"
+                : "no integrity baseline (legacy install)";
+            process.stderr.write(`skill ${skill.name} ${reason}; disabled. Run /skills verify ${skill.name} --confirm to re-baseline.\n`);
+            continue;
+        }
         chunks.push(`<skill name="${skill.name}">\n${skill.body.trim()}\n</skill>`);
     }
     if (chunks.length === 0)

package/dist/types.d.ts

@@ -121,6 +121,15 @@ export interface SlashCommand {
     /** Execute the command. Return text to render, or undefined for no output. */
     run(ctx: CommandContext): Promise<CommandResult> | CommandResult;
 }
+export interface CommandCompaction {
+    summaryRef?: string;
+    source: "local" | "server" | "none";
+    beforeTokens: number;
+    afterTokens: number;
+    droppedMessages: number;
+    keepMessages: number;
+    reason?: "threshold" | "heap" | "manual";
+}
 export interface CommandResult {
     /** Text rendered as a system message in the transcript. */
     message?: string;
@@ -130,6 +139,10 @@ export interface CommandResult {
     quit?: boolean;
     /** Open an interactive picker after the command runs. */
     picker?: PickerRequest;
+    /** Manual /compact result; the app appends the matching compacted fact. */
+    compacted?: CommandCompaction;
+    /** /clear result; the app appends a cleared fact so resume does not resurrect history. */
+    cleared?: boolean;
 }
 export interface CommandContext {
     args: string[];
@@ -163,6 +176,7 @@ export interface AppActions {
     setSystemPrompt(prompt: string): void;
     setSkillsRegistry(url: string): void;
     setReasoningEffort(effort: ReasoningEffort): void;
+    setShellPoolSize(size: number): void;
     enableSkill(name: string): void;
     disableSkill(name: string): void;
     enablePlugin(name: string): void;
@@ -178,6 +192,7 @@ export interface AppActions {
     startLogin(options: {
         provider?: string;
         model?: string;
+        flow?: "provider" | "model" | "login";
     }): void;
 }
 export interface SkillManifest {

package/dist/ui/StatusBar.js

@@ -9,7 +9,7 @@ export const StatusBar = ({ theme, providerId, model, inputTokens, outputTokens,
     const providerModel = `${providerId}/${model}`;
     const label = compact ? truncate(providerModel, Math.max(18, columns - 28)) : providerModel;
     const effort = reasoningEffort && reasoningEffort !== "auto" ? `effort:${reasoningEffort}` : "";
-    return (_jsxs(Box, { flexDirection: compact ? "column" : "row", justifyContent: "space-between", borderStyle: "round", borderColor: theme.border, paddingX: 1, children: [_jsxs(Text, { color: theme.muted, children: [_jsx(Text, { color: theme.accent, children: "\u25CF" }), " ", label, _jsx(Text, { color: theme.muted, children: "  \u00B7  " }), inputTokens, "\u2191 ", outputTokens, "\u2193 ", cost, effort ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.muted, children: "  \u00B7  " }), effort] })) : null, !compact ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.muted, children: "  \u00B7  " }), "skills: ", enabledSkillCount, _jsx(Text, { color: theme.muted, children: "  \u00B7  " }), platformLabel()] })) : null] }), _jsx(Text, { color: theme.muted, children: compact
+    return (_jsxs(Box, { flexDirection: compact ? "column" : "row", justifyContent: "space-between", borderStyle: "round", borderColor: theme.border, paddingX: 1, children: [_jsxs(Text, { color: theme.muted, children: [_jsx(Text, { color: theme.accent, children: "\u25CF" }), " ", label, _jsx(Text, { color: theme.muted, children: "  \u00B7  " }), inputTokens, "\u2191 ", outputTokens, "\u2193 ", cost, !compact && effort ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.muted, children: "  \u00B7  " }), effort] })) : null, !compact ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.muted, children: "  \u00B7  " }), "skills: ", enabledSkillCount, _jsx(Text, { color: theme.muted, children: "  \u00B7  " }), platformLabel()] })) : null] }), _jsx(Text, { color: theme.muted, children: compact
                     ? `${effort ? effort + " \u00B7 " : ""}${platformLabel()} \u00B7 skills:${enabledSkillCount} \u00B7 ${hint ?? "/help \u00B7 esc \u00B7 ctrl+c"}`
                     : hint ?? "/help \u00B7 esc cancel \u00B7 ctrl+c quit" })] }));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datename/fastcode-termux",
-  "version": "0.1.6-beta",
+  "version": "0.1.8-beta.0",
   "description": "FastCode — a blazing-fast TUI coding assistant. Multi-LLM, skills.sh skills, slash commands. Works on Termux, Linux, Windows, and macOS.",
   "type": "module",
   "bin": {
@@ -21,7 +21,7 @@
     "node": ">=18.17"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json && node scripts/build.mjs",
+    "build": "tsc -p tsconfig.build.json && node scripts/build.mjs",
     "build:bundle": "node scripts/build.mjs",
     "dev": "tsx src/index.ts",
     "start": "node bin/fastcode.mjs",
@@ -65,6 +65,7 @@
     "url": "https://github.com/dateName/fastcode-termux/issues"
   },
   "dependencies": {
+    "bash-parser": "^0.5.0",
     "boxen": "^7.1.1",
     "chalk": "^5.3.0",
     "cli-highlight": "^2.1.11",

package/src/agent/approval-json.ts

@@ -0,0 +1,103 @@
+/**
+ * Stable NDJSON gate protocol for GUI/JSON clients.
+ *
+ * This module is pure: it validates and encodes one request/decision at a
+ * time. A headless transport can consume it without leaking TUI output to
+ * stdout. Hard Block requests never reach this code.
+ */
+import type { ApprovalDecision, ApprovalOption, ApprovalRequest } from "./approval.js";
+import { decisionForOption } from "./approval.js";
+
+export const GATE_PROTOCOL_VERSION = 1;
+
+export interface GateAskEvent {
+    event: "gate:ask";
+    version: number;
+    id: string;
+    tier: number;
+    action: string;
+    reason: string;
+    prompt: string;
+    source: string;
+    targets: string[];
+    diffstat: { files: number; lines: number };
+    options: Array<{ id: string; label: string; kind: string; default?: boolean }>;
+    default: string;
+    require_input?: string;
+}
+
+function optionId(option: ApprovalOption, index: number): string {
+    return option.id ?? `${option.kind}-${index}`;
+}
+
+function targetsFor(request: ApprovalRequest): string[] {
+    const args: any = request.args ?? {};
+    const values = [args.path, args.from, args.to, args.cwd, request.preview?.kind === "diff" ? "diff" : undefined];
+    return values.filter((value): value is string => typeof value === "string" && value.length > 0);
+}
+
+export function encodeGateAsk(request: ApprovalRequest): GateAskEvent {
+    const options = request.options.map((option, index) => ({
+        id: optionId(option, index),
+        label: option.label,
+        kind: option.kind,
+        ...(index === (request.defaultIndex ?? 0) ? { default: true } : {}),
+    }));
+    const defaultIndex = Math.max(0, Math.min(request.defaultIndex ?? 0, options.length - 1));
+    const text = request.preview?.kind === "diff" ? request.preview.text : "";
+    const feedbackOption = request.options.find((option) => option.kind === "feedback");
+    const requireInput = request.freeInput?.prompt ?? feedbackOption?.prompt;
+    return {
+        event: "gate:ask",
+        version: GATE_PROTOCOL_VERSION,
+        id: request.id,
+        tier: request.tier ?? 2,
+        action: request.tool,
+        reason: request.reason,
+        prompt: request.prompt ?? "Approval required",
+        source: request.source ?? "system",
+        targets: targetsFor(request),
+        diffstat: { files: text ? text.split(/\r?\n/).filter(Boolean).length : 0, lines: text ? text.split(/\r?\n/).length : 0 },
+        options,
+        default: options[defaultIndex]?.id ?? "",
+        ...(requireInput ? { require_input: requireInput } : {}),
+    };
+}
+
+export interface GateDecisionResult {
+    decision: ApprovalDecision;
+    error?: string;
+}
+
+/**
+ * Accept only a well-formed decision for this exact request id and one of its
+ * stable option ids. Malformed JSON, wrong ids, unknown options and missing
+ * required input all fail closed.
+ */
+export function parseGateDecision(request: ApprovalRequest, line: string): GateDecisionResult {
+    let payload: any;
+    try {
+        payload = JSON.parse(line);
+    }
+    catch {
+        return { decision: { kind: "deny", reason: "malformed JSON decision" }, error: "malformed JSON" };
+    }
+    if (!payload || typeof payload !== "object" || payload.version !== GATE_PROTOCOL_VERSION)
+        return { decision: { kind: "deny", reason: "unsupported gate protocol version" }, error: "version" };
+    if (payload.event !== "gate:decision")
+        return { decision: { kind: "deny", reason: "unexpected gate event" }, error: "event" };
+    if (payload.id !== request.id)
+        return { decision: { kind: "deny", reason: "decision id does not match the pending request" }, error: "id" };
+    if (request.freeInput?.enabled && (typeof payload.input !== "string" || payload.input.trim() === ""))
+        return { decision: { kind: "deny", reason: "required free input is missing" }, error: "input" };
+    const option = request.options.find((entry, index) => optionId(entry, index) === payload.option);
+    if (!option)
+        return { decision: { kind: "deny", reason: "unknown approval option id" }, error: "option" };
+    if (option.kind === "feedback") {
+        const text = typeof payload.input === "string" ? payload.input.trim() : "";
+        if (!text)
+            return { decision: { kind: "deny", reason: "feedback input is required" }, error: "feedback" };
+        return { decision: { kind: "feedback", text } };
+    }
+    return { decision: decisionForOption(option) };
+}

package/src/agent/approval-native.ts

@@ -0,0 +1,168 @@
+/**
+ * Termux:API approval sheet.
+ *
+ * Returns undefined when termux-dialog is missing/times out/crashes so the
+ * caller can fall back to the TUI. A real cancellation returns a deny.
+ * The command is built with spawn args (no shell interpolation).
+ */
+import { spawn } from "node:child_process";
+import { decisionForOption, type ApprovalDecision, type ApprovalRequest } from "./approval.js";
+
+export function nativeDecisionFromPayload(request: ApprovalRequest, payload: any): ApprovalDecision | undefined {
+    if (payload?.code === -1)
+        return { kind: "deny", reason: "termux-dialog cancelled" };
+    if (payload?.code !== 0 || !Number.isInteger(payload.index) ||
+        payload.index < 0 || payload.index >= request.options.length)
+        return { kind: "deny", reason: "termux-dialog returned an invalid selection" };
+    return decisionForOption(request.options[payload.index]);
+}
+
+async function nativeFeedback(prompt: string, signal?: AbortSignal, timeoutMs = 60_000): Promise<string | undefined> {
+    if (signal?.aborted)
+        return undefined;
+    return await new Promise((resolve) => {
+        let settled = false;
+        let child: ReturnType<typeof spawn> | undefined;
+        let timer: ReturnType<typeof setTimeout> | undefined;
+        const finish = (value: string | undefined) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+            resolve(value);
+        };
+        const onAbort = () => {
+            try {
+                child?.kill("SIGKILL");
+            }
+            catch {
+                // Already gone.
+            }
+            finish(undefined);
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        child = spawn("termux-dialog", ["text", "-t", prompt], {
+            stdio: ["ignore", "pipe", "ignore"],
+            windowsHide: true,
+        });
+        let stdout = "";
+        child.stdout?.setEncoding("utf8");
+        child.stdout?.on("data", (chunk: string) => {
+            stdout += chunk;
+        });
+        child.on("error", () => finish(undefined));
+        child.on("close", () => {
+            let payload: any;
+            try {
+                payload = JSON.parse(stdout.trim());
+            }
+            catch {
+                finish(undefined);
+                return;
+            }
+            if (payload?.code === 0 && typeof payload.text === "string")
+                finish(payload.text);
+            else
+                finish(undefined);
+        });
+        timer = setTimeout(() => {
+            try {
+                child?.kill("SIGKILL");
+            }
+            catch {
+                // Already gone.
+            }
+            finish(undefined);
+        }, Math.max(1000, timeoutMs));
+        timer.unref?.();
+    });
+}
+
+export async function nativeApproval(request: ApprovalRequest, signal?: AbortSignal): Promise<ApprovalDecision | undefined> {
+    if (signal?.aborted)
+        return { kind: "deny", reason: "approval cancelled" };
+    const labels = request.options.map((option) => option.label);
+    const title = request.prompt ?? `Approval: ${request.tool}`;
+    return await new Promise((resolve) => {
+        let settled = false;
+        let child: ReturnType<typeof spawn> | undefined;
+        let timer: ReturnType<typeof setTimeout> | undefined;
+        const finish = (value: ApprovalDecision | undefined) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+            resolve(value);
+        };
+        const onAbort = () => {
+            try {
+                child?.kill("SIGKILL");
+            }
+            catch {
+                // Already gone.
+            }
+            finish({ kind: "deny", reason: "approval cancelled" });
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        child = spawn("termux-dialog", ["sheet", "-v", labels.join(","), "-t", title], {
+            stdio: ["ignore", "pipe", "ignore"],
+            windowsHide: true,
+        });
+        let stdout = "";
+        child.stdout?.setEncoding("utf8");
+        child.stdout?.on("data", (chunk: string) => {
+            stdout += chunk;
+        });
+        child.on("error", () => finish(undefined));
+        child.on("close", async () => {
+            let payload: any;
+            try {
+                payload = JSON.parse(stdout.trim());
+            }
+            catch {
+                finish(undefined);
+                return;
+            }
+            const selected = payload?.code === 0 && Number.isInteger(payload.index)
+                ? request.options[payload.index]
+                : undefined;
+            if (selected?.kind === "feedback") {
+                if (timer) {
+                    clearTimeout(timer);
+                    timer = undefined;
+                }
+                const prompt = selected.prompt || "Why should this be denied?";
+                const text = await nativeFeedback(prompt, signal, request.timeoutMs);
+                if (signal?.aborted) {
+                    finish({ kind: "deny", reason: "approval cancelled" });
+                    return;
+                }
+                if (typeof text !== "string") {
+                    // Text dialog unavailable/cancelled: fall back to the TUI prompt.
+                    finish(undefined);
+                    return;
+                }
+                const feedback = text.trim();
+                finish(feedback
+                    ? { kind: "feedback", text: feedback }
+                    : { kind: "deny", reason: "feedback was empty (fail closed)" });
+                return;
+            }
+            finish(nativeDecisionFromPayload(request, payload));
+        });
+        timer = setTimeout(() => {
+            try {
+                child?.kill("SIGKILL");
+            }
+            catch {
+                // Already gone.
+            }
+            finish(undefined);
+        }, Math.max(1000, request.timeoutMs ?? 60_000));
+        timer.unref?.();
+    });
+}

package/src/agent/approval-store.ts

@@ -0,0 +1,38 @@
+/**
+ * Approval scope storage.
+ *
+ * - once: no persistence
+ * - session: in-memory, implicitly cleared when the process exits
+ * - always: ~/.fastcode/trusted.json `tools` entry bound to catalogHash
+ *
+ * Keys include the normalized tool-call fingerprint so "always" cannot grant
+ * every future shell command from one approval.
+ */
+import type { ApprovalScope } from "./approval.js";
+import type { ToolCall } from "./tools/types.js";
+import { toolCallFingerprint } from "./guards.js";
+import { isToolApproved, rememberToolApproval } from "../config/trust.js";
+
+const sessionApprovals = new Set<string>();
+
+export function approvalKey(tool: string, call: ToolCall, cwd: string): string {
+    return `${tool}:${toolCallFingerprint(call, cwd)}`;
+}
+
+export function isPreApproved(key: string, catalogHash: string): boolean {
+    return sessionApprovals.has(`${catalogHash}:${key}`) || isToolApproved(key, catalogHash);
+}
+
+export function rememberApproval(key: string, catalogHash: string, scope: ApprovalScope): void {
+    if (scope === "once")
+        return;
+    if (scope === "session") {
+        sessionApprovals.add(`${catalogHash}:${key}`);
+        return;
+    }
+    rememberToolApproval(key, catalogHash);
+}
+
+export function clearSessionApprovals(): void {
+    sessionApprovals.clear();
+}