@cleanslate/sdk 0.1.0

package/dist/services/cleanSlateTaskSessionService.js

@@ -0,0 +1,1079 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) CleanSlate. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { AgentPhase } from '../agent/cleanSlatePrompts.js';
+import { CleanSlateTaskKind, CleanSlateTaskLifecycleStatus, CleanSlateTurnIntent, CleanSlateWorkspaceShape } from './cleanSlateTaskState.js';
+import { CleanSlateVerificationTargetTracker } from './cleanSlateVerificationTargetTracker.js';
+import { CleanSlateTaskEvidenceCodec } from './cleanSlateTaskEvidenceCodec.js';
+export class CleanSlateTaskSessionService {
+    constructor() {
+        this.verificationTargetTracker = new CleanSlateVerificationTargetTracker();
+        this.evidenceCodec = new CleanSlateTaskEvidenceCodec();
+        this.startedAt = 0;
+        this.currentPhase = AgentPhase.PLANNING;
+        this.currentStatus = CleanSlateTaskLifecycleStatus.IDLE;
+        this.awaitingApproval = false;
+        this.currentTaskKind = CleanSlateTaskKind.UNKNOWN;
+        this.currentWorkspaceShape = CleanSlateWorkspaceShape.UNKNOWN;
+        this.lastCheckpointAt = 0;
+        this.toDo = [];
+        this.discoveredPaths = [];
+        this.semanticHighlights = [];
+        this.executionFilesChanged = [];
+        this.resumeCount = 0;
+        this.checkpoints = [];
+        this.runLedger = [];
+        this.evidenceLedger = [];
+        this.verificationTargets = [];
+    }
+    static { this.MAX_CHECKPOINTS = 25; }
+    static { this.MAX_RUN_LEDGER_ENTRIES = 30; }
+    static { this.MAX_DISCOVERED_PATHS = 300; }
+    static { this.MAX_SEEDED_DISCOVERED_PATHS = 120; }
+    static { this.MAX_SEMANTIC_HIGHLIGHTS = 120; }
+    static { this.MAX_SEEDED_SEMANTIC_HIGHLIGHTS = 60; }
+    static { this.MAX_EVIDENCE_LEDGER_ENTRIES = 200; }
+    reset() {
+        this.taskId = undefined;
+        this.runId = undefined;
+        this.startedAt = 0;
+        this.currentPhase = AgentPhase.PLANNING;
+        this.currentStatus = CleanSlateTaskLifecycleStatus.IDLE;
+        this.awaitingApproval = false;
+        this.currentTaskKind = CleanSlateTaskKind.UNKNOWN;
+        this.currentWorkspaceShape = CleanSlateWorkspaceShape.UNKNOWN;
+        this.lastCheckpointAt = 0;
+        this.objective = undefined;
+        this.toDo = [];
+        this.discoveredPaths = [];
+        this.semanticHighlights = [];
+        this.executionFilesChanged = [];
+        this.currentWorkItem = undefined;
+        this.lastSummary = undefined;
+        this.lastError = undefined;
+        this.lastToolName = undefined;
+        this.resumeCount = 0;
+        this.checkpoints = [];
+        this.lastUserTurn = undefined;
+        this.lastAssistantTurn = undefined;
+        this.lastIntent = undefined;
+        this.runLedger = [];
+        this.evidenceLedger = [];
+        this.pendingRecovery = undefined;
+        this.verificationTargets = [];
+    }
+    startNewTask(taskKind, workspaceShape, initialUserTurn) {
+        this.archiveCurrentRunIfNeeded(this.getArchiveStatusForTaskSwitch());
+        const seededDiscoveredPaths = workspaceShape === CleanSlateWorkspaceShape.EXISTING
+            ? this.collectRecentDiscoveredPathsForNewTask()
+            : [];
+        const seededSemanticHighlights = workspaceShape === CleanSlateWorkspaceShape.EXISTING
+            ? this.collectRecentSemanticHighlightsForNewTask()
+            : [];
+        this.taskId = this.generateTaskId();
+        this.runId = this.generateRunId();
+        this.startedAt = Date.now();
+        this.currentPhase = AgentPhase.PLANNING;
+        this.awaitingApproval = false;
+        this.currentTaskKind = taskKind;
+        this.currentWorkspaceShape = workspaceShape;
+        this.currentStatus = taskKind === CleanSlateTaskKind.CHAT
+            ? CleanSlateTaskLifecycleStatus.CHAT
+            : CleanSlateTaskLifecycleStatus.PLANNING;
+        this.objective = initialUserTurn?.trim() || this.objective;
+        this.lastUserTurn = initialUserTurn?.trim() || this.lastUserTurn;
+        this.lastAssistantTurn = undefined;
+        this.toDo = [];
+        this.discoveredPaths = seededDiscoveredPaths;
+        this.semanticHighlights = seededSemanticHighlights;
+        this.executionFilesChanged = [];
+        this.currentWorkItem = undefined;
+        this.lastSummary = undefined;
+        this.lastError = undefined;
+        this.lastToolName = undefined;
+        this.resumeCount = 0;
+        this.checkpoints = [];
+        this.lastIntent = undefined;
+        this.evidenceLedger = [];
+        this.pendingRecovery = undefined;
+        this.verificationTargets = [];
+        this.checkpoint('lifecycle', this.objective ? `Started new task: ${this.objective}` : 'Started new task');
+    }
+    getTaskId() {
+        return this.taskId;
+    }
+    getRunId() {
+        return this.runId;
+    }
+    getPhase() {
+        return this.currentPhase;
+    }
+    setPhase(phase) {
+        const previousPhase = this.currentPhase;
+        this.currentPhase = phase;
+        if (this.awaitingApproval) {
+            this.currentStatus = CleanSlateTaskLifecycleStatus.AWAITING_APPROVAL;
+        }
+        else if (!this.isTerminalStatus(this.currentStatus) && this.currentStatus !== CleanSlateTaskLifecycleStatus.INTERRUPTED) {
+            this.currentStatus = this.phaseToStatus(phase);
+        }
+        if (previousPhase !== phase) {
+            this.checkpoint('phase', `Transitioned from ${previousPhase} to ${phase}`);
+        }
+        else {
+            this.checkpoint();
+        }
+    }
+    getStatus() {
+        return this.currentStatus;
+    }
+    markAwaitingApproval() {
+        this.currentPhase = AgentPhase.PLANNING;
+        this.awaitingApproval = true;
+        this.currentStatus = CleanSlateTaskLifecycleStatus.AWAITING_APPROVAL;
+        this.checkpoint('lifecycle', 'Plan drafted and awaiting approval');
+    }
+    approvePlan() {
+        this.awaitingApproval = false;
+        this.currentPhase = AgentPhase.EXECUTION;
+        this.currentStatus = CleanSlateTaskLifecycleStatus.EXECUTING;
+        this.checkpoint('lifecycle', 'Plan approved');
+    }
+    resumeCurrentTask() {
+        if (this.awaitingApproval) {
+            this.currentStatus = CleanSlateTaskLifecycleStatus.AWAITING_APPROVAL;
+        }
+        else if (this.currentStatus === CleanSlateTaskLifecycleStatus.INTERRUPTED || this.currentStatus === CleanSlateTaskLifecycleStatus.IDLE) {
+            this.currentStatus = this.phaseToStatus(this.currentPhase);
+        }
+        this.resumeCount += 1;
+        this.checkpoint('resume', `Resumed task in ${this.currentPhase}`);
+    }
+    markInterrupted() {
+        if (this.awaitingApproval || this.isTerminalStatus(this.currentStatus) || this.currentTaskKind === CleanSlateTaskKind.CHAT) {
+            return;
+        }
+        this.currentStatus = CleanSlateTaskLifecycleStatus.INTERRUPTED;
+        this.checkpoint('lifecycle', `Task interrupted during ${this.currentPhase}`);
+    }
+    markCompleted() {
+        this.awaitingApproval = false;
+        this.currentStatus = CleanSlateTaskLifecycleStatus.COMPLETED;
+        this.checkpoint('lifecycle', 'Task completed');
+    }
+    markFailed() {
+        this.awaitingApproval = false;
+        this.currentStatus = CleanSlateTaskLifecycleStatus.FAILED;
+        this.checkpoint('error', this.lastError || 'Task failed');
+    }
+    markCancelled() {
+        this.awaitingApproval = false;
+        this.currentStatus = CleanSlateTaskLifecycleStatus.CANCELLED;
+        this.checkpoint('lifecycle', 'Task cancelled');
+    }
+    isAwaitingApproval() {
+        return this.awaitingApproval;
+    }
+    setAwaitingApproval(awaiting) {
+        this.awaitingApproval = awaiting;
+        if (awaiting) {
+            this.currentPhase = AgentPhase.PLANNING;
+            this.currentStatus = CleanSlateTaskLifecycleStatus.AWAITING_APPROVAL;
+        }
+        else if (!this.isTerminalStatus(this.currentStatus) && this.currentStatus !== CleanSlateTaskLifecycleStatus.INTERRUPTED) {
+            this.currentStatus = this.phaseToStatus(this.currentPhase);
+        }
+        this.checkpoint('lifecycle', awaiting ? 'Awaiting approval' : `Approval cleared in ${this.currentPhase}`);
+    }
+    getTaskKind() {
+        return this.currentTaskKind;
+    }
+    setTaskKind(taskKind) {
+        this.currentTaskKind = taskKind;
+        if (taskKind === CleanSlateTaskKind.CHAT) {
+            this.currentStatus = CleanSlateTaskLifecycleStatus.CHAT;
+        }
+        this.checkpoint();
+    }
+    getWorkspaceShape() {
+        return this.currentWorkspaceShape;
+    }
+    setWorkspaceShape(workspaceShape) {
+        this.currentWorkspaceShape = workspaceShape;
+        this.checkpoint();
+    }
+    recordUserTurn(text) {
+        if (text.trim().length > 0) {
+            if (!this.objective || this.isTerminalStatus(this.currentStatus)) {
+                this.objective = text;
+            }
+            this.lastUserTurn = text;
+            this.checkpoint();
+        }
+    }
+    recordAssistantTurn(text) {
+        if (text.trim().length > 0) {
+            this.lastAssistantTurn = text;
+            this.checkpoint();
+        }
+    }
+    recordAssistantSummary(summary) {
+        if (typeof summary === 'string' && summary.trim().length > 0) {
+            const normalized = summary.trim();
+            if (this.lastSummary === normalized) {
+                return;
+            }
+            this.lastSummary = normalized;
+            this.checkpoint('progress', normalized);
+        }
+    }
+    recordProgressSummary(summary) {
+        this.recordAssistantSummary(summary);
+    }
+    getLastUserTurn() {
+        return this.lastUserTurn;
+    }
+    getLastAssistantTurn() {
+        return this.lastAssistantTurn;
+    }
+    recordIntent(intent) {
+        this.lastIntent = intent;
+        this.checkpoint();
+    }
+    updateObjective(objective) {
+        if (typeof objective === 'string' && objective.trim().length > 0) {
+            this.objective = objective.trim();
+            this.checkpoint();
+        }
+    }
+    getObjective() {
+        return this.objective;
+    }
+    updateToDo(toDo) {
+        const normalized = Array.isArray(toDo)
+            ? toDo
+                .map(item => typeof item === 'string' ? item.trim() : '')
+                .filter(item => item.length > 0)
+            : [];
+        if (this.areStringArraysEqual(this.toDo, normalized)) {
+            return;
+        }
+        this.toDo = normalized;
+        this.currentWorkItem = this.deriveCurrentWorkItem(normalized);
+        this.checkpoint('progress', this.currentWorkItem ? `Updated to do: ${this.currentWorkItem}` : 'Updated to do list');
+    }
+    recordDiscoveredPaths(paths) {
+        if (!Array.isArray(paths) || paths.length === 0) {
+            return;
+        }
+        let changed = false;
+        for (const candidate of paths) {
+            if (typeof candidate !== 'string') {
+                continue;
+            }
+            const trimmed = candidate.trim();
+            if (!trimmed) {
+                continue;
+            }
+            const normalized = trimmed.replace(/\\/g, '/');
+            const key = normalized.toLowerCase();
+            const existingIndex = this.discoveredPaths.findIndex(path => path.replace(/\\/g, '/').toLowerCase() === key);
+            if (existingIndex !== -1) {
+                if (existingIndex !== this.discoveredPaths.length - 1) {
+                    this.discoveredPaths.splice(existingIndex, 1);
+                    this.discoveredPaths.push(normalized);
+                    changed = true;
+                }
+                continue;
+            }
+            this.discoveredPaths.push(normalized);
+            changed = true;
+        }
+        if (!changed) {
+            return;
+        }
+        if (this.discoveredPaths.length > CleanSlateTaskSessionService.MAX_DISCOVERED_PATHS) {
+            this.discoveredPaths.splice(0, this.discoveredPaths.length - CleanSlateTaskSessionService.MAX_DISCOVERED_PATHS);
+        }
+    }
+    getDiscoveredPaths() {
+        return [...this.discoveredPaths];
+    }
+    recordSemanticHighlights(highlights) {
+        if (!Array.isArray(highlights) || highlights.length === 0) {
+            return;
+        }
+        let changed = false;
+        for (const candidate of highlights) {
+            if (typeof candidate !== 'string') {
+                continue;
+            }
+            const normalized = candidate.trim();
+            if (!normalized) {
+                continue;
+            }
+            const key = normalized.toLowerCase();
+            const existingIndex = this.semanticHighlights.findIndex(item => item.toLowerCase() === key);
+            if (existingIndex !== -1) {
+                if (existingIndex !== this.semanticHighlights.length - 1) {
+                    this.semanticHighlights.splice(existingIndex, 1);
+                    this.semanticHighlights.push(normalized);
+                    changed = true;
+                }
+                continue;
+            }
+            this.semanticHighlights.push(normalized);
+            changed = true;
+        }
+        if (!changed) {
+            return;
+        }
+        if (this.semanticHighlights.length > CleanSlateTaskSessionService.MAX_SEMANTIC_HIGHLIGHTS) {
+            this.semanticHighlights.splice(0, this.semanticHighlights.length - CleanSlateTaskSessionService.MAX_SEMANTIC_HIGHLIGHTS);
+        }
+    }
+    getSemanticHighlights() {
+        return [...this.semanticHighlights];
+    }
+    recordExecutionFilesChanged(filesChanged) {
+        if (!Array.isArray(filesChanged)) {
+            return;
+        }
+        const normalized = [];
+        const seen = new Set();
+        for (const change of filesChanged) {
+            if (!change || typeof change.path !== 'string') {
+                continue;
+            }
+            const path = change.path.trim().replace(/\\/g, '/');
+            if (!path) {
+                continue;
+            }
+            const key = path.toLowerCase();
+            const existingIndex = normalized.findIndex(item => item.path.toLowerCase() === key);
+            const normalizedChange = {
+                path,
+                added: typeof change.added === 'number' ? change.added : undefined,
+                deleted: typeof change.deleted === 'number' ? change.deleted : undefined
+            };
+            if (seen.has(key) && existingIndex !== -1) {
+                normalized.splice(existingIndex, 1);
+            }
+            else {
+                seen.add(key);
+            }
+            normalized.push(normalizedChange);
+        }
+        if (normalized.length === 0) {
+            return;
+        }
+        this.executionFilesChanged = normalized;
+    }
+    getExecutionFilesChanged() {
+        return [...this.executionFilesChanged];
+    }
+    setPendingRecovery(prompt, metadata) {
+        const normalizedPrompt = typeof prompt === 'string' ? prompt.trim() : '';
+        if (!normalizedPrompt) {
+            this.clearPendingRecovery();
+            return;
+        }
+        const nextState = {
+            prompt: normalizedPrompt,
+            updatedAt: Date.now(),
+            toolName: typeof metadata?.toolName === 'string' && metadata.toolName.trim().length > 0 ? metadata.toolName.trim() : undefined,
+            code: typeof metadata?.code === 'string' && metadata.code.trim().length > 0 ? metadata.code.trim() : undefined
+        };
+        if (this.pendingRecovery
+            && this.pendingRecovery.prompt === nextState.prompt
+            && this.pendingRecovery.toolName === nextState.toolName
+            && this.pendingRecovery.code === nextState.code) {
+            return;
+        }
+        this.pendingRecovery = nextState;
+        this.checkpoint('error', `Recovery required${nextState.toolName ? ` after ${nextState.toolName}` : ''}`);
+    }
+    clearPendingRecovery() {
+        if (!this.pendingRecovery) {
+            return;
+        }
+        this.pendingRecovery = undefined;
+        this.checkpoint('progress', 'Recovery requirement cleared');
+    }
+    hasPendingRecovery() {
+        return !!this.pendingRecovery;
+    }
+    getPendingRecovery() {
+        return this.pendingRecovery ? { ...this.pendingRecovery } : undefined;
+    }
+    getVerificationTargets() {
+        return this.verificationTargets.map(target => ({
+            ...target,
+            sourcePaths: [...target.sourcePaths],
+            routeHints: [...target.routeHints]
+        }));
+    }
+    getPendingVerificationTargets() {
+        return this.getVerificationTargets().filter(target => target.status !== 'verified');
+    }
+    hasPendingVerification() {
+        return this.verificationTargets.some(target => target.status !== 'verified');
+    }
+    registerVerificationTargetsForPaths(paths, objective) {
+        const update = this.verificationTargetTracker.register(this.verificationTargets, paths, objective);
+        this.verificationTargets = update.targets;
+        if (update.changed) {
+            this.checkpoint('progress', 'Browser verification required for updated UI surfaces');
+        }
+    }
+    getToDo() {
+        return [...this.toDo];
+    }
+    getCurrentWorkItem() {
+        return this.currentWorkItem;
+    }
+    recordToolStart(toolName, summary) {
+        if (!toolName) {
+            return;
+        }
+        this.lastToolName = toolName;
+        this.checkpoint('tool', summary || `Started tool ${toolName}`, toolName);
+    }
+    recordToolResult(toolName, success, summary) {
+        if (!toolName) {
+            return;
+        }
+        this.lastToolName = toolName;
+        if (!success && summary) {
+            this.lastError = summary;
+        }
+        this.checkpoint('tool', summary || `${toolName} ${success ? 'succeeded' : 'failed'}`, toolName);
+    }
+    recordError(error) {
+        if (typeof error === 'string' && error.trim().length > 0) {
+            this.lastError = error.trim();
+            this.checkpoint('error', this.lastError);
+        }
+    }
+    getLastError() {
+        return this.lastError;
+    }
+    getLastSummary() {
+        return this.lastSummary;
+    }
+    getCheckpoints() {
+        return [...this.checkpoints];
+    }
+    getRunSummary() {
+        return {
+            taskId: this.taskId,
+            runId: this.runId,
+            startedAt: this.startedAt,
+            phase: this.currentPhase,
+            status: this.currentStatus,
+            objective: this.objective,
+            currentWorkItem: this.currentWorkItem,
+            toDo: [...this.toDo],
+            discoveredPaths: [...this.discoveredPaths],
+            semanticHighlights: [...this.semanticHighlights],
+            lastSummary: this.lastSummary,
+            lastError: this.lastError,
+            lastToolName: this.lastToolName,
+            awaitingApproval: this.awaitingApproval,
+            resumeCount: this.resumeCount,
+            lastCheckpointAt: this.lastCheckpointAt,
+            hasPendingRecovery: this.hasPendingRecovery(),
+            hasPendingVerification: this.hasPendingVerification(),
+            pendingVerificationTargetCount: this.getPendingVerificationTargets().length,
+            pendingRecovery: this.getPendingRecovery(),
+            verificationTargets: this.getVerificationTargets()
+        };
+    }
+    getRunLedger() {
+        return [...this.runLedger];
+    }
+    getEvidenceLedger() {
+        return this.evidenceLedger.map(entry => this.cloneEvidenceEntry(entry));
+    }
+    recordEvidence(entry) {
+        const timestamp = typeof entry.timestamp === 'number' && Number.isFinite(entry.timestamp)
+            ? entry.timestamp
+            : Date.now();
+        const normalizedFilesChanged = this.evidenceCodec.normalizeFileChanges(entry.filesChanged);
+        const normalizedPaths = this.evidenceCodec.normalizeEvidencePaths(entry.paths);
+        const normalizedEntry = {
+            id: typeof entry.id === 'string' && entry.id.trim().length > 0
+                ? entry.id.trim()
+                : `evidence-${timestamp}-${Math.random().toString(16).slice(2, 8)}`,
+            timestamp,
+            kind: entry.kind,
+            phase: this.normalizeEvidencePhase(entry.phase),
+            status: this.isValidStatus(entry.status) ? entry.status : this.currentStatus,
+            taskId: typeof entry.taskId === 'string' ? entry.taskId : this.taskId,
+            runId: typeof entry.runId === 'string' ? entry.runId : this.runId,
+            toolName: this.evidenceCodec.trimOptional(entry.toolName),
+            toolCallId: this.evidenceCodec.trimOptional(entry.toolCallId),
+            success: typeof entry.success === 'boolean' ? entry.success : undefined,
+            summary: this.evidenceCodec.trimOptional(entry.summary),
+            error: this.evidenceCodec.trimOptional(entry.error),
+            code: this.evidenceCodec.trimOptional(entry.code),
+            input: this.evidenceCodec.sanitizeEvidenceValue(entry.input),
+            result: this.evidenceCodec.sanitizeEvidenceValue(entry.result),
+            paths: normalizedPaths.length > 0 ? normalizedPaths : undefined,
+            filesChanged: normalizedFilesChanged.length > 0 ? normalizedFilesChanged : undefined,
+            command: this.evidenceCodec.trimOptional(entry.command),
+            cwd: this.evidenceCodec.trimOptional(entry.cwd),
+            processId: this.evidenceCodec.trimOptional(entry.processId),
+            pid: typeof entry.pid === 'number' && Number.isFinite(entry.pid) ? entry.pid : undefined,
+            exitCode: typeof entry.exitCode === 'number' && Number.isFinite(entry.exitCode) ? entry.exitCode : undefined,
+            durationMs: typeof entry.durationMs === 'number' && Number.isFinite(entry.durationMs) ? entry.durationMs : undefined,
+            url: this.evidenceCodec.trimOptional(entry.url),
+            screenshotCount: typeof entry.screenshotCount === 'number' && Number.isFinite(entry.screenshotCount) ? entry.screenshotCount : undefined,
+            browserPageCount: typeof entry.browserPageCount === 'number' && Number.isFinite(entry.browserPageCount) ? entry.browserPageCount : undefined,
+            turnId: this.evidenceCodec.trimOptional(entry.turnId),
+            turnIndex: typeof entry.turnIndex === 'number' && Number.isFinite(entry.turnIndex) ? entry.turnIndex : undefined
+        };
+        this.evidenceLedger.push(normalizedEntry);
+        if (this.evidenceLedger.length > CleanSlateTaskSessionService.MAX_EVIDENCE_LEDGER_ENTRIES) {
+            this.evidenceLedger.splice(0, this.evidenceLedger.length - CleanSlateTaskSessionService.MAX_EVIDENCE_LEDGER_ENTRIES);
+        }
+        if (normalizedFilesChanged.length > 0) {
+            this.recordExecutionFilesChanged(this.evidenceCodec.mergeFileChanges(this.executionFilesChanged, normalizedFilesChanged));
+        }
+        if (normalizedEntry.kind === 'browser' && normalizedEntry.success !== false) {
+            const verificationUpdate = this.verificationTargetTracker.recordBrowserEvidence(this.verificationTargets, normalizedEntry);
+            this.verificationTargets = verificationUpdate.targets;
+            if (verificationUpdate.changed) {
+                this.checkpoint('progress', 'Browser verification refreshed for updated UI surfaces');
+            }
+        }
+    }
+    checkpoint(kind = 'progress', summary, toolName) {
+        this.lastCheckpointAt = Date.now();
+        if (summary) {
+            this.pushCheckpoint({
+                id: `checkpoint-${this.lastCheckpointAt}-${Math.random().toString(16).slice(2, 6)}`,
+                timestamp: this.lastCheckpointAt,
+                kind,
+                phase: this.currentPhase,
+                status: this.currentStatus,
+                summary,
+                toolName,
+                currentWorkItem: this.currentWorkItem
+            });
+        }
+    }
+    getStateSnapshot() {
+        return {
+            taskId: this.taskId,
+            runId: this.runId,
+            startedAt: this.startedAt,
+            phase: this.currentPhase,
+            status: this.currentStatus,
+            awaitingApproval: this.awaitingApproval,
+            taskKind: this.currentTaskKind,
+            workspaceShape: this.currentWorkspaceShape,
+            lastCheckpointAt: this.lastCheckpointAt,
+            objective: this.objective,
+            toDo: [...this.toDo],
+            discoveredPaths: [...this.discoveredPaths],
+            semanticHighlights: [...this.semanticHighlights],
+            executionFilesChanged: [...this.executionFilesChanged],
+            currentWorkItem: this.currentWorkItem,
+            lastSummary: this.lastSummary,
+            lastError: this.lastError,
+            lastToolName: this.lastToolName,
+            resumeCount: this.resumeCount,
+            checkpoints: [...this.checkpoints],
+            lastUserTurn: this.lastUserTurn,
+            lastAssistantTurn: this.lastAssistantTurn,
+            lastIntent: this.lastIntent,
+            runLedger: [...this.runLedger],
+            evidenceLedger: this.getEvidenceLedger(),
+            pendingRecovery: this.getPendingRecovery(),
+            verificationTargets: this.getVerificationTargets()
+        };
+    }
+    restoreStateSnapshot(snapshot, options) {
+        this.taskId = typeof snapshot?.taskId === 'string' && snapshot.taskId.trim().length > 0
+            ? snapshot.taskId
+            : this.generateTaskId();
+        this.runId = typeof snapshot?.runId === 'string' && snapshot.runId.trim().length > 0
+            ? snapshot.runId
+            : this.generateRunId();
+        this.startedAt = typeof snapshot?.startedAt === 'number' && Number.isFinite(snapshot.startedAt)
+            ? snapshot.startedAt
+            : Date.now();
+        const normalizedPhase = this.normalizeLegacyPhase(snapshot?.phase);
+        this.currentPhase = this.isValidPhase(normalizedPhase) ? normalizedPhase : AgentPhase.PLANNING;
+        this.awaitingApproval = typeof snapshot?.awaitingApproval === 'boolean' ? snapshot.awaitingApproval : false;
+        this.currentTaskKind = this.isValidTaskKind(snapshot?.taskKind) ? snapshot.taskKind : CleanSlateTaskKind.UNKNOWN;
+        this.currentWorkspaceShape = this.isValidWorkspaceShape(snapshot?.workspaceShape) ? snapshot.workspaceShape : CleanSlateWorkspaceShape.UNKNOWN;
+        const normalizedStatus = this.normalizeLegacyStatus(snapshot?.status);
+        this.currentStatus = this.isValidStatus(normalizedStatus)
+            ? normalizedStatus
+            : (this.awaitingApproval ? CleanSlateTaskLifecycleStatus.AWAITING_APPROVAL : this.phaseToStatus(this.currentPhase));
+        this.lastCheckpointAt = typeof snapshot?.lastCheckpointAt === 'number' ? snapshot.lastCheckpointAt : Date.now();
+        this.objective = typeof snapshot?.objective === 'string' ? snapshot.objective : undefined;
+        this.toDo = Array.isArray(snapshot?.toDo)
+            ? snapshot.toDo.filter((item) => typeof item === 'string' && item.trim().length > 0)
+            : [];
+        this.discoveredPaths = Array.isArray(snapshot?.discoveredPaths)
+            ? snapshot.discoveredPaths
+                .filter((path) => typeof path === 'string' && path.trim().length > 0)
+                .map(path => path.trim().replace(/\\/g, '/'))
+                .slice(-CleanSlateTaskSessionService.MAX_DISCOVERED_PATHS)
+            : [];
+        this.semanticHighlights = Array.isArray(snapshot?.semanticHighlights)
+            ? snapshot.semanticHighlights
+                .filter((item) => typeof item === 'string' && item.trim().length > 0)
+                .map(item => item.trim())
+                .slice(-CleanSlateTaskSessionService.MAX_SEMANTIC_HIGHLIGHTS)
+            : [];
+        this.executionFilesChanged = Array.isArray(snapshot?.executionFilesChanged)
+            ? snapshot.executionFilesChanged.flatMap((change) => {
+                if (!change || typeof change.path !== 'string') {
+                    return [];
+                }
+                const path = change.path.trim().replace(/\\/g, '/');
+                if (!path) {
+                    return [];
+                }
+                return [{
+                        path,
+                        added: typeof change.added === 'number' ? change.added : undefined,
+                        deleted: typeof change.deleted === 'number' ? change.deleted : undefined
+                    }];
+            })
+            : [];
+        this.currentWorkItem = typeof snapshot?.currentWorkItem === 'string'
+            ? snapshot.currentWorkItem
+            : this.deriveCurrentWorkItem(this.toDo);
+        this.lastSummary = typeof snapshot?.lastSummary === 'string' ? snapshot.lastSummary : undefined;
+        this.lastError = typeof snapshot?.lastError === 'string' ? snapshot.lastError : undefined;
+        this.lastToolName = typeof snapshot?.lastToolName === 'string' ? snapshot.lastToolName : undefined;
+        this.resumeCount = typeof snapshot?.resumeCount === 'number' ? snapshot.resumeCount : 0;
+        this.checkpoints = Array.isArray(snapshot?.checkpoints)
+            ? snapshot.checkpoints.flatMap((checkpoint) => {
+                if (!checkpoint
+                    || typeof checkpoint.id !== 'string'
+                    || typeof checkpoint.timestamp !== 'number'
+                    || typeof checkpoint.summary !== 'string') {
+                    return [];
+                }
+                const phase = this.normalizeLegacyPhase(checkpoint.phase);
+                const status = this.normalizeLegacyStatus(checkpoint.status);
+                if (!this.isValidPhase(phase) || !this.isValidStatus(status)) {
+                    return [];
+                }
+                return [{
+                        ...checkpoint,
+                        phase,
+                        status
+                    }];
+            })
+            : [];
+        this.lastUserTurn = typeof snapshot?.lastUserTurn === 'string' ? snapshot.lastUserTurn : undefined;
+        this.lastAssistantTurn = typeof snapshot?.lastAssistantTurn === 'string' ? snapshot.lastAssistantTurn : undefined;
+        this.lastIntent = this.isValidIntent(snapshot?.lastIntent) ? snapshot.lastIntent : undefined;
+        this.pendingRecovery = this.normalizePendingRecovery(snapshot?.pendingRecovery);
+        this.verificationTargets = this.verificationTargetTracker.normalize(snapshot?.verificationTargets);
+        this.runLedger = Array.isArray(snapshot?.runLedger)
+            ? snapshot.runLedger.flatMap((entry) => {
+                const normalizedEntry = this.normalizeLegacyRunLedgerEntry(entry);
+                return normalizedEntry ? [normalizedEntry] : [];
+            })
+            : [];
+        this.evidenceLedger = Array.isArray(snapshot?.evidenceLedger)
+            ? snapshot.evidenceLedger.flatMap((entry) => {
+                const normalizedEntry = this.normalizeEvidenceEntry(entry);
+                return normalizedEntry ? [normalizedEntry] : [];
+            }).slice(-CleanSlateTaskSessionService.MAX_EVIDENCE_LEDGER_ENTRIES)
+            : [];
+        const evidenceFilesChanged = this.evidenceLedger.flatMap(entry => entry.filesChanged ?? []);
+        if (evidenceFilesChanged.length > 0) {
+            this.executionFilesChanged = this.evidenceCodec.mergeFileChanges(this.executionFilesChanged, evidenceFilesChanged);
+        }
+        if (options?.markActiveTaskInterrupted && this.shouldMarkInterruptedAfterRestore()) {
+            this.currentStatus = CleanSlateTaskLifecycleStatus.INTERRUPTED;
+            this.lastCheckpointAt = Date.now();
+            this.pushCheckpoint({
+                id: `checkpoint-${this.lastCheckpointAt}-${Math.random().toString(16).slice(2, 6)}`,
+                timestamp: this.lastCheckpointAt,
+                kind: 'resume',
+                phase: this.currentPhase,
+                status: this.currentStatus,
+                summary: `Restored interrupted task in ${this.currentPhase}`,
+                currentWorkItem: this.currentWorkItem
+            });
+        }
+    }
+    normalizeEvidenceEntry(entry) {
+        if (!entry || typeof entry !== 'object') {
+            return undefined;
+        }
+        const candidate = entry;
+        if (!this.isValidEvidenceKind(candidate.kind)) {
+            return undefined;
+        }
+        const timestamp = typeof candidate.timestamp === 'number' && Number.isFinite(candidate.timestamp)
+            ? candidate.timestamp
+            : Date.now();
+        const filesChanged = this.evidenceCodec.normalizeFileChanges(candidate.filesChanged);
+        const paths = this.evidenceCodec.normalizeEvidencePaths(candidate.paths);
+        return {
+            id: typeof candidate.id === 'string' && candidate.id.trim().length > 0
+                ? candidate.id.trim()
+                : `evidence-${timestamp}-${Math.random().toString(16).slice(2, 8)}`,
+            timestamp,
+            kind: candidate.kind,
+            phase: this.normalizeEvidencePhase(candidate.phase),
+            status: this.isValidStatus(candidate.status) ? candidate.status : this.currentStatus,
+            taskId: this.evidenceCodec.trimOptional(candidate.taskId),
+            runId: this.evidenceCodec.trimOptional(candidate.runId),
+            toolName: this.evidenceCodec.trimOptional(candidate.toolName),
+            toolCallId: this.evidenceCodec.trimOptional(candidate.toolCallId),
+            success: typeof candidate.success === 'boolean' ? candidate.success : undefined,
+            summary: this.evidenceCodec.trimOptional(candidate.summary),
+            error: this.evidenceCodec.trimOptional(candidate.error),
+            code: this.evidenceCodec.trimOptional(candidate.code),
+            input: this.evidenceCodec.sanitizeEvidenceValue(candidate.input),
+            result: this.evidenceCodec.sanitizeEvidenceValue(candidate.result),
+            paths: paths.length > 0 ? paths : undefined,
+            filesChanged: filesChanged.length > 0 ? filesChanged : undefined,
+            command: this.evidenceCodec.trimOptional(candidate.command),
+            cwd: this.evidenceCodec.trimOptional(candidate.cwd),
+            processId: this.evidenceCodec.trimOptional(candidate.processId),
+            pid: typeof candidate.pid === 'number' && Number.isFinite(candidate.pid) ? candidate.pid : undefined,
+            exitCode: typeof candidate.exitCode === 'number' && Number.isFinite(candidate.exitCode) ? candidate.exitCode : undefined,
+            durationMs: typeof candidate.durationMs === 'number' && Number.isFinite(candidate.durationMs) ? candidate.durationMs : undefined,
+            url: this.evidenceCodec.trimOptional(candidate.url),
+            screenshotCount: typeof candidate.screenshotCount === 'number' && Number.isFinite(candidate.screenshotCount) ? candidate.screenshotCount : undefined,
+            browserPageCount: typeof candidate.browserPageCount === 'number' && Number.isFinite(candidate.browserPageCount) ? candidate.browserPageCount : undefined,
+            turnId: this.evidenceCodec.trimOptional(candidate.turnId),
+            turnIndex: typeof candidate.turnIndex === 'number' && Number.isFinite(candidate.turnIndex) ? candidate.turnIndex : undefined
+        };
+    }
+    normalizePendingRecovery(value) {
+        if (!value || typeof value !== 'object') {
+            return undefined;
+        }
+        const candidate = value;
+        const prompt = typeof candidate.prompt === 'string' ? candidate.prompt.trim() : '';
+        if (!prompt) {
+            return undefined;
+        }
+        return {
+            prompt,
+            updatedAt: typeof candidate.updatedAt === 'number' && Number.isFinite(candidate.updatedAt) ? candidate.updatedAt : Date.now(),
+            toolName: this.evidenceCodec.trimOptional(candidate.toolName),
+            code: this.evidenceCodec.trimOptional(candidate.code)
+        };
+    }
+    shouldMarkInterruptedAfterRestore() {
+        if (this.awaitingApproval || this.currentTaskKind === CleanSlateTaskKind.CHAT) {
+            return false;
+        }
+        return this.currentStatus === CleanSlateTaskLifecycleStatus.PLANNING
+            || this.currentStatus === CleanSlateTaskLifecycleStatus.EXECUTING
+            || this.currentStatus === CleanSlateTaskLifecycleStatus.VERIFYING;
+    }
+    phaseToStatus(phase) {
+        switch (phase) {
+            case AgentPhase.EXECUTION:
+                return CleanSlateTaskLifecycleStatus.EXECUTING;
+            case AgentPhase.VERIFICATION:
+                return CleanSlateTaskLifecycleStatus.VERIFYING;
+            case AgentPhase.PLANNING:
+            default:
+                return CleanSlateTaskLifecycleStatus.PLANNING;
+        }
+    }
+    generateTaskId() {
+        return `task-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
+    }
+    generateRunId() {
+        return `run-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
+    }
+    isTerminalStatus(status) {
+        return status === CleanSlateTaskLifecycleStatus.COMPLETED
+            || status === CleanSlateTaskLifecycleStatus.FAILED
+            || status === CleanSlateTaskLifecycleStatus.CANCELLED;
+    }
+    deriveCurrentWorkItem(toDo) {
+        const active = toDo.find(item => /^\s*\[(?:\s|\/)\]/.test(item))
+            ?? toDo.find(item => /^\s*\[x\]/i.test(item))
+            ?? toDo.at(-1);
+        if (!active) {
+            return undefined;
+        }
+        const clean = active.replace(/^\s*[-*]?\s*\[[xX/\s]\]\s*/, '').trim();
+        return clean || undefined;
+    }
+    pushCheckpoint(checkpoint) {
+        this.checkpoints.push(checkpoint);
+        if (this.checkpoints.length > CleanSlateTaskSessionService.MAX_CHECKPOINTS) {
+            this.checkpoints.splice(0, this.checkpoints.length - CleanSlateTaskSessionService.MAX_CHECKPOINTS);
+        }
+    }
+    cloneEvidenceEntry(entry) {
+        return {
+            ...entry,
+            input: this.evidenceCodec.sanitizeEvidenceValue(entry.input),
+            result: this.evidenceCodec.sanitizeEvidenceValue(entry.result),
+            paths: entry.paths ? [...entry.paths] : undefined,
+            filesChanged: entry.filesChanged ? entry.filesChanged.map(change => ({ ...change })) : undefined
+        };
+    }
+    archiveCurrentRunIfNeeded(statusOverride) {
+        const entry = this.createRunLedgerEntry(statusOverride);
+        if (!entry) {
+            return;
+        }
+        const existingIndex = this.runLedger.findIndex(run => run.runId === entry.runId);
+        if (existingIndex !== -1) {
+            this.runLedger.splice(existingIndex, 1);
+        }
+        this.runLedger.unshift(entry);
+        if (this.runLedger.length > CleanSlateTaskSessionService.MAX_RUN_LEDGER_ENTRIES) {
+            this.runLedger.length = CleanSlateTaskSessionService.MAX_RUN_LEDGER_ENTRIES;
+        }
+    }
+    collectRecentDiscoveredPathsForNewTask() {
+        const merged = [];
+        const seen = new Set();
+        const addPath = (candidate) => {
+            if (typeof candidate !== 'string') {
+                return;
+            }
+            const normalized = candidate.trim().replace(/\\/g, '/');
+            if (!normalized) {
+                return;
+            }
+            const key = normalized.toLowerCase();
+            if (seen.has(key)) {
+                const existingIndex = merged.findIndex(path => path.toLowerCase() === key);
+                if (existingIndex !== -1) {
+                    merged.splice(existingIndex, 1);
+                }
+            }
+            else {
+                seen.add(key);
+            }
+            merged.push(normalized);
+        };
+        const addPathList = (paths) => {
+            if (!Array.isArray(paths)) {
+                return;
+            }
+            for (const path of paths) {
+                addPath(path);
+            }
+        };
+        for (let i = this.runLedger.length - 1; i >= 0; i--) {
+            addPathList(this.runLedger[i].discoveredPaths);
+        }
+        addPathList(this.discoveredPaths);
+        if (merged.length > CleanSlateTaskSessionService.MAX_SEEDED_DISCOVERED_PATHS) {
+            merged.splice(0, merged.length - CleanSlateTaskSessionService.MAX_SEEDED_DISCOVERED_PATHS);
+        }
+        return merged;
+    }
+    collectRecentSemanticHighlightsForNewTask() {
+        const merged = [];
+        const seen = new Set();
+        const addHighlight = (candidate) => {
+            if (typeof candidate !== 'string') {
+                return;
+            }
+            const normalized = candidate.trim();
+            if (!normalized) {
+                return;
+            }
+            const key = normalized.toLowerCase();
+            if (seen.has(key)) {
+                const existingIndex = merged.findIndex(item => item.toLowerCase() === key);
+                if (existingIndex !== -1) {
+                    merged.splice(existingIndex, 1);
+                }
+            }
+            else {
+                seen.add(key);
+            }
+            merged.push(normalized);
+        };
+        const addHighlightList = (values) => {
+            if (!Array.isArray(values)) {
+                return;
+            }
+            for (const value of values) {
+                addHighlight(value);
+            }
+        };
+        for (let i = this.runLedger.length - 1; i >= 0; i--) {
+            addHighlightList(this.runLedger[i].semanticHighlights);
+        }
+        addHighlightList(this.semanticHighlights);
+        if (merged.length > CleanSlateTaskSessionService.MAX_SEEDED_SEMANTIC_HIGHLIGHTS) {
+            merged.splice(0, merged.length - CleanSlateTaskSessionService.MAX_SEEDED_SEMANTIC_HIGHLIGHTS);
+        }
+        return merged;
+    }
+    createRunLedgerEntry(statusOverride) {
+        if (!this.taskId || !this.runId) {
+            return undefined;
+        }
+        if (this.currentTaskKind === CleanSlateTaskKind.CHAT || this.currentStatus === CleanSlateTaskLifecycleStatus.IDLE) {
+            return undefined;
+        }
+        const status = statusOverride ?? this.currentStatus;
+        return {
+            taskId: this.taskId,
+            runId: this.runId,
+            startedAt: this.startedAt || this.lastCheckpointAt || Date.now(),
+            phase: this.currentPhase,
+            status,
+            objective: this.objective,
+            currentWorkItem: this.currentWorkItem,
+            toDo: [...this.toDo],
+            discoveredPaths: [...this.discoveredPaths],
+            semanticHighlights: [...this.semanticHighlights],
+            lastSummary: this.lastSummary,
+            lastError: this.lastError,
+            lastToolName: this.lastToolName,
+            awaitingApproval: this.awaitingApproval,
+            resumeCount: this.resumeCount,
+            lastCheckpointAt: this.lastCheckpointAt,
+            hasPendingRecovery: this.hasPendingRecovery(),
+            hasPendingVerification: this.hasPendingVerification(),
+            pendingVerificationTargetCount: this.getPendingVerificationTargets().length,
+            taskKind: this.currentTaskKind,
+            workspaceShape: this.currentWorkspaceShape,
+            archivedAt: Date.now()
+        };
+    }
+    getArchiveStatusForTaskSwitch() {
+        if (!this.taskId || this.currentStatus === CleanSlateTaskLifecycleStatus.IDLE || this.currentTaskKind === CleanSlateTaskKind.CHAT) {
+            return undefined;
+        }
+        if (this.isTerminalStatus(this.currentStatus) || this.currentStatus === CleanSlateTaskLifecycleStatus.INTERRUPTED) {
+            return this.currentStatus;
+        }
+        if (this.awaitingApproval) {
+            return CleanSlateTaskLifecycleStatus.AWAITING_APPROVAL;
+        }
+        return CleanSlateTaskLifecycleStatus.INTERRUPTED;
+    }
+    areStringArraysEqual(left, right) {
+        if (left.length !== right.length) {
+            return false;
+        }
+        for (let i = 0; i < left.length; i++) {
+            if (left[i] !== right[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    isValidPhase(value) {
+        return value === AgentPhase.PLANNING
+            || value === AgentPhase.EXECUTION
+            || value === AgentPhase.VERIFICATION;
+    }
+    normalizeEvidencePhase(value) {
+        if (value === 'CHAT') {
+            return 'CHAT';
+        }
+        const phase = this.normalizeLegacyPhase(value);
+        return this.isValidPhase(phase) ? phase : this.currentPhase;
+    }
+    isValidEvidenceKind(value) {
+        return value === 'assistant_turn_start'
+            || value === 'assistant_turn_complete'
+            || value === 'tool_start'
+            || value === 'tool_result'
+            || value === 'read'
+            || value === 'mutation'
+            || value === 'command'
+            || value === 'browser'
+            || value === 'artifact'
+            || value === 'diagnostic'
+            || value === 'completion'
+            || value === 'error';
+    }
+    isValidTaskKind(value) {
+        return value === CleanSlateTaskKind.UNKNOWN
+            || value === CleanSlateTaskKind.CHAT
+            || value === CleanSlateTaskKind.MODIFY_EXISTING
+            || value === CleanSlateTaskKind.BOOTSTRAP_PROJECT;
+    }
+    isValidWorkspaceShape(value) {
+        return value === CleanSlateWorkspaceShape.UNKNOWN
+            || value === CleanSlateWorkspaceShape.EMPTY
+            || value === CleanSlateWorkspaceShape.EXISTING;
+    }
+    isValidStatus(value) {
+        return value === CleanSlateTaskLifecycleStatus.IDLE
+            || value === CleanSlateTaskLifecycleStatus.CHAT
+            || value === CleanSlateTaskLifecycleStatus.PLANNING
+            || value === CleanSlateTaskLifecycleStatus.AWAITING_APPROVAL
+            || value === CleanSlateTaskLifecycleStatus.EXECUTING
+            || value === CleanSlateTaskLifecycleStatus.VERIFYING
+            || value === CleanSlateTaskLifecycleStatus.INTERRUPTED
+            || value === CleanSlateTaskLifecycleStatus.COMPLETED
+            || value === CleanSlateTaskLifecycleStatus.FAILED
+            || value === CleanSlateTaskLifecycleStatus.CANCELLED;
+    }
+    isValidIntent(value) {
+        return value === CleanSlateTurnIntent.APPROVE_PLAN
+            || value === CleanSlateTurnIntent.CONTINUE_CURRENT
+            || value === CleanSlateTurnIntent.START_NEW_TASK
+            || value === CleanSlateTurnIntent.CANCEL_CURRENT
+            || value === CleanSlateTurnIntent.RERUN_LAST_TASK
+            || value === CleanSlateTurnIntent.REVISE_PLAN;
+    }
+    isValidRunLedgerEntry(value) {
+        if (!value || typeof value !== 'object') {
+            return false;
+        }
+        const entry = value;
+        return typeof entry.runId === 'string'
+            && typeof entry.startedAt === 'number'
+            && typeof entry.archivedAt === 'number'
+            && this.isValidPhase(entry.phase)
+            && this.isValidStatus(entry.status)
+            && this.isValidTaskKind(entry.taskKind)
+            && this.isValidWorkspaceShape(entry.workspaceShape);
+    }
+    normalizeLegacyPhase(value) {
+        if (value === 'PREPARING') {
+            return AgentPhase.EXECUTION;
+        }
+        return this.isValidPhase(value) ? value : undefined;
+    }
+    normalizeLegacyStatus(value) {
+        if (value === 'PREPARING') {
+            return CleanSlateTaskLifecycleStatus.EXECUTING;
+        }
+        return this.isValidStatus(value) ? value : undefined;
+    }
+    normalizeLegacyRunLedgerEntry(value) {
+        if (!value || typeof value !== 'object') {
+            return undefined;
+        }
+        const entry = value;
+        const phase = this.normalizeLegacyPhase(entry.phase);
+        const status = this.normalizeLegacyStatus(entry.status);
+        if (!phase || !status) {
+            return undefined;
+        }
+        const normalizedEntry = {
+            ...entry,
+            phase,
+            status
+        };
+        return this.isValidRunLedgerEntry(normalizedEntry) ? normalizedEntry : undefined;
+    }
+}
+//# sourceMappingURL=cleanSlateTaskSessionService.js.map