@north-light/crouter 0.3.275 → 0.3.277

package/dist/core/__tests__/integration/command-plugins.test.js

@@ -821,9 +821,9 @@ describe('typed validation issues', () => {
 describe('plugin help addenda', () => {
     const gate = (paths) => ({
         reservedCoreNames: RESERVED,
-        coreCommandPaths: new Set(paths),
+        coreCommandPaths: () => Promise.resolve(new Set(paths)),
     });
-    test('a helpAddenda entry survives validation and is collected attributed to its plugin', () => {
+    test('a helpAddenda entry survives validation and is collected attributed to its plugin', async () => {
         const m = commandsJson();
         m['helpAddenda'] = { cron: 'Gate on the device: exit 75 parks the occurrence.' };
         installPlugin(userRoot, 'northlight-fixture', { manifest: m });
@@ -833,12 +833,12 @@ describe('plugin help addenda', () => {
         assert.equal(v.issues.length, 0, JSON.stringify(v.issues));
         assert.deepEqual(v.manifest?.helpAddenda, { cron: 'Gate on the device: exit 75 parks the occurrence.' });
         // The help-render lookup: attributed, and empty for an unaddended path.
-        assert.deepEqual(collectHelpAddenda('cron', gate(['cron', 'node']), emptyStart), [
+        assert.deepEqual(await collectHelpAddenda('cron', gate(['cron', 'node']), emptyStart), [
             { plugin: 'northlight-fixture', text: 'Gate on the device: exit 75 parks the occurrence.' },
         ]);
-        assert.deepEqual(collectHelpAddenda('node', gate(['cron', 'node']), emptyStart), []);
+        assert.deepEqual(await collectHelpAddenda('node', gate(['cron', 'node']), emptyStart), []);
     });
-    test('a key naming no core command path fails the strict gate and renders nothing, even beside a valid key', () => {
+    test('a key naming no core command path fails the strict gate and renders nothing, even beside a valid key', async () => {
         const m = commandsJson();
         m['helpAddenda'] = {
             cron: 'a valid target beside the typo',
@@ -860,7 +860,7 @@ describe('plugin help addenda', () => {
         // The render lookup reproduces the GATE verdict, not the compose one: the
         // rejected map contributes nothing — including its valid key — so render
         // can never show what the install report said was rejected.
-        assert.deepEqual(collectHelpAddenda('cron', gate(['cron', 'cron add']), emptyStart), []);
+        assert.deepEqual(await collectHelpAddenda('cron', gate(['cron', 'cron add']), emptyStart), []);
     });
     test('an installed addendum renders through the real help path as an attributed block', async () => {
         const m = commandsJson();

package/dist/core/__tests__/integration/worktree-land.test.js

@@ -440,8 +440,13 @@ test('close concludes a clean child after parent-first closure removes its check
         run(['commit', '-m', 'init'], repo);
         const parent = createManagedWorktree(repo, 'wt-parent-first-parent');
         createNode(node('wt-parent-first-parent', { cwd: parent.path, managed_worktree: parent }));
-        const child = createManagedWorktree(parent.path, 'wt-parent-first-child', parent.branch);
-        createNode(node('wt-parent-first-child', { cwd: child.path, managed_worktree: child }));
+        // Creation now refuses a managed worktree as its base (`managed_worktree_base`),
+        // so the child is cut from the real repository against the parent's BRANCH, and
+        // its record carries the parent checkout as `repo_root` — the exact legacy shape
+        // this case is about, still on disk for every record created before that guard.
+        const child = createManagedWorktree(repo, 'wt-parent-first-child', parent.branch);
+        const childRecord = { ...child, repo_root: parent.path };
+        createNode(node('wt-parent-first-child', { cwd: child.path, managed_worktree: childRecord }));
         assert.equal(gitSync(['rev-parse', 'HEAD'], child.path).stdout.trim(), child.base_sha, 'the child must be a clean zero-commit checkout at its recorded base');
         closeManagedWorktree('wt-parent-first-parent');
         run(['worktree', 'remove', parent.path], repo);

package/dist/core/__tests__/seam/broker-provider-retry.test.js

@@ -9,7 +9,7 @@ import { test, before, after, afterEach } from 'node:test';
 import assert from 'node:assert/strict';
 import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { createHeadlessHarness } from '../helpers/harness.js';
+import { createHeadlessHarness, readLines } from '../helpers/harness.js';
 import { createAttachKit } from '../helpers/broker-clients.js';
 import { defaultModelLaddersConfig } from '../../../types.js';
 import { admitProviderRetryEpisode, readFault, readProviderRetryEpisode } from '../../runtime/fault.js';
@@ -63,21 +63,8 @@ function overflowOutcome(id) {
 // re-drive is a fresh session.prompt → emitTurn, which fires one 'agent_start';
 // counting them is the observable proof of how many times the turn was re-driven.
 function agentStartCount(id) {
-    try {
-        return readFileSync(join(h.home, 'nodes', id, 'fake-pi.events.jsonl'), 'utf8')
-            .split('\n')
-            .filter((l) => {
-            try {
-                return JSON.parse(l).event === 'agent_start';
-            }
-            catch {
-                return false;
-            }
-        }).length;
-    }
-    catch {
-        return 0;
-    }
+    return readLines(join(h.home, 'nodes', id, 'fake-pi.events.jsonl'))
+        .filter((line) => JSON.parse(line).event === 'agent_start').length;
 }
 async function crashAndRespawn(id, boots) {
     const pid = h.node(id)?.pi_pid;

package/dist/core/canvas/types.d.ts

@@ -106,6 +106,24 @@ export interface ManagedWorktree {
         blocked: string;
     };
     sweep?: ManagedWorktreeSweep;
+    /** Recorded ONLY by an explicit branch-moved `close` when the checkout's
+     *  actual branch has drifted from `branch` (its recorded `crtr/*` ref is
+     *  gone — ordinary PR work moved it there) but that branch's content was
+     *  proven, immediately before this was written, already contained in the
+     *  recorded base or its upstream. Authorizes ONLY the daemon sweep's later
+     *  checkout removal for this EXACT path + git common dir + observed branch
+     *  + observed SHA — the sweep re-verifies all four before acting and NEVER
+     *  deletes `observed_branch`, since it is not a `crtr/*` branch crouter
+     *  created. A mismatch on re-verification invalidates the authorization; a
+     *  fresh explicit close must re-establish it. Absent for every ordinary
+     *  managed worktree, and for `abandon`'s branch-moved path (which disposes
+     *  immediately instead of deferring, so it needs no persisted grant). */
+    disposal?: {
+        observed_branch: string;
+        observed_sha: string;
+        common_dir: string;
+        authorized: string;
+    };
 }
 /** Immutable companion provenance. The origin session/leaf/model coordinates
  *  remain canonical in the review row rather than being duplicated into node

package/dist/core/command-manifests/manifest.d.ts

@@ -29,8 +29,10 @@ export declare function validateCommandManifest(raw: unknown, options: {
      *  (install, bundle parse, doctor/inspect reports) so a helpAddenda key
      *  naming no core command fails there — and by the help-render lookup
      *  (`collectHelpAddenda`), which reproduces the gate's verdict so render
-     *  and ingress report can never disagree. Omitted only on the tolerant
-     *  compose path, where mounting ignores addenda entirely. */
+     *  and ingress report can never disagree. Omitted on the tolerant compose
+     *  path, where mounting ignores addenda entirely, and on that lookup's
+     *  claimant pass, which only needs to know whether any addendum targets the
+     *  rendered path at all. */
     coreCommandPaths?: ReadonlySet<string>;
     /** A repository fragment attaches roots below an existing extensible branch. */
     extensionFragment?: boolean;

package/dist/core/command-plugins/bundle.d.ts

@@ -32,6 +32,13 @@ export interface ValidatedBundle {
         path: string;
         bytes: Uint8Array;
     }>;
+    hooks?: {
+        manifest: Uint8Array;
+        files: ReadonlyArray<{
+            path: string;
+            bytes: Uint8Array;
+        }>;
+    };
 }
 export interface PluginBundleValidation {
     bundle?: ValidatedBundle;

package/dist/core/command-plugins/bundle.js

@@ -38,13 +38,13 @@ function validateMemberName(path, type) {
 }
 function validateMemberShape(path, type) {
     if (type === 'file') {
-        if (path === 'bundle.json' || path === 'commands.json' || (path.startsWith('memory/') && path.endsWith('.md')))
+        if (path === 'bundle.json' || path === 'commands.json' || path === 'hooks.json' || (path.startsWith('memory/') && path.endsWith('.md')) || path.startsWith('hooks/'))
             return undefined;
-        return bundleInvalid('bundle contains an unsupported file member', path, 'bundle.json, commands.json, or memory/**/*.md', 'Remove unsupported members from the archive.', path);
+        return bundleInvalid('bundle contains an unsupported file member', path, 'bundle.json, commands.json, hooks.json, memory/**/*.md, or hooks/**', 'Remove unsupported members from the archive.', path);
     }
-    if (path === 'memory' || path.startsWith('memory/'))
+    if (path === 'memory' || path.startsWith('memory/') || path === 'hooks' || path.startsWith('hooks/'))
         return undefined;
-    return bundleInvalid('bundle contains an unsupported directory member', path, 'memory or a directory below memory/', 'Remove unsupported directory members from the archive.', path);
+    return bundleInvalid('bundle contains an unsupported directory member', path, 'memory or hooks, or a directory below either subtree', 'Remove unsupported directory members from the archive.', path);
 }
 /** A member path as it will exist on disk: directories carry no trailing slash. */
 function materializedPath(member) {
@@ -221,6 +221,14 @@ export async function validatePluginBundle(archive, options) {
             issues: [bundleInvalid('bundle must contain exactly one bundle.json and one commands.json regular file', `bundle.json=${bundle !== undefined}, commands.json=${commands !== undefined}`, 'one regular bundle.json and one regular commands.json member', 'Add the required metadata members to the archive.')],
         };
     }
+    const hookManifest = parsed.members.find((member) => member.path === 'hooks.json' && member.type === 'file');
+    const hookFiles = parsed.members.filter((member) => member.type === 'file' && member.path.startsWith('hooks/'));
+    const carriesHooks = hookManifest !== undefined || parsed.members.some((member) => member.path === 'hooks' || member.path.startsWith('hooks/'));
+    if (carriesHooks && (hookManifest === undefined || !hookFiles.some((member) => member.path === 'hooks/dispatch'))) {
+        return {
+            issues: [bundleInvalid('bundle hook payload must contain both hooks.json and hooks/dispatch regular files', `hooks.json=${hookManifest !== undefined}, hooks/dispatch=${hookFiles.some((member) => member.path === 'hooks/dispatch')}`, 'both hooks.json and hooks/dispatch regular files', 'Add both required hook members or remove the hook payload.')],
+        };
+    }
     const metadata = parseBundleMetadata(bundle.bytes);
     if (metadata.issue !== undefined)
         return { issues: [metadata.issue] };
@@ -241,6 +249,12 @@ export async function validatePluginBundle(archive, options) {
             memory: parsed.members
                 .filter((member) => member.type === 'file' && member.path.startsWith('memory/'))
                 .map((member) => ({ path: member.path, bytes: member.bytes })),
+            ...(hookManifest !== undefined ? {
+                hooks: {
+                    manifest: hookManifest.bytes,
+                    files: hookFiles.map((member) => ({ path: member.path, bytes: member.bytes })),
+                },
+            } : {}),
         },
         issues: [],
     };

package/dist/core/command-plugins/help-addenda.d.ts

@@ -5,8 +5,17 @@ export interface HelpAddendum {
 /** Collect every enabled plugin's addendum targeting `commandPath` (the
  *  space-joined walked path, e.g. "cron add"), in plugin-name order. `gate`
  *  carries the strict-validation inputs the install/bundle gates use; the
- *  help renderer already holds both (build-root exports them). */
+ *  help renderer already holds both (build-root exports them).
+ *
+ *  `coreCommandPaths` arrives as a thunk because producing that set walks EVERY
+ *  core subtree — the whole command tree loaded on a path that renders one
+ *  leaf's help. So the claimant pass below runs the SAME validator without it:
+ *  the core path set can only reject an addendum, never introduce one, so a
+ *  commandPath no manifest claims tolerantly claims none under the gate either,
+ *  and the expensive input is never forced. Claimants then re-validate strictly,
+ *  reproducing the gate's exact verdict — a manifest the gate rejects renders
+ *  nothing, including its valid keys. */
 export declare function collectHelpAddenda(commandPath: string, gate: {
     reservedCoreNames: ReadonlySet<string>;
-    coreCommandPaths: ReadonlySet<string>;
-}, startDir?: string, profileId?: string | null): HelpAddendum[];
+    coreCommandPaths: () => Promise<ReadonlySet<string>>;
+}, startDir?: string, profileId?: string | null): Promise<HelpAddendum[]>;

package/dist/core/command-plugins/help-addenda.js

@@ -15,13 +15,26 @@ import { effectiveCommandPlugins, validatePluginCommands } from './discovery.js'
 /** Collect every enabled plugin's addendum targeting `commandPath` (the
  *  space-joined walked path, e.g. "cron add"), in plugin-name order. `gate`
  *  carries the strict-validation inputs the install/bundle gates use; the
- *  help renderer already holds both (build-root exports them). */
-export function collectHelpAddenda(commandPath, gate, startDir, profileId) {
+ *  help renderer already holds both (build-root exports them).
+ *
+ *  `coreCommandPaths` arrives as a thunk because producing that set walks EVERY
+ *  core subtree — the whole command tree loaded on a path that renders one
+ *  leaf's help. So the claimant pass below runs the SAME validator without it:
+ *  the core path set can only reject an addendum, never introduce one, so a
+ *  commandPath no manifest claims tolerantly claims none under the gate either,
+ *  and the expensive input is never forced. Claimants then re-validate strictly,
+ *  reproducing the gate's exact verdict — a manifest the gate rejects renders
+ *  nothing, including its valid keys. */
+export async function collectHelpAddenda(commandPath, gate, startDir, profileId) {
     if (commandPath.length === 0)
         return [];
+    const claimants = effectiveCommandPlugins(startDir, profileId).filter((plugin) => validatePluginCommands(plugin, gate.reservedCoreNames).manifest?.helpAddenda?.[commandPath] !== undefined);
+    if (claimants.length === 0)
+        return [];
+    const coreCommandPaths = await gate.coreCommandPaths();
     const out = [];
-    for (const plugin of effectiveCommandPlugins(startDir, profileId)) {
-        const text = validatePluginCommands(plugin, gate.reservedCoreNames, gate.coreCommandPaths).manifest?.helpAddenda?.[commandPath];
+    for (const plugin of claimants) {
+        const text = validatePluginCommands(plugin, gate.reservedCoreNames, coreCommandPaths).manifest?.helpAddenda?.[commandPath];
         if (text !== undefined)
             out.push({ plugin: plugin.name, text });
     }

package/dist/core/command.js

@@ -209,9 +209,9 @@ async function renderNodeWithAddenda(node, path, focusedFlag) {
         import('./command-plugins/help-addenda.js'),
         import('../build-root.js'),
     ]);
-    const addenda = collectHelpAddenda(path.join(' '), {
+    const addenda = await collectHelpAddenda(path.join(' '), {
         reservedCoreNames: new Set(SUBTREE_NAMES),
-        coreCommandPaths: await coreCommandPaths(),
+        coreCommandPaths,
     });
     return body + addenda.map((a) => `\n\n<plugin-help plugin="${a.plugin}">\n${a.text}\n</plugin-help>`).join('');
 }

package/dist/core/git.d.ts

@@ -11,7 +11,11 @@ export interface GitSyncOptions {
     timeoutMs?: number;
 }
 export declare function gitSync(args: string[], cwd?: string, input?: string, options?: GitSyncOptions): GitResult;
-export declare function gitAsync(args: string[], cwd?: string, input?: string): Promise<GitResult>;
+export interface GitAsyncOptions {
+    timeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+}
+export declare function gitAsync(args: string[], cwd?: string, input?: string, options?: GitAsyncOptions): Promise<GitResult>;
 export declare function clone(url: string, dest: string, opts?: {
     ref?: string;
     depth?: number;

package/dist/core/git.js

@@ -10,22 +10,36 @@ export function gitSync(args, cwd, input, options = {}) {
     const timedOut = res.error?.code === 'ETIMEDOUT';
     return { status, stdout, stderr, ...(completed ? {} : { executionFailed: true }), ...(processError === undefined ? {} : { processError }), ...(timedOut ? { timedOut: true } : {}) };
 }
-export async function gitAsync(args, cwd, input) {
+export async function gitAsync(args, cwd, input, options = {}) {
     return new Promise((resolve) => {
-        const child = spawn('git', args, { cwd });
+        const child = spawn('git', args, { cwd, ...(options.env === undefined ? {} : { env: options.env }) });
         if (input === undefined)
             child.stdin.end();
         else
             child.stdin.end(input);
         let stdout = '';
         let stderr = '';
+        let timedOut = false;
+        let settled = false;
+        const timer = options.timeoutMs === undefined ? undefined : setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGTERM');
+        }, options.timeoutMs);
+        const settle = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer !== undefined)
+                clearTimeout(timer);
+            resolve(result);
+        };
         child.stdout.on('data', (d) => (stdout += d.toString()));
         child.stderr.on('data', (d) => (stderr += d.toString()));
         child.on('close', (status) => {
             const code = typeof status === 'number' ? status : 1;
-            resolve({ status: code, stdout, stderr });
+            settle({ status: code, stdout, stderr, ...(timedOut ? { timedOut: true, executionFailed: true } : {}) });
         });
-        child.on('error', (e) => resolve({ status: 1, stdout: '', stderr: String(e) }));
+        child.on('error', (e) => settle({ status: 1, stdout: '', stderr: String(e), executionFailed: true, processError: String(e) }));
     });
 }
 export function clone(url, dest, opts = {}) {

package/dist/core/runtime/spawn.d.ts

@@ -62,6 +62,8 @@ export interface SpawnChildOpts {
     worktree?: boolean;
     /** Local branch the managed worktree is cut from and later landed onto. */
     worktreeBase?: string;
+    /** Invocation-selected repository from which to cut a managed worktree. */
+    worktreeCwd?: string;
     /** Preallocated node id, used when a managed worktree must be named before birth. */
     nodeId?: string;
     /** Hidden ambient "current situation" text — NOT the visible prompt/body.

package/dist/core/runtime/spawn.js

@@ -251,7 +251,7 @@ export async function spawnChildPrepared(opts, beforeBrokerLaunch) {
     let spawnCwd = opts.cwd;
     try {
         if (wantsWorktree) {
-            managedWorktree = createManagedWorktree(opts.cwd, nodeId, opts.worktreeBase);
+            managedWorktree = createManagedWorktree(opts.worktreeCwd ?? opts.cwd, nodeId, opts.worktreeBase);
             spawnCwd = managedWorktree.path;
         }
         // Spine: a managed child reports up to its spawner (has a manager); an

package/dist/core/worktree-sweep.js

@@ -336,7 +336,7 @@ export async function reconcileManagedWorktree(nodeId, guard, now = Date.now())
         return { status: 'skipped', reason: 'already_reconciled' };
     const cwd = existsSync(wt.path) ? wt.path : wt.repo_root;
     if (!existsSync(cwd)) {
-        return finish(nodeId, wt, { status: 'refused', reason: 'repo_unavailable', detail: `neither the managed checkout (${wt.path}) nor its repository root (${wt.repo_root}) is present` }, { base: null, branch: null, checkout: null }, now, guard);
+        return persistComplete(nodeId, wt, guard);
     }
     const commonDir = await commonGitDirAsync(cwd);
     if (commonDir === null) {
@@ -423,9 +423,15 @@ async function reconcilePresentCheckout(nodeId, wt, guard) {
     const list = await gitAsync(['worktree', 'list', '--porcelain'], wt.path);
     if (list.status !== 0)
         return { status: 'failed', reason: 'worktree_list_failed', detail: detailOf(list) };
-    const registeredPath = registeredCheckoutPath(list.stdout, wt.path, wt.branch);
+    // An explicit `close` already proved a branch-moved checkout's identity and
+    // authorized its later disposal for THIS exact branch — never adopted here.
+    // Only the recorded authorization changes which branch this pass expects;
+    // everything else below is re-verified exactly as for an ordinary record.
+    const disposal = wt.disposal;
+    const expectedBranch = disposal?.observed_branch ?? wt.branch;
+    const registeredPath = registeredCheckoutPath(list.stdout, wt.path, expectedBranch);
     if (registeredPath === null) {
-        return { status: 'refused', reason: 'not_registered', detail: `${wt.path} is not registered to refs/heads/${wt.branch}; crtr will not act on a path it cannot prove it owns` };
+        return { status: 'refused', reason: 'not_registered', detail: `${wt.path} is not registered to refs/heads/${expectedBranch}; crtr will not act on a path it cannot prove it owns` };
     }
     const main = mainWorktreePath(list.stdout);
     if (main === null || samePath(main, registeredPath) || !existsSync(main)) {
@@ -439,8 +445,8 @@ async function reconcilePresentCheckout(nodeId, wt, guard) {
     const head = await gitAsync(['rev-parse', '--abbrev-ref', 'HEAD'], wt.path);
     if (head.status !== 0)
         return { status: 'failed', reason: 'branch_check_failed', detail: detailOf(head) };
-    if (head.stdout.trim() !== wt.branch) {
-        return { status: 'refused', reason: 'wrong_branch', detail: `expected ${wt.branch}, found ${head.stdout.trim() === 'HEAD' ? 'detached HEAD' : head.stdout.trim()}` };
+    if (head.stdout.trim() !== expectedBranch) {
+        return { status: 'refused', reason: 'wrong_branch', detail: `expected ${expectedBranch}, found ${head.stdout.trim() === 'HEAD' ? 'detached HEAD' : head.stdout.trim()}` };
     }
     // Uncommitted work blocks removal unconditionally. No containment proof
     // overrides this: those reason about committed content, and nothing here has
@@ -454,6 +460,23 @@ async function reconcilePresentCheckout(nodeId, wt, guard) {
     let branchSha = await revParseRef(wt.path, 'HEAD');
     if (branchSha === null)
         return { status: 'failed', reason: 'head_unreadable', detail: `could not read HEAD in ${wt.path}` };
+    if (disposal !== undefined) {
+        // Re-verify the exact identity `close` authorized before mutating anything.
+        // A mismatch invalidates the authorization instead of adopting whatever is
+        // observed now — only the explicit command that wrote it may refresh it.
+        const commonDir = await commonGitDirAsync(wt.path);
+        if (commonDir !== disposal.common_dir || branchSha !== disposal.observed_sha) {
+            return { status: 'refused', reason: 'disposal_authorization_stale', detail: `${wt.path} changed since \`close\` authorized its disposal; rerun \`crtr node worktree close\` from that node to re-authorize, or ask the user with \`crtr human send\`` };
+        }
+        if (!guard.stillEligible())
+            return NODE_REVIVED;
+        const removed = await gitAsync(['worktree', 'remove', registeredPath], main);
+        if (removed.status !== 0)
+            return { status: 'refused', reason: 'worktree_remove_failed', detail: detailOf(removed) };
+        // `disposal.observed_branch` is not a `crtr/*` branch crouter created — it
+        // is preserved, never deleted, unlike the ordinary path below.
+        return persistComplete(nodeId, wt, guard);
+    }
     let proof = await proveContained(wt.path, wt, branchSha);
     let stash;
     if (proof === null && wt.land_intent !== undefined) {

package/dist/core/worktree.d.ts

@@ -115,17 +115,6 @@ export interface AutoDroppedWorktree {
  * explicit close: removal and branch deletion are deferred until that owner
  * has exited. */
 export declare function autoDropCleanManagedWorktreeLocked(nodeId: string, wt: ManagedWorktree, proof: CleanEmptyProof): AutoDroppedWorktree | null;
-/** `push final`'s escape hatch: a managed worktree that has
- *  nothing to land is auto-dropped instead of blocking on an explicit
- *  `node worktree close` — one the caller may have been told NOT to run
- *  because a manager already landed the same change another way, or
- *  that never had anything to close in the first place (a read-only
- *  review node). Returns null and changes nothing when the worktree is not
- *  PROVABLY empty-and-clean by `proveCleanEmptyManagedWorktree`, OR when a
- *  concurrent mutation invalidates that proof before the record is closed
- *  (see `autoDropCleanManagedWorktreeLocked`); the caller's existing
- *  `open_managed_worktree` guard then still applies unchanged — real
- *  commits, real uncommitted changes, and a lost race all require the
- *  explicit path. */
+export declare function branchIsPushedAtCurrentTip(wt: ManagedWorktree): Promise<boolean>;
 export declare function autoDropCleanManagedWorktree(nodeId: string): AutoDroppedWorktree | null;
 export {};