@adhdev/daemon-core 0.9.82-rc.212 → 0.9.82-rc.214

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

@@ -70,6 +70,14 @@ export interface RepoMeshNode {
 export type RepoMeshNodeHealth = 'online' | 'offline' | 'degraded' | 'dirty' | 'wrong_branch' | 'unknown';
 export type RepoMeshSessionCleanupMode = 'preserve' | 'stop' | 'delete_stopped' | 'stop_and_delete';
 export type RepoMeshSpawnedSessionVisibility = 'visible' | 'hidden';
+export interface RepoMeshAutoFastForwardPolicy {
+    /** Defaults to true. Set false to disable daemon-initiated idle fast-forwards. */
+    enabled: boolean;
+    /** Maximum behind count eligible for automatic fast-forward. Missing means no limit. */
+    maxBehind?: number;
+    /** Defaults to true. Require submodule status to be clean before automatic fast-forward. */
+    requireCleanSubmodules?: boolean;
+}
 export interface RepoMeshPolicy {
     requirePreTaskCheckpoint: boolean;
     requirePostTaskCheckpoint: boolean;
@@ -97,6 +105,11 @@ export interface RepoMeshPolicy {
      * runtimes are never stopped/deleted unless the mesh owner opts in.
      */
     sessionCleanupOnNodeRemove?: RepoMeshSessionCleanupMode;
+    /**
+     * Daemon-initiated fast-forward for idle clean nodes that are only behind
+     * their tracked upstream. Defaults to enabled.
+     */
+    autoFastForward?: RepoMeshAutoFastForwardPolicy;
     /**
      * Maximum number of automatic retry recommendations for a failed task on the
      * same node before the daemon advises the coordinator to escalate or reassign.
@@ -358,6 +371,10 @@ export interface RepoMeshNodeStatus {
     activeSessionDetails?: RepoMeshSessionStatus[];
     providerPriority?: string[];
     launchReady?: boolean;
+    /** True when the node is clean, ahead=0, behind>0, and safe for fast-forward consideration. */
+    autoFastForwardEligible?: boolean;
+    /** Coordinator-facing suggestion for obvious clean catch-up work. */
+    suggestedAction?: 'auto_fast_forward';
     worktreeBootstrap?: LocalMeshNodeEntry['worktreeBootstrap'];
     launchBlockedReason?: string;
     launchBlockedMessage?: string;

package/package.json

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

package/src/cli-adapters/cli-state-engine.ts

@@ -555,11 +555,35 @@ export class CliStateEngine {
         // The real completion gate is applyIdle's idleFinishCandidate +
         // idleFinish timeout, which requires stable quiet AND a parsed
         // assistant message.
+        //
+        // Fast-path exception: only release the hold if the parser shows a
+        // *current-turn* final standard assistant after the last user message,
+        // and it is not still streaming. Using !!lastParsedAssistant was too
+        // broad — it matched previous-turn assistant messages and caused
+        // false-idle between the first assistant text chunk and the first
+        // tool call (the agent outputs text, then immediately begins tool use;
+        // the gap between them hit this fast path and committed idle).
+        const hasFinalCurrentTurnAssistant = (() => {
+            if (parsedStatus !== 'idle') return false;
+            const msgs: any[] = Array.isArray(parsedMessages) ? parsedMessages : [];
+            let lastUserIdx = -1;
+            for (let i = msgs.length - 1; i >= 0; i--) {
+                if (msgs[i]?.role === 'user') { lastUserIdx = i; break; }
+            }
+            // No user message visible: fall back to any non-streaming standard assistant.
+            const searchSlice = lastUserIdx >= 0 ? msgs.slice(lastUserIdx + 1) : msgs;
+            return searchSlice.some((m: any) => {
+                if (!m || m.role !== 'assistant') return false;
+                if (typeof m.content !== 'string' || !m.content.trim()) return false;
+                const kind = typeof m.kind === 'string' && m.kind.trim() ? m.kind.trim() : 'standard';
+                return kind === 'standard' && m.meta?.streaming !== true;
+            });
+        })();
         const shouldHoldGenerating = status === 'idle'
             && this.isWaitingForResponse
             && !!this.currentTurnScope
             && !modal
-            && !(parsedStatus === 'idle' && !!lastParsedAssistant);
+            && !hasFinalCurrentTurnAssistant;
 
         if (shouldHoldGenerating) { this.applyHoldGenerating(ctx); return; }
         if (status === 'error') {

package/src/commands/router.ts

@@ -66,6 +66,7 @@ import { getSessionCompletionMarker } from '../status/snapshot.js';
 import { execNpmCommandSync, resolveCurrentGlobalInstallSurface, spawnDetachedDaemonUpgradeHelper } from './upgrade-helper.js';
 import { getMeshQueueRevision } from '../mesh/mesh-work-queue.js';
 import type { RepoMeshSessionCleanupMode } from '../repo-mesh-types.js';
+import { DEFAULT_MESH_POLICY } from '../repo-mesh-types.js';
 import { homedir, hostname as osHostname } from 'os';
 import { basename as pathBasename, join as pathJoin, resolve as pathResolve } from 'path';
 import * as fs from 'fs';
@@ -669,6 +670,25 @@ function getGitSubmoduleDriftState(git: Record<string, unknown> | null | undefin
     return { dirty, outOfSync };
 }
 
+function isInlineMeshAutoFastForwardEligible(git: Record<string, unknown> | null | undefined): boolean {
+    if (!git) return false;
+    if (readBooleanValue(git.isGitRepo) !== true) return false;
+    if (!readStringValue(git.branch)) return false;
+    if (!readStringValue(git.upstream)) return false;
+    const upstreamStatus = readStringValue(git.upstreamStatus, git.upstream_status);
+    if (upstreamStatus !== 'fresh') return false;
+    if ((readNumberValue(git.ahead) ?? 0) !== 0) return false;
+    if ((readNumberValue(git.behind) ?? 0) <= 0) return false;
+    const hasConflicts = readBooleanValue(git.hasConflicts)
+        ?? (Array.isArray(git.conflictFiles) && git.conflictFiles.length > 0);
+    if (hasConflicts) return false;
+    if ((readNumberValue(git.stashCount, git.stash_count) ?? 0) > 0) return false;
+    const submoduleDrift = getGitSubmoduleDriftState(git);
+    if (submoduleDrift.dirty || submoduleDrift.outOfSync) return false;
+    const dirty = readBooleanValue(git.dirty) ?? (countGitWorktreeChanges(git) > 0);
+    return dirty !== true && countGitWorktreeChanges(git) === 0;
+}
+
 function deriveMeshNodeHealthFromGit(git: Record<string, unknown> | null | undefined): 'online' | 'dirty' | 'degraded' {
     if (!git || readBooleanValue(git.isGitRepo) === false) return 'degraded';
     const branch = readStringValue(git.branch);
@@ -815,6 +835,12 @@ function applyInlineMeshBranchConvergence(mesh: any, node: any, status: Record<s
     status.isDirty = uncommittedChanges > 0;
     status.uncommittedChanges = uncommittedChanges;
     status.branchConvergence = buildInlineMeshBranchConvergence({ mesh, node, status });
+    status.autoFastForwardEligible = isInlineMeshAutoFastForwardEligible(git);
+    if (status.autoFastForwardEligible) {
+        status.suggestedAction = 'auto_fast_forward';
+    } else {
+        delete status.suggestedAction;
+    }
 }
 
 function summarizeInlineMeshBranchConvergence(nodes: Array<Record<string, unknown>>): Record<string, unknown> {
@@ -3308,6 +3334,7 @@ export class DaemonCommandRouter {
                         success: result.success === true,
                         result,
                         finalBranchConvergenceState: result.finalBranchConvergenceState,
+                        ...(result.blockerContext ? { blockerContext: result.blockerContext } : {}),
                     } : {}),
                 },
             });
@@ -3879,6 +3906,30 @@ export class DaemonCommandRouter {
                 };
             }
 
+            // Push logic: after a successful merge, either auto-push or surface push info
+            // so coordinators don't need manual discovery after each refine.
+            const requireApprovalForPush: boolean = (mesh as any)?.policy?.requireApprovalForPush ?? DEFAULT_MESH_POLICY.requireApprovalForPush;
+            let pushResult: Record<string, unknown> | undefined;
+            if (!requireApprovalForPush) {
+                const pushStarted = Date.now();
+                try {
+                    await execFileAsync('git', ['push', 'origin', baseBranch], { cwd: repoRoot, encoding: 'utf8' });
+                    pushResult = { pushed: true, remote: 'origin', branch: baseBranch, durationMs: Date.now() - pushStarted };
+                    recordMeshRefineStage(refineStages, 'push', 'passed', pushStarted, pushResult);
+                    finalBranchConvergenceState.status = 'merged_pushed';
+                } catch (e: any) {
+                    pushResult = {
+                        pushed: false,
+                        remote: 'origin',
+                        branch: baseBranch,
+                        error: e?.message || String(e),
+                        stderr: e?.stderr,
+                        durationMs: Date.now() - pushStarted,
+                    };
+                    recordMeshRefineStage(refineStages, 'push', 'failed', pushStarted, pushResult);
+                }
+            }
+
             return {
                 success: true,
                 merged: true,
@@ -3893,6 +3944,14 @@ export class DaemonCommandRouter {
                 refineStages,
                 ...(ledgerError ? { ledgerError } : {}),
                 finalBranchConvergenceState,
+                // Push outcome or readiness info for coordinator.
+                ...(pushResult
+                    ? { pushResult }
+                    : {
+                        pushReady: true,
+                        pushCommand: `git push origin ${baseBranch}`,
+                        pushNote: 'requireApprovalForPush is enabled — run the push command or obtain user approval before pushing.',
+                    }),
             };
         } catch (e: any) {
             return { success: false, error: e.message, refineStages };
@@ -3927,9 +3986,59 @@ export class DaemonCommandRouter {
                                 ? 'cleanup_failed'
                                 : 'merge_failed'; // fallback for unclassified failures
         const isTerminalSuccess = refineTerminalKind === 'completed';
+
+        // Build structured blocker context for task_failed ledger entries so coordinators
+        // can inspect the failure cause without parsing free-form error strings.
+        const blockerContext: Record<string, unknown> | undefined = isTerminalSuccess ? undefined : (() => {
+            const code = typeof result.code === 'string' ? result.code : refineTerminalKind;
+            const stage = refineTerminalKind === 'validation_failed' ? 'validation'
+                : refineTerminalKind === 'submodule_reachability_failed' ? 'submodule_reachability'
+                : refineCode === 'patch_equivalence_failed' ? 'patch_equivalence'
+                : refineCode === 'needs_rebase' || refineCode === 'needs_rebase_with_conflicts' ? 'patch_equivalence'
+                : refineTerminalKind === 'merge_failed' ? 'merge'
+                : refineTerminalKind === 'cleanup_failed' ? 'cleanup'
+                : 'unknown';
+            const ctx: Record<string, unknown> = {
+                stage,
+                reason: code,
+                terminalKind: refineTerminalKind,
+            };
+            if (typeof result.error === 'string') ctx.error = result.error;
+            if (typeof result.blockedReason === 'string') ctx.blockedReason = result.blockedReason;
+            // Patch equivalence details
+            if (stage === 'patch_equivalence' && result.patchEquivalence) {
+                const pe = result.patchEquivalence as Record<string, unknown>;
+                ctx.details = {
+                    expectedPatchId: pe.expectedPatchId,
+                    actualPatchId: pe.actualPatchId,
+                    status: pe.status,
+                    actionableHint: pe.actionableHint,
+                    error: pe.error,
+                };
+            }
+            // Submodule reachability details
+            if (stage === 'submodule_reachability' && Array.isArray(result.unreachableSubmoduleCommits)) {
+                ctx.details = {
+                    unreachableCount: (result.unreachableSubmoduleCommits as unknown[]).length,
+                    paths: (result.unreachableSubmoduleCommits as Array<Record<string, unknown>>).map(e => e.path),
+                    autoPublishAllowed: (result.unreachableSubmoduleCommits as Array<Record<string, unknown>>)[0]?.autoPublishAllowed,
+                };
+            }
+            // Validation details
+            if (stage === 'validation' && result.validationSummary) {
+                const vs = result.validationSummary as Record<string, unknown>;
+                ctx.details = {
+                    failureCode: vs.failureCode,
+                    commandsRun: Array.isArray(vs.commandsRun) ? vs.commandsRun.length : undefined,
+                };
+            }
+            return ctx;
+        })();
+
         const normalizedResult = {
             ...result,
             terminalKind: refineTerminalKind,
+            ...(blockerContext ? { blockerContext } : {}),
             ...(result.nextStep === undefined && !isTerminalSuccess ? {
                 nextStep: refineTerminalKind === 'blocked_review'
                     ? 'Request user review/approval before attempting to merge again.'

package/src/config/mesh-config.ts

@@ -95,7 +95,17 @@ const SESSION_CLEANUP_MODES = new Set(['preserve', 'stop', 'delete_stopped', 'st
 const SPAWNED_SESSION_VISIBILITY_MODES = new Set(['visible', 'hidden']);
 
 function mergeMeshPolicy(base: RepoMeshPolicy | undefined, patch: Partial<RepoMeshPolicy> | undefined): RepoMeshPolicy {
-    const policy: RepoMeshPolicy = { ...DEFAULT_MESH_POLICY, ...(base || {}), ...(patch || {}) };
+    const autoFastForward = normalizeAutoFastForwardPolicy({
+        ...DEFAULT_MESH_POLICY.autoFastForward,
+        ...((base?.autoFastForward && typeof base.autoFastForward === 'object') ? base.autoFastForward : {}),
+        ...((patch?.autoFastForward && typeof patch.autoFastForward === 'object') ? patch.autoFastForward : {}),
+    });
+    const policy: RepoMeshPolicy = {
+        ...DEFAULT_MESH_POLICY,
+        ...(base || {}),
+        ...(patch || {}),
+        autoFastForward,
+    };
     if (!['block', 'warn', 'checkpoint_then_continue'].includes(policy.dirtyWorkspaceBehavior)) {
         policy.dirtyWorkspaceBehavior = 'warn';
     }
@@ -111,6 +121,18 @@ function mergeMeshPolicy(base: RepoMeshPolicy | undefined, patch: Partial<RepoMe
     return policy;
 }
 
+function normalizeAutoFastForwardPolicy(value: unknown): NonNullable<RepoMeshPolicy['autoFastForward']> {
+    const record = value && typeof value === 'object' && !Array.isArray(value)
+        ? value as Record<string, unknown>
+        : {};
+    const maxBehind = Number(record.maxBehind);
+    return {
+        enabled: record.enabled !== false,
+        ...(Number.isFinite(maxBehind) && maxBehind >= 0 ? { maxBehind: Math.floor(maxBehind) } : {}),
+        requireCleanSubmodules: record.requireCleanSubmodules !== false,
+    };
+}
+
 export function listMeshes(): LocalMeshEntry[] {
     return loadMeshConfig().meshes;
 }

package/src/mesh/mesh-events-coordinator.ts

@@ -349,6 +349,39 @@ function isDirtyNode(node: any): boolean {
     return node?.health === 'dirty' || node?.git?.dirty === true;
 }
 
+function resolveAutoFastForwardPolicy(mesh: any): { enabled: boolean; maxBehind?: number; requireCleanSubmodules: boolean } {
+    const record = mesh?.policy?.autoFastForward && typeof mesh.policy.autoFastForward === 'object' && !Array.isArray(mesh.policy.autoFastForward)
+        ? mesh.policy.autoFastForward as Record<string, unknown>
+        : {};
+    const maxBehind = Number(record.maxBehind);
+    return {
+        enabled: record.enabled !== false,
+        ...(Number.isFinite(maxBehind) && maxBehind >= 0 ? { maxBehind: Math.floor(maxBehind) } : {}),
+        requireCleanSubmodules: record.requireCleanSubmodules !== false,
+    };
+}
+
+function sessionStateLooksActive(state: any): boolean {
+    const status = readNonEmptyString(state?.status).toLowerCase();
+    const chatStatus = readNonEmptyString(state?.activeChat?.status).toLowerCase();
+    const active = new Set(['generating', 'streaming', 'long_generating', 'working', 'starting', 'waiting_approval']);
+    return active.has(status) || active.has(chatStatus);
+}
+
+function nodeHasActiveMeshWork(components: DaemonComponents, meshId: string, nodeId: string, currentSessionId?: string): boolean {
+    if (nodeHasActiveAssignment(meshId, nodeId)) return true;
+    return components.instanceManager.getByCategory('cli').some((inst: any) => {
+        const state = inst.getState();
+        const settings = state.settings as Record<string, unknown> || {};
+        if (readNonEmptyString(settings.meshNodeFor) !== meshId) return false;
+        const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
+        if (instNodeId !== nodeId) return false;
+        const sessionId = readNonEmptyString(state.instanceId);
+        if (currentSessionId && sessionId === currentSessionId && isIdleSessionState(state)) return false;
+        return sessionStateLooksActive(state);
+    });
+}
+
 function isLaunchableNode(node: any): boolean {
     if (!node || node.status === 'disabled' || node.status === 'removed') return false;
     const health = readNonEmptyString(node.health).toLowerCase();
@@ -759,6 +792,10 @@ async function maybeAutoFastForwardIdleNode(components: DaemonComponents, args:
     if (!workspace) return;
     if (!existsSync(workspace)) return;
 
+    const policy = resolveAutoFastForwardPolicy(mesh);
+    if (!policy.enabled) return;
+    if (nodeHasActiveMeshWork(components, args.meshId, args.nodeId, args.sessionId)) return;
+
     const throttleKey = `${args.meshId}:${args.nodeId}`;
     const now = Date.now();
     const lastAttempt = idleAutoFastForwardLastAttempt.get(throttleKey) || 0;
@@ -780,6 +817,12 @@ async function maybeAutoFastForwardIdleNode(components: DaemonComponents, args:
             trigger: 'idle_auto',
         });
         if (!dryRun || dryRun.code !== 'fast_forward_available' || dryRun.allowed !== true) return;
+        const behind = Number(dryRun.current?.behind);
+        if (policy.maxBehind !== undefined && Number.isFinite(behind) && behind > policy.maxBehind) return;
+        if (policy.requireCleanSubmodules) {
+            const submodules = Array.isArray(dryRun.current?.submodules) ? dryRun.current.submodules : [];
+            if (submodules.some((submodule: any) => submodule?.dirty || submodule?.outOfSync || submodule?.error)) return;
+        }
         await fastForwardMeshNode({
             meshId: args.meshId,
             nodeId: args.nodeId,

package/src/providers/native-history/codex-cli-transcript.ts

@@ -159,6 +159,44 @@ function extractToolOutputContent(payload: Record<string, unknown>): string {
   return '';
 }
 
+function hasAssistantStandardMessageSinceLastUser(records: NativeHistoryMessage[], content: string): boolean {
+  const normalized = content.trim();
+  if (!normalized) return false;
+  for (let i = records.length - 1; i >= 0; i--) {
+    const record = records[i];
+    if (record.kind === 'session_start') continue;
+    if (record.role === 'user') return false;
+    if (record.role === 'assistant' && record.kind === 'standard' && record.content.trim() === normalized) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function pushAssistantStandardMessage(
+  records: NativeHistoryMessage[],
+  sessionId: string,
+  receivedAt: number,
+  content: string,
+  workspace?: string,
+): void {
+  const text = content.trim();
+  if (!text) return;
+  if (hasAssistantStandardMessageSinceLastUser(records, text)) return;
+
+  const msg: NativeHistoryMessage = {
+    ts: new Date(receivedAt).toISOString(),
+    receivedAt,
+    role: 'assistant',
+    content: text,
+    kind: 'standard',
+    agent: 'codex-cli',
+    historySessionId: sessionId,
+  };
+  if (workspace) msg.workspace = workspace;
+  records.push(msg);
+}
+
 /**
  * Read the first line of a Codex JSONL session file and parse the session_meta record.
  * Returns the payload object (containing id, cwd, etc.) or null.
@@ -233,16 +271,38 @@ function parseSessionFile(
       continue;
     }
 
-    if (type !== 'response_item') continue;
-
     const payloadType = String(payload.type ?? '').trim();
 
+    if (type === 'event_msg') {
+      if (payloadType === 'task_complete') {
+        pushAssistantStandardMessage(
+          records,
+          sessionId,
+          receivedAt,
+          flattenCodexContent(payload.last_agent_message),
+          detectedWorkspace,
+        );
+      } else if (payloadType === 'agent_message' && String(payload.phase ?? '').trim() === 'final_answer') {
+        pushAssistantStandardMessage(
+          records,
+          sessionId,
+          receivedAt,
+          flattenCodexContent(payload.message),
+          detectedWorkspace,
+        );
+      }
+      continue;
+    }
+
+    if (type !== 'response_item') continue;
+
     if (payloadType === 'message') {
       const role = String(payload.role ?? '').trim();
       if (role !== 'user' && role !== 'assistant') continue;
 
       const content = flattenCodexContent(payload.content);
       if (!content) continue;
+      if (role === 'assistant' && hasAssistantStandardMessageSinceLastUser(records, content)) continue;
 
       const msg: NativeHistoryMessage = {
         ts: new Date(receivedAt).toISOString(),

package/src/repo-mesh-types.ts

@@ -90,6 +90,15 @@ export type RepoMeshNodeHealth =
 export type RepoMeshSessionCleanupMode = 'preserve' | 'stop' | 'delete_stopped' | 'stop_and_delete';
 export type RepoMeshSpawnedSessionVisibility = 'visible' | 'hidden';
 
+export interface RepoMeshAutoFastForwardPolicy {
+    /** Defaults to true. Set false to disable daemon-initiated idle fast-forwards. */
+    enabled: boolean;
+    /** Maximum behind count eligible for automatic fast-forward. Missing means no limit. */
+    maxBehind?: number;
+    /** Defaults to true. Require submodule status to be clean before automatic fast-forward. */
+    requireCleanSubmodules?: boolean;
+}
+
 export interface RepoMeshPolicy {
     requirePreTaskCheckpoint: boolean;
     requirePostTaskCheckpoint: boolean;
@@ -117,6 +126,11 @@ export interface RepoMeshPolicy {
      * runtimes are never stopped/deleted unless the mesh owner opts in.
      */
     sessionCleanupOnNodeRemove?: RepoMeshSessionCleanupMode;
+    /**
+     * Daemon-initiated fast-forward for idle clean nodes that are only behind
+     * their tracked upstream. Defaults to enabled.
+     */
+    autoFastForward?: RepoMeshAutoFastForwardPolicy;
     /**
      * Maximum number of automatic retry recommendations for a failed task on the
      * same node before the daemon advises the coordinator to escalate or reassign.
@@ -171,6 +185,7 @@ export const DEFAULT_MESH_POLICY: RepoMeshPolicy = {
     maxParallelTasks: 2,
     spawnedSessionVisibility: 'visible',
     sessionCleanupOnNodeRemove: 'preserve',
+    autoFastForward: { enabled: true },
     maxTaskRetries: 1,
 };
 
@@ -415,6 +430,10 @@ export interface RepoMeshNodeStatus {
     activeSessionDetails?: RepoMeshSessionStatus[];
     providerPriority?: string[];
     launchReady?: boolean;
+    /** True when the node is clean, ahead=0, behind>0, and safe for fast-forward consideration. */
+    autoFastForwardEligible?: boolean;
+    /** Coordinator-facing suggestion for obvious clean catch-up work. */
+    suggestedAction?: 'auto_fast_forward';
     worktreeBootstrap?: LocalMeshNodeEntry['worktreeBootstrap'];
     launchBlockedReason?: string;
     launchBlockedMessage?: string;