@adhdev/daemon-core 0.9.82-rc.27 → 0.9.82-rc.271

package/dist/commands/cli-manager.d.ts

@@ -6,7 +6,7 @@
  */
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { ProviderLoader } from '../providers/provider-loader.js';
-import { type ProviderModule, type ProviderResumeCapability } from '../providers/contracts.js';
+import { type MeshCoordinatorDelegatedWorkerIsolation, type ProviderModule, type ProviderResumeCapability } from '../providers/contracts.js';
 import type { CliAdapter } from '../cli-adapter-types.js';
 import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 import type { SessionRegistry } from '../sessions/registry.js';
@@ -68,6 +68,7 @@ export interface CoordinatorDelegatedCliLaunchOptionsInput {
     workspace: string;
     cliArgs?: string[];
     env?: Record<string, string>;
+    isolation?: MeshCoordinatorDelegatedWorkerIsolation;
 }
 export interface CoordinatorDelegatedCliLaunchOptions {
     cliArgs: string[];

package/dist/commands/handler.d.ts

@@ -104,7 +104,117 @@ export declare class DaemonCommandHandler implements CommandHelpers {
     setAgentStreamManager(manager: DaemonAgentStreamManager): void;
     handle(cmd: string, args: any): Promise<CommandResult>;
     private dispatch;
+    /**
+     * Reload providers from disk. Does NOT pull from the registry — the user
+     * controls installs explicitly via install_provider_manifest. To upgrade
+     * an installed provider, call install_provider_manifest again with the
+     * desired version (or with no version to pick up the latest from
+     * registry), or use check_provider_updates to see what is out of date.
+     */
     private handleRefreshScripts;
+    /**
+     * Return per-provider availability so the dashboard's provider catalog
+     * can show "Installed" badges. Reuses the existing detection state from
+     * ProviderLoader.getMachineProviderStatus() — no probing is triggered.
+     */
+    private handleListProviderAvailability;
+    /**
+     * Compute the *upstream cache root*. install_provider_manifest writes
+     * official-registry manifests here so the daemon's standard upstream
+     * layer picks them up — no special handling needed at load time, and
+     * the manifests inherit the official-trust badge instead of the
+     * untrusted-external one.
+     *
+     * Path matches ProviderLoader.upstreamDir but we recompute it from
+     * homedir() so this method stays usable in dev where userDir can
+     * point at a sibling git checkout.
+     */
+    private getUpstreamInstallRoot;
+    /**
+     * Download a single provider manifest from the registry and write it to
+     * ~/.adhdev/providers/.upstream/{category}/{type}/provider.json.
+     *
+     * Used by standalone onboarding to seed the upstream cache with the
+     * default provider set on first launch. Verifies SHA-256 checksum
+     * against the registry meta before persisting. Refuses to write
+     * outside the upstream root.
+     *
+     * Args: { type: string, category?: string, version?: string }
+     * If category/version are omitted, looks up the latest from the registry.
+     */
+    private handleInstallProviderManifest;
+    /**
+     * If `manifest.source = { type:'github', repo, ref, subdir? }` is set,
+     * walk each script directory the manifest references and download every
+     * file from the public GitHub raw endpoint. Returns a small summary so
+     * the caller can report what was fetched.
+     *
+     * Best-effort: failures don't reject the install — the manifest itself is
+     * usable for declarative-only providers, and the user still gets a clear
+     * error string back if a needed script is missing.
+     */
+    private fetchProviderSources;
+    /**
+     * Remove a provider manifest from the upstream cache root
+     * (~/.adhdev/providers/.upstream/{category}/{type}/). Refuses to touch
+     * anything outside that root. Used by onboarding to opt out of a
+     * provider the user doesn't want; the dashboard no longer exposes a
+     * per-provider uninstall button (external sources are removed as a
+     * whole via remove_provider_source).
+     */
+    private handleUninstallProviderManifest;
+    /**
+     * Return everything currently installed in the upstream cache with its
+     * version. This is the "what does this daemon have" answer used both by
+     * the UI and by the update checker.
+     */
+    private handleListInstalledProviders;
+    /**
+     * For each installed provider, ask the registry for its current latest
+     * version and report whether an update is available. The user can then
+     * call install_provider_manifest to upgrade (it overwrites the file).
+     *
+     * Returns { providers: [{ type, category, installedVersion, latestVersion,
+     *   updateAvailable, error? }] }
+     */
+    private handleCheckProviderUpdates;
+    /**
+     * Register a new external provider source. The daemon clones the repo
+     * to ~/.adhdev/external/<name>/, walks it once to detect provided
+     * types, and surfaces any conflicts with already-installed types so
+     * the dashboard can ask the user how to resolve them.
+     *
+     * Args: { url: string, ref?: string, name?: string }
+     *   - url: https://, git@, or any git-cloneable URL
+     *   - ref: branch/tag/commit (default "main")
+     *   - name: short identifier (default derived from URL)
+     *
+     * Returns: { source, providers, conflicts }
+     *   - conflicts: list of types this new source provides that another
+     *     source already exposes. UI uses this to prompt for active-source
+     *     selection before the load takes effect.
+     */
+    private handleAddProviderSource;
+    /**
+     * Remove a registered external source. Deletes the clone directory and
+     * any active-source entry pointing to it.
+     *
+     * Args: { name: string }
+     */
+    private handleRemoveProviderSource;
+    /**
+     * List registered external sources + each source's currently installed
+     * providers + the active selection for any conflicting types. Used by
+     * the dashboard's "Sources" tab.
+     */
+    private handleListProviderSources;
+    /**
+     * Pick which source's copy of a conflicting provider type is active.
+     * Other sources' copies stay on disk but the loader ignores them.
+     *
+     * Args: { type: string, sourceName: string }
+     */
+    private handleSetActiveProviderSource;
     private proxyDevServerPost;
     private proxyDevServerGet;
     private proxyDevServerScaffold;

package/dist/commands/mesh-coordinator.d.ts

@@ -1,4 +1,4 @@
-import type { ProviderModule, MeshCoordinatorMcpConfigFormat } from '../providers/contracts.js';
+import type { MeshCoordinatorMcpConfigFormat, MeshCoordinatorSystemPromptInjection, ProviderModule } from '../providers/contracts.js';
 export interface MeshCoordinatorMcpServerLaunch {
     command: string;
     args: string[];
@@ -25,6 +25,7 @@ export type MeshCoordinatorSetup = {
     command: string;
     requiresRestart: boolean;
     instructions: string;
+    mcpServer: MeshCoordinatorMcpServerLaunch;
 } | {
     kind: 'unsupported';
     reason: string;
@@ -42,3 +43,86 @@ export interface ResolveMeshCoordinatorSetupOptions {
 }
 export declare function createHermesManualMeshCoordinatorSetup(meshId: string, workspace: string): MeshCoordinatorSetup;
 export declare function resolveMeshCoordinatorSetup(options: ResolveMeshCoordinatorSetupOptions): MeshCoordinatorSetup;
+/**
+ * Apply a provider's declared system-prompt injection rule, mutating `cliArgs`
+ * and `launchEnv` in place and writing any required workspace context file.
+ *
+ * Replaces the previous hard-coded `if (cliType === 'claude-cli') ... else if
+ * (cliType === 'hermes-cli') ...` branches in router.ts. Adding a new CLI is
+ * now provider.v1.json data, not a router edit.
+ *
+ * Failures are non-fatal: log and continue with whatever was applied so the
+ * coordinator session still launches, just without the prompt for that
+ * provider. A missing/unknown rule means "skip injection" — safe by default
+ * (the previous fallback unconditionally pushed --append-system-prompt onto
+ * every non-Claude CLI, which crashed agy on launch).
+ */
+export interface CoordinatorInjectionEffect {
+    /** Absolute path the daemon wrote a wrapper-blocked file to. Only set for
+     *  context_file injection. R48 schedules a strip after launch so workers
+     *  don't see the wrapper on disk; R47's unregister cleanup uses it as a
+     *  fallback if the timer never fires (process crash, etc). */
+    contextFilePath?: string;
+}
+export declare function applyMeshCoordinatorSystemPromptInjection(systemPrompt: string, injection: MeshCoordinatorSystemPromptInjection | undefined, ctx: {
+    cliArgs: string[];
+    launchEnv: Record<string, string>;
+    workspace: string;
+    cliType: string;
+}): CoordinatorInjectionEffect;
+/**
+ * Strip the daemon's wrapper block from a context_file we previously wrote.
+ *
+ * Used in two places:
+ *   1. R48 inject-then-remove: ~5s after spawn, after agy/gemini have read
+ *      the file into their in-memory system-prompt cache. Removing it from
+ *      disk at that point doesn't affect the running coordinator but keeps
+ *      worker sessions (or fresh non-coordinator launches) in the same
+ *      workspace from picking up our wrapper.
+ *   2. R47 unregister fallback: if the timer never fires (process crash,
+ *      kill -9), coordinator-registry.unregisterMeshCoordinator runs the
+ *      same logic when its entry is dropped.
+ *
+ * Idempotent: missing file is fine, missing sentinels are fine, returns
+ * silently. Leaves user-authored content outside the sentinels intact.
+ * Deletes the file outright if our wrapper was the only content.
+ */
+export declare function stripCoordinatorWrapperFile(filePath: string): void;
+export interface PtyExecResult {
+    exitCode: number | null;
+    signal: number | null;
+    output: string;
+    timedOut: boolean;
+}
+export interface MeshCoordinatorRegistrationStep {
+    command: string;
+    args: string[];
+    required: boolean;
+    label: 'remove_existing' | 'register';
+}
+/**
+ * Codex rejects `mcp add` when a server with the same name already exists.
+ * Replace that entry before registering so transport/mesh changes do not leave
+ * a fresh coordinator attached to stale MCP launch arguments.
+ */
+export declare function buildMeshCoordinatorRegistrationPlan(cliType: string, serverName: string, registrationCommand: string): MeshCoordinatorRegistrationStep[];
+/**
+ * Run a one-shot CLI command under a real PTY and collect its output.
+ *
+ * Some provider mcp-registration commands (`agy mcp add`, future bubbletea
+ * TUIs) refuse to run without `/dev/tty`. Daemon-side `execFileSync` runs
+ * pipe-only, so those commands fail with errors like
+ *   `bubbletea: error opening TTY: open /dev/tty: device not configured`
+ * and silently skip the registration, leaving the launched session
+ * without the adhdev-mesh MCP tools — which is exactly what we saw with
+ * agy coordinators.
+ *
+ * Wrapping the registration through node-pty gives the child a real PTY,
+ * so the bubbletea check passes. We close stdin immediately and just
+ * collect stdout until the process exits or the timeout fires.
+ */
+export declare function execUnderPty(command: string, args: string[], options?: {
+    cwd?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+}): Promise<PtyExecResult>;

package/dist/commands/router.d.ts

@@ -14,6 +14,88 @@ import { DaemonCliManager } from './cli-manager.js';
 import type { ProviderLoader } from '../providers/provider-loader.js';
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { SessionRegistry } from '../sessions/registry.js';
+export declare function readCachedInlineMeshActiveSessionDetails(node: any): Array<Record<string, unknown>>;
+type MeshRefineStageStatus = 'passed' | 'failed' | 'skipped';
+type MeshRefineEffectiveDiffSummary = {
+    status: MeshRefineStageStatus;
+    /** True when there is at least one root-tree change between base and branch (incl. gitlink bumps). */
+    hasEffectiveDiff: boolean;
+    baseHead: string;
+    branchHead: string;
+    /** Root-level paths that differ between base and branch (capped). */
+    changedPaths?: string[];
+    /** Submodule paths with uncommitted/divergent commits but NO committed gitlink bump in the root tree. */
+    submoduleHints?: Array<{
+        path: string;
+        reason: string;
+    }>;
+    durationMs: number;
+    error?: string;
+    stdout?: string;
+    stderr?: string;
+};
+/**
+ * No-op guard: detect a "silent no-op" merge before the Refinery merge runs.
+ *
+ * A silent no-op occurs when the refine target branch's ROOT tree is byte-identical
+ * to the merge base (origin/main). This is the trap where a submodule (e.g. oss) has
+ * real commits but the root branch never committed the gitlink (oss-pointer) bump, so
+ * the root diff Refinery would merge is empty. Merging that produces a merge commit with
+ * no content change — reported as "success" while the actual work never reaches main.
+ *
+ * A committed gitlink bump (the legitimate oss-pointer bump) DOES show up in the root
+ * tree diff (as a 160000-mode entry), so this guard does NOT block legitimate refines —
+ * it only fires when the root tree diff vs base is COMPLETELY empty.
+ *
+ * Runs after the patch-equivalence gate; the "already merged via other path" case
+ * (branch has real changes already present in base) is handled upstream and never
+ * reaches here, so an empty root diff at this point is genuinely a no-op.
+ */
+export declare function runMeshRefineEffectiveDiffGate(repoRoot: string, baseHead: string, branchHead: string): Promise<MeshRefineEffectiveDiffSummary>;
+/**
+ * Result of evaluating whether a `git merge-tree --write-tree` submodule
+ * conflict is in fact a trivial gitlink fast-forward that should pass the
+ * patch-equivalence gate.
+ *
+ * `git merge-tree` (and `git merge` with the default recursive strategy)
+ * refuses to 3-way merge gitlinks unless the case is "trivial" — and it
+ * treats *any* gitlink that differs across merge-base/base/branch as
+ * non-trivial, even when the branch-side commit is a strict descendant of the
+ * base-side commit (i.e. a real fast-forward). Refinery only ever wants to
+ * accept the branch's recorded gitlink, so a fast-forwardable bump is safe to
+ * resolve to the branch side without any conflict.
+ */
+type GitlinkTrivialFastForwardEvaluation = {
+    /** True only when the merge-tree conflict is *fully* explained by trivial-ff gitlinks. */
+    trivial: boolean;
+    /** Why the evaluation declined to treat the conflict as trivial (set when trivial=false). */
+    reason?: string;
+    /** Per-path detail for the changed gitlinks that were inspected. */
+    gitlinks: Array<{
+        path: string;
+        baseCommit?: string;
+        branchCommit?: string;
+        fastForward: boolean;
+    }>;
+};
+/**
+ * Decide whether a merge-tree submodule conflict between base and branch is a
+ * trivial gitlink fast-forward (and nothing else).
+ *
+ * The conflict is treated as trivial ONLY when:
+ *   1. at least one changed gitlink exists,
+ *   2. every changed gitlink fast-forwards (base-commit is an ancestor of the
+ *      branch-commit inside that submodule's repo), and
+ *   3. the *only* paths that changed on both sides of the merge (i.e. the paths
+ *      that could possibly produce a 3-way conflict — the intersection of
+ *      mergeBase→base and mergeBase→branch changes) are gitlinks. Any
+ *      overlapping non-gitlink path means a genuine content conflict could be
+ *      hiding behind the submodule failure, so we keep the block.
+ *
+ * If any of these fail, the conflict is left as a genuine block. This never
+ * passes a regular-file conflict or a diverged (non-ff) gitlink.
+ */
+export declare function evaluateGitlinkTrivialFastForward(repoRoot: string, baseHead: string, branchHead: string): GitlinkTrivialFastForwardEvaluation;
 export interface SessionHostControlPlane {
     getDiagnostics(payload?: {
         includeSessions?: boolean;
@@ -55,12 +137,14 @@ export interface CommandRouterDeps {
         value: any[];
     };
     sessionRegistry: SessionRegistry;
-    /** Callback for CDP manager creation after launch_ide */
+    /** Callback after CDP manager created (transport-specific extras) */
     onCdpManagerCreated?: (ideType: string, manager: DaemonCdpManager) => void;
     /** Callback after IDE connected (e.g., startAgentStreamPolling) */
     onIdeConnected?: () => void;
     /** Callback after status change (stop_ide, restart) */
     onStatusChange?: () => void;
+    /** Callback when a mesh state is invalidated */
+    onMeshStateChange?: (meshId: string) => void;
     /** Callback after chat-related commands */
     onPostChatCommand?: () => void;
     /** Get a connected CDP manager (for agent stream reset check) */
@@ -87,10 +171,27 @@ export declare class DaemonCommandRouter {
      *  Allows the MCP server to query mesh data via get_mesh even when
      *  the mesh doesn't exist in the local meshes.json file. */
     private inlineMeshCache;
+    /** Coordinator-owned whole-mesh aggregate status snapshots. Browser callers read this by default. */
+    private aggregateMeshStatusCache;
+    /** In-memory async Refinery jobs keyed by meshId:nodeId to reject/return duplicate in-flight requests. */
+    private runningRefineJobs;
+    /** Terminal async Refinery jobs preserve a clear answer after the worktree node has been removed. */
+    private terminalRefineJobs;
+    /** In-memory async batch Refinery jobs keyed by meshId (one batch convergence per mesh at a time). */
+    private runningRefineBatchJobs;
+    /** Terminal async batch Refinery jobs preserve the last batch outcome for late readers. */
+    private terminalRefineBatchJobs;
     constructor(deps: CommandRouterDeps);
+    private cloneJsonValue;
+    private hydrateCachedAggregateMeshStatusFromInline;
+    private getCachedAggregateMeshStatus;
+    private rememberAggregateMeshStatus;
+    getCachedInlineMeshNodes(): any[];
     getCachedInlineMesh(meshId: string, inlineMesh?: unknown): any | undefined;
     private warmInlineMeshCache;
     private getMeshForCommand;
+    private invalidateAggregateMeshStatus;
+    private requireMeshHostMutationOwner;
     private updateInlineMeshNode;
     private removeInlineMeshNode;
     private normalizeMeshSessionCleanupMode;
@@ -113,6 +214,63 @@ export declare class DaemonCommandRouter {
      * @param source Log source ('ws' | 'p2p' | 'standalone' | etc.)
      */
     execute(cmd: string, args: any, source?: string): Promise<CommandRouterResult>;
+    private buildRefineJobKey;
+    private buildRefineJobHandle;
+    private queueRefineJobEvent;
+    private appendRefineJobLedger;
+    /**
+     * On daemon restart, scan all mesh ledgers for refine jobs that were dispatched
+     * but never completed/failed (i.e. the daemon died mid-job).  Re-queue each one
+     * so the job runs to completion automatically without coordinator intervention.
+     */
+    resumePendingRefineJobsOnStartup(): Promise<void>;
+    private executeMeshRefineNodeSynchronously;
+    /**
+     * Batch refinery: converge multiple sibling worktree nodes onto the base branch
+     * in one sequential pipeline, absorbing the rebase + patch-equivalence churn that
+     * arises when several siblings touch the same submodule.
+     *
+     * Reuses executeMeshRefineNodeSynchronously per node — every node goes through the
+     * exact same validation / patch-equivalence / submodule-reachability / merge / cleanup
+     * gates, including its built-in auto-rebase onto fresh origin/<base>. Because each
+     * node fetches origin/<base> at the start of its own refine, a node merged earlier in
+     * the batch advances the base, and the next node's refine auto-rebases onto it before
+     * re-running patch-equivalence. No force-push, no reset — conflicting nodes are
+     * isolated as blocked_review while the rest of the batch proceeds.
+     */
+    private batchRefineMeshNodes;
+    /**
+     * Convergence core shared by the synchronous batch entry and the async batch job.
+     * Refines each node in order: the per-node refine pipeline fetches origin/<base>
+     * fresh, so each merged sibling advances the base before the next node's auto-rebase
+     * + patch-equivalence re-check. A blocked/failed node is isolated; the batch
+     * continues with the remaining nodes. Does NOT touch the per-node merge logic — it
+     * only sequences calls to executeMeshRefineNodeSynchronously and aggregates outcomes.
+     */
+    private runMeshRefineBatchConvergence;
+    private buildRefineBatchJobKey;
+    private buildRefineBatchJobHandle;
+    /**
+     * Emit a batch Refinery terminal/accepted event through the SAME pending-event +
+     * forward mechanism single-node refine uses (queueRefineJobEvent), so the
+     * coordinator's existing refine:accepted/completed/failed handling and message
+     * renderer apply unchanged. The aggregate per-node results ride along in `result`.
+     */
+    private queueRefineBatchJobEvent;
+    private appendRefineBatchJobLedger;
+    private finishMeshRefineBatchJob;
+    /**
+     * Async entry for the batch Refinery execute path. Mirrors startMeshRefineJob:
+     * resolves the plan synchronously (so target/ordering errors and the dry-run shape
+     * stay synchronous), then for execute=true registers an in-flight batch job, returns
+     * {async:true, status:'accepted', batch:true, ...plan} immediately, and runs the
+     * convergence loop in the background — emitting the same terminal refine event.
+     * Idempotent: a batch already in flight for this mesh returns the running handle
+     * with duplicate:true rather than spawning a second background job.
+     */
+    private startMeshRefineBatchJob;
+    private finishMeshRefineJob;
+    private startMeshRefineJob;
     /**
      * Daemon-level command execution (IDE start/stop/restart, CLI, detect, logs).
      * Returns null if not handled at this level → caller delegates to CommandHandler.
@@ -123,3 +281,4 @@ export declare class DaemonCommandRouter {
      */
     private stopIde;
 }
+export {};

package/dist/config/chat-history.d.ts

@@ -110,12 +110,21 @@ export declare function readProviderChatHistory(agentType: string, options?: {
     excludeRecentCount?: number;
     historyBehavior?: ProviderHistoryBehavior;
     scripts?: ProviderNativeHistoryScripts;
+    excludeInProgressTurn?: boolean;
+    sessionStartedAtMs?: number;
+    envOverrides?: Record<string, string>;
+    forceRefresh?: boolean;
 }): {
     messages: HistoryMessage[];
     hasMore: boolean;
     source: 'provider-native' | 'adhdev-mirror' | 'native-unavailable';
     sourcePath?: string;
     sourceMtimeMs?: number;
+    providerSessionId?: string;
+    workspace?: string;
+    nativeHistoryCoverage?: string;
+    partialReason?: string;
+    unavailableReason?: string;
 };
 export declare function listProviderHistorySessions(agentType: string, options?: {
     canonicalHistory?: ProviderCanonicalHistoryConfig;

package/dist/config/config.d.ts

@@ -86,6 +86,11 @@ export declare function isStableMachineId(machineId?: string | null): boolean;
  * Get the config directory path
  */
 export declare function getConfigDir(): string;
+/**
+ * Get the daemon runtime data directory (~/.adhdev/daemon/).
+ * Distinct from the user-config dir so runtime state can be cleared independently.
+ */
+export declare function getDaemonDataDir(): string;
 /**
  * Load configuration from disk
  */

package/dist/config/mesh-config.d.ts

@@ -5,7 +5,7 @@
  * Cloud mode syncs these to D1 via server routes; standalone mode
  * uses this file as the single source of truth.
  */
-import type { LocalMeshEntry, LocalMeshNodeEntry, RepoMeshPolicy, RepoMeshNodePolicy, RepoMeshNodeCapabilities, RepoMeshCoordinatorConfig } from '../repo-mesh-types.js';
+import type { LocalMeshEntry, LocalMeshNodeEntry, RepoMeshPolicy, RepoMeshNodePolicy, RepoMeshNodeCapabilities, RepoMeshCoordinatorConfig, RepoMeshHostMetadata, RepoMeshDaemonRole } from '../repo-mesh-types.js';
 /**
  * Normalize a Git remote URL into a stable identity string.
  * e.g. "git@github.com:user/repo.git" → "github.com/user/repo"
@@ -22,6 +22,7 @@ export interface CreateMeshOptions {
     defaultBranch?: string;
     policy?: Partial<RepoMeshPolicy>;
     coordinator?: RepoMeshCoordinatorConfig;
+    meshHost?: RepoMeshHostMetadata;
 }
 export declare function createMesh(opts: CreateMeshOptions): LocalMeshEntry;
 export interface UpdateMeshOptions {
@@ -29,23 +30,93 @@ export interface UpdateMeshOptions {
     defaultBranch?: string;
     policy?: Partial<RepoMeshPolicy>;
     coordinator?: RepoMeshCoordinatorConfig;
+    meshHost?: RepoMeshHostMetadata;
 }
 export declare function updateMesh(meshId: string, opts: UpdateMeshOptions): LocalMeshEntry | undefined;
 export declare function deleteMesh(meshId: string): boolean;
+export declare function tokenIdForManualPairing(token: string): string;
+export interface ConfigureMeshHostPairingOptions {
+    hostAddress: string;
+    token: string;
+    now?: string;
+}
+export declare function configureMeshHostPairing(meshId: string, opts: ConfigureMeshHostPairingOptions): {
+    mesh: LocalMeshEntry;
+    meshHost: RepoMeshHostMetadata;
+    hostAddress: string;
+} | undefined;
+export interface CreateMeshHostPairingTokenOptions {
+    token?: string;
+    expiresAt?: string;
+    now?: string;
+}
+export declare function createMeshHostPairingToken(meshId: string, opts?: CreateMeshHostPairingTokenOptions): {
+    mesh: LocalMeshEntry;
+    meshHost: RepoMeshHostMetadata;
+    token: string;
+    tokenId: string;
+    expiresAt?: string;
+} | undefined;
+export interface MeshHostJoinMemberNodeInput {
+    id?: string;
+    workspace: string;
+    repoRoot?: string;
+    daemonId?: string;
+    machineId?: string;
+    userOverrides?: Partial<RepoMeshNodeCapabilities>;
+    policy?: RepoMeshNodePolicy;
+    role?: RepoMeshDaemonRole;
+}
+export interface ApplyMeshHostJoinOptions {
+    token: string;
+    memberNode: MeshHostJoinMemberNodeInput;
+    memberMeshId?: string;
+    now?: string;
+}
+export declare function applyMeshHostJoinRequest(meshId: string, opts: ApplyMeshHostJoinOptions): {
+    accepted: true;
+    mesh: LocalMeshEntry;
+    meshHost: RepoMeshHostMetadata;
+    node: LocalMeshNodeEntry;
+    tokenId: string;
+} | {
+    accepted: false;
+    mesh?: LocalMeshEntry;
+    meshHost?: RepoMeshHostMetadata;
+    tokenId?: string;
+    reason: string;
+} | undefined;
+export declare function markMeshHostPairingJoined(meshId: string, opts: {
+    hostDaemonId?: string;
+    hostNodeId?: string;
+    joinedAt?: string;
+    token?: string;
+    tokenId?: string;
+}): {
+    mesh: LocalMeshEntry;
+    meshHost: RepoMeshHostMetadata;
+} | undefined;
 export interface AddNodeOptions {
     workspace: string;
     repoRoot?: string;
     daemonId?: string;
     machineId?: string;
+    capabilities?: string[];
     userOverrides?: Partial<RepoMeshNodeCapabilities>;
     policy?: RepoMeshNodePolicy;
     isLocalWorktree?: boolean;
     worktreeBranch?: string;
     clonedFromNodeId?: string;
+    worktreeBootstrap?: LocalMeshNodeEntry['worktreeBootstrap'];
+    role?: RepoMeshDaemonRole;
 }
 export declare function addNode(meshId: string, opts: AddNodeOptions): LocalMeshNodeEntry | undefined;
 export declare function removeNode(meshId: string, nodeId: string): boolean;
 export declare function updateNode(meshId: string, nodeId: string, opts: {
     userOverrides?: Partial<RepoMeshNodeCapabilities>;
     policy?: RepoMeshNodePolicy;
+    worktreeBootstrap?: LocalMeshNodeEntry['worktreeBootstrap'];
+    /** Per-node instruction surfaced in the coordinator prompt. Pass an
+     *  empty string or undefined to clear it. */
+    systemPrompt?: string;
 }): LocalMeshNodeEntry | undefined;

package/dist/git/git-commands.d.ts

@@ -23,8 +23,12 @@ export interface GitLogResult extends GitRepoIdentity {
     lastCheckedAt: number;
 }
 export interface GitCheckpointResult extends GitRepoIdentity {
-    commit: string;
+    commit?: string;
     message: string;
+    status?: 'created' | 'skipped';
+    skipped?: boolean;
+    noop?: boolean;
+    reason?: 'nothing_to_commit';
     lastCheckedAt: number;
 }
 export interface GitStashPushResult extends GitRepoIdentity {
@@ -43,15 +47,19 @@ export interface GitCommandServices {
     getStatus?: (params: {
         workspace: string;
         refreshUpstream?: boolean;
+        includeSubmodules?: boolean;
+        submoduleIgnorePaths?: string[];
     }) => Promise<GitRepoStatus> | GitRepoStatus;
     getDiffSummary?: (params: {
         workspace: string;
         staged?: boolean;
+        base?: string;
     }) => Promise<GitDiffSummary> | GitDiffSummary;
     getDiffFile?: (params: {
         workspace: string;
         path: string;
         staged?: boolean;
+        base?: string;
     }) => Promise<GitFileDiff> | GitFileDiff;
     createSnapshot?: (params: {
         workspace: string;

package/dist/git/git-diff.d.ts

@@ -3,6 +3,12 @@ export interface GitDiffOptions {
     timeoutMs?: number;
     maxFiles?: number;
     maxBytes?: number;
+    /**
+     * When set, diff `<baseRef>...HEAD` (merge-base range — "what this branch
+     * adds on top of base") instead of the working tree. Staged/untracked
+     * sections do not apply in this mode.
+     */
+    baseRef?: string;
 }
 export interface GitFileDiffResult {
     workspace: string;

package/dist/git/git-status.d.ts

@@ -1,4 +1,5 @@
 import type { GitRepoStatus } from './git-types.js';
+import { type DaemonBuildInfo } from '../build-info.js';
 export interface GitStatusOptions {
     timeoutMs?: number;
     /** When true, include submodule status in the result. Defaults to true. */
@@ -10,6 +11,12 @@ export interface GitStatusOptions {
      * Callers should opt into this only for convergence-critical surfaces.
      */
     refreshUpstream?: boolean;
+    /**
+     * Test/override seam for the daemon build stamp used by the stale-build
+     * detector. Production callers omit this so the real baked-in build commit
+     * (getDaemonBuildInfo) is used.
+     */
+    daemonBuildInfo?: DaemonBuildInfo;
 }
 export declare function getGitRepoStatus(workspace: string, options?: GitStatusOptions): Promise<GitRepoStatus>;
 interface ParsedPorcelainStatus {