@code-yeongyu/senpi 2026.11.6-1 → 2026.11.6-2

package/dist/core/session-store/durable-binding.js

@@ -78,6 +78,12 @@ export class DurableSessionBinding {
         this.stale = false;
         // Bumped by every store commit: a deferred whole-image ledger record is skipped once a later write superseded it.
         this.generation = 0;
+        // Projected appends not yet in the ledger, in file order. A later append's record carries them, so a burst of appends
+        // keeps the ledger's prefix chain even though only the last one's record runs.
+        this.unrecordedTails = [];
+        // A whole-file write whose ledger record a later append superseded: the chain has no start until a record covers the
+        // whole file, so the next record writes today's whole image instead of the tails.
+        this.wholeUnrecorded = false;
         this.binding = binding;
         this.handle = handle;
         this.importer = importer;
@@ -134,10 +140,20 @@ export class DurableSessionBinding {
         const offset = this.projectedSize;
         this.projectedSize += Buffer.byteLength(entry.line) + 1;
         const sessionId = String(this.handle.header().id);
+        this.unrecordedTails.push({ key: entry.key, line: entry.line, offset });
         this.record(path, async () => {
+            const tails = [...this.unrecordedTails];
+            const whole = this.wholeUnrecorded ? projectionImage(this.handle.header(), this.handle.entries()) : undefined;
             const written = await stampOf(path);
-            if (written !== undefined)
-                await this.importer.recordProjectedTail(path, sessionId, { ...entry, offset }, written);
+            if (written === undefined)
+                return;
+            if (whole === undefined)
+                await this.importer.recordProjectedTail(path, sessionId, tails, written);
+            else
+                await this.importer.recordProjection(path, whole, written);
+            this.unrecordedTails.splice(0, tails.length);
+            if (whole !== undefined)
+                this.wholeUnrecorded = false;
         });
     }
     /** The caller wrote the whole file from today's serializer: record that image, unless a later write supersedes it. */
@@ -145,10 +161,14 @@ export class DurableSessionBinding {
         const path = resolve(sessionFile);
         const contents = projectionImage(this.handle.header(), this.handle.entries());
         this.projectedSize = Buffer.byteLength(contents);
+        this.unrecordedTails = [];
+        this.wholeUnrecorded = true;
         this.record(path, async () => {
             const written = await stampOf(path);
-            if (written !== undefined)
-                await this.importer.recordProjection(path, contents, written);
+            if (written === undefined)
+                return;
+            await this.importer.recordProjection(path, contents, written);
+            this.wholeUnrecorded = false;
         });
     }
     /** Marks the projection stale in the store (durable, so a crash before the repair still reprojects on open). */
@@ -198,6 +218,8 @@ export class DurableSessionBinding {
             this.binding.store.commitSync(this.binding.epoch, [{ op: "delete", key: staleKey(path) }], () => { });
             this.stale = false;
             this.projectedSize = Buffer.byteLength(contents);
+            this.unrecordedTails = [];
+            this.wholeUnrecorded = false;
             const written = await stampOf(path);
             if (written !== undefined && generation === this.generation) {
                 await this.importer.recordProjection(path, contents, written);

package/dist/core/settings-manager.d.ts

@@ -199,6 +199,15 @@ export interface SettingsManagerCreateOptions {
     projectTrusted?: boolean;
     /** The project trust exists only because the session runs Full access (senpi#3414): leaving it withdraws the trust. */
     trustFromFullAccess?: boolean;
+    /** The launch named the project trust explicitly (`--approve`/`--no-approve`): nothing in the session may change it. */
+    projectTrustLocked?: boolean;
+}
+/** The project settings file as stored, read whether or not the project is trusted (reading runs nothing). */
+export interface ProjectSettingsFile {
+    path: string;
+    exists: boolean;
+    settings: Settings | null;
+    error: string | null;
 }
 export interface SettingsStorage {
     withLock(scope: SettingsScope, fn: (current: string | undefined) => string | undefined): void;
@@ -293,6 +302,14 @@ export declare class SettingsManager {
     getSettings(): Settings;
     getGlobalSettings(): Settings;
     getProjectSettings(): Settings;
+    /** The project settings file at `path` as stored: parsed and migrated like a load, but never gated by trust. */
+    readProjectSettingsFile(path: string): ProjectSettingsFile;
+    /**
+     * Writes one top-level key of the project settings file (`null` removes it) through the same trusted-only,
+     * locked, merge-on-write path every project setter uses. Refuses a file that failed to load: that path skips
+     * the write silently, which an explicit caller must not mistake for success.
+     */
+    setProjectSetting(key: string, value: unknown): Promise<void>;
     getProviderSettings(): Record<string, ProviderConcurrencySettings>;
     getProviderConcurrencyLimit(providerId: string): number;
     subscribeToProviderSettings(listener: () => void): () => void;
@@ -322,6 +339,9 @@ export declare class SettingsManager {
     getTodoFirstTurnPlan(): TodoFirstTurnPlan;
     getTodoTurnEndBackstop(): boolean;
     isProjectTrusted(): boolean;
+    private projectTrustLocked;
+    /** True when the launch named the project trust explicitly; a trust decision saved in the session cannot apply. */
+    isProjectTrustLocked(): boolean;
     /**
      * True when this session's project trust came only from its Full access preset (never asked, never
      * saved): leaving Full access withdraws it, and going back restores it (senpi#3414, #3420).

package/dist/core/settings-manager.js

@@ -484,6 +484,7 @@ export class SettingsManager {
         this.selectedSources = new Map();
         this.sourceListeners = [];
         this.providerSettingsListeners = new Set();
+        this.projectTrustLocked = false;
         /**
          * True when this session's project trust came only from its Full access preset (never asked, never
          * saved): leaving Full access withdraws it, and going back restores it (senpi#3414, #3420).
@@ -534,6 +535,7 @@ export class SettingsManager {
         }
         const manager = new SettingsManager(storage, globalLoad.settings, projectLoad.settings, globalLoad.error, projectLoad.error, initialErrors, projectTrusted, initialSources, settingsPaths);
         manager.trustFromFullAccess = options.trustFromFullAccess === true;
+        manager.projectTrustLocked = options.projectTrustLocked === true;
         return manager;
     }
     /** Create an in-memory SettingsManager (no file I/O) */
@@ -695,6 +697,51 @@ export class SettingsManager {
     getProjectSettings() {
         return structuredClone(this.projectSettings);
     }
+    /** The project settings file at `path` as stored: parsed and migrated like a load, but never gated by trust. */
+    readProjectSettingsFile(path) {
+        let content;
+        try {
+            this.storage.withLock("project", (current) => {
+                content = current;
+                return undefined;
+            });
+            if (content === undefined)
+                return { path, exists: false, settings: null, error: null };
+            return {
+                path,
+                exists: true,
+                settings: SettingsManager.migrateSettings(parseSettingsJson(content)),
+                error: null,
+            };
+        }
+        catch (error) {
+            return { path, exists: content !== undefined, settings: null, error: String(error) };
+        }
+    }
+    /**
+     * Writes one top-level key of the project settings file (`null` removes it) through the same trusted-only,
+     * locked, merge-on-write path every project setter uses. Refuses a file that failed to load: that path skips
+     * the write silently, which an explicit caller must not mistake for success.
+     */
+    async setProjectSetting(key, value) {
+        this.assertProjectTrustedForWrite();
+        if (this.projectSettingsLoadError) {
+            throw new Error(`Project settings file could not be read; refusing to write: ${this.projectSettingsLoadError.message}`);
+        }
+        const field = key;
+        const recordedBefore = new Set(this.errors);
+        this.updateProjectSettings(field, (settings) => {
+            if (value === null)
+                delete settings[field];
+            else
+                settings[key] = value;
+        });
+        await this.flush();
+        // The queued write records its failure instead of throwing; an explicit caller is told.
+        const failure = this.errors.find((entry) => entry.scope === "project" && !recordedBefore.has(entry));
+        if (failure)
+            throw failure.error;
+    }
     getProviderSettings() {
         return structuredClone(this.settings.providers ?? {});
     }
@@ -785,6 +832,10 @@ export class SettingsManager {
     isProjectTrusted() {
         return this.projectTrusted;
     }
+    /** True when the launch named the project trust explicitly; a trust decision saved in the session cannot apply. */
+    isProjectTrustLocked() {
+        return this.projectTrustLocked;
+    }
     isTrustFromFullAccess() {
         return this.trustFromFullAccess && this.projectTrusted;
     }

package/dist/core/trust-manager.d.ts

@@ -1,3 +1,4 @@
+export { hasTrustRequiringProjectResources, projectAgentsSkillDirs } from "./trust-requiring-resources.ts";
 export type ProjectTrustDecision = boolean | null;
 export interface ProjectTrustStoreEntry {
     path: string;
@@ -17,24 +18,6 @@ export declare function getProjectTrustParentPath(cwd: string): string | undefin
 export declare function getProjectTrustOptions(cwd: string, options?: {
     includeSessionOnly?: boolean;
 }): ProjectTrustOption[];
-/**
- * The project `.agents/skills` directories for `cwd`, nearest first: one per folder from cwd up to
- * the git root (or the filesystem root), stopping below the user's home. Home and every folder
- * above it are never a project; `~/.agents/skills` is the user's own global skills. The ONE walk
- * both the trust check and the loader use, over the same spelling and the same git root (#3420
- * review): paths stay as spelled (resources are compared as strings), and each folder's real path
- * decides whether it is home or above, so a symlink can't carry the walk past home either way.
- */
-export declare function projectAgentsSkillDirs(cwd: string): string[];
-/**
- * Returns true when cwd has project-local resources that must be gated by
- * project trust: trust-requiring entries under the project config dir or the
- * legacy cwd/.pi dir (whose resources are also discovered), or a project
- * `.agents/skills` (`projectAgentsSkillDirs`, the same walk the loader uses).
- * The user's home and every folder above it are never a project: their config
- * dirs and .agents/skills are the user's own global resources (#2465).
- */
-export declare function hasTrustRequiringProjectResources(cwd: string): boolean;
 export declare class ProjectTrustStore {
     private trustPath;
     constructor(agentDir: string);

package/dist/core/trust-manager.js

@@ -1,70 +1,10 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { readFile, realpath, stat } from "node:fs/promises";
-import { homedir } from "node:os";
-import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, join, relative, resolve } from "node:path";
 import lockfile from "proper-lockfile";
-import { CONFIG_DIR_NAME } from "../config.js";
-import { canonicalizePath, canonicalizePathStrict, resolvePath } from "../utils/paths.js";
+import { canonicalizePathStrict, resolvePath } from "../utils/paths.js";
 import { stripBom } from "../utils/text.js";
-import { bundledBuiltinExtensions } from "./bundled-resources.js";
-const TRUST_REQUIRING_PROJECT_CONFIG_RESOURCES = [
-    "settings.json",
-    "mcp.json",
-    "extensions",
-    "skills",
-    "prompts",
-    "themes",
-    "SYSTEM.md",
-    "APPEND_SYSTEM.md",
-];
-const LEGACY_PROJECT_CONFIG_DIR_NAME = ".pi";
-/**
- * A project codemode file that sets any setting naming an executable (the codemode package's
- * `executable-settings.json` list, today `languages.pyInterpreter`) makes the session run that executable at start,
- * so it asks for a trust decision. A file the check cannot read is treated like a project `mcp.json`, whose mere
- * presence asks; so is any file when the list itself cannot be read.
- */
-function projectCodemodeNamesExecutable(configDir) {
-    const path = join(configDir, "codemode.json");
-    if (!existsSync(path))
-        return false;
-    const executableSettings = codemodeExecutableSettings();
-    if (executableSettings === undefined)
-        return true;
-    let parsed;
-    try {
-        parsed = JSON.parse(stripBom(readFileSync(path, "utf8")));
-    }
-    catch {
-        return true;
-    }
-    return executableSettings.some((settingPath) => valueAtPath(parsed, settingPath) !== undefined);
-}
-function codemodeExecutableSettings() {
-    const codemode = bundledBuiltinExtensions.find((extension) => extension.id === "codemode");
-    try {
-        const packageJson = codemode?.resolvePackage();
-        if (packageJson === undefined)
-            return undefined;
-        const list = JSON.parse(readFileSync(join(dirname(packageJson), "src", "config", "executable-settings.json"), "utf8"));
-        if (typeof list !== "object" || list === null)
-            return undefined;
-        const paths = Reflect.get(list, "projectExecutableSettings");
-        return Array.isArray(paths) && paths.every((entry) => typeof entry === "string") ? paths : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function valueAtPath(value, path) {
-    let current = value;
-    for (const key of path.split(".")) {
-        if (typeof current !== "object" || current === null)
-            return undefined;
-        current = Reflect.get(current, key);
-    }
-    return current;
-}
+export { hasTrustRequiringProjectResources, projectAgentsSkillDirs } from "./trust-requiring-resources.js";
 function normalizeCwd(cwd) {
     const resolved = resolvePath(cwd);
     try {
@@ -202,67 +142,6 @@ function withTrustFileLock(path, fn) {
         release();
     }
 }
-/** True when `dir` is the user's home or a folder above it: never a project (#2465). */
-function isHomeOrAboveDir(dir, homeDir) {
-    return dir === homeDir || homeDir.startsWith(dir.endsWith(sep) ? dir : `${dir}${sep}`);
-}
-/** The nearest folder at or above `dir` that holds `.git`, as spelled; undefined outside a repository. */
-function findGitRepoRoot(dir) {
-    let currentDir = dir;
-    while (!existsSync(join(currentDir, ".git"))) {
-        const parentDir = dirname(currentDir);
-        if (parentDir === currentDir)
-            return undefined;
-        currentDir = parentDir;
-    }
-    return currentDir;
-}
-/**
- * The project `.agents/skills` directories for `cwd`, nearest first: one per folder from cwd up to
- * the git root (or the filesystem root), stopping below the user's home. Home and every folder
- * above it are never a project; `~/.agents/skills` is the user's own global skills. The ONE walk
- * both the trust check and the loader use, over the same spelling and the same git root (#3420
- * review): paths stay as spelled (resources are compared as strings), and each folder's real path
- * decides whether it is home or above, so a symlink can't carry the walk past home either way.
- */
-export function projectAgentsSkillDirs(cwd) {
-    const homeDir = canonicalizePath(resolvePath(process.env.HOME || homedir()));
-    const startDir = resolvePath(cwd);
-    const gitRepoRoot = findGitRepoRoot(startDir);
-    const dirs = [];
-    let currentDir = startDir;
-    while (!isHomeOrAboveDir(canonicalizePath(currentDir), homeDir)) {
-        dirs.push(join(currentDir, ".agents", "skills"));
-        if (currentDir === gitRepoRoot)
-            break;
-        const parentDir = dirname(currentDir);
-        if (parentDir === currentDir)
-            break;
-        currentDir = parentDir;
-    }
-    return dirs;
-}
-/**
- * Returns true when cwd has project-local resources that must be gated by
- * project trust: trust-requiring entries under the project config dir or the
- * legacy cwd/.pi dir (whose resources are also discovered), or a project
- * `.agents/skills` (`projectAgentsSkillDirs`, the same walk the loader uses).
- * The user's home and every folder above it are never a project: their config
- * dirs and .agents/skills are the user's own global resources (#2465).
- */
-export function hasTrustRequiringProjectResources(cwd) {
-    const homeDir = canonicalizePath(resolvePath(process.env.HOME || homedir()));
-    const currentDir = canonicalizePath(resolvePath(cwd));
-    if (!isHomeOrAboveDir(currentDir, homeDir)) {
-        const configDirs = [join(currentDir, CONFIG_DIR_NAME), join(currentDir, LEGACY_PROJECT_CONFIG_DIR_NAME)];
-        if (configDirs.some((configDir) => TRUST_REQUIRING_PROJECT_CONFIG_RESOURCES.some((entry) => existsSync(join(configDir, entry))))) {
-            return true;
-        }
-        if (projectCodemodeNamesExecutable(join(currentDir, CONFIG_DIR_NAME)))
-            return true;
-    }
-    return projectAgentsSkillDirs(cwd).some((dir) => existsSync(dir));
-}
 export class ProjectTrustStore {
     constructor(agentDir) {
         this.trustPath = join(resolvePath(agentDir), "trust.json");

package/dist/core/trust-requiring-resources.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The project `.agents/skills` directories for `cwd`, nearest first: one per folder from cwd up to
+ * the git root (or the filesystem root), stopping below the user's home. Home and every folder
+ * above it are never a project; `~/.agents/skills` is the user's own global skills. The ONE walk
+ * both the trust check and the loader use, over the same spelling and the same git root (#3420
+ * review): paths stay as spelled (resources are compared as strings), and each folder's real path
+ * decides whether it is home or above, so a symlink can't carry the walk past home either way.
+ */
+export declare function projectAgentsSkillDirs(cwd: string): string[];
+/**
+ * Returns true when cwd has project-local resources that must be gated by
+ * project trust: trust-requiring entries under the project config dir or the
+ * legacy cwd/.pi dir (whose resources are also discovered), or a project
+ * `.agents/skills` (`projectAgentsSkillDirs`, the same walk the loader uses).
+ * The user's home and every folder above it are never a project: their config
+ * dirs and .agents/skills are the user's own global resources (#2465).
+ */
+export declare function hasTrustRequiringProjectResources(cwd: string): boolean;
+/** `hasTrustRequiringProjectResources` without blocking: the same walk, answered through `node:fs/promises`. */
+export declare function hasTrustRequiringProjectResourcesAsync(cwd: string): Promise<boolean>;
+//# sourceMappingURL=trust-requiring-resources.d.ts.map

package/dist/core/trust-requiring-resources.js

@@ -0,0 +1,189 @@
+import { existsSync, readFileSync } from "node:fs";
+import { access, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, sep } from "node:path";
+import { CONFIG_DIR_NAME } from "../config.js";
+import { canonicalizePath, resolvePath } from "../utils/paths.js";
+import { stripBom } from "../utils/text.js";
+import { bundledBuiltinExtensions } from "./bundled-resources.js";
+const TRUST_REQUIRING_PROJECT_CONFIG_RESOURCES = [
+    "settings.json",
+    "mcp.json",
+    "extensions",
+    "skills",
+    "prompts",
+    "themes",
+    "SYSTEM.md",
+    "APPEND_SYSTEM.md",
+];
+const LEGACY_PROJECT_CONFIG_DIR_NAME = ".pi";
+function* exists(path) {
+    return (yield { kind: "exists", path }) === true;
+}
+function* readText(path) {
+    const text = yield { kind: "read", path };
+    return typeof text === "string" ? text : undefined;
+}
+function parseJson(text) {
+    try {
+        return { ok: true, value: JSON.parse(stripBom(text)) };
+    }
+    catch {
+        return { ok: false };
+    }
+}
+function valueAtPath(value, path) {
+    let current = value;
+    for (const key of path.split(".")) {
+        if (typeof current !== "object" || current === null)
+            return undefined;
+        current = Reflect.get(current, key);
+    }
+    return current;
+}
+function* codemodeExecutableSettings() {
+    const codemode = bundledBuiltinExtensions.find((extension) => extension.id === "codemode");
+    let packageJson;
+    try {
+        packageJson = codemode?.resolvePackage();
+    }
+    catch {
+        return undefined;
+    }
+    if (packageJson === undefined)
+        return undefined;
+    const text = yield* readText(join(dirname(packageJson), "src", "config", "executable-settings.json"));
+    const list = text === undefined ? { ok: false } : parseJson(text);
+    if (!list.ok || typeof list.value !== "object" || list.value === null)
+        return undefined;
+    const paths = Reflect.get(list.value, "projectExecutableSettings");
+    return Array.isArray(paths) && paths.every((entry) => typeof entry === "string") ? paths : undefined;
+}
+/**
+ * A project codemode file that sets any setting naming an executable (the codemode package's
+ * `executable-settings.json` list, today `languages.pyInterpreter`) makes the session run that executable at start,
+ * so it asks for a trust decision. A file the check cannot read is treated like a project `mcp.json`, whose mere
+ * presence asks; so is any file when the list itself cannot be read.
+ */
+function* projectCodemodeNamesExecutable(configDir) {
+    const path = join(configDir, "codemode.json");
+    if (!(yield* exists(path)))
+        return false;
+    const executableSettings = yield* codemodeExecutableSettings();
+    if (executableSettings === undefined)
+        return true;
+    const text = yield* readText(path);
+    const parsed = text === undefined ? { ok: false } : parseJson(text);
+    if (!parsed.ok)
+        return true;
+    return executableSettings.some((settingPath) => valueAtPath(parsed.value, settingPath) !== undefined);
+}
+/** True when `dir` is the user's home or a folder above it: never a project (#2465). */
+function isHomeOrAboveDir(dir, homeDir) {
+    return dir === homeDir || homeDir.startsWith(dir.endsWith(sep) ? dir : `${dir}${sep}`);
+}
+/** The nearest folder at or above `dir` that holds `.git`, as spelled; undefined outside a repository. */
+function* findGitRepoRoot(dir) {
+    let currentDir = dir;
+    while (!(yield* exists(join(currentDir, ".git")))) {
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir)
+            return undefined;
+        currentDir = parentDir;
+    }
+    return currentDir;
+}
+function homeDirectory() {
+    return canonicalizePath(resolvePath(process.env.HOME || homedir()));
+}
+function* agentsSkillDirs(cwd) {
+    const homeDir = homeDirectory();
+    const startDir = resolvePath(cwd);
+    const gitRepoRoot = yield* findGitRepoRoot(startDir);
+    const dirs = [];
+    let currentDir = startDir;
+    while (!isHomeOrAboveDir(canonicalizePath(currentDir), homeDir)) {
+        dirs.push(join(currentDir, ".agents", "skills"));
+        if (currentDir === gitRepoRoot)
+            break;
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir)
+            break;
+        currentDir = parentDir;
+    }
+    return dirs;
+}
+function* trustRequiringResources(cwd) {
+    const homeDir = homeDirectory();
+    const currentDir = canonicalizePath(resolvePath(cwd));
+    if (!isHomeOrAboveDir(currentDir, homeDir)) {
+        for (const configDir of [join(currentDir, CONFIG_DIR_NAME), join(currentDir, LEGACY_PROJECT_CONFIG_DIR_NAME)]) {
+            for (const entry of TRUST_REQUIRING_PROJECT_CONFIG_RESOURCES) {
+                if (yield* exists(join(configDir, entry)))
+                    return true;
+            }
+        }
+        if (yield* projectCodemodeNamesExecutable(join(currentDir, CONFIG_DIR_NAME)))
+            return true;
+    }
+    for (const dir of yield* agentsSkillDirs(cwd)) {
+        if (yield* exists(dir))
+            return true;
+    }
+    return false;
+}
+function answerSync(probe) {
+    if (probe.kind === "exists")
+        return existsSync(probe.path);
+    try {
+        return readFileSync(probe.path, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+async function answerAsync(probe) {
+    if (probe.kind === "exists") {
+        return access(probe.path).then(() => true, () => false);
+    }
+    return readFile(probe.path, "utf8").catch(() => undefined);
+}
+function runSync(walk) {
+    let step = walk.next();
+    while (!step.done)
+        step = walk.next(answerSync(step.value));
+    return step.value;
+}
+async function runAsync(walk) {
+    let step = walk.next();
+    while (!step.done)
+        step = walk.next(await answerAsync(step.value));
+    return step.value;
+}
+/**
+ * The project `.agents/skills` directories for `cwd`, nearest first: one per folder from cwd up to
+ * the git root (or the filesystem root), stopping below the user's home. Home and every folder
+ * above it are never a project; `~/.agents/skills` is the user's own global skills. The ONE walk
+ * both the trust check and the loader use, over the same spelling and the same git root (#3420
+ * review): paths stay as spelled (resources are compared as strings), and each folder's real path
+ * decides whether it is home or above, so a symlink can't carry the walk past home either way.
+ */
+export function projectAgentsSkillDirs(cwd) {
+    return runSync(agentsSkillDirs(cwd));
+}
+/**
+ * Returns true when cwd has project-local resources that must be gated by
+ * project trust: trust-requiring entries under the project config dir or the
+ * legacy cwd/.pi dir (whose resources are also discovered), or a project
+ * `.agents/skills` (`projectAgentsSkillDirs`, the same walk the loader uses).
+ * The user's home and every folder above it are never a project: their config
+ * dirs and .agents/skills are the user's own global resources (#2465).
+ */
+export function hasTrustRequiringProjectResources(cwd) {
+    return runSync(trustRequiringResources(cwd));
+}
+/** `hasTrustRequiringProjectResources` without blocking: the same walk, answered through `node:fs/promises`. */
+export function hasTrustRequiringProjectResourcesAsync(cwd) {
+    return runAsync(trustRequiringResources(cwd));
+}
+//# sourceMappingURL=trust-requiring-resources.js.map

package/dist/index.d.ts

@@ -42,6 +42,7 @@ export { createSyntheticSourceInfo } from "./core/source-info.ts";
 export { type EditDiffResult, generateDiffString, generateUnifiedPatch } from "./core/tools/edit-diff.ts";
 export { type BashOperations, type BashSpawnContext, type BashSpawnHook, type BashToolDetails, type BashToolInput, type BashToolOptions, createBashToolDefinition, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLocalBashOperations, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, type EditOperations, type EditToolDetails, type EditToolInput, type EditToolOptions, type FindOperations, type FindToolDetails, type FindToolInput, type FindToolOptions, formatSize, type GrepOperations, type GrepToolDetails, type GrepToolInput, type GrepToolOptions, type LsOperations, type LsToolDetails, type LsToolInput, type LsToolOptions, type ReadOperations, type ReadToolDetails, type ReadToolInput, type ReadToolOptions, type ToolsOptions, type TruncationOptions, type TruncationResult, truncateHead, truncateLine, truncateTail, type WriteOperations, type WriteToolInput, type WriteToolOptions, withFileMutationQueue, } from "./core/tools/index.ts";
 export { type CompactReadClassification, classifyRead, type ReadClassifier, registerReadClassifier, } from "./core/tools/read-classifiers.ts";
+export { registerRpcRemoteSource, type RpcRemoteHandlers, type RpcRemoteOpenOptions, type RpcRemoteSettledTurn, type RpcRemoteSource, type RpcRemoteState, type RpcRemoteSubscription, type RpcRemoteTarget, } from "./core/extensions/builtin/terminal/rpc-remote-source.ts";
 export { hasTrustRequiringProjectResources, type ProjectTrustDecision, ProjectTrustStore, type ProjectTrustStoreEntry, type ProjectTrustUpdate, } from "./core/trust-manager.ts";
 export { UnknownCommandError, type UnknownCommandReason } from "./core/unknown-command.ts";
 export { type ModelRoute, type ModelRouteReason, type ModelRouteRequest, VIRTUAL_MODEL_STATE_ENTRY, type VirtualModelDefinition, type VirtualModelStateData, } from "./core/virtual-models.ts";

package/dist/index.js

@@ -50,6 +50,7 @@ export { generateDiffString, generateUnifiedPatch } from "./core/tools/edit-diff
 // Tools
 export { createBashToolDefinition, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLocalBashOperations, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateHead, truncateLine, truncateTail, withFileMutationQueue, } from "./core/tools/index.js";
 export { classifyRead, registerReadClassifier, } from "./core/tools/read-classifiers.js";
+export { registerRpcRemoteSource, } from "./core/extensions/builtin/terminal/rpc-remote-source.js";
 export { hasTrustRequiringProjectResources, ProjectTrustStore, } from "./core/trust-manager.js";
 export { UnknownCommandError } from "./core/unknown-command.js";
 export { VIRTUAL_MODEL_STATE_ENTRY, } from "./core/virtual-models.js";