@taskforcehq/taskforce 0.3.324 → 0.3.327

package/dist/utils/taskReferences.d.ts

@@ -1,10 +1,25 @@
 import type { TaskItem } from '../types';
+import { type CanonicalEntityReferenceContract } from './entityReferences.js';
 export declare const TASK_REFERENCE_PREFIX = "T-";
 export declare const LOCAL_TASK_REFERENCE_PREFIX = "LT-";
 export interface TaskReferenceDisplayState {
     label: string;
     isProvisional: boolean;
 }
+export interface TaskReferenceContract {
+    resolve: (token: string) => string | null;
+    activate: (taskId: string) => void;
+    entityReferences?: CanonicalEntityReferenceContract;
+}
+export interface TaskReferenceIndex {
+    revision: string;
+    resolve: (token: string) => string | null;
+}
+type TaskReferenceSource = Pick<TaskItem, 'id' | 'referenceNumber' | 'referenceLabel' | 'localReferenceNumber'>;
+export declare const TASK_REFERENCE_TOKEN_PATTERN: RegExp;
+export declare function isTaskReferenceToken(value: string | null | undefined): boolean;
+export declare function resolveTaskReferenceId(tasks: TaskReferenceSource[], value: string | null | undefined): string | null;
+export declare function createTaskReferenceIndex(tasks: TaskReferenceSource[]): TaskReferenceIndex;
 export declare function formatTaskReference(value: number | Pick<TaskItem, 'referenceNumber'> | null | undefined): string;
 export declare function formatLocalTaskReference(value: number | Pick<TaskItem, 'localReferenceNumber'> | null | undefined): string;
 export declare function parseTaskReference(value: string | null | undefined): number | null;
@@ -13,3 +28,4 @@ export declare function getTaskReferenceLabel(task: Pick<TaskItem, 'referenceNum
 export declare function isTaskReferenceProvisional(task: Pick<TaskItem, 'referenceNumber' | 'localReferenceNumber'> | null | undefined): boolean;
 export declare function getTaskReferenceDisplayState(task: Pick<TaskItem, 'referenceNumber' | 'referenceLabel' | 'localReferenceNumber'> | null | undefined): TaskReferenceDisplayState;
 export declare function shouldUseProvisionalTaskReferences(runtimeMode: string | null | undefined): boolean;
+export {};

package/dist/utils/taskReferences.js

@@ -1,6 +1,69 @@
 import { formatEntityReference, getEntityReferenceLabel, parseEntityReference, } from './entityReferences.js';
 export const TASK_REFERENCE_PREFIX = 'T-';
 export const LOCAL_TASK_REFERENCE_PREFIX = 'LT-';
+const CURRENT_TASK_ID_PATTERN = /^task-[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i;
+const LEGACY_TASK_ID_PATTERN = /^task-\d{10,}-[a-z0-9]+$/i;
+export const TASK_REFERENCE_TOKEN_PATTERN = /(?<![\w-])((?:LT|T)-\d+|task-(?:[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}|\d{10,}-[a-z0-9]+))(?![\w-])/gi;
+export function isTaskReferenceToken(value) {
+    const normalized = String(value || '').trim();
+    return parseTaskReference(normalized) !== null
+        || parseLocalTaskReference(normalized) !== null
+        || CURRENT_TASK_ID_PATTERN.test(normalized)
+        || LEGACY_TASK_ID_PATTERN.test(normalized);
+}
+export function resolveTaskReferenceId(tasks, value) {
+    const token = String(value || '').trim();
+    if (!token || !isTaskReferenceToken(token))
+        return null;
+    const normalized = token.toLowerCase();
+    const canonicalReferenceNumber = parseTaskReference(token);
+    const localReferenceNumber = parseLocalTaskReference(token);
+    const matches = tasks.filter((task) => {
+        if (task.id.toLowerCase() === normalized)
+            return true;
+        if (canonicalReferenceNumber !== null && task.referenceNumber === canonicalReferenceNumber)
+            return true;
+        if (localReferenceNumber !== null && task.localReferenceNumber === localReferenceNumber)
+            return true;
+        return getTaskReferenceLabel(task).toLowerCase() === normalized;
+    });
+    return matches.length === 1 ? matches[0].id : null;
+}
+export function createTaskReferenceIndex(tasks) {
+    const referenceIds = new Map();
+    const addReference = (value, taskId) => {
+        const token = String(value || '').trim().toLowerCase();
+        if (!token)
+            return;
+        if (!referenceIds.has(token)) {
+            referenceIds.set(token, taskId);
+            return;
+        }
+        if (referenceIds.get(token) !== taskId) {
+            referenceIds.set(token, null);
+        }
+    };
+    tasks.forEach((task) => {
+        addReference(task.id, task.id);
+        if (task.referenceNumber) {
+            addReference(formatTaskReference(task.referenceNumber), task.id);
+        }
+        if (task.localReferenceNumber) {
+            addReference(formatLocalTaskReference(task.localReferenceNumber), task.id);
+        }
+        addReference(getTaskReferenceLabel(task), task.id);
+    });
+    const revision = JSON.stringify(Array.from(referenceIds.entries()).sort(([left], [right]) => left.localeCompare(right)));
+    return {
+        revision,
+        resolve: (value) => {
+            const token = String(value || '').trim();
+            if (!token || !isTaskReferenceToken(token))
+                return null;
+            return referenceIds.get(token.toLowerCase()) ?? null;
+        },
+    };
+}
 export function formatTaskReference(value) {
     return formatEntityReference(TASK_REFERENCE_PREFIX, value);
 }

package/dist/utils/taskforceAgentEvents.d.ts

@@ -0,0 +1,8 @@
+export declare const TASKFORCE_AGENTS_MUTATED_EVENT = "taskforce:agents-mutated";
+export interface TaskforceAgentsMutatedDetail {
+    workspaceId?: string | null;
+    agentId?: string | null;
+    conversationId?: string | null;
+    reason?: 'agent-save' | 'agent-archive' | 'agent-avatar-generate' | 'agent-avatar-upload' | 'agent-avatar-remove' | 'conversation-create' | 'conversation-update' | 'role-save' | 'role-retire' | 'role-restore' | 'sync-apply';
+}
+export declare function dispatchTaskforceAgentsMutated(detail: TaskforceAgentsMutatedDetail): void;

package/dist/utils/taskforceAgentEvents.js

@@ -0,0 +1,6 @@
+export const TASKFORCE_AGENTS_MUTATED_EVENT = 'taskforce:agents-mutated';
+export function dispatchTaskforceAgentsMutated(detail) {
+    if (typeof window === 'undefined' || typeof window.dispatchEvent !== 'function')
+        return;
+    window.dispatchEvent(new CustomEvent(TASKFORCE_AGENTS_MUTATED_EVENT, { detail }));
+}

package/dist/utils/taskforceAgentSkillEvents.d.ts

@@ -0,0 +1,7 @@
+export declare const TASKFORCE_AGENT_SKILLS_MUTATED_EVENT = "taskforce:agent-skills-mutated";
+export interface TaskforceAgentSkillsMutatedDetail {
+    workspaceId: string;
+    skillId?: string | null;
+    reason: 'create' | 'update' | 'retire' | 'restore' | 'sync-apply';
+}
+export declare function dispatchTaskforceAgentSkillsMutated(detail: TaskforceAgentSkillsMutatedDetail): void;

package/dist/utils/taskforceAgentSkillEvents.js

@@ -0,0 +1,8 @@
+export const TASKFORCE_AGENT_SKILLS_MUTATED_EVENT = 'taskforce:agent-skills-mutated';
+export function dispatchTaskforceAgentSkillsMutated(detail) {
+    if (typeof window === 'undefined')
+        return;
+    window.dispatchEvent(new CustomEvent(TASKFORCE_AGENT_SKILLS_MUTATED_EVENT, {
+        detail,
+    }));
+}

package/dist/utils/theme.js

@@ -1,5 +1,5 @@
 export const TASKFORCE_THEME_IDS = ['light', 'dawn', 'dark', 'midnight'];
-export const DEFAULT_TASKFORCE_THEME = 'dark';
+export const DEFAULT_TASKFORCE_THEME = 'dawn';
 export const TASKFORCE_THEME_OPTIONS = [
     { id: 'light', label: 'Light', family: 'light', icon: 'sun' },
     { id: 'dawn', label: 'Dawn', family: 'light', icon: 'wind' },

package/dist/utils/uiNotice.d.ts

@@ -3,5 +3,8 @@ export interface UiNotice {
     message: string;
     tone: UiNoticeTone;
     ttlMs?: number;
+    actionLabel?: string;
+    onAction?: () => void;
+    ownerKey?: string;
 }
 export declare function resolveUiNoticeTtl(tone: UiNoticeTone, ttlMs?: number): number;

package/dist/utils/uiNotice.js

@@ -2,5 +2,5 @@ export function resolveUiNoticeTtl(tone, ttlMs) {
     if (typeof ttlMs === 'number' && Number.isFinite(ttlMs) && ttlMs > 0) {
         return ttlMs;
     }
-    return tone === 'error' ? 3600 : 2600;
+    return tone === 'error' ? 12000 : 2600;
 }

package/dist/utils/workspaceResourceEvents.d.ts

@@ -0,0 +1,7 @@
+export declare const TASKFORCE_WORKSPACE_RESOURCES_INVALIDATED_EVENT = "taskforce:workspace-resources-invalidated";
+export interface TaskforceWorkspaceResourcesInvalidatedDetail {
+    workspaceId: string;
+    source: 'data-version' | 'realtime';
+    dataVersion?: number;
+}
+export declare function dispatchTaskforceWorkspaceResourcesInvalidated(detail: TaskforceWorkspaceResourcesInvalidatedDetail): void;

package/dist/utils/workspaceResourceEvents.js

@@ -0,0 +1,6 @@
+export const TASKFORCE_WORKSPACE_RESOURCES_INVALIDATED_EVENT = 'taskforce:workspace-resources-invalidated';
+export function dispatchTaskforceWorkspaceResourcesInvalidated(detail) {
+    if (typeof window === 'undefined')
+        return;
+    window.dispatchEvent(new CustomEvent(TASKFORCE_WORKSPACE_RESOURCES_INVALIDATED_EVENT, { detail }));
+}

package/dist/utils/workspaceSyncPresentation.d.ts

@@ -1,3 +1,4 @@
+import type { LocalSyncCoordinatorStatusResponse } from '../sync/coordinator/localSyncCoordinatorBrowserClient';
 export type HeaderWorkspaceSyncStatus = 'off' | 'syncing' | 'attention' | 'healthy';
 type WorkspaceSyncBlockedReason = 'cloud-auth-unconfigured' | 'runtime-not-local' | 'sync-disabled' | 'invalid-workspace' | 'repair-active' | 'attach-cloud' | 'provision-local' | 'auth-required' | 'push-in-flight' | 'pull-in-flight' | 'retry-pending' | 'lease-held';
 interface ResolveHeaderWorkspaceSyncPresentationInput {
@@ -11,6 +12,7 @@ interface ResolveHeaderWorkspaceSyncPresentationInput {
     pushBlockedReason?: WorkspaceSyncBlockedReason | null;
     pullBlockedReason?: WorkspaceSyncBlockedReason | null;
     retryBlockedReason?: WorkspaceSyncBlockedReason | null;
+    coordinatorRecoveryObligations?: number;
 }
 export interface HeaderWorkspaceSyncPresentation {
     actionable: boolean;
@@ -20,5 +22,27 @@ export interface HeaderWorkspaceSyncPresentation {
     recommendedAction: string;
     lastError: string;
 }
+export interface CoordinatorWorkspaceSyncPresentation {
+    header: HeaderWorkspaceSyncPresentation;
+    pendingLocalChanges: number | 'Unknown';
+    incomingCloudChanges: string;
+    stage: string;
+    lastPullAt: string | null;
+    lastPushAt: string | null;
+    lastSyncedAt: string | null;
+    busy: boolean;
+    repairBusy: boolean;
+    diagnostics: Array<{
+        label: string;
+        value: string;
+    }>;
+}
+export interface CoordinatorWorkspaceSyncStatusSource {
+    phase: 'idle' | 'attaching' | 'ready' | 'error';
+    snapshot: LocalSyncCoordinatorStatusResponse | null;
+    errorMessage: string | null;
+}
+export declare function isWorkspaceSyncAuthenticationError(message: string | null | undefined): boolean;
+export declare function resolveCoordinatorWorkspaceSyncPresentation(source: CoordinatorWorkspaceSyncStatusSource | null | undefined): CoordinatorWorkspaceSyncPresentation | null;
 export declare function resolveHeaderWorkspaceSyncPresentation(input: ResolveHeaderWorkspaceSyncPresentationInput): HeaderWorkspaceSyncPresentation;
 export {};

package/dist/utils/workspaceSyncPresentation.js

@@ -1,3 +1,227 @@
+export function isWorkspaceSyncAuthenticationError(message) {
+    return /\btaskforce session is invalid\b|\bauthenticated taskforce session is required\b/i
+        .test(message || '');
+}
+export function resolveCoordinatorWorkspaceSyncPresentation(source) {
+    if (!source)
+        return null;
+    const snapshot = source.snapshot;
+    if (source.phase !== 'ready') {
+        if (snapshot?.state.ownershipMode === 'browser-gateway' && source.phase !== 'error') {
+            return null;
+        }
+        const unavailable = source.phase === 'error';
+        const authenticationRequired = isWorkspaceSyncAuthenticationError(source.errorMessage);
+        return {
+            header: {
+                actionable: true,
+                status: unavailable ? 'attention' : 'syncing',
+                syncEnabledLabel: 'unknown',
+                summary: unavailable
+                    ? 'The shared sync coordinator status is unavailable.'
+                    : 'Reading shared sync coordinator status.',
+                recommendedAction: unavailable
+                    ? authenticationRequired
+                        ? 'Sign out and sign back in, then retry sync.'
+                        : 'Retry sync. If the coordinator remains unavailable, restart the local server.'
+                    : 'Wait for the coordinator status check to finish.',
+                lastError: source.errorMessage || (unavailable ? 'Coordinator status unavailable.' : 'None'),
+            },
+            pendingLocalChanges: 'Unknown',
+            incomingCloudChanges: 'Not checked',
+            stage: unavailable ? 'unavailable' : 'checking coordinator',
+            lastPullAt: null,
+            lastPushAt: null,
+            lastSyncedAt: null,
+            busy: source.phase === 'attaching',
+            repairBusy: false,
+            diagnostics: [{
+                    label: 'Coordinator',
+                    value: source.errorMessage || source.phase,
+                }],
+        };
+    }
+    if (!snapshot || snapshot.state.ownershipMode !== 'server')
+        return null;
+    const workspace = snapshot.workspace;
+    const runner = workspace?.runner || null;
+    const checkpoint = runner?.checkpoint?.checkpoint || null;
+    const outbox = workspace?.outbox || null;
+    const operationStates = outbox?.operationStates;
+    const stale = operationStates?.stale || 0;
+    const blocked = operationStates?.blocked ?? outbox?.blocked ?? 0;
+    const retryScheduled = operationStates?.retryScheduled || 0;
+    const recoveryOpen = Boolean(outbox?.recovery && outbox.recovery.state !== 'completed');
+    const attachmentApplyOpen = outbox?.attachmentApplyObligations?.open || 0;
+    const credentialBlocked = snapshot.credential.status !== 'ready';
+    const transitioning = snapshot.state.transitionState !== 'idle';
+    const runnerUnavailable = !runner || !runner.running || !runner.acceptingWork || !checkpoint;
+    const runnerError = checkpoint?.controlState === 'error' || Boolean(checkpoint?.lastError);
+    const retryWait = checkpoint?.controlState === 'retry-wait' || retryScheduled > 0;
+    const recoveryObligations = snapshot.permits.recoveryObligations;
+    const pendingV2Push = checkpoint?.pendingV2Push || null;
+    const pushBatchProgress = pendingV2Push?.lastBatchProgress || null;
+    const pendingV2PushChangeCount = Math.max(0, (pendingV2Push?.frozenPayload.changes.length || 0)
+        - (pushBatchProgress?.completedChanges || 0));
+    const contentPushBlocked = Boolean(pushBatchProgress
+        && (pushBatchProgress.failureDomain === 'content'
+            || pushBatchProgress.failureDomain === 'mixed')
+        && pendingV2PushChangeCount > 0);
+    const baselineUnknown = Boolean(checkpoint?.syncEnabled
+        && checkpoint.syncPhase === 'attach-cloud'
+        && !checkpoint.lastPullAt);
+    const runnerOperationActive = Boolean(runner?.queuedCommandCount
+        || ['starting', 'pulling', 'pushing', 'repairing', 'stopping']
+            .includes(checkpoint?.controlState || '')
+        || (operationStates?.inFlight ?? outbox?.inFlight ?? 0) > 0);
+    const active = runnerOperationActive || (outbox?.pending || 0) > 0;
+    const contentPushNeedsAttention = contentPushBlocked && !runnerOperationActive;
+    const runnerBusy = runnerOperationActive;
+    const repairBusy = checkpoint?.controlState === 'repairing';
+    let status = 'healthy';
+    let summary = 'Sync is healthy.';
+    let recommendedAction = 'No action needed.';
+    let lastError = checkpoint?.lastError || 'None';
+    if (credentialBlocked) {
+        status = 'attention';
+        summary = 'Sync is paused because the coordinator credential is unavailable.';
+        recommendedAction = 'Sign in again, then retry sync.';
+    }
+    else if (transitioning) {
+        status = 'syncing';
+        summary = 'Sync ownership is changing safely.';
+        recommendedAction = 'Wait for the coordinator transition to finish.';
+    }
+    else if (runnerUnavailable) {
+        status = 'attention';
+        summary = 'The shared sync runner is unavailable.';
+        recommendedAction = 'Retry sync. If the runner does not recover, restart the local server.';
+    }
+    else if (attachmentApplyOpen > 0) {
+        status = 'attention';
+        summary = `${attachmentApplyOpen} incoming attachment ${attachmentApplyOpen === 1 ? 'change is' : 'changes are'} waiting for content.`;
+        recommendedAction = checkpoint && !checkpoint.syncEnabled
+            ? 'Turn on sync to resume automatic attachment hydration.'
+            : 'Wait for the scheduled attachment hydration retry.';
+        lastError = outbox?.attachmentApplyObligations?.lastError || lastError;
+    }
+    else if (recoveryObligations > 0 || blocked > 0 || stale > 0 || recoveryOpen) {
+        status = 'attention';
+        summary = 'Durable local changes need reconciliation.';
+        recommendedAction = checkpoint && !checkpoint.syncEnabled
+            ? 'Turn on sync, then press Repair to reconcile and replay supported changes.'
+            : 'Press Repair to reconcile and replay supported changes.';
+    }
+    else if (contentPushNeedsAttention) {
+        status = 'attention';
+        const failedChangeKind = pushBatchProgress.failureDomain === 'content'
+            ? 'content'
+            : 'push';
+        summary = `${pushBatchProgress.failedChangeCount} ${failedChangeKind} ${pushBatchProgress.failedChangeCount === 1 ? 'change is' : 'changes are'} waiting to retry; ${pendingV2PushChangeCount} total push ${pendingV2PushChangeCount === 1 ? 'change remains' : 'changes remain'}.`;
+        recommendedAction = checkpoint && !checkpoint.syncEnabled
+            ? 'Turn on sync to resume the bounded content retry.'
+            : 'Wait for the scheduled content retry, or press Retry now.';
+    }
+    else if (checkpoint && !checkpoint.syncEnabled) {
+        status = 'off';
+        summary = 'Workspace sync is turned off.';
+        recommendedAction = 'Turn on sync when you are ready to connect this workspace.';
+        lastError = 'None';
+    }
+    else if (runnerError && !runnerOperationActive) {
+        status = 'attention';
+        summary = checkpoint?.lastError || 'The shared sync runner reported an error.';
+        recommendedAction = 'Press Retry now. If the same issue returns, press Repair.';
+    }
+    else if (retryWait) {
+        status = 'attention';
+        summary = 'Sync is waiting for a scheduled retry.';
+        recommendedAction = 'Wait for the retry, or press Retry now.';
+    }
+    else if (baselineUnknown) {
+        status = 'attention';
+        summary = 'The initial cloud baseline has not completed.';
+        recommendedAction = 'Keep sync enabled until the first cloud check completes.';
+    }
+    else if (active) {
+        status = 'syncing';
+        summary = 'The shared sync runner is processing workspace changes.';
+        recommendedAction = 'Wait for the current transfer to finish.';
+    }
+    const incomingCloudChanges = !checkpoint?.lastPullAt
+        ? checkpoint?.controlState === 'pulling'
+            ? 'Checking — total unknown'
+            : 'Not checked'
+        : checkpoint.controlState === 'pulling'
+            ? 'Checking — total unknown'
+            : 'No known backlog at last check';
+    const pendingLocalChanges = outbox
+        ? outbox.activeDepth + pendingV2PushChangeCount
+        : pendingV2Push
+            ? pendingV2PushChangeCount
+            : 'Unknown';
+    const runnerStage = checkpoint?.controlState || 'unavailable';
+    return {
+        header: {
+            actionable: true,
+            status,
+            syncEnabledLabel: checkpoint?.syncEnabled ? 'yes' : 'no',
+            summary,
+            recommendedAction,
+            lastError,
+        },
+        pendingLocalChanges,
+        incomingCloudChanges,
+        stage: runnerStage,
+        lastPullAt: checkpoint?.lastPullAt || null,
+        lastPushAt: checkpoint?.lastPushAt || null,
+        lastSyncedAt: checkpoint?.lastSyncedAt || null,
+        busy: runnerBusy,
+        repairBusy,
+        diagnostics: [
+            {
+                label: 'Coordinator',
+                value: `Generation ${snapshot.state.coordinatorGeneration}; server-owned`,
+            },
+            {
+                label: 'Durable outbox',
+                value: outbox
+                    ? `${operationStates?.pending ?? outbox.pending} pending, `
+                        + `${retryScheduled} retry scheduled, `
+                        + `${operationStates?.inFlight ?? outbox.inFlight} in flight, `
+                        + `${stale} stale, ${blocked} blocked`
+                    : 'Unavailable',
+            },
+            {
+                label: 'Recovery obligations',
+                value: String(recoveryObligations),
+            },
+            {
+                label: 'Attachment apply obligations',
+                value: outbox?.attachmentApplyObligations
+                    ? `${outbox.attachmentApplyObligations.open} open, `
+                        + `${outbox.attachmentApplyObligations.due} due, `
+                        + `${outbox.attachmentApplyObligations.totalAttempts} attempts`
+                    : 'Unavailable',
+            },
+            {
+                label: 'Content push backlog',
+                value: contentPushBlocked
+                    ? `${pushBatchProgress.failedChangeCount} blocked ${pushBatchProgress.failureDomain === 'content' ? 'content' : 'push'} ${pushBatchProgress.failedChangeCount === 1 ? 'change' : 'changes'}; ${pendingV2PushChangeCount} total push ${pendingV2PushChangeCount === 1 ? 'change remains' : 'changes remain'}; `
+                        + `${pushBatchProgress.completedBatches}/${pushBatchProgress.totalBatches} batches settled`
+                    : 'None',
+            },
+            {
+                label: 'Oldest actionable change',
+                value: outbox?.oldestActionableAt || 'None',
+            },
+            {
+                label: 'Local data version',
+                value: String(snapshot.state.localDataVersion),
+            },
+        ],
+    };
+}
 function resolveBlockedReasonPresentation(reason) {
     switch (reason) {
         case 'auth-required':
@@ -25,12 +249,6 @@ function resolveBlockedReasonPresentation(reason) {
                 summary: 'Sync hit a temporary problem and is waiting for its scheduled retry.',
                 recommendedAction: 'Wait for the automatic retry, or press Sync to retry now.'
             };
-        case 'push-in-flight':
-        case 'pull-in-flight':
-            return {
-                summary: 'A sync request is already running for this workspace.',
-                recommendedAction: 'Wait for the current sync request to finish.'
-            };
         case 'lease-held':
             return {
                 summary: 'Another local window is already syncing this workspace.',
@@ -63,10 +281,29 @@ function resolveBlockedReasonPresentation(reason) {
 export function resolveHeaderWorkspaceSyncPresentation(input) {
     const actionable = input.runtimeMode === 'local' && input.isAuthenticated;
     if (actionable) {
+        const coordinatorRecoveryObligations = Math.max(0, Number(input.coordinatorRecoveryObligations || 0));
         const blockedReasonPresentation = resolveBlockedReasonPresentation(input.retryBlockedReason
             || input.pullBlockedReason
             || input.pushBlockedReason
             || null);
+        if (coordinatorRecoveryObligations > 0
+            && input.retryBlockedReason !== 'auth-required'
+            && input.pullBlockedReason !== 'auth-required'
+            && input.pushBlockedReason !== 'auth-required'
+            && input.retryBlockedReason !== 'repair-active'
+            && input.pullBlockedReason !== 'repair-active'
+            && input.pushBlockedReason !== 'repair-active') {
+            return {
+                actionable,
+                status: 'attention',
+                syncEnabledLabel: input.workspaceCloudSyncEnabled ? 'yes' : 'no',
+                summary: `${coordinatorRecoveryObligations} durable sync recovery obligation${coordinatorRecoveryObligations === 1 ? '' : 's'} remain.`,
+                recommendedAction: input.workspaceCloudSyncEnabled
+                    ? 'Press Repair to reconcile the durable sync ledger.'
+                    : 'Turn on sync, then press Repair to reconcile the durable sync ledger.',
+                lastError: input.workspaceSyncError,
+            };
+        }
         return {
             actionable,
             status: input.workspaceSyncStatus,