@adhdev/daemon-core 0.9.80 → 0.9.81

package/dist/repo-mesh-types.d.ts

@@ -87,6 +87,21 @@ export interface RepoMeshNodePolicy {
      * sibling paths so freshness checks stay fail-closed and non-surprising.
      */
     relatedRepos?: RepoMeshRelatedRepo[];
+    /**
+     * When true (default), mesh_git_status automatically discovers git submodules
+     * and includes their status. Set to false to disable auto-discovery.
+     */
+    autoDiscoverSubmodules?: boolean;
+    /**
+     * Submodule paths to ignore when autoDiscoverSubmodules is true.
+     * Useful for vendored dependencies that change frequently but are not deploy-critical.
+     */
+    submoduleIgnorePaths?: string[];
+    /**
+     * When true (default), mesh_clone_node runs `git submodule update --init --recursive`
+     * after creating a worktree. Set to false to skip submodule initialization.
+     */
+    initSubmodulesOnClone?: boolean;
 }
 export declare const DEFAULT_MESH_POLICY: RepoMeshPolicy;
 export interface RepoMeshNodeCapabilities {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.80",
+  "version": "0.9.81",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/commands/router.ts

@@ -2303,13 +2303,29 @@ export class DaemonCommandRouter {
                         if (!node) return { success: false, error: 'Failed to register worktree node' };
                     }
 
+                    // Initialize submodules if policy allows (default: true)
+                    const initSubmodules = (sourceNode.policy as any)?.initSubmodulesOnClone !== false;
+                    if (initSubmodules) {
+                        try {
+                            const { runGit } = await import('../git/git-executor.js');
+                            await runGit(
+                                { workspace: result.worktreePath, repoRoot: result.worktreePath, isGitRepo: true },
+                                ['submodule', 'update', '--init', '--recursive'],
+                                { timeoutMs: 120000 },
+                            );
+                        } catch (subErr: any) {
+                            // Submodule init is best-effort; don't fail the clone
+                            console.warn('[mesh] Submodule init failed for worktree:', subErr.message);
+                        }
+                    }
+
                     // Record in task ledger
                     try {
                         const { appendLedgerEntry } = await import('../mesh/mesh-ledger.js');
                         appendLedgerEntry(meshId, {
                             kind: 'node_cloned',
                             nodeId: node.id,
-                            payload: { sourceNodeId, branch: result.branch, worktreePath: result.worktreePath },
+                            payload: { sourceNodeId, branch: result.branch, worktreePath: result.worktreePath, submodulesInitialized: initSubmodules },
                         });
                     } catch { /* ledger append is best-effort */ }
 

package/src/git/git-status.ts

@@ -1,8 +1,12 @@
-import type { GitRepoStatus } from './git-types.js';
+import type { GitRepoStatus, GitSubmoduleStatus } from './git-types.js';
 import { GitCommandError, resolveGitRepository, runGit } from './git-executor.js';
 
 export interface GitStatusOptions {
   timeoutMs?: number;
+  /** When true, include submodule status in the result. Defaults to true. */
+  includeSubmodules?: boolean;
+  /** Optional filter to exclude specific submodule paths from status */
+  submoduleIgnorePaths?: string[];
 }
 
 export async function getGitRepoStatus(
@@ -10,6 +14,7 @@ export async function getGitRepoStatus(
   options: GitStatusOptions = {},
 ): Promise<GitRepoStatus> {
   const lastCheckedAt = Date.now();
+  const includeSubmodules = options.includeSubmodules !== false;
 
   try {
     const repo = await resolveGitRepository(workspace, options);
@@ -18,6 +23,11 @@ export async function getGitRepoStatus(
     const head = await readHead(repo, options);
     const stashCount = await readStashCount(repo, options);
 
+    let submodules: GitSubmoduleStatus[] | undefined;
+    if (includeSubmodules) {
+      submodules = await getSubmoduleStatuses(repo, options);
+    }
+
     return {
       workspace: repo.workspace,
       repoRoot: repo.repoRoot,
@@ -37,6 +47,7 @@ export async function getGitRepoStatus(
       conflictFiles: parsed.conflictFiles,
       stashCount,
       lastCheckedAt,
+      submodules,
     };
   } catch (error) {
     if (error instanceof GitCommandError) {
@@ -191,3 +202,54 @@ function emptyStatus(workspace: string, lastCheckedAt: number, error: GitCommand
     reason: error.reason,
   };
 }
+
+// ─── Submodule Status ───────────────────────────
+
+async function getSubmoduleStatuses(
+  repo: { workspace: string; repoRoot: string | null; isGitRepo: boolean },
+  options: GitStatusOptions,
+): Promise<GitSubmoduleStatus[]> {
+  if (!repo.repoRoot) return [];
+
+  try {
+    const result = await runGit(repo, ['submodule', 'status', '--recursive'], options);
+    return parseSubmoduleStatusOutput(result.stdout, repo.repoRoot, options.submoduleIgnorePaths);
+  } catch {
+    return [];
+  }
+}
+
+function parseSubmoduleStatusOutput(
+  output: string,
+  repoRoot: string,
+  ignorePaths?: string[],
+): GitSubmoduleStatus[] {
+  const submodules: GitSubmoduleStatus[] = [];
+  const ignoreSet = new Set(ignorePaths || []);
+
+  for (const line of output.split('\n')) {
+    if (!line.trim()) continue;
+
+    // Format: [+- ]<commit> <path> (<branch>)
+    // - = out of sync, + = dirty, ' ' = clean
+    const match = line.match(/^([\-+\s])([0-9a-f]{40})\s+(\S+)(?:\s+\(([^)]+)\))?/);
+    if (!match) continue;
+
+    const prefix = match[1];
+    const commit = match[2];
+    const path = match[3];
+
+    if (ignoreSet.has(path)) continue;
+
+    submodules.push({
+      path,
+      commit,
+      repoPath: repoRoot + '/' + path,
+      dirty: prefix === '+',
+      outOfSync: prefix === '-',
+      lastCheckedAt: Date.now(),
+    });
+  }
+
+  return submodules;
+}

package/src/git/git-types.ts

@@ -23,6 +23,23 @@ export interface GitRepoIdentity {
   isGitRepo: boolean;
 }
 
+export interface GitSubmoduleStatus {
+  /** Submodule path relative to repo root */
+  path: string;
+  /** Current commit SHA the submodule is at */
+  commit: string;
+  /** Path to the submodule repo (absolute) */
+  repoPath: string;
+  /** Whether the submodule has uncommitted changes */
+  dirty: boolean;
+  /** Whether the submodule commit differs from what the parent repo expects */
+  outOfSync: boolean;
+  /** Last checked timestamp */
+  lastCheckedAt: number;
+  /** Error message if submodule status could not be read */
+  error?: string;
+}
+
 export interface GitRepoStatus extends GitRepoIdentity {
   branch: string | null;
   headCommit: string | null;
@@ -39,6 +56,8 @@ export interface GitRepoStatus extends GitRepoIdentity {
   conflictFiles: string[];
   stashCount: number;
   lastCheckedAt: number;
+  /** Submodule statuses when auto-discover is enabled */
+  submodules?: GitSubmoduleStatus[];
   error?: string;
   reason?: GitFailureReason;
 }

package/src/repo-mesh-types.ts

@@ -105,6 +105,21 @@ export interface RepoMeshNodePolicy {
      * sibling paths so freshness checks stay fail-closed and non-surprising.
      */
     relatedRepos?: RepoMeshRelatedRepo[];
+    /**
+     * When true (default), mesh_git_status automatically discovers git submodules
+     * and includes their status. Set to false to disable auto-discovery.
+     */
+    autoDiscoverSubmodules?: boolean;
+    /**
+     * Submodule paths to ignore when autoDiscoverSubmodules is true.
+     * Useful for vendored dependencies that change frequently but are not deploy-critical.
+     */
+    submoduleIgnorePaths?: string[];
+    /**
+     * When true (default), mesh_clone_node runs `git submodule update --init --recursive`
+     * after creating a worktree. Set to false to skip submodule initialization.
+     */
+    initSubmodulesOnClone?: boolean;
 }
 
 export const DEFAULT_MESH_POLICY: RepoMeshPolicy = {