@datename/fastcode-termux 0.1.6-beta → 0.1.6

package/dist/config/store.js

@@ -5,12 +5,14 @@
  * edit it from `nano ~/.fastcode/config.json` if needed. Atomic writes prevent
  * partial files on Ctrl+C.
  *
- * API keys are scoped to a provider, not to a model. auth.json stores one
- * credential per provider id, so switching between models of the same provider
- * reuses the same key. The old "provider::model" (v2) and provider-only (v1)
- * formats are read and migrated to the provider-scoped v3 layout on first load.
+ * API keys are NOT a single global string: each one is scoped to a concrete
+ * "provider + model" pair. auth.json stores one credential per
+ * `<provider>::<model>` scope, and a stored key is only used when the current
+ * provider AND model match that scope. The old provider-only format is read as
+ * "legacy": it is shown back to the user but never used silently, because a
+ * provider-only key does not tell us which model it was meant for.
  */
-import { readFileSync, writeFileSync, existsSync, renameSync, copyFileSync } from "node:fs";
+import { readFileSync, writeFileSync, existsSync, renameSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { getPaths, lockdown, ensureDir } from "./paths.js";
 import { DEFAULT_THEME } from "./themes.js";
@@ -27,26 +29,7 @@ export const DEFAULT_CONFIG = {
     enabledPlugins: [],
     skillsRegistry: "https://skillshub.wtf",
     lifetimeCostUsd: 0,
-    /**
-     * Extra directories the file tools may read and write outside the project
-     * root. Relative entries are resolved against the project root; `~/` is
-     * expanded against the user's home directory.
-     */
-    sharedDirs: [],
-    /** Maximum agent tool turns before the loop asks the user to continue. */
-    maxAgentTurns: 24,
-    /** Abort a stream that receives no data for this long (ms). */
-    requestIdleTimeoutMs: 60_000,
-    /** Approximate character budget before history compaction kicks in. */
-    contextBudgetChars: 400_000,
-    /** Thinking depth: auto = send nothing, provider default. */
-    reasoningEffort: "auto",
-    /** Cached per-provider/model capabilities (native vs pseudo tool calling). */
-    capabilities: {
-        toolCalling: {},
-    },
 };
-export const AUTH_VERSION = 3;
 export function loadConfig() {
     const { config } = getPaths();
     if (!existsSync(config))
@@ -63,97 +46,58 @@ export function saveConfig(cfg) {
     const { config } = getPaths();
     atomicWrite(config, JSON.stringify(cfg, null, 2));
 }
-/** Composite id used by the legacy v2 format; kept for API compatibility. */
+/** Composite scope id for a provider + model credential. */
 export function scopeId(providerId, model) {
     return `${providerId}::${model}`;
 }
-/** Pick the most recently saved credential when several legacy scopes map to one provider. */
-function keepNewest(keys, credential) {
-    const existing = keys[credential.provider];
-    if (!existing) {
-        keys[credential.provider] = credential;
-        return;
-    }
-    const previous = Date.parse(existing.addedAt || "") || 0;
-    const next = Date.parse(credential.addedAt || "") || 0;
-    if (next > previous)
-        keys[credential.provider] = credential;
-}
-let migrationChecked = false;
 export function loadAuth() {
     const { auth } = getPaths();
-    const empty = { version: AUTH_VERSION, keys: {}, legacy: {} };
+    const empty = { version: 2, keys: {}, legacy: {} };
     if (!existsSync(auth))
         return empty;
-    let raw;
     try {
-        raw = JSON.parse(readFileSync(auth, "utf8"));
-    }
-    catch {
-        return empty;
-    }
-    if (!raw || typeof raw !== "object")
-        return empty;
-    const keys = {};
-    const legacy = {};
-    let migrated = false;
-    const source = raw.keys && typeof raw.keys === "object" ? raw.keys : {};
-    for (const [id, value] of Object.entries(source)) {
-        if (value && typeof value === "object" && typeof value.key === "string" && value.key.trim()) {
-            const [idProvider, idModel] = id.split("::");
-            const provider = typeof value.provider === "string" && value.provider ? value.provider : idProvider || id;
-            const model = typeof value.model === "string" ? value.model : idModel || "";
-            if (id.includes("::") || raw.version !== AUTH_VERSION)
-                migrated = true;
-            keepNewest(keys, {
-                provider,
-                model,
-                key: value.key,
-                addedAt: typeof value.addedAt === "string" ? value.addedAt : "",
-            });
-        }
-        else if (typeof value === "string" && value.trim()) {
-            // v1: keys were plain provider -> key strings.
-            keepNewest(keys, { provider: id, key: value, addedAt: "" });
-            migrated = true;
+        const raw = JSON.parse(readFileSync(auth, "utf8"));
+        const keys = {};
+        const legacy = {};
+        const source = raw && typeof raw === "object" ? (raw.keys ?? {}) : {};
+        for (const [id, value] of Object.entries(source)) {
+            if (value && typeof value === "object" && typeof value.key === "string") {
+                const [idProvider, idModel] = id.split("::");
+                const provider = value.provider || idProvider || id;
+                const model = value.model || idModel || "";
+                keys[scopeId(provider, model)] = {
+                    provider,
+                    model,
+                    key: value.key,
+                    addedAt: value.addedAt ?? "",
+                };
+            }
+            else if (typeof value === "string" && value.trim()) {
+                legacy[id] = value;
+            }
         }
-    }
-    if (raw.legacy && typeof raw.legacy === "object") {
-        for (const [provider, value] of Object.entries(raw.legacy)) {
-            if (typeof value === "string" && value.trim()) {
-                // Provider-only keys are exactly what v3 wants: migrate instead
-                // of leaving them unusable.
-                keepNewest(keys, { provider, key: value, addedAt: "" });
-                migrated = true;
+        if (raw && typeof raw === "object" && raw.legacy && typeof raw.legacy === "object") {
+            for (const [id, value] of Object.entries(raw.legacy)) {
+                if (typeof value === "string" && value.trim())
+                    legacy[id] = value;
             }
         }
+        return { version: 2, keys, legacy };
     }
-    if (migrated && !migrationChecked) {
-        try {
-            // Keep the pre-migration file so a user with several old model
-            // keys can recover a credential we had to collapse.
-            const backup = auth + ".v2.bak";
-            if (!existsSync(backup))
-                copyFileSync(auth, backup);
-            writeAuth({ version: AUTH_VERSION, keys, legacy });
-        }
-        catch {
-            // Read-only home (or locked file): keep the migrated view in memory.
-        }
+    catch {
+        return empty;
     }
-    migrationChecked = true;
-    return { version: AUTH_VERSION, keys, legacy };
 }
-function writeAuth(store) {
+export function saveAuth(store) {
     const { auth } = getPaths();
-    atomicWrite(auth, JSON.stringify({ version: AUTH_VERSION, keys: store.keys }, null, 2));
+    const payload = { version: 2, keys: store.keys };
+    if (Object.keys(store.legacy).length > 0)
+        payload.legacy = store.legacy;
+    atomicWrite(auth, JSON.stringify(payload, null, 2));
     lockdown(auth);
 }
-export function saveAuth(store) {
-    writeAuth(store);
-}
-export function getCredential(providerId, _model) {
-    return loadAuth().keys[providerId];
+export function getCredential(providerId, model) {
+    return loadAuth().keys[scopeId(providerId, model)];
 }
 export function listCredentials() {
     return Object.values(loadAuth().keys);
@@ -164,7 +108,7 @@ export function listLegacy() {
 export function getLegacy(providerId) {
     return loadAuth().legacy[providerId];
 }
-/** Save/replace the provider-wide credential (drops any legacy key). */
+/** Save/replace the credential for one provider+model scope (drops the legacy key). */
 export function setCredential(providerId, model, key) {
     const store = loadAuth();
     const credential = {
@@ -173,26 +117,29 @@ export function setCredential(providerId, model, key) {
         key: key.trim(),
         addedAt: new Date().toISOString(),
     };
-    store.keys[providerId] = credential;
+    store.keys[scopeId(providerId, model)] = credential;
     delete store.legacy[providerId];
     saveAuth(store);
     return credential;
 }
-export function removeCredential(providerId, _model) {
+export function removeCredential(providerId, model) {
     const store = loadAuth();
-    if (!store.keys[providerId])
+    const id = scopeId(providerId, model);
+    if (!store.keys[id])
         return false;
-    delete store.keys[providerId];
+    delete store.keys[id];
     saveAuth(store);
     return true;
 }
-/** Remove the provider-wide credential plus any legacy leftovers. */
+/** Remove every credential for a provider (all models) plus its legacy key. */
 export function removeCredentialsForProvider(providerId) {
     const store = loadAuth();
     let removed = 0;
-    if (store.keys[providerId]) {
-        delete store.keys[providerId];
-        removed += 1;
+    for (const id of Object.keys(store.keys)) {
+        if (store.keys[id].provider === providerId) {
+            delete store.keys[id];
+            removed += 1;
+        }
     }
     if (store.legacy[providerId]) {
         delete store.legacy[providerId];
@@ -212,16 +159,16 @@ export function maskKey(key) {
     return value.slice(0, 3) + "****" + value.slice(-4);
 }
 /**
- * Resolve the key to use for a provider:
- *   1. the provider-wide credential in auth.json,
+ * Resolve the key to use for a specific provider+model:
+ *   1. the scoped credential in auth.json (exact provider+model match), then
  *   2. the provider's environment variable (provider-scoped, any model), and
- *   3. a legacy provider-only key that somehow escaped migration.
+ *   3. report an "unbound" legacy key instead of using it silently.
  */
-export function resolveApiKey(providerId, _model, envVars) {
+export function resolveApiKey(providerId, model, envVars) {
     const store = loadAuth();
-    const credential = store.keys[providerId];
-    if (credential && credential.key)
-        return { status: "ok", key: credential.key, source: "file" };
+    const scoped = store.keys[scopeId(providerId, model)];
+    if (scoped && scoped.key)
+        return { status: "ok", key: scoped.key, source: "file" };
     for (const envVar of envVars ?? []) {
         const value = process.env[envVar];
         if (value && value.trim())
@@ -234,9 +181,10 @@ export function resolveApiKey(providerId, _model, envVars) {
 /** Best-effort key for a provider regardless of model (used to list models). */
 export function resolveProviderKey(providerId, envVars) {
     const store = loadAuth();
-    const credential = store.keys[providerId];
-    if (credential && credential.key)
-        return { key: credential.key, source: "file" };
+    for (const credential of Object.values(store.keys)) {
+        if (credential.provider === providerId && credential.key)
+            return { key: credential.key, source: "file" };
+    }
     for (const envVar of envVars ?? []) {
         const value = process.env[envVar];
         if (value && value.trim())

package/dist/config/trust.d.ts

@@ -1,22 +1,9 @@
-export interface TrustPathEntry {
-    grantedAt: string;
-    lastUsed: string;
-}
-export interface TrustToolEntry extends TrustPathEntry {
-    catalogHash: string;
-}
-export interface TrustStore {
-    version: 1;
-    tools: Record<string, TrustToolEntry>;
-    paths: Record<string, TrustPathEntry>;
-}
-export declare function normalizeProjectPath(dir: string): string;
-export declare function loadTrust(): TrustStore;
+export declare function normalizeProjectPath(dir: any): string;
+export declare function loadTrust(): {
+    trusted: any;
+};
 export declare function trustAllEnabled(): boolean;
-export declare function isTrusted(dir: string): boolean;
-export declare function trustProject(dir: string): string;
-export declare function untrustProject(dir: string): boolean;
-export declare function listTrusted(): Array<{
-    path: string;
-    addedAt: string;
-}>;
+export declare function isTrusted(dir: any): any;
+export declare function trustProject(dir: any): string;
+export declare function untrustProject(dir: any): boolean;
+export declare function listTrusted(): any;

package/dist/config/trust.js

@@ -7,11 +7,10 @@
  *
  * FASTCODE_TRUST_ALL=1 marks every directory trusted (scripts, CI).
  */
-import { existsSync, readFileSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { ensureDir, getPaths } from "./paths.js";
 const TRUTHY = ["1", "true", "yes", "on"];
-let cache;
 export function normalizeProjectPath(dir) {
     const absolute = resolve(dir);
     try {
@@ -21,104 +20,22 @@ export function normalizeProjectPath(dir) {
         return absolute;
     }
 }
-function emptyStore() {
-    return { version: 1, tools: {}, paths: {} };
-}
-function normalizePaths(raw) {
-    const paths = {};
-    if (!raw || typeof raw !== "object")
-        return paths;
-    for (const [key, value] of Object.entries(raw)) {
-        if (!key || !value || typeof value !== "object")
-            continue;
-        paths[key] = {
-            grantedAt: typeof value.grantedAt === "string" ? value.grantedAt : "",
-            lastUsed: typeof value.lastUsed === "string" ? value.lastUsed : "",
-        };
-    }
-    return paths;
-}
-function normalizeTools(raw) {
-    const tools = {};
-    if (!raw || typeof raw !== "object")
-        return tools;
-    for (const [key, value] of Object.entries(raw)) {
-        if (!key || !value || typeof value !== "object" || typeof value.catalogHash !== "string")
-            continue;
-        tools[key] = {
-            grantedAt: typeof value.grantedAt === "string" ? value.grantedAt : "",
-            lastUsed: typeof value.lastUsed === "string" ? value.lastUsed : "",
-            catalogHash: value.catalogHash,
-        };
-    }
-    return tools;
-}
-function migrateLegacy(raw) {
-    if (!raw || typeof raw !== "object" || !Array.isArray(raw.trusted))
-        return undefined;
-    const store = emptyStore();
-    for (const entry of raw.trusted) {
-        if (!entry || typeof entry.path !== "string" || !entry.path)
-            continue;
-        const at = typeof entry.addedAt === "string" ? entry.addedAt : new Date().toISOString();
-        store.paths[entry.path] = { grantedAt: at, lastUsed: at };
-    }
-    return store;
-}
-function readStore(file) {
-    if (!existsSync(file))
-        return emptyStore();
-    try {
-        const raw = JSON.parse(readFileSync(file, "utf8"));
-        if (raw && raw.version === 1) {
-            return {
-                version: 1,
-                tools: normalizeTools(raw.tools),
-                paths: normalizePaths(raw.paths),
-            };
-        }
-        const migrated = migrateLegacy(raw);
-        if (!migrated)
-            return emptyStore();
-        try {
-            writeFileSync(file, JSON.stringify(migrated, null, 2), "utf8");
-        }
-        catch {
-            // A read-only home still gets the migrated view in memory.
-        }
-        return migrated;
-    }
-    catch {
-        return emptyStore();
-    }
-}
 export function loadTrust() {
     const { trust } = getPaths();
-    let key = "missing";
+    if (!existsSync(trust))
+        return { trusted: [] };
     try {
-        const info = statSync(trust);
-        key = `${info.mtimeMs}:${info.size}`;
+        const raw = JSON.parse(readFileSync(trust, "utf8"));
+        return { trusted: Array.isArray(raw.trusted) ? raw.trusted.filter((entry) => entry && typeof entry.path === "string") : [] };
     }
     catch {
-        // Missing file: cache the empty store until it appears.
+        return { trusted: [] };
     }
-    if (cache && cache.file === trust && cache.key === key)
-        return cache.state;
-    const state = readStore(trust);
-    cache = { file: trust, key, state };
-    return state;
 }
 function saveTrust(state) {
     const paths = getPaths();
     ensureDir(paths.root);
     writeFileSync(paths.trust, JSON.stringify(state, null, 2), "utf8");
-    try {
-        const info = statSync(paths.trust);
-        cache = { file: paths.trust, key: `${info.mtimeMs}:${info.size}`, state };
-    }
-    catch {
-        cache = undefined;
-    }
 }
 export function trustAllEnabled() {
     return TRUTHY.includes((process.env["FASTCODE_TRUST_ALL"] ?? "").trim().toLowerCase());
@@ -127,14 +44,13 @@ export function isTrusted(dir) {
     if (trustAllEnabled())
         return true;
     const target = normalizeProjectPath(dir);
-    return Boolean(loadTrust().paths[target]);
+    return loadTrust().trusted.some((entry) => entry.path === target);
 }
 export function trustProject(dir) {
     const target = normalizeProjectPath(dir);
     const state = loadTrust();
-    if (!state.paths[target]) {
-        const at = new Date().toISOString();
-        state.paths[target] = { grantedAt: at, lastUsed: at };
+    if (!state.trusted.some((entry) => entry.path === target)) {
+        state.trusted.push({ path: target, addedAt: new Date().toISOString() });
         saveTrust(state);
     }
     return target;
@@ -142,12 +58,10 @@ export function trustProject(dir) {
 export function untrustProject(dir) {
     const target = normalizeProjectPath(dir);
     const state = loadTrust();
-    if (!state.paths[target])
-        return false;
-    delete state.paths[target];
-    saveTrust(state);
-    return true;
+    const next = state.trusted.filter((entry) => entry.path !== target);
+    saveTrust({ trusted: next });
+    return state.trusted.length !== next.length;
 }
 export function listTrusted() {
-    return Object.entries(loadTrust().paths).map(([path, entry]) => ({ path, addedAt: entry.grantedAt }));
+    return loadTrust().trusted;
 }

package/dist/lib/diagnostics.d.ts

@@ -12,54 +12,29 @@ export declare function collectDiagnostics(): {
     configRoot: any;
     configFile: any;
     authFile: any;
-    authMode: string;
-    tmpdir: string;
-    memTotalMb: number;
-    memFreeMb: number;
     providerId: any;
     model: any;
     keyPresent: boolean;
-    keyStatus: "ok" | "missing" | "unbound";
-    keyEnv: string;
+    keyStatus: "ok" | "unbound" | "missing";
+    keyEnv: any;
     skillsInstalled: number;
     pluginsInstalled: number;
     enabledSkills: any;
     enabledPlugins: any;
     sessionLogEnabled: boolean;
     sessionCacheMb: number;
-    sessionFsync: "auto" | "off" | "on";
-    unclosedSessions: number;
     sessionsDir: any;
     sessionsCount: number;
     sessionsBytes: number;
     trustFile: any;
-    trusted: boolean;
+    trusted: any;
     shellDenyPatterns: number;
     allowDangerous: boolean;
     toolOutputLimit: number;
-    tokenBudget: number;
-    costBudgetUsd: number;
-    compactionEnabled: boolean;
-    compactionRatio: number;
-    compactionHeapMb: number;
-    compactionHeapUsedMb: number;
-    compactionForced: boolean;
-    serverCompactionAware: boolean;
-    shellActive: number;
-    shellPool: number;
-    shellSpawns: number;
-    shellMaxSpawn: number;
-    sseIdleMs: number;
-    toolProtocol: import("../agent/protocol-mode.js").ToolProtocol;
-    toolProtocolMode: string;
-    toolCapability: any;
-    loopExempt: string[];
-    modelMetaFile: string;
-    modelMeta: import("./model-meta.js").ModelMeta;
     providers: {
         id: string;
         label: string;
-        env: string[];
+        env: any[] | string[];
         keyPresent: boolean;
     }[];
 };

package/dist/lib/diagnostics.js

@@ -5,8 +5,6 @@
  * diagnosed without opening the TUI: Node version, Termux detection, whether
  * stdout is a real terminal, the config root, and which provider keys exist.
  */
-import { existsSync, statSync } from "node:fs";
-import { totalmem, freemem, tmpdir as osTmpdir } from "node:os";
 import { detectPlatform, platformLabel } from "./platform.js";
 import { readPackageMeta } from "./pkg.js";
 import { shouldUseStableTerminalUi } from "./uiMode.js";
@@ -15,14 +13,10 @@ import { loadConfig, resolveApiKey, resolveProviderKey } from "../config/store.j
 import { PROVIDERS } from "../providers/index.js";
 import { listInstalledSkills } from "../skills/manager.js";
 import { listInstalledPlugins } from "../plugins/manager.js";
-import { findUnclosedSessions, fsyncMode, loggingEnabled, listSessions, sessionCacheLimitBytes } from "../session/log.js";
+import { loggingEnabled, listSessions, sessionCacheLimitBytes } from "../session/log.js";
 import { isTrusted } from "../config/trust.js";
-import { DEFAULT_DENY_PATTERNS, loopExemptTools } from "../agent/guards.js";
+import { DEFAULT_DENY_PATTERNS } from "../agent/guards.js";
 import { toolOutputLimit } from "../agent/limits.js";
-import { compactionConfigFromEnv, heapExceeded } from "../agent/compaction.js";
-import { shellPoolStats } from "../agent/shell-session.js";
-import { resolveToolProtocol, toolCapabilityKey } from "../agent/protocol-mode.js";
-import { getModelMeta, modelMetaOverridePath } from "./model-meta.js";
 const NODE_REQUIRED = "18.17";
 function readVersion() {
     return readPackageMeta().version;
@@ -61,16 +55,6 @@ export function collectDiagnostics() {
         // Same for plugins.
     }
     const platform = detectPlatform();
-    const compaction = compactionConfigFromEnv();
-    const shells = shellPoolStats();
-    let authMode = "missing";
-    try {
-        if (paths?.auth && existsSync(paths.auth))
-            authMode = (statSync(paths.auth).mode & 0o777).toString(8).padStart(4, "0");
-    }
-    catch {
-        authMode = "unreadable";
-    }
     return {
         version: readVersion(),
         node: process.version,
@@ -85,10 +69,6 @@ export function collectDiagnostics() {
         configRoot: paths?.root,
         configFile: paths?.config,
         authFile: paths?.auth,
-        authMode,
-        tmpdir: process.env["TMPDIR"] || osTmpdir(),
-        memTotalMb: totalmem() / 1024 / 1024,
-        memFreeMb: freemem() / 1024 / 1024,
         providerId: config.providerId,
         model: config.model,
         keyPresent,
@@ -100,8 +80,6 @@ export function collectDiagnostics() {
         enabledPlugins: (config.enabledPlugins ?? []).length,
         sessionLogEnabled: loggingEnabled(),
         sessionCacheMb: Math.round(sessionCacheLimitBytes() / (1024 * 1024)),
-        sessionFsync: fsyncMode(),
-        unclosedSessions: findUnclosedSessions().length,
         sessionsDir: paths?.sessions,
         sessionsCount: listSessions().length,
         sessionsBytes: listSessions().reduce((sum, entry) => sum + entry.bytes, 0),
@@ -110,25 +88,6 @@ export function collectDiagnostics() {
         shellDenyPatterns: DEFAULT_DENY_PATTERNS.length,
         allowDangerous: ["1", "true", "yes", "on"].includes((process.env["FASTCODE_ALLOW_DANGEROUS"] ?? "").trim().toLowerCase()),
         toolOutputLimit: toolOutputLimit(),
-        tokenBudget: positiveEnv("FASTCODE_TOKEN_BUDGET"),
-        costBudgetUsd: positiveEnv("FASTCODE_COST_BUDGET_USD"),
-        compactionEnabled: compaction.enabled,
-        compactionRatio: compaction.localThresholdRatio,
-        compactionHeapMb: compaction.heapLimitMb,
-        compactionHeapUsedMb: process.memoryUsage().heapUsed / 1024 / 1024,
-        compactionForced: heapExceeded(compaction),
-        serverCompactionAware: compaction.serverCompactionAware,
-        shellActive: shells.active,
-        shellPool: shells.pool,
-        shellSpawns: shells.spawns,
-        shellMaxSpawn: shells.maxSpawnPerTurn,
-        sseIdleMs: positiveEnv("FASTCODE_SSE_IDLE_MS") || 25_000,
-        toolProtocol: resolveToolProtocol(config, config.providerId, config.model),
-        toolProtocolMode: (process.env["FASTCODE_TOOL_PROTOCOL"] ?? "legacy").trim().toLowerCase(),
-        toolCapability: config.capabilities?.toolCalling?.[toolCapabilityKey(config.providerId, config.model)] ?? "unknown",
-        loopExempt: Array.from(loopExemptTools()),
-        modelMetaFile: modelMetaOverridePath(),
-        modelMeta: getModelMeta(config.providerId, config.model),
         providers: PROVIDERS.map((p) => ({
             id: p.id,
             label: p.label,
@@ -137,10 +96,6 @@ export function collectDiagnostics() {
         })),
     };
 }
-function positiveEnv(name) {
-    const value = Number(process.env[name]);
-    return Number.isFinite(value) && value > 0 ? value : 0;
-}
 export function formatDiagnostics(info) {
     const lines = [];
     lines.push(`FastCode ${info.version} — environment check`);
@@ -151,21 +106,12 @@ export function formatDiagnostics(info) {
     lines.push(`  stable UI     ${info.stableUi ? "on (anti-flicker)" : "off"}`);
     lines.push("  config root   " + (info.configRoot ?? "(unavailable)"));
     lines.push("  config file   " + (info.configFile ?? "(unavailable)"));
-    lines.push("  keys file     " + (info.authFile ?? "(unavailable)") + "   mode " + info.authMode + (info.authMode !== "missing" && info.authMode !== "0600" ? "  [WARN: expected 0600]" : ""));
-    lines.push("  tmpdir        " + info.tmpdir + (info.termux && !String(info.tmpdir).startsWith("/data/data/com.termux") ? "  [WARN: use $PREFIX/tmp]" : ""));
-    lines.push("  memory        " + info.memFreeMb.toFixed(0) + "MB free / " + info.memTotalMb.toFixed(0) + "MB total");
+    lines.push("  keys file     " + (info.authFile ?? "(unavailable)") + "   (separate, chmod 0600)");
     lines.push("  trusted cwd   " + (info.trusted ? "yes" : "NO - agent tools ask first or stay off") + "   (" + (info.trustFile ?? "?") + ")");
     lines.push("  session log   " + (info.sessionLogEnabled ? "on" : "off") + "   cache cap " + info.sessionCacheMb + "MB, " + info.sessionsCount + " file(s), " + (info.sessionsBytes / 1024 / 1024).toFixed(2) + "MB used");
-    lines.push("  session fsync " + info.sessionFsync + "   unclosed " + info.unclosedSessions + "   " + (info.sessionsDir ?? "(unavailable)"));
+    lines.push("  session dir   " + (info.sessionsDir ?? "(unavailable)"));
     lines.push("  shell guard   " + info.shellDenyPatterns + " deny patterns" + (info.allowDangerous ? "   [FASTCODE_ALLOW_DANGEROUS is ON]" : ""));
     lines.push("  tool output   " + info.toolOutputLimit + " chars max (streaming cap)");
-    lines.push(`  budgets       ${info.tokenBudget > 0 ? "tokens ≤ " + info.tokenBudget : "token budget off"} · ${info.costBudgetUsd > 0 ? "$" + info.costBudgetUsd : "cost budget off"}`);
-    lines.push(`  compaction    ${info.compactionEnabled ? "on" : "off"} · ${Math.round(info.compactionRatio * 100)}% · heap ${info.compactionHeapUsedMb.toFixed(1)}/${info.compactionHeapMb}MB${info.compactionForced ? " [FORCED]" : ""}${info.serverCompactionAware ? " · server-aware" : ""}`);
-    lines.push(`  shell pool    ${info.shellActive} active · ${info.shellPool} resident · ${info.shellSpawns} spawns · cap ${info.shellMaxSpawn}/turn`);
-    lines.push(`  loop exempt   ${info.loopExempt.length > 0 ? info.loopExempt.join(", ") : "(none)"}`);
-    lines.push(`  model meta    ctx ${info.modelMeta.contextWindow} · ~${info.modelMeta.charsPerToken} chars/token · ${info.modelMeta.supportsTools ? "tools" : "no tools"} · ${info.modelMetaFile}`);
-    lines.push(`  sse timeout   ${info.sseIdleMs}ms idle`);
-    lines.push(`  tool protocol ${info.toolProtocol} (${info.toolProtocolMode}) · cached ${info.toolCapability}`);
     lines.push(`  provider      ${info.providerId} · model ${info.model}`);
     let apiKeyStatus;
     if (info.keyPresent)
@@ -188,8 +134,6 @@ export function formatDiagnostics(info) {
         lines.push("    - pkg install nodejs git");
         lines.push("    - keep the session alive with: termux-wake-lock");
         lines.push("    - add an extra-keys row for Esc/Ctrl in ~/.termux/termux.properties");
-        lines.push("    - long tasks: export TMPDIR=$PREFIX/tmp and use termux-wake-lock");
-        lines.push(`    - Android 12+ caps phantom processes (~32); background shells are pooled (${info.shellPool} resident, cap ${info.shellMaxSpawn}/turn)`);
     }
     return lines.join("\n");
 }

package/dist/lib/http.d.ts

@@ -6,18 +6,8 @@
  * Anthropic's older streaming) handle their own parsing.
  */
 export declare function fetchJson(url: string, init?: any): Promise<any>;
-export declare class NetworkStallError extends Error {
-    readonly code = "NETWORK_STALL";
-    readonly bytesReceived: number;
-    constructor(message: string, bytesReceived?: number);
-}
-export interface StreamSseOptions {
-    idleTimeoutMs?: number;
-    totalTimeoutMs?: number;
-}
 /** Async iterator over SSE events from a streaming HTTP response. */
-export declare function streamSSE(res: any, options?: StreamSseOptions): AsyncGenerator<{
+export declare function streamSSE(res: any): AsyncGenerator<{
     event: any;
     data: string;
 }, void, unknown>;
-export declare function probeConnectivity(url: string, timeoutMs?: number): Promise<boolean>;