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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.213",
+  "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';
@@ -3333,6 +3334,7 @@ export class DaemonCommandRouter {
                         success: result.success === true,
                         result,
                         finalBranchConvergenceState: result.finalBranchConvergenceState,
+                        ...(result.blockerContext ? { blockerContext: result.blockerContext } : {}),
                     } : {}),
                 },
             });
@@ -3904,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,
@@ -3918,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 };
@@ -3952,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/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(),