@danypops/papyrus 0.11.4 → 0.13.0

package/src/ports/task-focus-store.ts

@@ -1,3 +1,5 @@
+import { TASK_FOCUS_DEFAULT_SCOPE, TASK_FOCUS_MAX_SCOPES, TASK_FOCUS_SCOPE_MAX_LENGTH } from "../constants.ts";
+
 export type TaskFocusStatus = "active" | "paused";
 
 export interface TaskFocusState {
@@ -7,37 +9,77 @@ export interface TaskFocusState {
 	pauseReason?: string;
 }
 
+export function normalizeFocusScope(scope: string | undefined): string {
+	const value = scope ?? TASK_FOCUS_DEFAULT_SCOPE;
+	if (value.length === 0 || value.length > TASK_FOCUS_SCOPE_MAX_LENGTH) {
+		throw new Error(`task focus scope must be between 1 and ${TASK_FOCUS_SCOPE_MAX_LENGTH} characters`);
+	}
+	return value;
+}
+
+/**
+ * One Task Focus per scope. A scope defaults to "global" for callers that don't supply
+ * a session id (CLI, legacy behavior) but is normally the requesting agent's session id,
+ * so concurrent agents each get their own Focus instead of clobbering a shared singleton.
+ */
 export interface TaskFocusStore {
-	get(): TaskFocusState | undefined;
-	set(taskId: string): TaskFocusState;
-	pause(taskId: string, reason?: string): TaskFocusState;
-	unpause(taskId: string): TaskFocusState;
-	clear(taskId?: string): void;
+	get(scope?: string): TaskFocusState | undefined;
+	set(taskId: string, scope?: string): TaskFocusState;
+	pause(taskId: string, reason?: string, scope?: string): TaskFocusState;
+	unpause(taskId: string, scope?: string): TaskFocusState;
+	clear(taskId?: string, scope?: string): void;
+	/** Clears this task's Focus in every scope (session), not just one — for lifecycle events (e.g. cancel) that are not scoped to a single caller. */
+	clearEverywhere(taskId: string): void;
 }
 
 export class InMemoryTaskFocusStore implements TaskFocusStore {
-	private state: TaskFocusState | undefined;
+	private readonly state = new Map<string, TaskFocusState>();
 
-	get(): TaskFocusState | undefined { return this.state; }
+	get(scope?: string): TaskFocusState | undefined { return this.state.get(normalizeFocusScope(scope)); }
+
+	set(taskId: string, scope?: string): TaskFocusState {
+		const key = normalizeFocusScope(scope);
+		if (!this.state.has(key) && this.state.size >= TASK_FOCUS_MAX_SCOPES) this.evictOldest();
+		const focus: TaskFocusState = { taskId, status: "active", updatedAt: new Date().toISOString() };
+		this.state.set(key, focus);
+		return focus;
+	}
+
+	pause(taskId: string, reason?: string, scope?: string): TaskFocusState {
+		const key = normalizeFocusScope(scope);
+		const current = this.state.get(key);
+		if (current?.taskId !== taskId) throw new Error(`task "${taskId}" is not focused`);
+		const focus: TaskFocusState = { ...current, status: "paused", updatedAt: new Date().toISOString(), ...(reason ? { pauseReason: reason } : {}) };
+		this.state.set(key, focus);
+		return focus;
+	}
 
-	set(taskId: string): TaskFocusState {
-		this.state = { taskId, status: "active", updatedAt: new Date().toISOString() };
-		return this.state;
+	unpause(taskId: string, scope?: string): TaskFocusState {
+		const key = normalizeFocusScope(scope);
+		const current = this.state.get(key);
+		if (current?.taskId !== taskId) throw new Error(`task "${taskId}" is not focused`);
+		const focus: TaskFocusState = { taskId, status: "active", updatedAt: new Date().toISOString() };
+		this.state.set(key, focus);
+		return focus;
 	}
 
-	pause(taskId: string, reason?: string): TaskFocusState {
-		if (this.state?.taskId !== taskId) throw new Error(`task "${taskId}" is not focused`);
-		this.state = { ...this.state, status: "paused", updatedAt: new Date().toISOString(), ...(reason ? { pauseReason: reason } : {}) };
-		return this.state;
+	clear(taskId?: string, scope?: string): void {
+		const key = normalizeFocusScope(scope);
+		if (taskId === undefined || this.state.get(key)?.taskId === taskId) this.state.delete(key);
 	}
 
-	unpause(taskId: string): TaskFocusState {
-		if (this.state?.taskId !== taskId) throw new Error(`task "${taskId}" is not focused`);
-		this.state = { taskId, status: "active", updatedAt: new Date().toISOString() };
-		return this.state;
+	clearEverywhere(taskId: string): void {
+		for (const [key, focus] of this.state) {
+			if (focus.taskId === taskId) this.state.delete(key);
+		}
 	}
 
-	clear(taskId?: string): void {
-		if (taskId === undefined || this.state?.taskId === taskId) this.state = undefined;
+	private evictOldest(): void {
+		let oldestKey: string | undefined;
+		let oldestAt: string | undefined;
+		for (const [key, focus] of this.state) {
+			if (oldestAt === undefined || focus.updatedAt < oldestAt) { oldestKey = key; oldestAt = focus.updatedAt; }
+		}
+		if (oldestKey !== undefined) this.state.delete(oldestKey);
 	}
 }