@straiffi/archon 1.10.8 → 1.10.10

package/dist/server/lib/failedBuildSequenceRecovery.js

@@ -0,0 +1,133 @@
+import db from '../db.js';
+// Legacy resumes have no workload tag. Require the exact stopped parent and
+// pre-provider failure evidence instead of inferring continuation from a ticket session.
+// UNION also terminates malformed retry cycles; only a chain reaching the bound
+// legacy failure, with exclusively pre-start queue failures after it, is admitted.
+export const getFailedBuildSequenceRecovery = (projectId, runId, replacementRunId = null) => db.prepare(`
+  WITH RECURSIVE recovery_chain(id, retry_of_run_id) AS (
+    SELECT id, retry_of_run_id FROM execution_runs WHERE id = @source AND project_id = @project
+    UNION
+    SELECT prior.id, prior.retry_of_run_id FROM execution_runs prior
+    JOIN recovery_chain child ON child.retry_of_run_id = prior.id WHERE prior.project_id = @project
+  )
+  SELECT sequence.id AS sequenceId, ticket.id AS ticketId, ticket.session_id AS sessionId,
+    original.id AS parentRunId, failed.id AS boundRunId, item.finished_at AS finishedAt
+  FROM execution_runs failed
+  JOIN recovery_chain root ON root.id = failed.id
+  JOIN execution_runs original ON original.id = failed.parent_run_id AND original.project_id = failed.project_id
+  JOIN build_sequence_tickets item ON item.activation_execution_run_id = failed.id
+  JOIN build_sequences sequence ON sequence.id = item.build_sequence_id AND sequence.project_id = failed.project_id
+  JOIN tickets ticket ON ticket.id = item.ticket_id AND ticket.project_id = failed.project_id
+  WHERE failed.project_id = @project
+    AND failed.kind = 'build' AND failed.status = 'failed' AND failed.domain_status = 'error'
+    AND failed.initiated_by = 'user' AND failed.retry_of_run_id IS NULL
+    AND failed.failure_code = 'build_failed'
+    AND failed.failure_message = 'Execution run authority workload does not match the durable run intent'
+    AND (json_type(failed.metadata_json, '$.build_workload') IS NULL
+      OR json_extract(failed.metadata_json, '$.build_workload') = 'build_continuation')
+    AND original.kind = 'build' AND original.status = 'cancelled' AND original.domain_status = 'stopped'
+    AND original.initiated_by = 'user'
+    AND sequence.status = 'failed' AND item.status = 'failed'
+    AND item.execution_profile_revision_id IS NOT NULL AND item.execution_profile_fingerprint IS NOT NULL
+    AND item.execution_profile_selection_reason IS NOT NULL
+    AND ticket.worktree_bundle_id = sequence.worktree_bundle_id
+    AND ticket.state = 'build' AND ticket.agent_status = 'error'
+    AND ticket.build_completed_at IS NULL AND length(ticket.session_id) > 0
+    AND ticket.tool = json_extract(original.metadata_json, '$.retry_tool')
+    AND ticket.model IS json_extract(original.metadata_json, '$.retry_model')
+    AND ticket.variant IS json_extract(original.metadata_json, '$.retry_variant')
+    AND EXISTS (SELECT 1 FROM agent_runs agent WHERE agent.execution_run_id = original.id
+      AND agent.parent_type = 'ticket' AND agent.parent_id = ticket.id AND agent.role = 'main'
+      AND agent.agent_status = 'stopped' AND agent.session_id = ticket.session_id)
+    AND EXISTS (SELECT 1 FROM agent_runs agent WHERE agent.execution_run_id = failed.id
+      AND agent.parent_type = 'ticket' AND agent.parent_id = ticket.id AND agent.role = 'main'
+      AND agent.agent_status = 'error' AND agent.session_id IS NULL)
+    AND NOT EXISTS (SELECT 1 FROM agent_runs agent WHERE agent.execution_run_id = failed.id
+      AND (agent.session_id IS NOT NULL OR agent.response_text IS NOT NULL OR agent.streaming_response IS NOT NULL
+        OR agent.role != 'main' OR agent.agent_status != 'error'))
+    AND NOT EXISTS (SELECT 1 FROM execution_run_authorities authority
+      WHERE authority.execution_run_id IN (SELECT id FROM recovery_chain))
+    AND NOT EXISTS (
+      SELECT 1 FROM execution_runs attempt JOIN recovery_chain chain ON chain.id = attempt.id
+      WHERE attempt.id != failed.id AND (
+        attempt.kind != 'build' OR attempt.status != 'failed' OR attempt.domain_status IS NOT 'error'
+        OR attempt.initiated_by != 'user' OR attempt.failure_code IS NOT 'queue_failed'
+        OR attempt.started_at IS NOT NULL OR attempt.parent_run_id IS NOT original.id
+        OR attempt.correlation_id != failed.correlation_id
+        OR json_extract(attempt.metadata_json, '$.build_workload') IS NOT 'build_continuation'
+        OR json_extract(attempt.metadata_json, '$.retry_model') IS NOT ticket.model
+        OR json_extract(attempt.metadata_json, '$.retry_variant') IS NOT ticket.variant
+        OR EXISTS (SELECT 1 FROM agent_runs agent WHERE agent.execution_run_id = attempt.id)
+        OR EXISTS (SELECT 1 FROM execution_run_links link
+          WHERE link.execution_run_id = attempt.id AND link.relationship = 'result')
+      )
+    )
+    AND NOT EXISTS (SELECT 1 FROM build_sequences busy WHERE busy.project_id = sequence.project_id
+      AND busy.worktree_bundle_id = sequence.worktree_bundle_id AND busy.status = 'active')
+    AND NOT EXISTS (SELECT 1 FROM build_sequence_tickets other WHERE other.build_sequence_id = sequence.id
+       AND other.ticket_id != ticket.id AND other.status != 'done')
+    AND NOT EXISTS (SELECT 1 FROM execution_runs newer
+      JOIN execution_run_links link ON link.execution_run_id = newer.id AND link.project_id = newer.project_id
+      WHERE newer.project_id = failed.project_id AND link.entity_type = 'ticket'
+        AND link.entity_id = ticket.id AND link.relationship = 'primary' AND newer.id IS NOT @replacement
+        AND newer.id NOT IN (SELECT id FROM recovery_chain)
+        AND (newer.status IN ('queued', 'running', 'waiting')
+          OR (newer.created_at, newer.id) > (failed.created_at, failed.id)))
+    AND NOT EXISTS (SELECT 1 FROM execution_runs retry
+      WHERE retry.retry_of_run_id IN (SELECT id FROM recovery_chain)
+        AND retry.id NOT IN (SELECT id FROM recovery_chain) AND retry.id IS NOT @replacement)
+    AND NOT EXISTS (
+      SELECT 1 FROM execution_runs owner WHERE (owner.id = original.id OR owner.id IN (SELECT id FROM recovery_chain))
+      AND (json_extract(owner.metadata_json, '$.execution_profile_revision_id') IS NOT item.execution_profile_revision_id
+        OR json_extract(owner.metadata_json, '$.execution_profile_fingerprint') IS NOT item.execution_profile_fingerprint
+        OR json_extract(owner.metadata_json, '$.execution_profile_selection_reason') IS NOT item.execution_profile_selection_reason
+        OR json_extract(owner.metadata_json, '$.retry_tool') IS NOT ticket.tool
+        OR NOT EXISTS (SELECT 1 FROM execution_run_links link WHERE link.execution_run_id = owner.id
+          AND link.project_id = failed.project_id AND link.entity_type = 'ticket' AND link.entity_id = ticket.id AND link.relationship = 'primary')
+        OR NOT EXISTS (SELECT 1 FROM execution_run_links link WHERE link.execution_run_id = owner.id
+          AND link.project_id = failed.project_id AND link.entity_type = 'bundle' AND link.entity_id = sequence.worktree_bundle_id AND link.relationship = 'context')
+        OR NOT EXISTS (SELECT 1 FROM execution_run_links link WHERE link.execution_run_id = owner.id
+          AND link.project_id = failed.project_id AND link.entity_type = 'build_sequence' AND link.entity_id = sequence.id AND link.relationship = 'context'))
+    )
+`).get({ replacement: replacementRunId, source: runId, project: projectId });
+export const handoffFailedBuildSequenceRecovery = (projectId, sequenceId, ticketId, sessionId, replacementRunId) => {
+    const next = db.prepare(`SELECT retry_of_run_id AS sourceId FROM execution_runs
+    WHERE id = ? AND project_id = ? AND kind = 'build' AND status = 'queued'
+      AND initiated_by = 'user' AND json_extract(metadata_json, '$.build_workload') = 'build_continuation'`)
+        .get(replacementRunId, projectId);
+    if (!next?.sourceId) {
+        return null;
+    }
+    const recovery = getFailedBuildSequenceRecovery(projectId, next.sourceId, replacementRunId);
+    if (!recovery || recovery.sequenceId !== sequenceId || recovery.ticketId !== ticketId || recovery.sessionId !== sessionId) {
+        throw new Error('The failed Build resume has no verified recovery lineage');
+    }
+    const matching = db.prepare(`SELECT 1 FROM execution_runs next
+    JOIN build_sequence_tickets item ON item.build_sequence_id = ? AND item.ticket_id = ?
+    WHERE next.id = ? AND next.parent_run_id = ?
+      AND EXISTS (SELECT 1 FROM execution_run_links link WHERE link.execution_run_id = next.id
+        AND link.project_id = next.project_id AND link.entity_type = 'ticket' AND link.entity_id = item.ticket_id AND link.relationship = 'primary')
+      AND EXISTS (SELECT 1 FROM execution_run_links link WHERE link.execution_run_id = next.id
+        AND link.project_id = next.project_id AND link.entity_type = 'build_sequence' AND link.entity_id = item.build_sequence_id AND link.relationship = 'context')
+      AND json_extract(next.metadata_json, '$.execution_profile_revision_id') = item.execution_profile_revision_id
+      AND json_extract(next.metadata_json, '$.execution_profile_fingerprint') = item.execution_profile_fingerprint
+      AND json_extract(next.metadata_json, '$.execution_profile_selection_reason') = item.execution_profile_selection_reason`)
+        .get(sequenceId, ticketId, replacementRunId, recovery.parentRunId);
+    if (!matching) {
+        throw new Error('The failed Build resume recovery profile does not match');
+    }
+    db.prepare("UPDATE build_sequences SET status = 'active', updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(sequenceId);
+    db.prepare(`UPDATE build_sequence_tickets SET status = 'active', finished_at = NULL, activation_execution_run_id = ?
+    WHERE build_sequence_id = ? AND ticket_id = ?`).run(replacementRunId, sequenceId, ticketId);
+    return () => {
+        const restored = db.prepare(`UPDATE build_sequence_tickets SET status = 'failed', finished_at = ?, activation_execution_run_id = ?
+      WHERE build_sequence_id = ? AND ticket_id = ? AND status = 'active' AND activation_execution_run_id = ?
+        AND EXISTS (SELECT 1 FROM execution_runs WHERE id = ? AND status = 'queued')`)
+            .run(recovery.finishedAt, recovery.boundRunId, sequenceId, ticketId, replacementRunId, replacementRunId);
+        if (restored.changes !== 1) {
+            throw new Error('Unable to restore the failed Build sequence');
+        }
+        db.prepare("UPDATE build_sequences SET status = 'failed', updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(sequenceId);
+    };
+};
+//# sourceMappingURL=failedBuildSequenceRecovery.js.map

package/dist/server/lib/failedBuildSequenceRecovery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"failedBuildSequenceRecovery.js","sourceRoot":"","sources":["../../../server/lib/failedBuildSequenceRecovery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,UAAU,CAAA;AAEzB,4EAA4E;AAC5E,yFAAyF;AACzF,gFAAgF;AAChF,mFAAmF;AACnF,MAAM,CAAC,MAAM,8BAA8B,GAAG,CAAC,SAAiB,EAAE,KAAa,EAAE,mBAAkC,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsFtI,CAAC,CAAC,GAAG,CAAC,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,CAE9D,CAAA;AAEb,MAAM,CAAC,MAAM,kCAAkC,GAAG,CAChD,SAAiB,EAAE,UAAkB,EAAE,QAAgB,EAAE,SAAiB,EAAE,gBAAwB,EAC/E,EAAE;IACvB,MAAM,IAAI,GAAG,EAAE,CAAC,OAAO,CAAC;;2GAEiF,CAAC;SACvG,GAAG,CAAC,gBAAgB,EAAE,SAAS,CAA4C,CAAA;IAC9E,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,CAAC;QACpB,OAAO,IAAI,CAAA;IACb,CAAC;IACD,MAAM,QAAQ,GAAG,8BAA8B,CAAC,SAAS,EAAE,IAAI,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAA;IAC3F,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,UAAU,KAAK,UAAU,IAAI,QAAQ,CAAC,QAAQ,KAAK,QAAQ,IAAI,QAAQ,CAAC,SAAS,KAAK,SAAS,EAAE,CAAC;QAC1H,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAA;IAC7E,CAAC;IACD,MAAM,QAAQ,GAAG,EAAE,CAAC,OAAO,CAAC;;;;;;;;;6HAS+F,CAAC;SACzH,GAAG,CAAC,UAAU,EAAE,QAAQ,EAAE,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAA;IACpE,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAA;IAC5E,CAAC;IACD,EAAE,CAAC,OAAO,CAAC,2FAA2F,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;IACvH,EAAE,CAAC,OAAO,CAAC;kDACqC,CAAC,CAAC,GAAG,CAAC,gBAAgB,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAA;IAC7F,OAAO,GAAG,EAAE;QACV,MAAM,QAAQ,GAAG,EAAE,CAAC,OAAO,CAAC;;qFAEqD,CAAC;aAC/E,GAAG,CAAC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAE,gBAAgB,EAAE,gBAAgB,CAAC,CAAA;QAC1G,IAAI,QAAQ,CAAC,OAAO,KAAK,CAAC,EAAE,CAAC;YAC3B,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAA;QAChE,CAAC;QACD,EAAE,CAAC,OAAO,CAAC,2FAA2F,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;IACzH,CAAC,CAAA;AACH,CAAC,CAAA"}

package/dist/server/lib/git.js

@@ -5,6 +5,7 @@ import { cp as cpAsync, lstat as lstatAsync, mkdir as mkdirAsync, stat as statAs
 import { tmpdir } from 'os';
 import { dirname, isAbsolute, join, relative, resolve } from 'path';
 import db from '../db.js';
+import { runBoundedProcess } from './boundedProcess.js';
 import { getProjectWorktreeSync } from './projects.js';
 import { createWorkspaceProcessEnvironment } from './workspaceProcessEnvironment.js';
 export class UnpushedCommitDiffSelectionError extends Error {
@@ -12,8 +13,10 @@ export class UnpushedCommitDiffSelectionError extends Error {
 const PROJECT_BRANCH_REMOTE_REFRESH_TTL_MS = 30_000;
 const MAX_GIT_OUTPUT_BYTES = 512 * 1024 * 1024;
 const GIT_READ_TIMEOUT_MS = 15_000;
+const GIT_REMOTE_KILL_GRACE_MS = 500;
 const MAX_CONCURRENT_DIFF_PROCESSES = 8;
 const lastProjectBranchRemoteRefreshAt = new Map();
+const projectBranchRemoteRefreshes = new Map();
 const resolveCurrentBranchName = (cwd) => {
     try {
         const branch = runGitText(['branch', '--show-current'], cwd).trim();
@@ -113,6 +116,22 @@ const runGitTextAsync = (args, cwd, options = {}) => new Promise((resolvePromise
         });
     });
 });
+const runGitRemoteTextAsync = async (args, cwd) => {
+    const result = await runBoundedProcess('git', args, {
+        cwd,
+        env: createWorkspaceProcessEnvironment(cwd, { GIT_TERMINAL_PROMPT: '0' }),
+        timeoutMs: GIT_READ_TIMEOUT_MS,
+        killGraceMs: GIT_REMOTE_KILL_GRACE_MS,
+        maxOutputBytes: MAX_GIT_OUTPUT_BYTES,
+    });
+    if (result.code !== 0) {
+        const error = new Error(result.stderr.trim() || `git exited with code ${result.code ?? 'unknown'}`);
+        error.stderr = result.stderr;
+        error.status = result.code;
+        throw error;
+    }
+    return { stdout: result.stdout, stderr: result.stderr };
+};
 const mapWithConcurrency = async (inputs, concurrency, operation) => {
     const results = new Array(inputs.length);
     let nextIndex = 0;
@@ -357,7 +376,7 @@ const refreshSquashUpstream = async (branch, cwd) => {
         return localUpstreamCommitSha;
     }
     try {
-        await runGitTextAsync(['fetch', '--quiet', fetchSpec.remote, fetchSpec.branch], cwd);
+        await runGitRemoteTextAsync(['fetch', '--quiet', fetchSpec.remote, fetchSpec.branch], cwd);
     }
     catch {
         throw new Error('Unable to refresh the upstream branch before squashing commits. Pull or reconcile the branch and try again.');
@@ -477,21 +496,6 @@ const getEmptyProjectBranchResponse = (status = 'unknown') => ({
     can_pull: false,
     diff_stats: null,
 });
-const refreshProjectBranchTracking = (repoPath, branch) => {
-    if (!branch) {
-        return;
-    }
-    try {
-        const upstreamFetchSpec = resolveBranchUpstreamFetchSpec(branch, repoPath);
-        const args = upstreamFetchSpec
-            ? ['fetch', '--quiet', upstreamFetchSpec.remote, upstreamFetchSpec.branch]
-            : ['fetch', '--quiet', 'origin', branch];
-        runGitText(args, repoPath);
-    }
-    catch {
-        // Keep the last known tracking state when fetch is unavailable.
-    }
-};
 const shouldRefreshProjectBranchTracking = (cacheKey, force) => {
     if (force) {
         lastProjectBranchRemoteRefreshAt.set(cacheKey, Date.now());
@@ -1390,15 +1394,9 @@ export const deleteWorktree = (branch, project = null) => {
 export const getProjectBranch = (project = null, options = {}) => {
     const repoPath = getRepoPath(project);
     const includeDiffStats = options.includeDiffStats ?? true;
-    let output = runGitText(['status', '--porcelain=v2', '--branch', '-z'], repoPath);
-    let entries = output.split('\0').filter(Boolean);
-    let branchState = getBranchSyncState(entries, repoPath);
-    if (branchState.branch && shouldRefreshProjectBranchTracking(getProjectBranchRefreshCacheKey(repoPath, branchState.branch), options.refreshRemote ?? false)) {
-        refreshProjectBranchTracking(repoPath, branchState.branch);
-        output = runGitText(['status', '--porcelain=v2', '--branch', '-z'], repoPath);
-        entries = output.split('\0').filter(Boolean);
-        branchState = getBranchSyncState(entries, repoPath);
-    }
+    const output = runGitText(['status', '--porcelain=v2', '--branch', '-z'], repoPath);
+    const entries = output.split('\0').filter(Boolean);
+    const branchState = getBranchSyncState(entries, repoPath);
     if (!branchState.branch) {
         const statusLine = output.split('\0').find(entry => entry.startsWith('# branch.head ')) ?? '';
         if (statusLine.endsWith('(detached)')) {
@@ -1416,13 +1414,46 @@ export const getProjectBranch = (project = null, options = {}) => {
         diff_stats: includeDiffStats ? summarizeTicketDiffFiles(getGitDiffFiles(repoPath)) : null,
     };
 };
+export const getProjectBranchAsync = async (project = null, options = {}) => {
+    const repoPath = getRepoPath(project);
+    const includeDiffStats = options.includeDiffStats ?? true;
+    const readBranchState = async () => {
+        const output = (await runGitTextAsync(['status', '--porcelain=v2', '--branch', '-z'], repoPath, { timeoutMs: GIT_READ_TIMEOUT_MS })).stdout;
+        const entries = output.split('\0').filter(Boolean);
+        const branchState = await getBranchSyncStateAsync(entries, repoPath, null);
+        return { output, branchState };
+    };
+    let { output, branchState } = await readBranchState();
+    if (branchState.branch && shouldRefreshProjectBranchTracking(getProjectBranchRefreshCacheKey(repoPath, branchState.branch), options.refreshRemote ?? false)) {
+        await refreshProjectBranchTrackingAsync(repoPath, branchState.branch);
+        const refreshed = await readBranchState();
+        output = refreshed.output;
+        branchState = refreshed.branchState;
+    }
+    if (!branchState.branch) {
+        const statusLine = output.split('\0').find(entry => entry.startsWith('# branch.head ')) ?? '';
+        return getEmptyProjectBranchResponse(statusLine.endsWith('(detached)') ? 'detached' : 'unknown');
+    }
+    const diffStats = includeDiffStats
+        ? summarizeTicketDiffFiles(await getGitDiffFilesAsync(repoPath))
+        : null;
+    return {
+        branch: branchState.branch,
+        status: 'ready',
+        ahead: branchState.ahead,
+        behind: branchState.behind,
+        has_upstream: branchState.hasUpstream,
+        can_pull: branchState.behind > 0,
+        diff_stats: diffStats,
+    };
+};
 export const getLocalProjectBranch = (project = null) => {
     const repoPath = getRepoPath(project);
     const output = runGitText(['status', '--porcelain=v2', '--branch', '-z'], repoPath);
     return getBranchSyncState(output.split('\0').filter(Boolean), repoPath).branch;
 };
 export const pullGitBranch = async (cwd, branch = null, project = null) => {
-    const gitStatus = getGitStatus(cwd, branch, project, { refreshRemote: true });
+    const gitStatus = await getGitStatusAsync(cwd, branch, project, { refreshRemote: true });
     if (gitStatus.pull_disabled_reason) {
         throw new Error(gitStatus.pull_disabled_reason);
     }
@@ -1433,16 +1464,16 @@ export const pullGitBranch = async (cwd, branch = null, project = null) => {
     if (!upstreamFetchSpec) {
         throw new Error(`Branch "${gitStatus.branch}" has no configured upstream.`);
     }
-    await runGitTextAsync(['fetch', '--quiet', upstreamFetchSpec.remote, upstreamFetchSpec.branch], cwd);
+    await runGitRemoteTextAsync(['fetch', '--quiet', upstreamFetchSpec.remote, upstreamFetchSpec.branch], cwd);
     await runGitTextAsync(['merge', '--no-edit', 'FETCH_HEAD'], cwd);
 };
 export const pullProjectBranch = async (project = null) => {
     const repoPath = getRepoPath(project);
-    const branchState = getProjectBranch(project, { refreshRemote: true });
+    const branchState = getProjectBranch(project, { includeDiffStats: false });
     await pullGitBranch(repoPath, branchState.branch, project);
 };
 export const rebaseGitBranchOntoBase = async (cwd, branch = null, project = null, baseBranch = null) => {
-    const gitStatus = getGitStatus(cwd, branch, project, { refreshRemote: true });
+    const gitStatus = await getGitStatusAsync(cwd, branch, project, { refreshRemote: true });
     const resolvedBaseBranch = baseBranch?.trim() || gitStatus.base_branch;
     const rebaseDisabledReason = getRebaseDisabledReason(gitStatus, resolvedBaseBranch);
     if (rebaseDisabledReason) {
@@ -1454,7 +1485,7 @@ export const rebaseGitBranchOntoBase = async (cwd, branch = null, project = null
     if (!resolvedBaseBranch || resolvedBaseBranch === gitStatus.branch) {
         throw new Error('No base branch is available for this target.');
     }
-    await runGitTextAsync(['fetch', '--quiet', 'origin', resolvedBaseBranch], cwd);
+    await runGitRemoteTextAsync(['fetch', '--quiet', 'origin', resolvedBaseBranch], cwd);
     await runGitTextAsync(['rebase', `origin/${resolvedBaseBranch}`], cwd);
     if (project && resolve(cwd) !== getRepoPath(project)) {
         const nextBaseCommit = resolveCommitBaseFromBaseRef(resolveNamedBranchRef(resolvedBaseBranch, cwd), cwd);
@@ -1633,9 +1664,6 @@ const applyGitActionState = (status, options) => {
 export const getGitStatus = (cwd, branch = null, project = null, options = {}) => {
     const recordedBase = branch && project ? resolveRecordedBaseForCwd(cwd, branch, project) : null;
     const branchName = branch ?? resolveCurrentBranchName(cwd);
-    if (branchName && (options.refreshRemote ?? false) && shouldRefreshProjectBranchTracking(getProjectBranchRefreshCacheKey(cwd, branchName), options.refreshRemote ?? false)) {
-        refreshProjectBranchTracking(cwd, branchName);
-    }
     try {
         const output = runGitText(['status', '--porcelain=v2', '--branch', '--untracked-files=all', '-z'], cwd);
         const parsedOutput = parseGitStatusOutput(output);
@@ -1764,18 +1792,31 @@ const resolveFallbackBaseAsync = async (branch, project) => {
         return null;
     }
 };
-const refreshProjectBranchTrackingAsync = async (cwd, branch) => {
-    try {
-        const upstreamRef = await resolveBranchUpstreamRefAsync(branch, cwd);
-        const fetchSpec = parseRemoteBranchRef(upstreamRef);
-        const args = fetchSpec
-            ? ['fetch', '--quiet', fetchSpec.remote, fetchSpec.branch]
-            : ['fetch', '--quiet', 'origin', branch];
-        await runGitTextAsync(args, cwd, { timeoutMs: GIT_READ_TIMEOUT_MS });
-    }
-    catch {
-        // Keep the last known tracking state when fetch is unavailable.
+const refreshProjectBranchTrackingAsync = (cwd, branch) => {
+    const key = getProjectBranchRefreshCacheKey(cwd, branch);
+    const existing = projectBranchRemoteRefreshes.get(key);
+    if (existing) {
+        return existing;
     }
+    const refresh = (async () => {
+        try {
+            const upstreamRef = await resolveBranchUpstreamRefAsync(branch, cwd);
+            const fetchSpec = parseRemoteBranchRef(upstreamRef);
+            const args = fetchSpec
+                ? ['fetch', '--quiet', fetchSpec.remote, fetchSpec.branch]
+                : ['fetch', '--quiet', 'origin', branch];
+            await runGitRemoteTextAsync(args, cwd);
+        }
+        catch {
+            // Keep the last known tracking state when fetch is unavailable.
+        }
+    })().finally(() => {
+        if (projectBranchRemoteRefreshes.get(key) === refresh) {
+            projectBranchRemoteRefreshes.delete(key);
+        }
+    });
+    projectBranchRemoteRefreshes.set(key, refresh);
+    return refresh;
 };
 const getUnreadableGitStatus = () => ({
     branch: null,
@@ -1893,7 +1934,7 @@ export const getBoardGitStatus = (cwd, branch = null, project = null) => {
     return getGitStatus(cwd, branch, project, {
         refreshRemote: false,
         includeFiles: false,
-        includeWorkspaceSignature: false,
+        includeWorkspaceSignature: true,
     });
 };
 export const getBoardWorktreeGitStatus = (branch, project = null) => {
@@ -2168,7 +2209,7 @@ export const pushAutomationTarget = async (cwd, branch, targetSha, expectedOrigi
     if (expectedOriginIdentity && getAutomationRemoteIdentity(cwd) !== expectedOriginIdentity) {
         throw new Error('Automation origin remote changed after push intent was persisted');
     }
-    await runGitTextAsync(['push', '-u', 'origin', `${targetSha}:refs/heads/${branch}`], cwd);
+    await runGitRemoteTextAsync(['push', '-u', 'origin', `${targetSha}:refs/heads/${branch}`], cwd);
     if (expectedOriginIdentity && getAutomationRemoteIdentity(cwd) !== expectedOriginIdentity) {
         throw new Error('Automation origin remote changed while push was running');
     }
@@ -2236,7 +2277,7 @@ export const fetchRemoteBranchState = async (cwd, branch, expectedOriginIdentity
     }
     let output;
     try {
-        output = await runGitTextAsync(['ls-remote', '--exit-code', 'origin', `refs/heads/${branch}`], cwd);
+        output = await runGitRemoteTextAsync(['ls-remote', '--exit-code', 'origin', `refs/heads/${branch}`], cwd);
     }
     catch (error) {
         if (error.status === 2) {
@@ -2251,7 +2292,7 @@ export const fetchRemoteBranchState = async (cwd, branch, expectedOriginIdentity
     if (!sha || !ref || extra || ref !== `refs/heads/${branch}` || !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(sha)) {
         throw new Error('Remote branch observation was incomplete');
     }
-    await runGitTextAsync(['fetch', '--quiet', '--no-tags', 'origin', sha], cwd);
+    await runGitRemoteTextAsync(['fetch', '--quiet', '--no-tags', 'origin', sha], cwd);
     if (expectedOriginIdentity && getAutomationRemoteIdentity(cwd) !== expectedOriginIdentity) {
         throw new Error('Automation origin remote changed while observing push state');
     }