mintree 0.1.2

package/dist/lib/git.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Returns the absolute path of the **main** git repo root (not a worktree's
+ * checkout). When invoked from inside a linked worktree, `git rev-parse
+ * --show-toplevel` would return the worktree path; we resolve the common git
+ * directory instead so callers always get the canonical place where `.mintree/`
+ * lives. Returns `null` when not inside a git repository.
+ */
+export declare function findMainRepoRoot(cwd?: string): string | null;
+export declare function getMintreeDir(repoRoot: string): string;
+export declare function getMetadataPath(repoRoot: string): string;
+export declare function getWorktreesDir(repoRoot: string): string;
+export declare function getSessionStatesDir(repoRoot: string): string;
+export declare function getInitScriptPath(repoRoot: string): string;
+/** Checks whether a path is gitignored according to the repo's rules. */
+export declare function isGitIgnored(relativePath: string, cwd: string): boolean;
+/**
+ * True when the path is currently tracked by git in the repo at `cwd`. A
+ * gitignore'd path can still be tracked if it was added before being
+ * ignored — in that case `git rm --cached` is required to untrack it.
+ */
+export declare function isGitTracked(relativePath: string, cwd: string): boolean;
+/**
+ * Looks for a file or directory in the repo that's likely to document the
+ * project's branch / git conventions. The first hit wins — we just want
+ * something to point the user at, not an exhaustive scan. Paths returned
+ * are relative to `repoRoot` so they're safe to display.
+ */
+export declare function findBranchConventionDoc(repoRoot: string): string | null;
+export declare function pathExists(p: string): boolean;
+export declare function isExecutable(p: string): boolean;
+/**
+ * Appends `entries` to `<repoRoot>/.gitignore`, skipping any entry already
+ * matched by the repo's gitignore rules. Creates the file if missing. Returns
+ * the entries that were actually appended.
+ */
+export declare function ensureGitignoreEntries(repoRoot: string, entries: string[]): string[];
+/**
+ * Best-effort default branch detection. Tries `origin/HEAD` first (the most
+ * authoritative source when the repo has a remote), then falls back to `main`
+ * and `master` as on-disk heuristics. Returns null only when none of those
+ * exist locally or on the remote.
+ */
+export declare function getDefaultBranch(repoRoot: string): string | null;
+export type BranchExistence = "local" | "remote" | null;
+export declare function branchExists(repoRoot: string, branch: string): BranchExistence;
+/**
+ * Returns the absolute path where `branch` is checked out as a worktree, or
+ * null when the branch is not checked out anywhere. Parses the porcelain
+ * format of `git worktree list --porcelain`.
+ */
+export declare function worktreeForBranch(repoRoot: string, branch: string): string | null;
+/**
+ * Creates a git worktree at `worktreePath` checked out on `branch`. Behavior
+ * depending on whether `branch` already exists:
+ *  - new branch: `git worktree add -b <branch> <path> <base>`
+ *  - local branch: `git worktree add <path> <branch>`
+ *  - remote-only branch: `git worktree add --track -b <branch> <path>
+ *    origin/<branch>` (creates a tracking local)
+ *
+ * Throws on failure with stderr included so the caller can surface it.
+ */
+export declare function addWorktree(args: {
+    repoRoot: string;
+    branch: string;
+    worktreePath: string;
+    base?: string;
+}): void;
+/**
+ * Removes a worktree via `git worktree remove`. With `force=true`, also
+ * removes the worktree even if it has uncommitted changes. Throws on failure.
+ */
+export declare function removeWorktree(args: {
+    repoRoot: string;
+    worktreePath: string;
+    force?: boolean;
+}): void;
+/**
+ * Runs `git worktree prune` to clean up worktree references whose on-disk
+ * directory no longer exists.
+ */
+export declare function pruneWorktrees(repoRoot: string): void;
+export type WorktreeEntry = {
+    path: string;
+    branch: string | null;
+    head: string | null;
+};
+/**
+ * Parses `git worktree list --porcelain` into structured entries. Includes
+ * detached HEADs (branch=null) and the main worktree. Caller is responsible
+ * for filtering to mintree-managed worktrees.
+ */
+export declare function listWorktrees(repoRoot: string): WorktreeEntry[];
+/** True when the worktree has any uncommitted changes (porcelain non-empty). */
+export declare function isDirty(worktreePath: string): boolean;
+/**
+ * Returns the current branch of the git checkout at `cwd`, or null when in a
+ * detached HEAD or outside a git repo.
+ */
+export declare function getCurrentBranch(cwd: string): string | null;
+export type AheadBehind = {
+    ahead: number;
+    behind: number;
+    against: string;
+};
+/**
+ * Returns commits ahead/behind `against` from the worktree's HEAD. `against`
+ * is resolved in this priority: explicit param > `@{upstream}` > null.
+ * Returns null when no comparison ref is available.
+ */
+export declare function getAheadBehind(worktreePath: string, against?: string): AheadBehind | null;

package/dist/lib/git.js

@@ -0,0 +1,320 @@
+import { execSync } from "child_process";
+import * as path from "path";
+import * as fs from "fs";
+/**
+ * Returns the absolute path of the **main** git repo root (not a worktree's
+ * checkout). When invoked from inside a linked worktree, `git rev-parse
+ * --show-toplevel` would return the worktree path; we resolve the common git
+ * directory instead so callers always get the canonical place where `.mintree/`
+ * lives. Returns `null` when not inside a git repository.
+ */
+export function findMainRepoRoot(cwd = process.cwd()) {
+    try {
+        const commonDir = execSync("git rev-parse --git-common-dir", {
+            cwd,
+            stdio: ["ignore", "pipe", "ignore"],
+        })
+            .toString()
+            .trim();
+        const absoluteCommonDir = path.isAbsolute(commonDir)
+            ? commonDir
+            : path.resolve(cwd, commonDir);
+        // `--git-common-dir` points at `<root>/.git` in a normal repo. Its parent
+        // is the working tree root we want.
+        if (path.basename(absoluteCommonDir) === ".git") {
+            return path.dirname(absoluteCommonDir);
+        }
+        // Bare repos or unusual setups: fall back to --show-toplevel.
+        const top = execSync("git rev-parse --show-toplevel", {
+            cwd,
+            stdio: ["ignore", "pipe", "ignore"],
+        })
+            .toString()
+            .trim();
+        return top || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function getMintreeDir(repoRoot) {
+    return path.join(repoRoot, ".mintree");
+}
+export function getMetadataPath(repoRoot) {
+    return path.join(getMintreeDir(repoRoot), "metadata.json");
+}
+export function getWorktreesDir(repoRoot) {
+    return path.join(getMintreeDir(repoRoot), "worktrees");
+}
+export function getSessionStatesDir(repoRoot) {
+    return path.join(getMintreeDir(repoRoot), "session-states");
+}
+export function getInitScriptPath(repoRoot) {
+    return path.join(getMintreeDir(repoRoot), "init.sh");
+}
+/** Checks whether a path is gitignored according to the repo's rules. */
+export function isGitIgnored(relativePath, cwd) {
+    try {
+        execSync(`git check-ignore -q "${relativePath}"`, { cwd, stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * True when the path is currently tracked by git in the repo at `cwd`. A
+ * gitignore'd path can still be tracked if it was added before being
+ * ignored — in that case `git rm --cached` is required to untrack it.
+ */
+export function isGitTracked(relativePath, cwd) {
+    try {
+        execSync(`git ls-files --error-unmatch "${relativePath}"`, {
+            cwd,
+            stdio: "ignore",
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Looks for a file or directory in the repo that's likely to document the
+ * project's branch / git conventions. The first hit wins — we just want
+ * something to point the user at, not an exhaustive scan. Paths returned
+ * are relative to `repoRoot` so they're safe to display.
+ */
+export function findBranchConventionDoc(repoRoot) {
+    const candidates = [
+        "docs/conventions/git-workflow.md",
+        "docs/git-workflow.md",
+        "docs/branching.md",
+        "BRANCHING.md",
+        "CONTRIBUTING.md",
+        ".claude/skills",
+    ];
+    for (const c of candidates) {
+        if (fs.existsSync(path.join(repoRoot, c)))
+            return c;
+    }
+    return null;
+}
+export function pathExists(p) {
+    return fs.existsSync(p);
+}
+export function isExecutable(p) {
+    try {
+        fs.accessSync(p, fs.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Appends `entries` to `<repoRoot>/.gitignore`, skipping any entry already
+ * matched by the repo's gitignore rules. Creates the file if missing. Returns
+ * the entries that were actually appended.
+ */
+export function ensureGitignoreEntries(repoRoot, entries) {
+    const gitignorePath = path.join(repoRoot, ".gitignore");
+    const toAdd = entries.filter(entry => !isGitIgnored(entry, repoRoot));
+    if (toAdd.length === 0)
+        return [];
+    const existing = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, "utf-8") : "";
+    const parts = [];
+    if (existing.length > 0 && !existing.endsWith("\n"))
+        parts.push("\n");
+    if (existing.length > 0)
+        parts.push("\n");
+    parts.push("# mintree\n");
+    parts.push(toAdd.join("\n") + "\n");
+    fs.appendFileSync(gitignorePath, parts.join(""));
+    return toAdd;
+}
+/**
+ * Best-effort default branch detection. Tries `origin/HEAD` first (the most
+ * authoritative source when the repo has a remote), then falls back to `main`
+ * and `master` as on-disk heuristics. Returns null only when none of those
+ * exist locally or on the remote.
+ */
+export function getDefaultBranch(repoRoot) {
+    const head = trySh(`git symbolic-ref refs/remotes/origin/HEAD`, repoRoot);
+    if (head) {
+        // e.g. "refs/remotes/origin/main" -> "main"
+        const m = head.match(/refs\/remotes\/origin\/(.+)$/);
+        if (m && m[1])
+            return m[1];
+    }
+    for (const candidate of ["main", "master"]) {
+        if (branchExists(repoRoot, candidate) !== null)
+            return candidate;
+    }
+    return null;
+}
+export function branchExists(repoRoot, branch) {
+    if (trySh(`git rev-parse --verify --quiet "refs/heads/${branch}"`, repoRoot))
+        return "local";
+    if (trySh(`git rev-parse --verify --quiet "refs/remotes/origin/${branch}"`, repoRoot))
+        return "remote";
+    return null;
+}
+/**
+ * Returns the absolute path where `branch` is checked out as a worktree, or
+ * null when the branch is not checked out anywhere. Parses the porcelain
+ * format of `git worktree list --porcelain`.
+ */
+export function worktreeForBranch(repoRoot, branch) {
+    const output = trySh(`git worktree list --porcelain`, repoRoot);
+    if (!output)
+        return null;
+    const ref = `refs/heads/${branch}`;
+    const blocks = output.split(/\n\n+/);
+    for (const block of blocks) {
+        const lines = block.split("\n");
+        let wtPath = null;
+        let wtBranch = null;
+        for (const line of lines) {
+            if (line.startsWith("worktree "))
+                wtPath = line.slice("worktree ".length);
+            if (line.startsWith("branch "))
+                wtBranch = line.slice("branch ".length);
+        }
+        if (wtPath && wtBranch === ref)
+            return wtPath;
+    }
+    return null;
+}
+/**
+ * Creates a git worktree at `worktreePath` checked out on `branch`. Behavior
+ * depending on whether `branch` already exists:
+ *  - new branch: `git worktree add -b <branch> <path> <base>`
+ *  - local branch: `git worktree add <path> <branch>`
+ *  - remote-only branch: `git worktree add --track -b <branch> <path>
+ *    origin/<branch>` (creates a tracking local)
+ *
+ * Throws on failure with stderr included so the caller can surface it.
+ */
+export function addWorktree(args) {
+    const { repoRoot, branch, worktreePath, base } = args;
+    const existence = branchExists(repoRoot, branch);
+    const safePath = shellQuote(worktreePath);
+    const safeBranch = shellQuote(branch);
+    let cmd;
+    if (existence === "local") {
+        cmd = `git worktree add ${safePath} ${safeBranch}`;
+    }
+    else if (existence === "remote") {
+        cmd = `git worktree add --track -b ${safeBranch} ${safePath} ${shellQuote(`origin/${branch}`)}`;
+    }
+    else {
+        if (!base)
+            throw new Error(`Cannot create new branch ${branch}: no base branch resolved.`);
+        cmd = `git worktree add -b ${safeBranch} ${safePath} ${shellQuote(base)}`;
+    }
+    execSync(cmd, { cwd: repoRoot, stdio: ["ignore", "pipe", "pipe"] });
+}
+/**
+ * Removes a worktree via `git worktree remove`. With `force=true`, also
+ * removes the worktree even if it has uncommitted changes. Throws on failure.
+ */
+export function removeWorktree(args) {
+    const { repoRoot, worktreePath, force } = args;
+    const cmd = `git worktree remove ${force ? "--force " : ""}${shellQuote(worktreePath)}`;
+    execSync(cmd, { cwd: repoRoot, stdio: ["ignore", "pipe", "pipe"] });
+}
+/**
+ * Runs `git worktree prune` to clean up worktree references whose on-disk
+ * directory no longer exists.
+ */
+export function pruneWorktrees(repoRoot) {
+    execSync("git worktree prune", { cwd: repoRoot, stdio: ["ignore", "pipe", "pipe"] });
+}
+/**
+ * Runs a shell command in `cwd` and returns trimmed stdout, or null if the
+ * command exits non-zero. Used for git probes whose absence is meaningful.
+ */
+function trySh(cmd, cwd) {
+    try {
+        return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "ignore"] })
+            .toString()
+            .trim();
+    }
+    catch {
+        return null;
+    }
+}
+/** Single-quote a value for safe inclusion in a shell command line. */
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+/**
+ * Parses `git worktree list --porcelain` into structured entries. Includes
+ * detached HEADs (branch=null) and the main worktree. Caller is responsible
+ * for filtering to mintree-managed worktrees.
+ */
+export function listWorktrees(repoRoot) {
+    const output = trySh("git worktree list --porcelain", repoRoot);
+    if (!output)
+        return [];
+    const entries = [];
+    const blocks = output.split(/\n\n+/);
+    for (const block of blocks) {
+        let entryPath = null;
+        let head = null;
+        let branch = null;
+        for (const line of block.split("\n")) {
+            if (line.startsWith("worktree "))
+                entryPath = line.slice("worktree ".length);
+            else if (line.startsWith("HEAD "))
+                head = line.slice("HEAD ".length);
+            else if (line.startsWith("branch ")) {
+                const ref = line.slice("branch ".length);
+                branch = ref.startsWith("refs/heads/") ? ref.slice("refs/heads/".length) : ref;
+            }
+        }
+        if (entryPath)
+            entries.push({ path: entryPath, branch, head });
+    }
+    return entries;
+}
+/** True when the worktree has any uncommitted changes (porcelain non-empty). */
+export function isDirty(worktreePath) {
+    const out = trySh("git status --porcelain", worktreePath);
+    return out !== null && out.length > 0;
+}
+/**
+ * Returns the current branch of the git checkout at `cwd`, or null when in a
+ * detached HEAD or outside a git repo.
+ */
+export function getCurrentBranch(cwd) {
+    const out = trySh("git symbolic-ref --short -q HEAD", cwd);
+    return out && out.length > 0 ? out : null;
+}
+/**
+ * Returns commits ahead/behind `against` from the worktree's HEAD. `against`
+ * is resolved in this priority: explicit param > `@{upstream}` > null.
+ * Returns null when no comparison ref is available.
+ */
+export function getAheadBehind(worktreePath, against) {
+    let ref = against;
+    if (!ref) {
+        const upstream = trySh("git rev-parse --abbrev-ref --symbolic-full-name @{upstream}", worktreePath);
+        if (upstream)
+            ref = upstream;
+    }
+    if (!ref)
+        return null;
+    const counts = trySh(`git rev-list --left-right --count HEAD...${shellQuote(ref)}`, worktreePath);
+    if (!counts)
+        return null;
+    const parts = counts.split(/\s+/);
+    if (parts.length < 2)
+        return null;
+    const ahead = Number(parts[0]);
+    const behind = Number(parts[1]);
+    if (Number.isNaN(ahead) || Number.isNaN(behind))
+        return null;
+    return { ahead, behind, against: ref };
+}

package/dist/lib/github.d.ts

@@ -0,0 +1,7 @@
+export declare function ghCliAvailable(): Promise<boolean>;
+export declare function getGhUserLogin(): Promise<string | null>;
+/**
+ * Returns "owner/name" for the GitHub repo of the current working directory,
+ * or null if not a GitHub repo / `gh` can't reach the API.
+ */
+export declare function getRepoFullName(): Promise<string | null>;

package/dist/lib/github.js

@@ -0,0 +1,15 @@
+import { tryExec } from "./exec.js";
+export async function ghCliAvailable() {
+    const out = await tryExec("which gh");
+    return !!out;
+}
+export async function getGhUserLogin() {
+    return tryExec("gh api user --jq .login 2>/dev/null");
+}
+/**
+ * Returns "owner/name" for the GitHub repo of the current working directory,
+ * or null if not a GitHub repo / `gh` can't reach the API.
+ */
+export async function getRepoFullName() {
+    return tryExec("gh repo view --json nameWithOwner --jq .nameWithOwner 2>/dev/null");
+}

package/dist/lib/markers.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Emits the shell-wrapper markers. When `MINTREE_MARKER_FILE` is set in env
+ * (the dashboard wrapper does this so it can run the TUI without capturing
+ * stdout), the markers are appended there. Otherwise they go to stdout —
+ * the `worktree create` wrapper greps stdout for them after capturing it.
+ *
+ * Each marker is written on its own line, terminated with a newline.
+ */
+export declare function emitMarkers(markers: string[]): void;
+export type CreateMarkers = {
+    worktreePath: string;
+    work: boolean;
+    promptFile?: string;
+    permissionMode?: string;
+};
+/**
+ * Builds the marker block emitted after a successful `worktree create`.
+ * Same layout the shell wrapper expects: MINTREE_CD always present, the
+ * three work-related markers only when --work was on.
+ */
+export declare function buildCreateMarkers(input: CreateMarkers): string[];

package/dist/lib/markers.js

@@ -0,0 +1,43 @@
+import * as fs from "fs";
+/**
+ * Emits the shell-wrapper markers. When `MINTREE_MARKER_FILE` is set in env
+ * (the dashboard wrapper does this so it can run the TUI without capturing
+ * stdout), the markers are appended there. Otherwise they go to stdout —
+ * the `worktree create` wrapper greps stdout for them after capturing it.
+ *
+ * Each marker is written on its own line, terminated with a newline.
+ */
+export function emitMarkers(markers) {
+    if (markers.length === 0)
+        return;
+    const text = markers.join("\n") + "\n";
+    const file = process.env["MINTREE_MARKER_FILE"];
+    if (file) {
+        try {
+            fs.appendFileSync(file, text);
+            return;
+        }
+        catch {
+            // If the file is unwritable for any reason, fall through to stdout
+            // rather than silently swallow the markers.
+        }
+    }
+    process.stdout.write(text);
+}
+/**
+ * Builds the marker block emitted after a successful `worktree create`.
+ * Same layout the shell wrapper expects: MINTREE_CD always present, the
+ * three work-related markers only when --work was on.
+ */
+export function buildCreateMarkers(input) {
+    const lines = [`MINTREE_CD:${input.worktreePath}`];
+    if (input.work)
+        lines.push("MINTREE_WORK:1");
+    if (input.work && input.promptFile) {
+        lines.push(`MINTREE_WORK_PROMPT_FILE:${input.promptFile}`);
+    }
+    if (input.work && input.permissionMode) {
+        lines.push(`MINTREE_PERMISSION_MODE:${input.permissionMode}`);
+    }
+    return lines;
+}

package/dist/lib/metadata.d.ts

@@ -0,0 +1,18 @@
+export type IssueMeta = {
+    base_branch?: string;
+    session_id?: string;
+};
+export type Metadata = {
+    version: 1;
+    issues: Record<string, IssueMeta>;
+};
+export declare function readMetadata(repoRoot: string): Metadata;
+export declare function writeMetadata(repoRoot: string, data: Metadata): void;
+/**
+ * Merges `partial` into the metadata entry for `issueId`, creating the entry
+ * if missing. Persists the result. Existing fields not present in `partial`
+ * are preserved.
+ */
+export declare function upsertIssue(repoRoot: string, issueId: string, partial: IssueMeta): Metadata;
+export declare function getSessionId(repoRoot: string, issueId: string): string | undefined;
+export declare function setSessionId(repoRoot: string, issueId: string, sessionId: string): void;

package/dist/lib/metadata.js

@@ -0,0 +1,44 @@
+import * as fs from "fs";
+import { getMetadataPath } from "./git.js";
+const EMPTY = { version: 1, issues: {} };
+export function readMetadata(repoRoot) {
+    const filePath = getMetadataPath(repoRoot);
+    if (!fs.existsSync(filePath))
+        return { ...EMPTY, issues: {} };
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        if (typeof parsed !== "object" || parsed === null)
+            return { ...EMPTY, issues: {} };
+        return {
+            version: 1,
+            issues: typeof parsed.issues === "object" && parsed.issues !== null
+                ? parsed.issues
+                : {},
+        };
+    }
+    catch {
+        return { ...EMPTY, issues: {} };
+    }
+}
+export function writeMetadata(repoRoot, data) {
+    const filePath = getMetadataPath(repoRoot);
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+}
+/**
+ * Merges `partial` into the metadata entry for `issueId`, creating the entry
+ * if missing. Persists the result. Existing fields not present in `partial`
+ * are preserved.
+ */
+export function upsertIssue(repoRoot, issueId, partial) {
+    const data = readMetadata(repoRoot);
+    const previous = data.issues[issueId] ?? {};
+    data.issues[issueId] = { ...previous, ...partial };
+    writeMetadata(repoRoot, data);
+    return data;
+}
+export function getSessionId(repoRoot, issueId) {
+    return readMetadata(repoRoot).issues[issueId]?.session_id;
+}
+export function setSessionId(repoRoot, issueId, sessionId) {
+    upsertIssue(repoRoot, issueId, { session_id: sessionId });
+}

package/dist/lib/session-signal.d.ts

@@ -0,0 +1,63 @@
+export type SessionState = "waiting" | "idle" | "active" | "exited";
+/**
+ * Synchronously slurps stdin to a string. Used by hook handlers to read the
+ * JSON payload Claude pipes in. Returns "" on any failure so the caller can
+ * exit silently — a hook crash would interrupt Claude.
+ */
+export declare function readStdin(): string;
+/**
+ * Extracts the main repo root and worktree directory name from an absolute
+ * cwd that lives under `<repo>/.mintree/worktrees/<dir>/...`. Returns null
+ * when the cwd is outside that pattern (Claude was launched somewhere else
+ * or the worktree was already removed).
+ */
+export declare function extractRepoAndDir(cwd: string): {
+    repoRoot: string;
+    worktreeDir: string;
+} | null;
+/**
+ * Pulls the issue number out of a `<issue>-<desc>` worktree directory name.
+ * Returns null when the directory name doesn't follow the convention (e.g.
+ * a manually-created worktree dropped under .mintree/worktrees/).
+ */
+export declare function issueIdFromWorktreeDir(worktreeDir: string): string | null;
+export type StatePayload = {
+    state: SessionState;
+    session_id: string;
+    issue_id: string;
+    worktree_dir: string;
+    message: string | null;
+    at: string;
+};
+/**
+ * Writes the state file for an issue under `<repo>/.mintree/session-states/`.
+ * Creates the directory if missing. Atomic-ish: same write pattern as
+ * metadata.json — fine for state probing from the dashboard, fast to refresh.
+ */
+export declare function writeStateFile(repoRoot: string, issueId: string, payload: StatePayload): string;
+/**
+ * The only entry point the hook sub-commands call. Reads the JSON payload
+ * Claude piped in, locates the worktree+issue from the payload's `cwd`, and
+ * writes the state file. Exits 0 unconditionally — the worst case is a
+ * silent no-op, never an error that would interrupt Claude.
+ */
+export declare function signalState(state: SessionState): void;
+/**
+ * The hook tree mintree wants to see in `~/.claude/settings.json`. Each
+ * inner command runs async with a 10s timeout — slow hooks would otherwise
+ * block Claude's UI thread. The Notification entry is gated on the
+ * `permission_prompt` matcher so the dashboard's "waiting" state only
+ * lights up when Claude is actually waiting for a permission decision,
+ * not for every notification.
+ */
+export declare function getHooksJson(): Record<string, unknown>;
+/**
+ * Installs (or replaces) the four mintree hooks in `~/.claude/settings.json`.
+ * Existing non-mintree hooks for the same events are preserved; previous
+ * mintree entries are filtered out and re-added so re-running this is safe.
+ * Returns the path of the file we wrote.
+ */
+export declare function installHooks(): {
+    settingsPath: string;
+    created: boolean;
+};