@bendyline/gezel 0.1.0

package/dist/paths.d.ts

@@ -0,0 +1,578 @@
+/**
+ * Marker written by the privileged installer after a legacy machine-home
+ * migration has completed. Merely finding a writable-looking directory is
+ * not enough to mount it: the marker is the installer's assertion that the
+ * root has the intended cross-account ACL and contains migrated product data.
+ */
+declare const MACHINE_SHARED_MARKER = ".gezel-machine-shared-v1.json";
+/**
+ * Canonical root for explicit machine-shared product data. This is separate
+ * from the machine engine broker's private home: user daemons perform every
+ * project/gezel filesystem operation with the logged-in user's permissions.
+ *
+ * GEZEL_MACHINE_SHARED_HOME is primarily an operator/test override. A root is
+ * mounted only when {@link MACHINE_SHARED_MARKER} exists beneath it.
+ */
+declare function machineSharedHome(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): string | null;
+declare function machineSharedMarkerFile(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): string | null;
+/** A shared root is trusted only after the installer publishes its marker. */
+declare function activeMachineSharedHome(env?: NodeJS.ProcessEnv): string | null;
+type MachineStorageScope = 'user' | 'machine-shared';
+/** Explicit user-home entity locations, bypassing shared-root resolution. */
+declare function userGezelDir(root: string, gezelId: string, external?: ExternalFolders): string;
+declare function userProjectDir(root: string, projectId: string): string;
+/**
+ * Per-account sidecar for project runtime state.
+ *
+ * Unlike {@link projectStorageDir}, this NEVER follows a machine-shared project
+ * into the installer-managed shared root. It is the only appropriate home for
+ * approvals, questions, histories, terminals, executable installs, and
+ * derived databases that belong to the logged-in user's daemon.
+ *
+ * A sidecar deliberately has no `project.json`; projectStorageScope therefore
+ * continues to resolve the canonical definition from the machine-shared root.
+ */
+declare function projectPrivateDir(root: string, projectId: string): string;
+declare function machineSharedGezelDir(gezelId: string): string | null;
+declare function machineSharedProjectDir(projectId: string): string | null;
+/**
+ * Local definition wins on id collision. Sidecar-only user directories (for
+ * private sessions/memories belonging to a shared gezel) deliberately do not:
+ * `gezel.md` is the definition/ownership signal.
+ */
+declare function gezelStorageScope(root: string, gezelId: string, external?: ExternalFolders): MachineStorageScope;
+/** `project.json` is the project definition/ownership signal. */
+declare function projectStorageScope(root: string, projectId: string): MachineStorageScope;
+/**
+ * Resolve the root of the Gezel user directory. Defaults to `~/.gezel`
+ * but can be overridden with the `GEZEL_HOME` environment variable (used
+ * heavily by the integration tests).
+ */
+declare function gezelHome(env?: NodeJS.ProcessEnv): string;
+/**
+ * Per-scope external roots. When a field is set, that scope's content
+ * lives outside `~/.gezel/` (e.g. on a OneDrive folder). Configured via
+ * Settings → Folders; persisted on `GezelConfig.externalFolders`. The
+ * helpers below take this struct as an optional trailing argument and
+ * route to the external location when present, otherwise fall back to
+ * the local layout.
+ *
+ * Some subdirectories deliberately stay local even when their parent
+ * scope is externalized (gezel `toolsets/`, project `workspace/`, `gh/`,
+ * `scripts/`, `project.json`, `history.jsonl`, `questions.json`). Those
+ * paths use the `*LocalDir` helpers, which never consult `external`.
+ */
+interface ExternalFolders {
+    documents?: string;
+    gezels?: string;
+    projects?: string;
+}
+interface GezelPaths {
+    root: string;
+    config: string;
+    runtime: {
+        dir: string;
+        pid: string;
+        port: string;
+        /**
+         * Per-launch first-party client credential used for service discovery.
+         * It carries the reserved `ui` plus local-facade `openai` scopes; the
+         * daemon root credential is process-local and must never be written here.
+         */
+        token: string;
+        /**
+         * PEM-encoded loopback TLS cert. Public material; chmod 0644 so
+         * external clients (CLI, ad-hoc curl) can read it. Rotated on every
+         * daemon start, same as `token`. Only present when the daemon is
+         * serving HTTPS — absent under `GEZEL_INSECURE_TRANSPORT=1`.
+         */
+        cert: string;
+        /**
+         * Hex SHA-256 of the cert's DER bytes — what the Electron renderer
+         * pins via `session.setCertificateVerifyProc`. Stored as a separate
+         * file so the supervisor can read the fingerprint without parsing
+         * the PEM.
+         */
+        fingerprint: string;
+        /**
+         * Per-launch ephemeral token for the browser web-UI mode (`gezel
+         * start --web`). Written only when web mode is on; the CLI reads it
+         * to compose the one-time `?token=` URL it prints, so the root token
+         * never lands in a URL / shell history. Same lifecycle as `token` —
+         * rotates every boot, not persisted to `tokens.json`.
+         */
+        webUiToken: string;
+    };
+    /**
+     * Directory where Electron extracts the `service-bundle/` tree on first
+     * launch. This is the stable path users can `cd` into to run local dev
+     * commands against the bundled CLI (e.g. `npx @github/copilot login`).
+     */
+    install: string;
+    gezels: string;
+    projects: string;
+    documents: string;
+    logs: string;
+}
+declare function gezelPaths(root?: string, external?: ExternalFolders): GezelPaths;
+/**
+ * Always-local private transaction state. Unlike `runtime/`, this directory
+ * contains daemon-internal recovery metadata and must never be exposed as
+ * desktop-client discovery material on a machine-wide install.
+ */
+declare function daemonTransactionsRoot(root: string): string;
+/** Durable journals + isolated staging homes for atomic typed-project creation. */
+declare function projectCreateTransactionsRoot(root: string): string;
+/**
+ * Per-gezel directory holding `gezel.md`, `about.md`, `icon.svg`,
+ * `icons/`, `sessions/`, `memories/`, `resources/`. Routes to the
+ * external location when `external.gezels` is set.
+ *
+ * Note: `toolsets/` and `toolsets.json` are deliberately NOT under this
+ * dir when externalized — they stay local (see {@link gezelLocalDir}).
+ */
+declare function gezelDir(root: string, gezelId: string, external?: ExternalFolders): string;
+/**
+ * Always-local per-gezel directory. Holds installed toolsets (npm
+ * package extracts) — kept out of cloud-synced folders because
+ * node_modules churn is hostile to OneDrive/Dropbox-style sync.
+ */
+declare function gezelLocalDir(root: string, gezelId: string): string;
+declare function gezelSessionsDir(root: string, gezelId: string, external?: ExternalFolders): string;
+declare function gezelSessionFile(root: string, gezelId: string, sessionId: string, external?: ExternalFolders): string;
+/**
+ * Per-gezel memories directory (daily markdown + summary + vectra index).
+ * Moves with the gezel when externalized.
+ */
+declare function gezelMemoriesDir(root: string, gezelId: string, external?: ExternalFolders): string;
+/**
+ * Per-gezel growth.json — level / XP / pending level-up state. Travels
+ * with the gezel when externalized, like the memories dir.
+ */
+declare function gezelGrowthPath(root: string, gezelId: string, external?: ExternalFolders): string;
+/** JSON file of installed toolsets for a gezel. Always local. */
+declare function gezelToolsetsFile(root: string, gezelId: string): string;
+/**
+ * Optional per-gezel `tools.md` — power-user override that fully
+ * replaces the auto-injected `## Tools available this turn` block in
+ * the system prompt. When present, the gezel's owner takes
+ * responsibility for keeping the listing accurate as the install's
+ * registered tools evolve. When absent (the default), the runtime
+ * computes the listing from the live MCP bridge's
+ * `getOpenAITools()` post-allowlist set.
+ *
+ * Lives in the externalizable per-gezel directory alongside `gezel.md`
+ * and `icon.svg` (NOT in the always-local `gezelLocalDir`) — it
+ * describes how the gezel uses tools, which is character-shaped, so
+ * it should travel with the gezel when externalized.
+ */
+declare function gezelToolsPath(root: string, gezelId: string, external?: ExternalFolders): string;
+/** Root for on-disk toolset installs, e.g. npm-package extracts. Always local. */
+declare function gezelToolsetsInstallDir(root: string, gezelId: string): string;
+/**
+ * Per-gezel `poppetje.json` — the resolved Poppetje struct (body shape,
+ * skin, hair, hat, etc.) that drives the parametric SVG renderer in the
+ * UI. Persisted explicitly so adding new catalog entries or tuning slot
+ * odds later never drifts existing characters. Travels with the gezel
+ * when externalized.
+ */
+declare function gezelPoppetjePath(root: string, gezelId: string, external?: ExternalFolders): string;
+/**
+ * Per-project directory holding the project's content. Routes to the
+ * external location when `external.projects` is set.
+ *
+ * The canonical `project.json` plus an internal `workspace/` / legacy `gh/`
+ * checkout follow this directory. Account-private runtime state does not: it
+ * stays under {@link projectPrivateDir}, even when this project is
+ * machine-shared.
+ */
+declare function projectDir(root: string, projectId: string, external?: ExternalFolders): string;
+/**
+ * Canonical on-machine project directory. For a machine-shared project this
+ * follows the project into the installer-managed shared root; otherwise it is
+ * the user's project directory.
+ *
+ * This helper is for the project definition and intentionally shared project
+ * content such as its internal workspace. Per-account runtime state must use
+ * {@link projectPrivateDir} instead.
+ */
+declare function projectStorageDir(root: string, projectId: string): string;
+/**
+ * @deprecated The old name blurred canonical project storage with private
+ * daemon state. Use {@link projectStorageDir} for shared project content or
+ * {@link projectPrivateDir} for per-account state.
+ */
+declare function projectLocalDir(root: string, projectId: string): string;
+/** Per-project `project.json` metadata file. Always local. */
+declare function projectMetaFile(root: string, projectId: string): string;
+/** Durable user/worker lifecycle for indexed code findings. Account-private. */
+declare function projectFindingLifecycleFile(root: string, projectId: string): string;
+/** Durable per-project code-review records for this account. */
+declare function projectCodeReviewsFile(root: string, projectId: string): string;
+/** Durable per-account report-action lifecycle records. */
+declare function projectReportActionsFile(root: string, projectId: string): string;
+/** Per-project documents folder — holds about.md, missionObjectives.md, etc. */
+declare function projectDocsDir(root: string, projectId: string, external?: ExternalFolders): string;
+/** Per-project artifacts folder — agent-generated outputs. */
+declare function projectArtifactsDir(root: string, projectId: string, external?: ExternalFolders): string;
+/** Per-project memories folder (daily markdown + summary + vectra index). */
+declare function projectMemoriesDir(root: string, projectId: string, external?: ExternalFolders): string;
+/**
+ * Per-account derived vector index for project memories. The canonical memory
+ * markdown follows the project via {@link projectMemoriesDir}; mutable SQLite
+ * never does.
+ */
+declare function projectMemoryIndexDir(root: string, projectId: string): string;
+/**
+ * Default location for the cloned GitHub repo when neither (a) the project
+ * has a workingDir nor (b) the existing workingDir already holds the repo.
+ * Internal-only checkout: lives under the project folder. Always local.
+ *
+ * Pre-Phase-2: this was where every github-linked project's clone landed.
+ * Post-Phase-2: new projects clone into the workspace directly; this path
+ * is kept around to (a) adopt legacy clones in `GitManager.resolveCheckout`
+ * and (b) feed the one-shot `Store.migrateLegacyGhCheckouts` migration that
+ * moves legacy `gh/` clones into `workspace/`. New code should not assume
+ * a clone lives here.
+ */
+declare function projectInternalGithubDir(root: string, projectId: string): string;
+/**
+ * Root for shared bare clones (Phase 3). Multiple projects pointing at
+ * the same github URL share a single bare clone here; each project's
+ * workspace is created via `git worktree add` off the bare clone. Saves
+ * disk space (no duplicate `.git/objects` per project) and unlocks the
+ * "PR review + main branch in parallel" workflow without re-fetching.
+ *
+ * Lives at `<root>/git-clones/`. Always local — the bare clones are
+ * host-specific (worktree paths, packed refs, hooks) and shouldn't
+ * cloud-sync.
+ */
+declare function sharedClonesRoot(root: string): string;
+/**
+ * Path to the bare clone for a specific github URL. The `key` is the
+ * caller-derived stable identifier (typically `<owner>-<repo>-<hash>`)
+ * so two URL strings that normalize to the same repo share one clone.
+ */
+declare function sharedCloneDir(root: string, key: string): string;
+/**
+ * Per-project background-index folder. Holds `commands.json`,
+ * `files.json`, `tokens.json`, `index.meta.json` — produced by the
+ * workspace indexer. Always local: the index is host-machine-specific
+ * (paths, mtimes, installed CLIs) and shouldn't sync across machines.
+ */
+declare function projectIndexDir(root: string, projectId: string): string;
+/**
+ * Per-project terminal-threads folder. Holds `{threadId}.json` files,
+ * one per (project, workingDir) pair. Always local: terminal output
+ * is host-machine-specific and not interesting to sync across
+ * machines.
+ */
+declare function projectTerminalsDir(root: string, projectId: string): string;
+declare function projectTerminalFile(root: string, projectId: string, threadId: string): string;
+/** JSONL file holding events that aren't scoped to any project. */
+declare function globalHistoryFile(root: string): string;
+/**
+ * Home-scoped index directory for cross-project derived caches (session
+ * transcripts, history mirror, documents library). Always local: it's a
+ * rebuildable sqlite cache, never user data, so it stays out of
+ * `ExternalFolders` on purpose.
+ */
+declare function globalIndexDir(root: string): string;
+declare function globalIndexDbFile(root: string): string;
+/** Per-project JSONL holding events scoped to that project. Always local. */
+declare function projectHistoryFile(root: string, projectId: string): string;
+/**
+ * Single per-project file holding the array of structured Q&A
+ * (`Question` records) created by the `ask_user_question` MCP tool.
+ * One file rather than per-id because volume is low and the panels
+ * always want the full list. Always local.
+ */
+declare function projectQuestionsFile(root: string, projectId: string): string;
+/**
+ * Per-project last-activity stamp maintained by the ActivityTracker.
+ * Separate from `project.json` so ambient stamping never contends with
+ * (or bumps `updatedAt` on) the metadata file. Always local.
+ */
+declare function projectActivityFile(root: string, projectId: string): string;
+/**
+ * Home for the meester's status report — the dynamic Home greeting
+ * headline + dashboard markdown (`status.json`) and the generator's
+ * run budget / idempotency state (`state.json`). Store-managed.
+ */
+declare function meesterStatusDir(root: string): string;
+declare function meesterStatusFile(root: string): string;
+declare function meesterStatusStateFile(root: string): string;
+declare function projectTasksDir(root: string, projectId: string, external?: ExternalFolders): string;
+declare function projectTaskNextIdFile(root: string, projectId: string, external?: ExternalFolders): string;
+declare function projectTaskDir(root: string, projectId: string, num: number, external?: ExternalFolders): string;
+declare function projectTaskFile(root: string, projectId: string, num: number, external?: ExternalFolders): string;
+declare function projectTaskNotesFile(root: string, projectId: string, num: number, external?: ExternalFolders): string;
+/**
+ * Free-form prose `about.md` at the root of a task folder. Stores the
+ * task's `description` body — the long "what we're solving and what
+ * success looks like" prose that's injected into task-scoped chat
+ * sessions. Kept out of `task.json` so the JSON stays compact and
+ * the prose can be edited as a real markdown file.
+ */
+declare function projectTaskAboutFile(root: string, projectId: string, num: number, external?: ExternalFolders): string;
+/**
+ * Account-private project-scoped scripts directory. Holds `.ts` files with a mandatory
+ * `export const meta` block; see `schemas/script.ts`. Not recursive —
+ * one script per file, resolved by `meta.name`. Always local.
+ */
+declare function projectScriptsDir(root: string, projectId: string): string;
+declare function projectScriptFile(root: string, projectId: string, name: string): string;
+/**
+ * The user's machine-wide script library (`scope: 'user'` refs) —
+ * scripts shared across every project on this device. Same file
+ * conventions as project scripts. Always local.
+ */
+declare function userScriptsDir(root: string): string;
+declare function userScriptFile(root: string, name: string): string;
+/**
+ * Per-project directory holding persisted `ScriptRun` records, sharded
+ * by UTC date so a long-lived project doesn't accumulate a single
+ * giant directory. Always local.
+ */
+declare function projectScriptRunsDir(root: string, projectId: string): string;
+declare function projectScriptRunFile(root: string, projectId: string, isoDate: string, runId: string): string;
+/**
+ * Local catalog source for user-authored craftbook templates. Mirrors
+ * the bundled catalog layout under
+ * `~/.gezel/craftbook-templates/{prefix}/{id}/versions/{version}/`. The
+ * `CatalogService` picks this up alongside the bundled source so user
+ * craftbooks browse next to shipped ones.
+ */
+declare function craftbookTemplatesRoot(root: string): string;
+declare function craftbookTemplateDir(root: string, prefix: string, id: string): string;
+declare function craftbookTemplateManifestFile(root: string, prefix: string, id: string): string;
+declare function craftbookTemplateVersionDir(root: string, prefix: string, id: string, version: string): string;
+declare function craftbookTemplateVersionManifestFile(root: string, prefix: string, id: string, version: string): string;
+/** Directory holding a craftbook version's bundled `*.ts` scripts. */
+declare function craftbookTemplateScriptsDir(root: string, prefix: string, id: string, version: string): string;
+/** A single bundled script file inside a craftbook version. */
+declare function craftbookTemplateScriptFile(root: string, prefix: string, id: string, version: string, name: string): string;
+/** First two lowercased chars of a craftbook id — the catalog's shard prefix. */
+declare function craftbookShardPrefix(id: string): string;
+/**
+ * Local catalog source for user-installed / imported project types. Mirrors
+ * the bundled catalog layout under
+ * `~/.gezel/project-types/{prefix}/{id}/versions/{version}/`. A `.gzl`
+ * import or a "install from gilde" action copies items here so they browse
+ * next to the bundled ones. See docs/project-types.md.
+ */
+declare function projectTypesRoot(root: string): string;
+declare function projectTypeDir(root: string, prefix: string, id: string): string;
+declare function projectTypeManifestFile(root: string, prefix: string, id: string): string;
+declare function projectTypeVersionDir(root: string, prefix: string, id: string, version: string): string;
+declare function projectTypeVersionManifestFile(root: string, prefix: string, id: string, version: string): string;
+/** First two lowercased chars of a project-type id — the catalog's shard prefix. */
+declare function projectTypeShardPrefix(id: string): string;
+/**
+ * Per-project authored definitions that travel WITH the repo. They live
+ * in a `.gezel/` folder inside the project's resolved WORKSPACE directory
+ * (workingDir > github checkout > internal workspace), NOT under
+ * `~/.gezel`. Holds the `@project` gezel + any other project-local
+ * gezels, project-local craftbooks, and import provenance.
+ *
+ * IMPORTANT: these helpers take a `workspaceDir` (resolved via
+ * `Store.projectWorkspaceDir`), not the gezel `root`. Runtime/derived
+ * state for a project-local gezel (poppetje, sessions, memories)
+ * deliberately stays in app-data under `~/.gezel/gezels/<encoded-id>/`
+ * keyed by the encoded id — the workspace `.gezel/` carries only the
+ * authored definition, so chat history never lands in the user's repo.
+ */
+declare function projectLocalRoot(workspaceDir: string): string;
+/**
+ * Workspace content-index store (code/doc intelligence — the boekwachter
+ * index). Lives under the project-local `.gezel/index/` so it travels with the
+ * repo *folder*, but gezel writes a `.gitignore` inside it so the binary sqlite
+ * DB + regenerable artifacts are never committed. Distinct from the host-local
+ * `_index/` (commands/files/tokens) under `~/.gezel`: that one is machine-
+ * specific (mtimes, installed CLIs); this one is content-derived.
+ */
+declare function projectLocalIndexDir(workspaceDir: string): string;
+declare function projectLocalIndexDbFile(workspaceDir: string): string;
+/**
+ * Converted-document artifacts (squisq-flavored markdown + media + CSV),
+ * mirroring the source tree under `.gezel/files/<mirror>/<name>_files/`.
+ */
+declare function projectLocalFilesDir(workspaceDir: string): string;
+/**
+ * Quarantine for untrusted content the safety scanner refused to index
+ * (prompt-injection payloads, attachments that failed parser-safety checks).
+ * Lives under `.gezel/quarantine/` — inside the project-local root the content
+ * indexer skips, so quarantined material is structurally unreachable by search
+ * + embeddings. Operators can inspect the raw artifacts here manually.
+ */
+declare function projectLocalQuarantineDir(workspaceDir: string): string;
+/**
+ * Home-local fallback for the content index when the workspace `.gezel/` isn't
+ * writable (external read-only repos). Mirrors the `_index` placement but for
+ * the content-derived DB.
+ */
+declare function fallbackProjectIndexDir(root: string, projectId: string): string;
+/**
+ * Mutable content-index database for a project. Ordinary writable workspaces
+ * retain the historical `.gezel/index/` placement; machine-shared workspaces
+ * always use the account-private fallback to prevent cross-daemon SQLite use.
+ */
+declare function projectContentIndexDbFile(root: string, projectId: string, workspaceDir: string): string;
+/**
+ * The committable code-map "city file": placement anchors, user overrides, and
+ * the layout journal. Deliberately OUTSIDE the self-gitignored `.gezel/index/`
+ * subtree — committing it keeps the city stable across machines and index
+ * rebuilds.
+ */
+declare function projectLocalVillageFile(workspaceDir: string): string;
+/** Home-local village-file fallback (no external workingDir, or read-only repo). */
+declare function fallbackProjectVillageFile(root: string, projectId: string): string;
+/** `@project` about-source mapping (which instruction file feeds the prompt). */
+declare function projectLocalConfigFile(workspaceDir: string): string;
+/** Import provenance — hashes, ids, userEdited flags. */
+declare function projectLocalImportsFile(workspaceDir: string): string;
+/** Review-before-save proposals for generated JS scripts. */
+declare function projectLocalPendingImportsFile(workspaceDir: string): string;
+declare function projectLocalGezelsRoot(workspaceDir: string): string;
+declare function projectLocalGezelDir(workspaceDir: string, localId: string): string;
+declare function projectLocalCraftbooksRoot(workspaceDir: string): string;
+declare function projectLocalCraftbookDir(workspaceDir: string, id: string): string;
+/** JSON file of the shared toolsets — toolsets every gezel inherits. */
+declare function sharedToolsetsFile(root: string): string;
+/** Install root for the shared toolsets' on-disk extracts. */
+declare function sharedToolsetsInstallDir(root: string): string;
+/**
+ * JSON file of this account's project toolsets — installed by a custom project
+ * type and seen by this account's sessions scoped to that project. Kept in the
+ * private project sidecar so executable selection never crosses accounts.
+ * See docs/project-types.md.
+ */
+declare function projectToolsetsFile(root: string, projectId: string): string;
+/** Install root for a project's toolsets' on-disk extracts. */
+declare function projectToolsetsInstallDir(root: string, projectId: string): string;
+/**
+ * JSON tracking file for system-scope toolsets — records exactly what's on
+ * disk (id, version, integrity, installedAt) plus top-level `pnpmVersion`
+ * + `chromiumRevision`. Compared to the shipped `SYSTEM_TOOLSETS` manifest
+ * on boot; mismatch triggers a re-install for the affected entries.
+ */
+declare function systemToolsetsFile(root: string): string;
+/**
+ * Store-level `InstalledToolset[]` list for system-scope toolsets. Kept
+ * **separate** from {@link systemToolsetsFile}: that file carries the
+ * bootstrap's `SystemTrackingRecord` (object schema with `toolsets` map
+ * + `chromiumRevision`), while this one carries the Store's runtime list
+ * (array schema with `installPath` + full `runtime` snapshot). Previously,
+ * they shared the same path and silently overwrote each other
+ * — a bootstrap followed by a Store write would leave `systemToolsetsFile`
+ * unreadable as a `SystemTrackingRecord`, and the next boot would report
+ * "not installed" for everything.
+ */
+declare function systemInstalledToolsetsFile(root: string): string;
+/** Install root for system-scope toolset extracts (Playwright, etc.). */
+declare function systemToolsetsInstallDir(root: string): string;
+/**
+ * Opt-in live gilde content cache — newer `@bendyline/gilde` patch releases
+ * fetched at runtime by the GildeUpdateManager. Holds `versions/<v>/` (the
+ * extracted npm package) plus `state.json`. Rebuildable: the bundled pin is
+ * the permanent fallback, so deleting this tree only reverts content.
+ */
+declare function gildeLiveRoot(root: string): string;
+/** Version-named extracted `@bendyline/gilde` packages, `<version>/package/`. */
+declare function gildeLiveVersionsDir(root: string): string;
+/** One extracted live gilde version (contains the npm `package/` dir). */
+declare function gildeLiveVersionDir(root: string, version: string): string;
+/** Active-version + last-check tracking state for live gilde updates. */
+declare function gildeLiveStateFile(root: string): string;
+/**
+ * Directory where Playwright's own CLI drops browser binaries. Exported
+ * to both the service (sets `PLAYWRIGHT_BROWSERS_PATH` when spawning
+ * Playwright) and the bootstrap (verifies Chromium installed).
+ */
+declare function playwrightBrowsersDir(root: string): string;
+/** Directory holding one subfolder per toolset for its global config. */
+declare function toolsetConfigsDir(root: string): string;
+/** Per-toolset global config file (non-secret values only). */
+declare function toolsetConfigFile(root: string, toolsetId: string): string;
+/** AES-GCM encrypted blob file for the fallback FileSecretStore. */
+declare function secretsFile(root: string): string;
+/** Key material file for the fallback FileSecretStore (POSIX 0600). */
+declare function secretsKeyFile(root: string): string;
+/**
+ * Persisted per-app bearer tokens issued to third-party local apps via the
+ * `/v1/apps/register` consent flow. The ephemeral root token (rotated every
+ * launch) is **not** persisted here and never leaves process memory.
+ * `runtime/auth-token` contains a separate, scoped first-party client
+ * credential. POSIX 0600 on this file keeps third-party app bearer secrets
+ * private. Always local.
+ */
+declare function tokensFile(root: string): string;
+/**
+ * Persisted `/v1/apps/register` consent requests — both pending grants
+ * (waiting for the user to approve/deny in the Connected Apps UI) and
+ * decided grants (kept so a polling app can still observe the verdict
+ * after a daemon restart). The file is small; no rotation.
+ *
+ * Headless-Electron fallback: when the daemon runs without a UI attached,
+ * pending grants accumulate here. The next time the Electron app starts,
+ * it reads this file and surfaces them as notifications. Always local.
+ */
+declare function pendingGrantsFile(root: string): string;
+/**
+ * Public half of this device's stable identity keypair (Ed25519) plus its
+ * `deviceId` and fingerprint. Used by the remote-model-execution pairing
+ * flow: a paired client pins this device's identity fingerprint (TOFU), and
+ * the private half (held in the SecretStore) signs the rotating TLS cert so
+ * trust survives reboots even though the loopback/LAN cert rotates. Public
+ * material; POSIX 0600 anyway so the deviceId isn't world-readable. Always
+ * local.
+ */
+declare function deviceIdentityFile(root: string): string;
+/**
+ * Servers this device has paired with for remote model execution (Device A's
+ * view): per-remote `{baseUrl, token, pinnedIdentityKey, ...}`. Holds bearer
+ * secrets, so POSIX 0600, same posture as `tokens.json`. Always local.
+ */
+declare function remotesFile(root: string): string;
+/** Root for all communication-channel per-channel state (future channels). */
+declare function channelsDir(root: string): string;
+/**
+ * Backups produced by the folder-externalization move worker. Each
+ * successful move snapshots the source tree under
+ * `~/.gezel/backup/<ISO-timestamp>/<scope>/` before swapping the config.
+ * Always local.
+ */
+declare function backupsDir(root: string): string;
+/**
+ * Sentinel + queue directory for the folder-externalization worker.
+ * Holds `active-move.json` while a move is in flight so the next boot
+ * can detect a crashed mid-move. Always local.
+ */
+declare function foldersStateDir(root: string): string;
+/**
+ * Keurmeester supervision state: append-only case records plus generated
+ * digest reports. A deliberate Store carve-out owned by KeurmeesterManager
+ * (packages/service/src/keurmeester/) — same posture as `history.jsonl`.
+ * Always local.
+ */
+declare function keurmeesterDir(root: string): string;
+/** Monthly-sharded JSONL case records: `cases/YYYY-MM.jsonl`. */
+declare function keurmeesterCasesDir(root: string): string;
+/** Generated digest reports: `digests/YYYY-MM-DD.md`. */
+declare function keurmeesterDigestsDir(root: string): string;
+/** Digest idempotency state (last generated date, last case offset). */
+declare function keurmeesterDigestStatePath(root: string): string;
+/**
+ * Read the on-disk `config.json` without instantiating a Store. Used at
+ * boot to discover `externalFolders` before the Store is constructed
+ * (the Store needs `external` to resolve every other path correctly,
+ * but the config file itself always lives at `<root>/config.json`).
+ *
+ * Returns an empty object if the file is missing or unreadable; callers
+ * fall back to defaults. Intentionally typed loosely (`unknown`-ish) —
+ * no Zod parse here so schema additions don't tie the boot path to
+ * regenerating types.
+ */
+declare function readConfigRaw(root: string): Promise<Record<string, unknown>>;
+
+export { type ExternalFolders, type GezelPaths, MACHINE_SHARED_MARKER, type MachineStorageScope, activeMachineSharedHome, backupsDir, channelsDir, craftbookShardPrefix, craftbookTemplateDir, craftbookTemplateManifestFile, craftbookTemplateScriptFile, craftbookTemplateScriptsDir, craftbookTemplateVersionDir, craftbookTemplateVersionManifestFile, craftbookTemplatesRoot, daemonTransactionsRoot, deviceIdentityFile, fallbackProjectIndexDir, fallbackProjectVillageFile, foldersStateDir, gezelDir, gezelGrowthPath, gezelHome, gezelLocalDir, gezelMemoriesDir, gezelPaths, gezelPoppetjePath, gezelSessionFile, gezelSessionsDir, gezelStorageScope, gezelToolsPath, gezelToolsetsFile, gezelToolsetsInstallDir, gildeLiveRoot, gildeLiveStateFile, gildeLiveVersionDir, gildeLiveVersionsDir, globalHistoryFile, globalIndexDbFile, globalIndexDir, keurmeesterCasesDir, keurmeesterDigestStatePath, keurmeesterDigestsDir, keurmeesterDir, machineSharedGezelDir, machineSharedHome, machineSharedMarkerFile, machineSharedProjectDir, meesterStatusDir, meesterStatusFile, meesterStatusStateFile, pendingGrantsFile, playwrightBrowsersDir, projectActivityFile, projectArtifactsDir, projectCodeReviewsFile, projectContentIndexDbFile, projectCreateTransactionsRoot, projectDir, projectDocsDir, projectFindingLifecycleFile, projectHistoryFile, projectIndexDir, projectInternalGithubDir, projectLocalConfigFile, projectLocalCraftbookDir, projectLocalCraftbooksRoot, projectLocalDir, projectLocalFilesDir, projectLocalGezelDir, projectLocalGezelsRoot, projectLocalImportsFile, projectLocalIndexDbFile, projectLocalIndexDir, projectLocalPendingImportsFile, projectLocalQuarantineDir, projectLocalRoot, projectLocalVillageFile, projectMemoriesDir, projectMemoryIndexDir, projectMetaFile, projectPrivateDir, projectQuestionsFile, projectReportActionsFile, projectScriptFile, projectScriptRunFile, projectScriptRunsDir, projectScriptsDir, projectStorageDir, projectStorageScope, projectTaskAboutFile, projectTaskDir, projectTaskFile, projectTaskNextIdFile, projectTaskNotesFile, projectTasksDir, projectTerminalFile, projectTerminalsDir, projectToolsetsFile, projectToolsetsInstallDir, projectTypeDir, projectTypeManifestFile, projectTypeShardPrefix, projectTypeVersionDir, projectTypeVersionManifestFile, projectTypesRoot, readConfigRaw, remotesFile, secretsFile, secretsKeyFile, sharedCloneDir, sharedClonesRoot, sharedToolsetsFile, sharedToolsetsInstallDir, systemInstalledToolsetsFile, systemToolsetsFile, systemToolsetsInstallDir, tokensFile, toolsetConfigFile, toolsetConfigsDir, userGezelDir, userProjectDir, userScriptFile, userScriptsDir };