toolroll 0.9.88 → 0.9.89

package/dist/chat-channel.js

@@ -12,11 +12,21 @@ import { canonicalProject } from "./project.js";
 import { phoneText, projectLabel } from "./telegram-status.js";
 import { CHAT_CONTROLS, chatControlHref, isChatControl, } from "./chat-controls.js";
 import { CHAT_TASK_ACTIONS, isChatTaskAction } from "./chat-task-actions.js";
+import { FolderUnavailable } from "./folder-gate.js";
 export function channelRepos(store, approver, registry) {
     const seen = new Set();
     const repos = [];
     for (const path of registry) {
-        const canonical = canonicalProject(path) ?? path;
+        let canonical;
+        // A folder the console's gate holds back (folder-gate.ts) is left out, never matched by its spelling.
+        try {
+            canonical = canonicalProject(path) ?? path;
+        }
+        catch (error) {
+            if (error instanceof FolderUnavailable)
+                continue;
+            throw error;
+        }
         if (seen.has(canonical) || !store.accountCanAccess(approver, canonical))
             continue;
         seen.add(canonical);

package/dist/egress.js

@@ -18,6 +18,7 @@ import { readdirSync } from "node:fs";
 import { basename, join } from "node:path";
 import { connectFirst, isPublicAddress } from "./scout-net.js";
 import { lookup as dnsLookup } from "node:dns/promises";
+import { folderAnswers } from "./folder-gate.js";
 /** The policy's shape version: a worker enforces the versions it knows and refuses any other. */
 export const NETWORK_POLICY_VERSION = 1;
 export const PROJECT_NETWORK_DEFAULT = { mode: "allowlist", hosts: [], loopback: "proxy-only" };
@@ -114,6 +115,10 @@ const WALK_SKIP = new Set(["node_modules", "vendor", "target", "dist", "build",
  * project's own hosts only.
  */
 export function repositoryEcosystems(repo) {
+    // In the console, a folder that hasn't answered a look lately is not walked on its thread (folder-gate.ts): it names
+    // none, as an unreadable folder does.
+    if (!folderAnswers(repo))
+        return [];
     const paths = [];
     const walk = (folder, depth) => {
         let entries;

package/dist/flow-starters.js

@@ -10,6 +10,7 @@ import { flowDefinitionOf } from "./flow-engine.js";
 import { addFlowTriggerTo, githubRepoOf } from "./flow-triggers.js";
 import { flowFromSteps, ISSUE_LABEL } from "./flows.js";
 import { publishingOf } from "./pull-request-flow.js";
+import { folderAnswers } from "./folder-gate.js";
 export const STARTER_IDS = ["ci-fix", "issue-task", "overnight", "plane-review"];
 export const STARTER_FLOWS = [
     {
@@ -87,6 +88,8 @@ export function planeReviewSteps(own) {
 }
 /** Whether a project is Toolroll's own source. */
 export function isToolrollRepo(repo) {
+    if (!folderAnswers(repo))
+        return false;
     try {
         return JSON.parse(readFileSync(join(repo, "package.json"), "utf8")).name === "toolroll";
     }

package/dist/flow-triggers.js

@@ -52,6 +52,7 @@ import { envValue } from "./names.js";
 import { recordBranchCheckRun, unprovenNoticeRuns } from "./tidy.js";
 import { linearLabelNames, readFormSubmission, readGithubEvent, readGithubIssue, readGithubIssueEventList, readGithubIssueList, readGithubRun, readGithubRunList, readInboundMail, readLinearAnswer, readLinearEvent, readLinearIssue, readWebhookPayload } from "./contracts/trigger-payloads.js";
 import { isRecord } from "./is-record.js";
+import { folderAnswers } from "./folder-gate.js";
 export { FLOW_TRIGGER_KINDS };
 export const CHAT_APP_NAMES = { slack: "Slack", discord: "Discord", teams: "Teams", telegram: "Telegram" };
 /** What each kind is called on the canvas. */
@@ -124,6 +125,9 @@ export function scheduleFromWords(text) {
 }
 /** A GitHub repository as owner/name, read from a project's origin remote when it is on GitHub. */
 export function githubRepoOf(path) {
+    // In the console, a folder that hasn't answered a look lately is not read on its thread (folder-gate.ts).
+    if (!folderAnswers(path))
+        return null;
     try {
         const dot = join(path, ".git");
         const config = statSync(dot).isDirectory() ? readFileSync(join(dot, "config"), "utf8") : null;

package/dist/folder-gate.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Whether the console may read a folder synchronously right now.
+ *
+ * The console answers every page on one thread, so one synchronous read of a folder that has stopped answering (a
+ * drive that hangs, a folder macOS holds in iCloud) freezes the console with it: it listens and answers nothing, not
+ * even /healthz (the 0.9.82 and 0.9.87 deploys). So the console's own work (its request handling and its background
+ * pass, serve.ts) runs inside a folder scope: there, a synchronous read of a person's folder goes ahead only when that
+ * folder answered an off-thread look lately (project-identity.ts `answering`), or it lies in the console's own data.
+ * Otherwise the read isn't made and its caller refuses, says the folder is unavailable, or throws FolderUnavailable.
+ *
+ * Availability never decides authorization: a held-back canonicalization throws FolderUnavailable (project.ts), never
+ * answers null, so no caller falls back to a path's spelling because a folder didn't answer.
+ *
+ * Work outside a console scope (the worker, even in the same process as the console; `up`; the CLI) reads as it
+ * always did.
+ */
+/** One console's answer for a resolved path. `pointer`: the path came from a file a build can write (a checkout's
+ * `.git` or `commondir`), so the console's own folders (build checkouts among them) don't vouch for it by spelling. */
+export type FolderGate = (path: string, pointer: boolean) => boolean;
+/** What a caller says, and throws, when the gate holds a read back. */
+export declare const FOLDER_DIDNT_ANSWER = "the folder didn't answer";
+/** A synchronous read the console's folder gate held back: the folder is unavailable now, which is never a "no". */
+export declare class FolderUnavailable extends Error {
+    readonly path: string;
+    constructor(path: string);
+}
+/** Runs `work` (and everything it starts) inside the console's folder scope. */
+export declare function inFolderScope<T>(gate: FolderGate, work: () => T): T;
+/** Whether a synchronous read of `path` may happen now. Outside a console's folder scope: always. */
+export declare function folderAnswers(path: string, pointer?: boolean): boolean;
+/** `path` is `folder` or inside it (both resolved). */
+export declare function insideFolder(path: string, folder: string): boolean;

package/dist/folder-gate.js

@@ -0,0 +1,43 @@
+/**
+ * Whether the console may read a folder synchronously right now.
+ *
+ * The console answers every page on one thread, so one synchronous read of a folder that has stopped answering (a
+ * drive that hangs, a folder macOS holds in iCloud) freezes the console with it: it listens and answers nothing, not
+ * even /healthz (the 0.9.82 and 0.9.87 deploys). So the console's own work (its request handling and its background
+ * pass, serve.ts) runs inside a folder scope: there, a synchronous read of a person's folder goes ahead only when that
+ * folder answered an off-thread look lately (project-identity.ts `answering`), or it lies in the console's own data.
+ * Otherwise the read isn't made and its caller refuses, says the folder is unavailable, or throws FolderUnavailable.
+ *
+ * Availability never decides authorization: a held-back canonicalization throws FolderUnavailable (project.ts), never
+ * answers null, so no caller falls back to a path's spelling because a folder didn't answer.
+ *
+ * Work outside a console scope (the worker, even in the same process as the console; `up`; the CLI) reads as it
+ * always did.
+ */
+import { AsyncLocalStorage } from "node:async_hooks";
+import { resolve, sep } from "node:path";
+const scope = new AsyncLocalStorage();
+/** What a caller says, and throws, when the gate holds a read back. */
+export const FOLDER_DIDNT_ANSWER = "the folder didn't answer";
+/** A synchronous read the console's folder gate held back: the folder is unavailable now, which is never a "no". */
+export class FolderUnavailable extends Error {
+    path;
+    constructor(path) {
+        super(FOLDER_DIDNT_ANSWER);
+        this.path = path;
+        this.name = "FolderUnavailable";
+    }
+}
+/** Runs `work` (and everything it starts) inside the console's folder scope. */
+export function inFolderScope(gate, work) {
+    return scope.run(gate, work);
+}
+/** Whether a synchronous read of `path` may happen now. Outside a console's folder scope: always. */
+export function folderAnswers(path, pointer = false) {
+    const gate = scope.getStore();
+    return gate === undefined || gate(resolve(path), pointer);
+}
+/** `path` is `folder` or inside it (both resolved). */
+export function insideFolder(path, folder) {
+    return path === folder || path.startsWith(folder.endsWith(sep) ? folder : folder + sep);
+}

package/dist/project-access.js

@@ -1,6 +1,7 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { isAbsolute, resolve } from "node:path";
 import { canonicalProject } from "./project.js";
+import { FolderUnavailable } from "./folder-gate.js";
 export function normalizeProjectAccess(value) {
     if (value === null)
         return null;
@@ -26,7 +27,20 @@ export function readProjectAccess(value) {
     }
 }
 export function projectAccessAllows(access, repo) {
-    return access === null || (repo !== null && access.includes(canonicalProject(repo) ?? resolve(repo)));
+    if (access === null)
+        return true;
+    if (repo === null)
+        return false;
+    // A folder the console's gate holds back (folder-gate.ts) is unavailable: access to it is denied, never decided by
+    // its spelling.
+    try {
+        return access.includes(canonicalProject(repo) ?? resolve(repo));
+    }
+    catch (error) {
+        if (error instanceof FolderUnavailable)
+            return false;
+        throw error;
+    }
 }
 /** SQL: projectAccessAllows for an `approver` row (`alias`) and a project path expression, for the dispatch belts. A
  * null list reaches every project; an unreadable one reaches none. */

package/dist/project-admission.d.ts

@@ -42,9 +42,11 @@ export type Released = {
     removed: boolean;
 };
 export declare const PROJECT_ADDED = "project added";
+/** A folder's real path (a folder), null (not one), or "no-answer" (it didn't answer in time). */
+export type FolderResolver = (path: string) => Promise<string | null | "no-answer">;
 export declare const PROJECT_REMOVED = "project removed";
 /** The checkout root a folder belongs to, canonical; never a shell. */
-export declare function proveProjectRoot(path: string, exec?: ProjectExec): Promise<{
+export declare function proveProjectRoot(path: string, exec?: ProjectExec, resolveFolder?: FolderResolver): Promise<{
     ok: true;
     repo: string;
 } | AdmissionFailure>;
@@ -63,6 +65,9 @@ export declare function admitProject(store: Store, input: {
     /** The caller's authority, asked again about the proved repo inside the locked registry update and inside the
      * database transaction (the console: nothing it proved before an await moved, and the repo is still visible). */
     stillAllowed?: (repo: string) => boolean;
+    /** How the folder and its checkout root are resolved (the console: off its thread, under a deadline). Absent:
+     * canonicalProject. */
+    resolveFolder?: FolderResolver;
 }): Promise<Admitted | AdmissionFailure>;
 /**
  * Remove one project from the lists and the builder. Its tasks, results and

package/dist/project-admission.js

@@ -17,6 +17,7 @@ import { run } from "./exec.js";
 import { canonicalProject, projectName, sameRepo } from "./project.js";
 import { remoteUrlProblem } from "./remote-main.js";
 import { addRepos, loadProjectRegistry, removeRepos, updateRepos } from "./repos.js";
+import { FolderUnavailable } from "./folder-gate.js";
 const ADMISSION_GIT = {
     envAllowlist: ["PATH", "HOME", "TMPDIR", "LANG", "LC_ALL"],
     env: { GIT_CONFIG_NOSYSTEM: "1", GIT_CONFIG_GLOBAL: "/dev/null", GIT_NO_REPLACE_OBJECTS: "1" },
@@ -24,15 +25,23 @@ const ADMISSION_GIT = {
 export const PROJECT_ADDED = "project added";
 export const PROJECT_REMOVED = "project removed";
 /** The checkout root a folder belongs to, canonical; never a shell. */
-export async function proveProjectRoot(path, exec = run) {
+export async function proveProjectRoot(path, exec = run, resolveFolder) {
     if (path.trim() === "" || path.length > 4096 || /[\x00-\x1f]/.test(path)) {
         return { ok: false, reason: "unavailable", message: "Choose a valid project folder." };
     }
-    const canonical = canonicalProject(path);
+    // The console resolves both folders off its thread (project-identity.ts resolveNow): its thread never waits on one.
+    const canon = async (one) => resolveFolder === undefined ? canonicalProject(one) : resolveFolder(one);
+    const didntAnswer = (one) => ({ ok: false, reason: "unavailable", message: `${one} didn't answer. It may be on a drive that's disconnected, or waiting on macOS; try again in a moment.` });
+    const canonical = await canon(path);
+    if (canonical === "no-answer")
+        return didntAnswer(path);
     if (canonical === null)
         return { ok: false, reason: "unavailable", message: `${path} isn't a folder on this computer.` };
     const top = await exec("git", ["rev-parse", "--show-toplevel"], { cwd: canonical, timeoutMs: 5_000, ...ADMISSION_GIT });
-    const repo = top.code === 0 ? canonicalProject(top.stdout.trim()) : null;
+    const topReal = top.code === 0 ? await canon(top.stdout.trim()) : null;
+    if (topReal === "no-answer")
+        return didntAnswer(top.stdout.trim());
+    const repo = topReal;
     if (repo === null)
         return { ok: false, reason: "not-git", message: `${path} isn't a Git repository. Run git init there first, or choose a folder inside one.` };
     return { ok: true, repo };
@@ -48,7 +57,7 @@ async function originOf(repo, exec) {
 }
 /** Registry first, then the project and its audit records in one transaction. Re-adds preserve trust. */
 export async function admitProject(store, input) {
-    const proved = await proveProjectRoot(input.path, input.exec);
+    const proved = await proveProjectRoot(input.path, input.exec, input.resolveFolder);
     if (!proved.ok)
         return proved;
     const { repo } = proved;
@@ -110,12 +119,40 @@ export async function admitProject(store, input) {
  * saved project changes nothing.
  */
 export async function releaseProject(store, input) {
-    const asked = canonicalProject(input.path) ?? resolve(input.path);
+    // Removing only narrows: a folder the console's gate holds back (folder-gate.ts) is removed by its exact saved path,
+    // and matches no other spelling.
+    // Latched for the whole removal: once its folder was unavailable, a later answer (during an await below) never
+    // widens it to other spellings.
+    const unavailable = (error) => error instanceof FolderUnavailable;
+    let asked, exactOnly = false;
+    try {
+        asked = canonicalProject(input.path) ?? resolve(input.path);
+    }
+    catch (error) {
+        if (!unavailable(error))
+            throw error;
+        asked = resolve(input.path);
+        exactOnly = true;
+    }
+    const same = (one) => {
+        if (exactOnly)
+            return false;
+        try {
+            return sameRepo(one, asked);
+        }
+        catch (error) {
+            if (unavailable(error)) {
+                exactOnly = true;
+                return false;
+            }
+            throw error;
+        }
+    };
     const loaded = input.registryFile === null ? { repos: [] } : await loadProjectRegistry(input.registryFile);
     if ("error" in loaded)
         return { ok: false, reason: "registry", message: loaded.error };
-    const entries = loaded.repos.filter(one => one === asked || sameRepo(one, asked));
-    const rows = store.listProjects().filter(one => one.path === asked || sameRepo(one.path, asked)).map(one => one.path);
+    const entries = loaded.repos.filter(one => one === asked || same(one));
+    const rows = store.listProjects().filter(one => one.path === asked || same(one.path)).map(one => one.path);
     const repo = entries[0] ?? rows[0] ?? asked;
     if (entries.length === 0 && rows.length === 0)
         return { ok: true, repo, name: projectName(repo), removed: false };

package/dist/project-identity.d.ts

@@ -16,6 +16,7 @@
  *
  * An embedder or test that passes no identities gets `syncProjectIdentities`: the old synchronous reads, unchanged.
  */
+import { type FolderGate } from "./folder-gate.js";
 import { type FolderLookOptions } from "./folder-look.js";
 export type ProjectIdentities = {
     /** For display and grouping only: the last known identity, else the path as saved (resolved lexically). Reads
@@ -36,9 +37,16 @@ export type ProjectIdentities = {
     /** Moves whenever a known identity changes or goes: a decision made before an await is re-checked against it right
      * before its write. */
     generation: () => number;
+    /** Whether a synchronous read inside `path` may happen on the console's thread now (folder-gate.ts): the folder it is
+     * in answered a look within the last few minutes, and no look at it since went unanswered. Reads nothing. */
+    answering: (path: string) => boolean;
 };
 /** How many folders a pass looks at side by side when they're looked at one by one (within FOLDER_LOOK_CHILDREN). */
 export declare const IDENTITY_LOOKS = 4;
 export declare function projectIdentities(look?: FolderLookOptions, now?: () => number): ProjectIdentities;
 /** The synchronous reads, as before: for embedders and tests that pass no identities. */
 export declare function syncProjectIdentities(): ProjectIdentities;
+/** The console's folder gate (folder-gate.ts): its own data folders (the database's, evidence, build checkouts) are read
+ * freely when the console names them; a path read from a file a build can write (`pointer`), and anything else, only
+ * while `answering` vouches for where it leads. */
+export declare function consoleFolderGate(identities: ProjectIdentities, own: readonly (string | undefined)[]): FolderGate;

package/dist/project-identity.js

@@ -17,10 +17,14 @@
  * An embedder or test that passes no identities gets `syncProjectIdentities`: the old synchronous reads, unchanged.
  */
 import { resolve } from "node:path";
+import { insideFolder } from "./folder-gate.js";
 import { lookIdentities } from "./folder-look.js";
 import { canonicalProject } from "./project.js";
 /** How long an answer stands before the background pass resolves the path again. */
 const STALE_MS = 60_000;
+/** How long an answer vouches that its folder answers, for `answering`: past it (the background pass every 30 s
+ * renews it each minute), a synchronous read waits for the next look. */
+const ANSWERING_MS = 3 * STALE_MS;
 /** How many folders a pass looks at side by side when they're looked at one by one (within FOLDER_LOOK_CHILDREN). */
 export const IDENTITY_LOOKS = 4;
 export function projectIdentities(look = {}, now = Date.now) {
@@ -137,6 +141,37 @@ export function projectIdentities(look = {}, now = Date.now) {
             passes = pass.then(() => undefined, () => undefined);
             return pass;
         },
+        answering: path => {
+            const when = now();
+            const recent = (at) => when - at < ANSWERING_MS;
+            // Decided on real paths only. First the spelling: a path under an answered spelling (the longest) is read where
+            // that answer says it leads, and only while that answer is recent, since a link can be pointed elsewhere.
+            let real = resolve(path);
+            let spelled = null;
+            for (const [key, answer] of answers) {
+                if (answer.real !== null && insideFolder(real, key) && (spelled === null || key.length > spelled.key.length))
+                    spelled = { key, real: answer.real, at: answer.at };
+            }
+            if (spelled !== null) {
+                if (!recent(spelled.at))
+                    return false;
+                real = resolve(spelled.real, `.${real.slice(spelled.key.length)}`);
+            }
+            // A folder whose last look didn't answer holds back every read inside where it leads, whatever older answer stands.
+            for (const key of suspect)
+                if (insideFolder(real, answers.get(key)?.real ?? key))
+                    return false;
+            // Otherwise the nearest real folder an answer names decides, by its newest answer; "/" vouches for nothing below it.
+            let nearest = null;
+            for (const answer of answers.values()) {
+                const folder = answer.real;
+                if (folder === null || (folder === "/" && real !== "/") || !insideFolder(real, folder))
+                    continue;
+                if (nearest === null || folder.length > nearest.folder.length || (folder.length === nearest.folder.length && answer.at > nearest.at))
+                    nearest = { folder, at: answer.at };
+            }
+            return nearest !== null && recent(nearest.at);
+        },
     };
 }
 /** The synchronous reads, as before: for embedders and tests that pass no identities. */
@@ -149,5 +184,13 @@ export function syncProjectIdentities() {
         resolveNow: async (path) => canonicalProject(path),
         generation: () => 0,
         refresh: async () => true,
+        answering: () => true,
     };
 }
+/** The console's folder gate (folder-gate.ts): its own data folders (the database's, evidence, build checkouts) are read
+ * freely when the console names them; a path read from a file a build can write (`pointer`), and anything else, only
+ * while `answering` vouches for where it leads. */
+export function consoleFolderGate(identities, own) {
+    const folders = [...new Set(own.filter((one) => typeof one === "string" && one !== "").map(one => resolve(one)))];
+    return (path, pointer) => (!pointer && folders.some(folder => insideFolder(path, folder))) || identities.answering(path);
+}

package/dist/project.d.ts

@@ -16,6 +16,7 @@ export type ProjectExec = (file: string, args: readonly string[], options?: RunO
  * One canonicalization for every path that becomes project identity:
  * startup config, a session open, task placement. Comparisons elsewhere
  * fall back to raw equality for legacy rows written before this existed.
+ * Throws FolderUnavailable when the console's folder gate holds the read back (folder-gate.ts).
  */
 export declare function canonicalProject(path: string): string | null;
 /** Two repo identities, canonical when possible, raw-equal as the legacy fallback. */

package/dist/project.js

@@ -13,12 +13,18 @@
 import { realpathSync, statSync } from "node:fs";
 import { basename, resolve, sep } from "node:path";
 import { run } from "./exec.js";
+import { folderAnswers, FolderUnavailable } from "./folder-gate.js";
 /**
  * One canonicalization for every path that becomes project identity:
  * startup config, a session open, task placement. Comparisons elsewhere
  * fall back to raw equality for legacy rows written before this existed.
+ * Throws FolderUnavailable when the console's folder gate holds the read back (folder-gate.ts).
  */
 export function canonicalProject(path) {
+    // In the console, a folder that hasn't answered a look lately is not read on its thread (folder-gate.ts). That is
+    // "unavailable", never "not a folder": it throws, so no caller falls back to the path's spelling because of it.
+    if (!folderAnswers(path))
+        throw new FolderUnavailable(resolve(path));
     try {
         const real = realpathSync(resolve(path));
         return statSync(real).isDirectory() ? real : null;

package/dist/proposal.js

@@ -30,6 +30,7 @@ export { validateTaskText } from "./task-text.js";
 import { resolve } from "node:path";
 import { canonicalProject } from "./project.js";
 import { heuristicSizing, planningSignals, refineFiledSizing } from "./task-sizing.js";
+import { FolderUnavailable } from "./folder-gate.js";
 /** Provenance tokens are part of the audit surface: lowercase, bounded,
  * nothing that could render as anything but itself. */
 const FILED_VIA = /^[a-z][a-z0-9:-]{0,63}$/;
@@ -75,7 +76,16 @@ function checkRepo(given, admitted) {
     // directory resolves through symlinks; a path that does not exist yet
     // still normalizes, because filing must not depend on this machine
     // seeing every repo the plane knows about.
-    const canonical = canonicalProject(given) ?? resolve(given);
+    let canonical;
+    // A folder the console's gate holds back (folder-gate.ts) is unavailable: refused, never filed by its spelling.
+    try {
+        canonical = canonicalProject(given) ?? resolve(given);
+    }
+    catch (error) {
+        if (error instanceof FolderUnavailable)
+            return refuse("bad-repo", "that repository's folder didn't answer — it may be on a drive that's disconnected; try again in a moment");
+        throw error;
+    }
     if (admitted !== undefined && !admitted.includes(canonical)) {
         return refuse("outside-ceiling", "that repository is outside what this surface was configured to show");
     }

package/dist/recipes.js

@@ -12,6 +12,7 @@ import { applyModeToNewFiling } from "./plan-auto.js";
 import { canonicalProject } from "./project.js";
 import { RECIPE_FORMAT, RECIPE_LIMITS, readRecipeDocument } from "./contracts/recipes.js";
 import { resolve } from "node:path";
+import { FolderUnavailable } from "./folder-gate.js";
 export const RECIPE_SCHEMA = `
 CREATE TABLE IF NOT EXISTS workflow_recipe (
   id TEXT NOT NULL, revision INTEGER NOT NULL CHECK(revision > 0),
@@ -47,7 +48,17 @@ export class RecipeError extends Error {
     }
 }
 const honest = (text) => !hasForbiddenControls(text) && !hasDisguisedText(text);
-const recipeProject = (repo) => canonicalProject(repo) ?? resolve(repo);
+const recipeProject = (repo) => {
+    // A project folder the console's gate holds back (folder-gate.ts) is unavailable, never matched by its spelling.
+    try {
+        return canonicalProject(repo) ?? resolve(repo);
+    }
+    catch (error) {
+        if (error instanceof FolderUnavailable)
+            throw new RecipeError("This project's folder didn't answer. Try again in a moment.", 503);
+        throw error;
+    }
+};
 /** What a refusal at each top-level field tells the person, after the path-named line. */
 const FIELD_ADVICE = {
     name: "Name, goal, exclusions, and allowed paths must be readable text.", description: "Name, goal, exclusions, and allowed paths must be readable text.",

package/dist/serve.js

@@ -1,6 +1,7 @@
 import { secretFolder } from "./tool-secret-store.js";
 import { acceptedIdentities, recoverLearning } from "./project-learning.js";
-import { syncProjectIdentities } from "./project-identity.js";
+import { consoleFolderGate, syncProjectIdentities } from "./project-identity.js";
+import { inFolderScope } from "./folder-gate.js";
 import { firstTasksOffThread, recoverLearningOffThread } from "./learning-look.js";
 import { loadOrCreateVapidKeys } from "./push.js";
 import { checkoutPlan } from "./checkout-cleanup.js";
@@ -670,7 +671,7 @@ export function createDecisionServer(options) {
         instrumentRequest(store.telemetry, request, response);
         // Every password checked while answering counts against where this request came from (sign-in-guard.ts).
         // A GET or HEAD only reads (docs/plans/get-side-effects.md): store reads that would tidy up as they go don't.
-        const answer = () => handle(request, response);
+        const answer = () => consoleFolders(options, identities, () => handle(request, response));
         void withPasswordSource(joinSourceOf(request), () => request.method === "GET" || request.method === "HEAD" ? asReadOnlyRequest(answer) : answer()).catch(error => {
             // Every unhandled error is logged (v99): the path and the message, never the request's body or query. The reference
             // is what a person's error page shows, so the log line can be found from it.
@@ -1986,7 +1987,9 @@ export function createDecisionServer(options) {
     // deterministic scan is idle without new meaningful work; shutdown drains it.
     let leadMaintenance = null;
     let leadClosing = false;
-    server.once('listening', () => {
+    // Started in the console's folder scope (folder-gate.ts), so their own timers and the personal queue's kick (which
+    // restores the context it was started in, never a request's) read folders as the console's work does.
+    server.once('listening', () => consoleFolders(options, identities, () => {
         team.start();
         personalQueue.start();
         leadMaintenance = startMaintenance({ intervalMs: 5_000, shouldStop: () => leadClosing,
@@ -1996,7 +1999,7 @@ export function createDecisionServer(options) {
             // Pending delivery is durable and is read again on the next pass; a failure is said where follow status is read.
             onError: error => recordLeadFollowFailure(store, error, clock()),
         });
-    });
+    }));
     // Background checks (docs/plans/get-side-effects.md): what pages show about this computer's agent sign-ins and the
     // services Toolroll uses is asked here, on a timer, and a page reads the last answer. A page visit never starts a
     // process or a network call, and never acts on what a check finds: lifting a sign-in pause and the lead-by-default
@@ -2011,7 +2014,7 @@ export function createDecisionServer(options) {
             }
             catch { /* a page says secrets can't be read; the next action reports why */ }
             backgroundChecks = startMaintenance({ intervalMs: options.backgroundChecksMs ?? BACKGROUND_CHECKS_MS, shouldStop: () => leadClosing,
-                run: async () => {
+                run: () => consoleFolders(options, identities, async () => {
                     const now = Date.now();
                     const waits = [];
                     if (now - agentsCheckedAt >= (options.backgroundChecksMs ?? LOCAL_AGENTS_EVERY_MS)) {
@@ -2109,7 +2112,7 @@ export function createDecisionServer(options) {
                         catch { /* shown as last saved */ }
                     }
                     await Promise.all(waits);
-                },
+                }),
                 onError: () => { }, });
             void backgroundChecks.runNow();
         });
@@ -2415,3 +2418,22 @@ function startupCeiling(repos, roots, identities, canon) {
         configuredPaths,
     };
 }
+/** Each console's folder gate (folder-gate.ts), made once for its options. */
+const consoleGates = new WeakMap();
+/**
+ * Runs the console's own work (a request, a background pass) in its folder scope: with identities resolved off its
+ * thread (up and serve), it reads a person's folder synchronously only while that folder answered a look lately; its
+ * own data (the database's folder, evidence, build checkouts) is read freely. Without identities (embedders, tests):
+ * as before. Work that isn't the console's (a worker in the same process) never runs in it.
+ */
+function consoleFolders(options, identities, work) {
+    if (options.identities === undefined)
+        return work();
+    let gate = consoleGates.get(options);
+    if (gate === undefined) {
+        const databaseFile = options.store.databaseFile();
+        gate = consoleFolderGate(identities, [options.configDir, options.evidenceRoot, options.poolRoot, databaseFile === null ? undefined : dirname(databaseFile)]);
+        consoleGates.set(options, gate);
+    }
+    return inFolderScope(gate, work);
+}

package/dist/server/pages.js

@@ -703,7 +703,7 @@ export function createPagesHandlers(runtime) {
         // connects its builder; there is no separate restart or binding step.
         // The admission asks again, inside its registry lock and its transaction, about the repo it proves.
         const stillAllowed = (repo) => identities.generation() === decidedOn && visible(repo);
-        const admitted = await admitProject(store, { registryFile: options.registryPath ?? null, path: canonical, actor: { label: who.name, origin: "console" }, now, stillAllowed });
+        const admitted = await admitProject(store, { registryFile: options.registryPath ?? null, path: canonical, actor: { label: who.name, origin: "console" }, now, stillAllowed, resolveFolder: identities.resolveNow });
         if (!admitted.ok) {
             return void projectsScreen(response, who, admitted.reason === "not-git" ? "that path is not a git repository" : `that project is valid, but it could not be added — ${admitted.message}`, admitted.reason === "moved" ? 409 : 400, safeReturn(body.get("return")), "open");
         }
@@ -891,7 +891,7 @@ export function createPagesHandlers(runtime) {
             return projectsScreen(response, who, `the clone landed at ${cloned.target} but did not prove under the ceiling — it was left in place; enroll it by hand`, 400, "/", "clone");
         }
         const stillAllowed = (repo) => identities.generation() === decidedOn && visible(repo);
-        const joined = await admitProject(store, { registryFile: options.registryPath ?? null, path: admitted, actor: { label: who.name, origin: "console" }, now, stillAllowed });
+        const joined = await admitProject(store, { registryFile: options.registryPath ?? null, path: admitted, actor: { label: who.name, origin: "console" }, now, stillAllowed, resolveFolder: identities.resolveNow });
         if (!joined.ok) {
             return projectsScreen(response, who, `${cloned.target} is cloned but not added — ${joined.message}`, joined.reason === "moved" ? 409 : 400, "/", "clone");
         }

package/dist/server/render-tasks.js

@@ -1083,8 +1083,10 @@ export function decisionAnswerScript() {
         `var f=e.target;if(!f||!f.classList||!f.classList.contains("decide-inline"))return;` +
         `e.preventDefault();` +
         `var card=f.closest("[data-decision-id]");` +
-        `var page=f.action.replace(/\\/answer$/,"");` +
-        `fetch(f.action,{method:"POST",credentials:"same-origin",` +
+        // The action attribute, not f.action: a field named "action" would shadow that property (DOM clobbering).
+        `var to=new URL(HTMLFormElement.prototype.getAttribute.call(f,"action")||"",location.href).href;` +
+        `var page=to.replace(/\\/answer$/,"");` +
+        `fetch(to,{method:"POST",credentials:"same-origin",` +
         `headers:{"content-type":"application/x-www-form-urlencoded"},` +
         `body:new URLSearchParams(new FormData(f)).toString()})` +
         `.then(function(r){return r.text().then(function(t){return{r:r,t:t}})})` +

package/dist/setup-guide.js

@@ -6,6 +6,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { validModelId } from "./provider.js";
 import { planInstall, applyInstall, skillContent, SKILL_DIR, SKILL_FILE } from "./skills.js";
+import { folderAnswers } from "./folder-gate.js";
 export const ASSISTANTS = withAcp({
     claude: { name: "Claude", description: "Use Claude Code for your tasks." },
     codex: { name: "Codex", description: "Use your OpenAI coding assistant." },
@@ -37,6 +38,9 @@ export function modelChoices(provider, configured, home = homedir()) {
     return choices;
 }
 export function detectPreparation(repo) {
+    // In the console, a folder that hasn't answered a look lately is not read on its thread (folder-gate.ts).
+    if (!folderAnswers(repo))
+        return null;
     const has = (file) => existsSync(join(repo, file));
     if (has("package.json")) {
         if (has("pnpm-lock.yaml"))
@@ -59,6 +63,8 @@ export function detectPreparation(repo) {
 }
 /** Browser installation may write only this known file inside its project. */
 export function previewProjectInstructions(repo) {
+    if (!folderAnswers(repo))
+        return { ok: false, message: "This project folder didn't answer. Try again in a moment." };
     try {
         if (!lstatSync(repo).isDirectory())
             return { ok: false, message: "This project folder is unavailable. Reconnect it before adding instructions." };