@adhdev/daemon-core 0.9.82-rc.114 → 0.9.82-rc.116

package/dist/mesh/mesh-active-work.d.ts

@@ -41,6 +41,14 @@ export interface MeshActiveWorkSummary {
      */
     staleDirectNote?: string;
 }
+export interface MeshStaleDirectWorkSummary {
+    count: number;
+    sampleLimit: number;
+    sample: Array<Pick<MeshActiveWorkRecord, 'taskId' | 'status' | 'nodeId' | 'sessionId' | 'taskTitle' | 'createdAt' | 'staleReason'>>;
+    reasonCounts: Record<string, number>;
+    detailHint: string;
+    note?: string;
+}
 export interface BuildMeshActiveWorkOptions {
     meshId: string;
     queue?: MeshWorkQueueEntry[];
@@ -58,3 +66,8 @@ export declare function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): {
     terminalDirectWork: MeshActiveWorkRecord[];
     summary: MeshActiveWorkSummary;
 };
+export declare function buildCompactStaleDirectWorkSummary(staleDirectWork: MeshActiveWorkRecord[], opts?: {
+    sampleLimit?: number;
+    detailHint?: string;
+    note?: string;
+}): MeshStaleDirectWorkSummary;

package/dist/mesh/mesh-refine-status.d.ts

@@ -0,0 +1,27 @@
+import type { MeshLedgerEntry } from './mesh-ledger.js';
+import type { PendingMeshCoordinatorEvent } from './mesh-events.js';
+export type MeshAsyncRefineJobStatus = 'accepted' | 'running' | 'completed' | 'failed';
+export interface MeshAsyncRefineJobSummary {
+    jobId: string;
+    interactionId?: string;
+    status: MeshAsyncRefineJobStatus;
+    meshId?: string;
+    nodeId?: string;
+    targetNodeId?: string;
+    targetDaemonId?: string;
+    workspace?: string;
+    branch?: string;
+    into?: string;
+    startedAt?: string;
+    completedAt?: string;
+    retryOfJobId?: string;
+    lastEvent?: string;
+    lastLedgerKind?: string;
+    lastUpdatedAt?: string;
+    instruction: string;
+}
+export declare function buildMeshAsyncRefineJobs(args: {
+    meshId?: string;
+    ledgerEntries?: MeshLedgerEntry[];
+    pendingEvents?: PendingMeshCoordinatorEvent[];
+}): MeshAsyncRefineJobSummary[];

package/dist/mesh/preview-freshness.d.ts

@@ -0,0 +1,18 @@
+export type PreviewFreshnessStatus = 'fresh' | 'stale' | 'unknown' | 'not_configured';
+export interface PreviewFreshness {
+    status: PreviewFreshnessStatus;
+    lastPreviewCommit: string | null;
+    currentMainCommit: string | null;
+    currentMainCommitSource: 'origin/main' | 'HEAD' | 'unknown';
+    recordPath: string;
+    lastDeployedAt?: string;
+    lastTarget?: string;
+    previewVersion?: string;
+    targets: Record<'npm' | 'server' | 'web', {
+        commit: string | null;
+        deployedAt?: string;
+        status: PreviewFreshnessStatus;
+    }>;
+    nextAction: string;
+}
+export declare function buildPreviewFreshness(repoRoot: string): PreviewFreshness;

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

@@ -8,6 +8,7 @@ export interface RepoMeshRefineValidationCommandConfig {
     category?: MeshRefineValidationCategory;
     cwd?: string;
     timeoutMs?: number;
+    outputLimitBytes?: number;
     env?: Record<string, string>;
 }
 export interface RepoMeshRefineConfig {
@@ -37,6 +38,7 @@ export interface MeshRefineValidationCommandPlan {
     source: string;
     cwd?: string;
     timeoutMs?: number;
+    outputLimitBytes?: number;
     env?: Record<string, string>;
 }
 export interface MeshRefineConfigLoadResult {
@@ -110,6 +112,11 @@ export declare const MESH_REFINE_CONFIG_SCHEMA: {
                                 readonly minimum: 1000;
                                 readonly maximum: 600000;
                             };
+                            readonly outputLimitBytes: {
+                                readonly type: "number";
+                                readonly minimum: 1024;
+                                readonly maximum: 1048576;
+                            };
                             readonly env: {
                                 readonly type: "object";
                                 readonly additionalProperties: {
@@ -148,6 +155,11 @@ export declare const MESH_REFINE_CONFIG_SCHEMA: {
                                 readonly minimum: 1000;
                                 readonly maximum: 600000;
                             };
+                            readonly outputLimitBytes: {
+                                readonly type: "number";
+                                readonly minimum: 1024;
+                                readonly maximum: 1048576;
+                            };
                             readonly env: {
                                 readonly type: "object";
                                 readonly additionalProperties: {
@@ -161,6 +173,11 @@ export declare const MESH_REFINE_CONFIG_SCHEMA: {
         };
     };
 };
+export declare function isMeshConfigRecord(value: unknown): value is Record<string, unknown>;
+export declare function normalizeMeshCommandConfig(entry: unknown, source: string): {
+    command?: MeshRefineValidationCommandPlan;
+    rejected?: Record<string, unknown>;
+};
 export declare function validateMeshRefineConfig(config: unknown, source?: string): {
     valid: boolean;
     errors: string[];

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

@@ -0,0 +1,115 @@
+import { type MeshRefineValidationCommandPlan, type RepoMeshRefineValidationCommandConfig } from './refine-config.js';
+export type WorktreeBootstrapStatus = 'ready' | 'running' | 'failed' | 'not_configured' | 'disabled' | 'stale';
+export interface RepoMeshWorktreeBootstrapConfig {
+    version: 1;
+    enabled?: boolean;
+    runOnClone?: boolean;
+    required?: boolean;
+    commands?: RepoMeshRefineValidationCommandConfig[];
+    staleInputs?: string[];
+}
+export interface WorktreeBootstrapState {
+    status: WorktreeBootstrapStatus;
+    required: boolean;
+    configSource?: string;
+    configSourceType?: 'repo_file' | 'mesh_policy' | 'unavailable' | 'invalid';
+    startedAt?: string;
+    completedAt?: string;
+    lastCommand?: string;
+    exitCode?: number | null;
+    error?: string;
+    commandsRun?: Array<Record<string, unknown>>;
+    staleInputs?: string[];
+}
+export interface WorktreeBootstrapConfigLoadResult {
+    config?: RepoMeshWorktreeBootstrapConfig;
+    source: string;
+    sourceType: 'repo_file' | 'mesh_policy' | 'unavailable' | 'invalid';
+    path?: string;
+    error?: string;
+}
+export declare const MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS: string[];
+export declare const MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly title: "ADHDev Repo Mesh Worktree Bootstrap Config";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["version"];
+    readonly properties: {
+        readonly version: {
+            readonly const: 1;
+        };
+        readonly enabled: {
+            readonly type: "boolean";
+            readonly default: true;
+        };
+        readonly runOnClone: {
+            readonly type: "boolean";
+            readonly default: true;
+        };
+        readonly required: {
+            readonly type: "boolean";
+            readonly default: true;
+        };
+        readonly staleInputs: {
+            readonly type: "array";
+            readonly maxItems: 16;
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+        };
+        readonly commands: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly maxItems: 4;
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["command"];
+                readonly properties: {
+                    readonly command: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly args: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly category: {
+                        readonly enum: readonly ["typecheck", "test", "lint", "build", "custom"];
+                    };
+                    readonly cwd: {
+                        readonly type: "string";
+                    };
+                    readonly timeoutMs: {
+                        readonly type: "number";
+                        readonly minimum: 1000;
+                        readonly maximum: 600000;
+                    };
+                    readonly outputLimitBytes: {
+                        readonly type: "number";
+                        readonly minimum: 1024;
+                        readonly maximum: 1048576;
+                    };
+                    readonly env: {
+                        readonly type: "object";
+                        readonly additionalProperties: {
+                            readonly type: "string";
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+export declare function validateMeshWorktreeBootstrapConfig(config: unknown, source?: string): {
+    valid: boolean;
+    errors: string[];
+    commands: MeshRefineValidationCommandPlan[];
+    rejectedCommands: Array<Record<string, unknown>>;
+};
+export declare function loadMeshWorktreeBootstrapConfig(mesh: any, workspace: string): WorktreeBootstrapConfigLoadResult;
+export declare function runMeshWorktreeBootstrap(mesh: any, workspace: string): Promise<WorktreeBootstrapState>;

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

@@ -240,6 +240,20 @@ export interface LocalMeshNodeEntry {
     worktreeBranch?: string;
     /** Node ID this worktree was cloned from */
     clonedFromNodeId?: string;
+    /** Repo-local preparation result for ADHDev-created worktree nodes. */
+    worktreeBootstrap?: {
+        status: 'ready' | 'running' | 'failed' | 'not_configured' | 'disabled' | 'stale';
+        required?: boolean;
+        configSource?: string;
+        configSourceType?: string;
+        startedAt?: string;
+        completedAt?: string;
+        lastCommand?: string;
+        exitCode?: number | null;
+        error?: string;
+        commandsRun?: Array<Record<string, unknown>>;
+        staleInputs?: string[];
+    };
     /** Optional associated/external repos configured as node metadata. */
     relatedRepos?: RepoMeshRelatedRepo[];
     role?: RepoMeshDaemonRole;
@@ -304,6 +318,9 @@ export interface RepoMeshNodeStatus {
     activeSessionDetails?: RepoMeshSessionStatus[];
     providerPriority?: string[];
     launchReady?: boolean;
+    worktreeBootstrap?: LocalMeshNodeEntry['worktreeBootstrap'];
+    launchBlockedReason?: string;
+    launchBlockedMessage?: string;
     lastSeenAt?: string;
     updatedAt?: string;
     connection?: RepoMeshPeerConnectionStatus;

package/package.json

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

package/src/commands/chat-commands.ts

@@ -455,18 +455,45 @@ function hasSafeNativeHistoryMapping(args: {
     ptyMessages?: ChatMessage[];
     requireWorkspaceContentOverlap?: boolean;
 }): boolean {
+    const isCoordinatorTranscript = args.nativeMessages.some((m: any) => {
+        const text = typeof m?.content === 'string' ? m.content : JSON.stringify(m?.content || '');
+        return text.includes('mesh_send_task') || text.includes('mesh_status') || text.includes('mesh_read_chat') || text.includes('mesh_launch_session');
+    });
+
     const explicitSessionId = String(args.historySessionId || args.providerSessionId || '').trim();
     if (explicitSessionId) {
         const messageSessionIds = args.nativeMessages
             .map((message: any) => typeof message?.historySessionId === 'string' ? message.historySessionId.trim() : '')
             .filter(Boolean);
-        if (messageSessionIds.length === 0) return true;
-        return messageSessionIds.some((id) => id === explicitSessionId);
+        if (messageSessionIds.length > 0) {
+            return messageSessionIds.some((id) => id === explicitSessionId);
+        }
+
+        if (isCoordinatorTranscript && args.ptyMessages && args.ptyMessages.length > 0) {
+            const ptyHasCoordinator = args.ptyMessages.some((m: any) => {
+                const text = typeof m?.content === 'string' ? m.content : JSON.stringify(m?.content || '');
+                return text.includes('mesh_send_task') || text.includes('mesh_status') || text.includes('mesh_read_chat');
+            });
+            if (!ptyHasCoordinator) {
+                return false;
+            }
+        }
     }
     const workspace = String(args.workspace || '').trim();
     if (!workspace) return false;
     const workspaceMatches = args.nativeMessages.some((message: any) => String(message?.workspace || '').trim() === workspace);
     if (!workspaceMatches) return false;
+
+    if (isCoordinatorTranscript && args.ptyMessages && args.ptyMessages.length > 0) {
+        const ptyHasCoordinator = args.ptyMessages.some((m: any) => {
+            const text = typeof m?.content === 'string' ? m.content : JSON.stringify(m?.content || '');
+            return text.includes('mesh_send_task') || text.includes('mesh_status') || text.includes('mesh_read_chat');
+        });
+        if (!ptyHasCoordinator) {
+            return false;
+        }
+    }
+
     if (!args.requireWorkspaceContentOverlap) return true;
     return hasOverlappingVisibleConversationText(args.nativeMessages, args.ptyMessages || []);
 }