@adhdev/daemon-core 0.9.82-rc.113 → 0.9.82-rc.115

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.113",
+  "version": "0.9.82-rc.115",
   "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

@@ -279,7 +279,18 @@ function readHistorySessionIdFromMessages(messages: ChatMessage[]): string | und
     return undefined;
 }
 
-function normalizeNativeHistoryMessages(providerType: string, messages: ChatMessage[]): ChatMessage[] {
+function shouldPreserveNativeIdentity(providerType: string, sessionId: string, message: ChatMessage): boolean {
+    const providerUnitKey = typeof message.providerUnitKey === 'string' ? message.providerUnitKey.trim() : '';
+    const turnKey = typeof message._turnKey === 'string' ? message._turnKey.trim() : '';
+    if (!providerUnitKey || !turnKey) return false;
+    if (providerType === 'hermes-cli' && sessionId) {
+        return providerUnitKey.startsWith(`${providerType}:native:${sessionId}:`)
+            && turnKey.startsWith(`${providerType}:native-turn:${sessionId}:`);
+    }
+    return true;
+}
+
+function normalizeNativeHistoryMessages(providerType: string, messages: ChatMessage[], nativeSessionId?: string): ChatMessage[] {
     let turnIndex = 0;
     return normalizeChatMessages(messages).map((message, index) => {
         const role = typeof message.role === 'string' ? message.role.trim().toLowerCase() : '';
@@ -296,9 +307,13 @@ function normalizeNativeHistoryMessages(providerType: string, messages: ChatMess
             kind,
             flattenContent(message.content),
         ]).slice(0, 12);
-        const providerUnitKey = typeof message.providerUnitKey === 'string' && message.providerUnitKey.trim()
-            ? message.providerUnitKey.trim()
-            : `${providerType}:native:${historySessionId || 'workspace'}:${index}:${role || 'message'}:${kind}:${contentHash}`;
+        const nativeIdentitySessionId = historySessionId || (typeof nativeSessionId === 'string' ? nativeSessionId.trim() : '');
+        const preserveNativeIdentity = shouldPreserveNativeIdentity(providerType, nativeIdentitySessionId, message);
+        const existingProviderUnitKey = typeof message.providerUnitKey === 'string' ? message.providerUnitKey.trim() : '';
+        const existingTurnKey = typeof message._turnKey === 'string' ? message._turnKey.trim() : '';
+        const providerUnitKey = preserveNativeIdentity
+            ? existingProviderUnitKey
+            : `${providerType}:native:${nativeIdentitySessionId || 'workspace'}:${index}:${role || 'message'}:${kind}:${contentHash}`;
         const meta = message.meta && typeof message.meta === 'object' ? message.meta as Record<string, unknown> : undefined;
         const isSystemSessionStart = role === 'system' || kind === 'system' || kind === 'session_start';
         const isActivity = role === 'assistant' && (kind === 'tool' || kind === 'terminal' || kind === 'thought');
@@ -308,11 +323,12 @@ function normalizeNativeHistoryMessages(providerType: string, messages: ChatMess
             kind: isSystemSessionStart ? 'system' : kind,
             providerUnitKey,
             bubbleId: typeof message.bubbleId === 'string' && message.bubbleId.trim()
+                && preserveNativeIdentity
                 ? message.bubbleId.trim()
                 : `bubble:${providerUnitKey}`,
-            _turnKey: typeof message._turnKey === 'string' && message._turnKey.trim()
-                ? message._turnKey.trim()
-                : `${providerType}:native-turn:${historySessionId || 'workspace'}:${turnIndex}`,
+            _turnKey: preserveNativeIdentity
+                ? existingTurnKey
+                : `${providerType}:native-turn:${nativeIdentitySessionId || 'workspace'}:${turnIndex}`,
             bubbleState: message.bubbleState || 'final',
             ...(isSystemSessionStart ? {
                 visibility: message.visibility || 'hidden',
@@ -1194,7 +1210,9 @@ export async function handleChatHistory(h: CommandHelpers, args: any): Promise<C
             });
         if (supportsCliNativeTranscript(agentStr, provider) && isNativeSourceCanonicalHistory(provider?.canonicalHistory)) {
             const lookup = (result as any).lookup === 'workspace' ? 'workspace' : 'session';
-            const messages = Array.isArray((result as any).messages) ? normalizeNativeHistoryMessages(agentStr, (result as any).messages as ChatMessage[]) : [];
+            const messages = Array.isArray((result as any).messages)
+                ? normalizeNativeHistoryMessages(agentStr, (result as any).messages as ChatMessage[], (result as any)?.providerSessionId)
+                : [];
             const historyProviderSessionId = typeof (result as any)?.providerSessionId === 'string'
                 ? (result as any).providerSessionId
                 : readHistorySessionIdFromMessages(messages) || historySessionId;
@@ -1335,7 +1353,7 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
 
                 if (nativeHistory) {
                     const nativeMessages = Array.isArray((nativeHistory as any).messages)
-                        ? normalizeNativeHistoryMessages(agentStr, (nativeHistory as any).messages as ChatMessage[])
+                        ? normalizeNativeHistoryMessages(agentStr, (nativeHistory as any).messages as ChatMessage[], (nativeHistory as any)?.providerSessionId)
                         : [];
                     const historyProviderSessionId = typeof (nativeHistory as any)?.providerSessionId === 'string'
                         ? (nativeHistory as any).providerSessionId
@@ -1497,7 +1515,7 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
             });
             const lookup = (history as any).lookup === 'workspace' ? 'workspace' : 'session';
             const historyMessages = Array.isArray((history as any)?.messages)
-                ? normalizeNativeHistoryMessages(agentStr, (history as any).messages as ChatMessage[])
+                ? normalizeNativeHistoryMessages(agentStr, (history as any).messages as ChatMessage[], (history as any)?.providerSessionId)
                 : [];
             const historyProviderSessionId = typeof (history as any)?.providerSessionId === 'string'
                 ? (history as any).providerSessionId