@tekmidian/pai 0.66.1 → 0.66.2

package/dist/work-queue-worker-4tLa5gpQ.mjs

@@ -1,567 +0,0 @@
-import { A as archiveSessionFilesToSessionsDir, D as appendCheckpoint, E as addWorkToSessionNote, F as performScan, O as finalizeSessionNote, _ as spawnSummarizer, a as enqueue, b as updateTodoContinue, f as contentToText$2, h as handleSessionSummary, i as dequeue, j as findNotesDir, k as getCurrentNotePath, l as markCompleted, m as getGitContext, n as writeContextHandoverCache, p as findLatestJsonl, r as cleanup, s as hasPendingOrProcessingOfType, t as readContextHandoverCache, u as markFailed, y as sessionIdFromTranscript } from "./context-handover-cache-pkHzmL3c.mjs";
-import { d as registryBackend, k as storageBackend } from "./state-HyjqTihC.mjs";
-import { t as detectTopicShift } from "./detector-BRTtAWrM.mjs";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
-
-//#region src/daemon/templates/context-handover-prompt.ts
-function buildContextHandoverPrompt(params) {
-	const { turns, gitLog, cwd, previousHandover } = params;
-	const turnsSection = turns.length > 0 ? turns.join("\n\n") : "(No turns extracted)";
-	const gitSection = gitLog.trim() || "(No git commits during this session)";
-	return `This session is approaching a context-window compaction. Write the \
-handover that would let a successor continue WITHOUT re-reading this \
-conversation and WITHOUT asking the user to repeat themselves.
-
-Project directory: ${cwd}
-${previousHandover ? `\nA PREVIOUS HANDOVER already exists for this session (from an earlier, \
-lower threshold). Carry it forward — start your response with a one-line \
-pointer to it ("Carries forward from the previous handover, which stays for \
-its detail.") and then write only what has happened SINCE it that a compact \
-would also lose. Do not re-derive or repeat what it already covered.\n\n\
-PREVIOUS HANDOVER:\n${previousHandover}\n` : ""}
-SCOPING RULE — the single most important instruction here: this is a DIFF \
-against everything already durable, not a summary of the session. Assume \
-the successor can and will read git history, the issue tracker, and any \
-notes files themselves. Do NOT restate anything recoverable there — no file \
-inventories, no "implemented X" restatements, no chronology of commands run. \
-Write down ONLY what existed exclusively in this conversation and would \
-otherwise be gone: the reasoning, not the result.
-
-Write ONLY the sections below that this session actually has content for — \
-omit a section entirely rather than writing "none" or padding it:
-
-WHERE THIS SESSION ENDED — the concrete state right now: what is verified \
-working (tests green, tree clean, etc.) versus merely attempted, any branch \
-or working-tree state that isn't obvious from git status alone (e.g. a \
-detached HEAD, an intentionally uncommitted change, a stash).
-
-WHAT CLOSED — each item paired with the evidence that closed it, not just \
-the claim that it did.
-
-WHAT IS FILED AND STILL OPEN — each with its next concrete step or who/what \
-it is waiting on.
-
-DECISIONS & REASONING — choices actually made, each with why this way and \
-not another way.
-
-REJECTED ALTERNATIVES — approaches considered and set aside, and why. An \
-alternative without a reason is not worth recording.
-
-NEGATIVE RESULTS — something investigated that turned out NOT to be the \
-answer, kept WITH the reasoning that ruled it out (e.g. "X looked like the \
-cause — it wasn't; the actual mechanism was Y"). Without the reasoning \
-attached, a successor re-investigates the same dead end.
-
-TRAPS — anything discovered that is invisible from the repo alone and would \
-otherwise bite a successor immediately (a required manual step, an ordering \
-constraint, a state that looks fine but isn't).
-
-CRITICAL VALUES — any specific id, path, URL, credential name, version \
-number, or configuration value that appeared in conversation and whose loss \
-would force someone to go find it again.
-
-THE FEW THINGS THAT MATTER MOST, IF NOTHING ELSE IS READ — at most 3 bullets. \
-Forces a priority judgement; do not pad this to fill space.
-
-Format your response as markdown with those section headers (only the ones \
-you have content for), no other structure.
-
----
-
-CONVERSATION:
-${turnsSection}
-
-GIT COMMITS:
-${gitSection}`;
-}
-
-//#endregion
-//#region src/daemon/context-handover-worker.ts
-/**
-* context-handover-worker.ts — the threshold-triggered pre-compaction
-* handover.
-*
-* `session-summary-worker.ts` already spawns a model to write session notes,
-* but only from the PreCompact hook itself — which fires at the compaction
-* boundary, far too late to be injected INTO that same compaction's
-* post-compact context. This worker runs earlier, off a token-count
-* threshold (see ../hooks/ts/lib/context-fill.ts), so a model-written
-* handover already exists in a cache file by the time compaction happens.
-*
-* Deliberately narrow: this does not write a session note, does not touch
-* the session-summary cooldown file, and does not run KG extraction. It
-* writes one thing — a cache file the PreCompact hook can read — because its
-* only job is to exist before compaction does, not to duplicate what
-* session-summary-worker already does well.
-*
-* The prompt itself (see templates/context-handover-prompt.ts) treats the
-* handover as a DIFF against everything already durable — git, the tracker,
-* the notes — not a session summary, and a refresh run carries the previous
-* cached handover forward rather than overwriting it.
-*/
-/** How much of the tail of the transcript to feed the summarizer. Generous —
-*  this runs at most twice per session, not on every tool call. */
-const MAX_TURN_CHARS = 15e4;
-/** Max turns to include (a hard floor even if MAX_TURN_CHARS is not hit). */
-const MAX_TURNS = 120;
-/**
-* Interleaved "User:"/"Assistant:" turns, oldest-kept-from-the-end so a long
-* transcript is truncated to its most recent content rather than its
-* earliest. Unlike session-summary-worker's extractFromJsonl (which keeps
-* only user messages, because a session note doesn't need the assistant's
-* own reasoning) this keeps BOTH sides — the whole point of this prompt is
-* the assistant's reasoning, which lives in assistant turns.
-*/
-function extractTurns(jsonlPath) {
-	let raw;
-	try {
-		raw = readFileSync(jsonlPath, "utf-8");
-	} catch {
-		return [];
-	}
-	if (raw.length > MAX_TURN_CHARS) {
-		const truncPoint = raw.indexOf("\n", raw.length - MAX_TURN_CHARS);
-		raw = truncPoint >= 0 ? raw.slice(truncPoint + 1) : raw.slice(-MAX_TURN_CHARS);
-	}
-	const turns = [];
-	for (const line of raw.trim().split("\n")) {
-		if (!line.trim()) continue;
-		let entry;
-		try {
-			entry = JSON.parse(line);
-		} catch {
-			continue;
-		}
-		if (entry.type === "user") {
-			const msg = entry.message;
-			const text = contentToText$2(msg?.content);
-			if (text && text.length >= 3 && !text.startsWith("<system-reminder>")) turns.push(`User: ${text.slice(0, 2e3)}`);
-		} else if (entry.type === "assistant") {
-			const msg = entry.message;
-			const text = contentToText$2(msg?.content);
-			if (text && text.length >= 3) turns.push(`Assistant: ${text.slice(0, 4e3)}`);
-		}
-	}
-	return turns.slice(-MAX_TURNS);
-}
-/**
-* Process a `context-handover` work item.
-*
-* THROWS on every failure path (missing input, no transcript, no turns, an
-* empty/failed summarizer run) rather than logging and returning silently.
-* That used to be a deliberate choice — avoid the work queue's own retry
-* piling up redundant LLM calls — but it made a real failure invisible: a
-* daemon restart mid-spawn (session 77084e72-...) left no cache, no error
-* anywhere the work queue's own stats could show, and a trigger-side marker
-* that (at the time) had already been set to "done". Throwing here makes
-* work-queue-worker.ts call markFailed(), which logs prominently AND is
-* visible via `work_queue_stats` / `pai daemon status` — not just a stderr
-* line that can scroll away. It is a second, faster (seconds-to-minutes
-* backoff) retry path alongside the primary one in context-handover-
-* trigger.ts (which retries on its own ~5-minute cadence based on whether a
-* cache actually appeared); the two are complementary, not redundant — a
-* failed cache write costs nothing to retry twice.
-*/
-async function handleContextHandover(payload) {
-	const { cwd, sessionId, transcriptPath, threshold, urgent } = payload;
-	if (!cwd || !sessionId) throw new Error("[context-handover] payload missing cwd or sessionId");
-	process.stderr.write(`[context-handover] Starting for ${cwd} (session=${sessionId}, threshold=${threshold}${urgent ? ", urgent" : ""}).\n`);
-	let jsonlPath = transcriptPath && existsSync(transcriptPath) ? transcriptPath : null;
-	if (!jsonlPath) jsonlPath = findLatestJsonl(cwd);
-	if (!jsonlPath) throw new Error(`[context-handover] No transcript found for ${cwd} (session=${sessionId})`);
-	const turns = extractTurns(jsonlPath);
-	if (turns.length === 0) throw new Error(`[context-handover] No turns extracted from ${jsonlPath} (session=${sessionId})`);
-	const prompt = buildContextHandoverPrompt({
-		turns,
-		gitLog: await getGitContext(cwd),
-		cwd,
-		previousHandover: readContextHandoverCache(sessionId)?.summary
-	});
-	process.stderr.write(`[context-handover] Sending ${prompt.length} char prompt to sonnet...\n`);
-	const summary = await spawnSummarizer(prompt, "sonnet");
-	if (!summary || !summary.trim()) throw new Error(`[context-handover] sonnet produced no output (session=${sessionId})`);
-	writeContextHandoverCache({
-		sessionId,
-		cwd,
-		threshold,
-		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-		model: "sonnet",
-		summary: summary.trim()
-	});
-	process.stderr.write(`[context-handover] Wrote cache for session ${sessionId} (${summary.length} chars).\n`);
-}
-
-//#endregion
-//#region src/daemon/topic-detect-worker.ts
-/**
-* topic-detect-worker.ts — Topic shift detection for session note splitting
-*
-* Processes `topic-detect` work items by:
-*   1. Extracting recent user messages from the JSONL transcript
-*   2. Running the BM25-based topic shift detector against the PAI memory DB
-*   3. If a shift is detected, recording a topic boundary marker
-*
-* The actual note splitting is handled by session-summary-worker.ts when it
-* processes the next `session-summary` work item — it uses the TOPIC: line
-* from the summarizer to decide whether to create a new note.
-*
-* This worker provides an additional signal: project-level topic shift
-* (e.g., conversation moved from project A to project B). The session
-* summary worker handles intra-project topic shifts (e.g., from "dark mode"
-* to "keyboard IPC" within the same project).
-*/
-const MAX_CONTEXT_MESSAGES = 5;
-const MAX_CONTEXT_CHARS = 2e3;
-/**
-* Extract recent user messages from a JSONL transcript for topic detection.
-* Takes only the last few messages to represent the current topic.
-*/
-function extractRecentContext(jsonlPath) {
-	try {
-		const raw = readFileSync(jsonlPath, "utf-8");
-		const lines = (raw.length > 5e4 ? raw.slice(-5e4) : raw).trim().split("\n");
-		const messages = [];
-		for (let i = lines.length - 1; i >= 0 && messages.length < MAX_CONTEXT_MESSAGES; i--) {
-			const line = lines[i].trim();
-			if (!line) continue;
-			try {
-				const entry = JSON.parse(line);
-				if (entry.type === "user") {
-					const msg = entry.message;
-					if (msg?.content) {
-						const text = contentToText$1(msg.content);
-						if (text && text.length > 3) messages.unshift(text.slice(0, 500));
-					}
-				}
-			} catch {}
-		}
-		return messages.join("\n\n").slice(0, MAX_CONTEXT_CHARS);
-	} catch {
-		return "";
-	}
-}
-/** Convert Claude content (string or content block array) to plain text. */
-function contentToText$1(content) {
-	if (typeof content === "string") return content;
-	if (Array.isArray(content)) return content.map((c) => {
-		if (typeof c === "string") return c;
-		const block = c;
-		if (block?.text) return String(block.text);
-		if (block?.content) return String(block.content);
-		return "";
-	}).join(" ").trim();
-	return "";
-}
-const TOPIC_BOUNDARY_FILE = "topic-boundary.json";
-/**
-* Write a topic boundary marker into the Notes directory.
-* The session-summary-worker checks for this file and uses it as an
-* additional signal that a new note should be created.
-*/
-function writeTopicBoundary(cwd, boundary) {
-	try {
-		const boundaryPath = join(findNotesDir(cwd).path, TOPIC_BOUNDARY_FILE);
-		writeFileSync(boundaryPath, JSON.stringify(boundary, null, 2), "utf-8");
-		process.stderr.write(`[topic-detect] Wrote topic boundary marker: ${boundaryPath}\n`);
-	} catch (e) {
-		process.stderr.write(`[topic-detect] Could not write boundary marker: ${e}\n`);
-	}
-}
-/**
-* Process a `topic-detect` work item.
-*
-* Called by work-queue-worker.ts. Throws on fatal errors so the work queue
-* retry logic handles them.
-*/
-async function handleTopicDetect(payload) {
-	const { cwd, currentProject, transcriptPath, sessionId } = payload;
-	if (!cwd) throw new Error("topic-detect payload missing cwd");
-	process.stderr.write(`[topic-detect] Starting for ${cwd}${currentProject ? ` (project=${currentProject})` : ""}${sessionId ? ` (session=${sessionId})` : ""}\n`);
-	if (!registryBackend || !storageBackend) {
-		process.stderr.write("[topic-detect] Registry backend or storage backend not available — skipping.\n");
-		return;
-	}
-	let context = payload.context || "";
-	if (!context && transcriptPath && existsSync(transcriptPath)) context = extractRecentContext(transcriptPath);
-	if (!context || context.trim().length < 10) {
-		process.stderr.write("[topic-detect] Insufficient context for topic detection — skipping.\n");
-		return;
-	}
-	process.stderr.write(`[topic-detect] Context: ${context.length} chars, checking against memory...\n`);
-	const result = await detectTopicShift(registryBackend, storageBackend, {
-		context,
-		currentProject,
-		threshold: .6,
-		candidates: 20
-	});
-	process.stderr.write(`[topic-detect] Result: shifted=${result.shifted}, suggested=${result.suggestedProject}, confidence=${result.confidence.toFixed(2)}, chunks=${result.chunkCount}\n`);
-	if (result.topProjects.length > 0) process.stderr.write(`[topic-detect] Top projects: ${result.topProjects.map((p) => `${p.slug}(${(p.score * 100).toFixed(0)}%)`).join(", ")}\n`);
-	if (result.shifted) {
-		writeTopicBoundary(cwd, {
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			previousProject: result.currentProject,
-			suggestedProject: result.suggestedProject,
-			confidence: result.confidence,
-			context: context.slice(0, 200)
-		});
-		try {
-			const notePath = getCurrentNotePath(findNotesDir(cwd).path);
-			if (notePath) appendCheckpoint(notePath, `Topic shift detected: conversation moved from **${result.currentProject}** to **${result.suggestedProject}** (confidence: ${(result.confidence * 100).toFixed(0)}%). A new session note will be created for the new topic.`);
-		} catch (e) {
-			process.stderr.write(`[topic-detect] Could not append checkpoint: ${e}\n`);
-		}
-	}
-	process.stderr.write("[topic-detect] Done.\n");
-}
-
-//#endregion
-//#region src/daemon/work-queue-worker.ts
-/**
-* work-queue-worker.ts — Daemon worker loop for the persistent work queue
-*
-* Runs every 5 seconds to drain the queue.
-* Handles 'session-end' work items by reading the transcript, extracting
-* work summaries, updating the session note, and updating TODO.md.
-* Handles 'session-summary' items by spawning Haiku for AI-powered note generation.
-* Handles 'context-handover' items by spawning Sonnet to write the
-* threshold-triggered pre-compaction reasoning handover (see
-* context-handover-worker.ts and hooks/ts/lib/context-fill.ts).
-* Handles 'registry-scan' items by running performScan() against the registry DB.
-*
-* Handles 'topic-detect' items by running BM25-based topic shift detection.
-* Other item types (note-update, todo-update) are stubs — they log and
-* complete immediately, ready for future expansion.
-*/
-const WORKER_INTERVAL_MS = 5e3;
-const HOUSEKEEPING_INTERVAL_MS = 600 * 1e3;
-let workerTimer = null;
-let housekeepingTimer = null;
-/** Start the background worker and housekeeping timers. */
-function startWorker() {
-	process.stderr.write("[work-queue-worker] Starting worker loop.\n");
-	workerTimer = setInterval(async () => {
-		try {
-			await processNextItem();
-		} catch (e) {
-			process.stderr.write(`[work-queue-worker] Uncaught error in worker loop: ${e}\n`);
-		}
-	}, WORKER_INTERVAL_MS);
-	housekeepingTimer = setInterval(() => {
-		try {
-			cleanup();
-		} catch (e) {
-			process.stderr.write(`[work-queue-worker] Housekeeping error: ${e}\n`);
-		}
-	}, HOUSEKEEPING_INTERVAL_MS);
-	process.stderr.write("[work-queue-worker] Worker started (interval=5s, housekeeping=10min).\n");
-}
-/** Stop the worker timers gracefully. */
-function stopWorker() {
-	if (workerTimer !== null) {
-		clearInterval(workerTimer);
-		workerTimer = null;
-	}
-	if (housekeepingTimer !== null) {
-		clearInterval(housekeepingTimer);
-		housekeepingTimer = null;
-	}
-	process.stderr.write("[work-queue-worker] Worker stopped.\n");
-}
-/**
-* Signal that new work has been enqueued.
-* The worker will run on its next tick — we don't need to reset the timer
-* since 5 s is fast enough. The flag allows future optimisations.
-*/
-function notifyNewWork() {}
-async function processNextItem() {
-	const item = dequeue();
-	if (!item) return;
-	process.stderr.write(`[work-queue-worker] Processing ${item.type} (id=${item.id}, attempt=${item.attempts}).\n`);
-	try {
-		switch (item.type) {
-			case "session-end":
-				await handleSessionEnd(item);
-				break;
-			case "session-summary":
-				await handleSessionSummary(item.payload);
-				break;
-			case "context-handover":
-				await handleContextHandover(item.payload);
-				break;
-			case "topic-detect":
-				await handleTopicDetect(item.payload);
-				break;
-			case "registry-scan":
-				await handleRegistryScan();
-				break;
-			case "note-update":
-			case "todo-update":
-				process.stderr.write(`[work-queue-worker] Item type '${item.type}' is not yet implemented — completing as no-op.\n`);
-				break;
-			default: throw new Error(`Unknown work item type: ${item.type}`);
-		}
-		markCompleted(item.id);
-		process.stderr.write(`[work-queue-worker] Completed ${item.type} (id=${item.id}).\n`);
-	} catch (e) {
-		const msg = e instanceof Error ? e.message : String(e);
-		markFailed(item.id, msg);
-	}
-}
-/**
-* Process a 'session-end' work item.
-*
-* Expected payload:
-*   transcriptPath: string   — absolute path to the .jsonl transcript
-*   cwd: string              — working directory of the session
-*   message?: string         — COMPLETED: line extracted by the hook (optional)
-*/
-async function handleSessionEnd(item) {
-	const { transcriptPath, cwd, message: hookMessage } = item.payload;
-	if (!transcriptPath) throw new Error("session-end payload missing transcriptPath");
-	if (!cwd) throw new Error("session-end payload missing cwd");
-	let transcript;
-	try {
-		transcript = readFileSync(transcriptPath, "utf-8");
-	} catch (e) {
-		throw new Error(`Could not read transcript at ${transcriptPath}: ${e}`);
-	}
-	const lines = transcript.trim().split("\n");
-	const workItems = extractWorkFromTranscript(lines);
-	let message = hookMessage ?? "";
-	if (!message) {
-		const lastEntry = tryParseJson(lines[lines.length - 1]);
-		if (lastEntry?.type === "assistant" && lastEntry.message?.content) {
-			const m = contentToText(lastEntry.message.content).match(/COMPLETED:\s*(.+?)(?:\n|$)/i);
-			if (m) message = m[1].trim().replace(/\*+/g, "").replace(/\[.*?\]/g, "").trim();
-		}
-	}
-	const currentNotePath = getCurrentNotePath(findNotesDir(cwd).path);
-	if (currentNotePath) {
-		if (workItems.length > 0) {
-			addWorkToSessionNote(currentNotePath, workItems);
-			process.stderr.write(`[work-queue-worker] Added ${workItems.length} work item(s) to note.\n`);
-		} else if (message) {
-			addWorkToSessionNote(currentNotePath, [{
-				title: message,
-				completed: true
-			}]);
-			process.stderr.write("[work-queue-worker] Added completion message to note.\n");
-		}
-		finalizeSessionNote(currentNotePath, message || "Session completed.");
-		process.stderr.write(`[work-queue-worker] Finalized session note: ${basename(currentNotePath)}.\n`);
-		if (workItems.length === 0 && !message) process.stderr.write("[work-queue-worker] Nothing to hand over — leaving TODO.md ## Continue intact.\n");
-		else try {
-			const stateLines = [];
-			stateLines.push(`Working directory: ${cwd}`);
-			if (workItems.length > 0) {
-				stateLines.push("", "Work completed:");
-				for (const wi of workItems.slice(0, 5)) stateLines.push(`- ${wi.title}`);
-			}
-			if (message) stateLines.push("", `Last completed: ${message}`);
-			updateTodoContinue(cwd, basename(currentNotePath), stateLines.join("\n"), "session-end", sessionIdFromTranscript(transcriptPath));
-		} catch (todoError) {
-			process.stderr.write(`[work-queue-worker] Could not update TODO.md: ${todoError}\n`);
-		}
-	} else process.stderr.write("[work-queue-worker] No current session note found — skipping note update.\n");
-	try {
-		const archivedCount = archiveSessionFilesToSessionsDir(dirname(transcriptPath));
-		if (archivedCount > 0) process.stderr.write(`[work-queue-worker] Archived ${archivedCount} session file(s) to sessions/.\n`);
-	} catch (moveError) {
-		process.stderr.write(`[work-queue-worker] Could not move session files: ${moveError}\n`);
-	}
-}
-/**
-* Run performScan() against the registry DB.
-*
-* Debounce: if another registry-scan job is already pending in the queue,
-* we still run this one (dequeue already picked it), but enqueueRegistryScan()
-* checks before enqueuing so duplicates rarely reach here.
-*/
-async function handleRegistryScan() {
-	if (!registryBackend) throw new Error("registry-scan: registryBackend not initialized yet");
-	const t0 = Date.now();
-	process.stderr.write("[work-queue-worker] Running registry scan...\n");
-	const result = await performScan();
-	const elapsed = Date.now() - t0;
-	process.stderr.write(`[work-queue-worker] Registry scan complete: ${result.projectsScanned} projects (${result.projectsNew} new, ${result.projectsUpdated} updated), ${result.sessionsScanned} sessions (${result.sessionsNew} new) in ${elapsed}ms.\n`);
-	if (result.skipped.length > 0) process.stderr.write(`[work-queue-worker] Registry scan: ${result.skipped.length} project(s) skipped (path not found).\n`);
-}
-/**
-* Enqueue a registry-scan work item — debounced.
-* If a registry-scan item is already pending or processing, skip enqueue.
-*/
-function enqueueRegistryScan() {
-	if (hasPendingOrProcessingOfType("registry-scan")) {
-		process.stderr.write("[work-queue-worker] Registry scan already pending/processing — skipping duplicate enqueue.\n");
-		return;
-	}
-	enqueue({
-		type: "registry-scan",
-		priority: 5,
-		payload: {}
-	});
-}
-function tryParseJson(line) {
-	try {
-		return JSON.parse(line);
-	} catch {
-		return null;
-	}
-}
-function contentToText(content) {
-	if (typeof content === "string") return content;
-	if (Array.isArray(content)) return content.map((c) => {
-		if (typeof c === "string") return c;
-		const block = c;
-		if (block?.text) return String(block.text);
-		if (block?.content) return String(block.content);
-		return "";
-	}).join(" ").trim();
-	return "";
-}
-function extractWorkFromTranscript(lines) {
-	const workItems = [];
-	const seenSummaries = /* @__PURE__ */ new Set();
-	for (const line of lines) {
-		const entry = tryParseJson(line);
-		if (!entry || entry.type !== "assistant") continue;
-		const msg = entry.message;
-		if (!msg?.content) continue;
-		const content = contentToText(msg.content);
-		const summaryMatch = content.match(/SUMMARY:\s*(.+?)(?:\n|$)/i);
-		if (summaryMatch) {
-			const summary = summaryMatch[1].trim();
-			if (summary && !seenSummaries.has(summary) && summary.length > 5) {
-				seenSummaries.add(summary);
-				const details = [];
-				const actionsMatch = content.match(/ACTIONS:\s*(.+?)(?=\n[A-Z]+:|$)/is);
-				if (actionsMatch) {
-					const actionLines = actionsMatch[1].split("\n").map((l) => l.replace(/^[-*•]\s*/, "").replace(/^\d+\.\s*/, "").trim()).filter((l) => l.length > 3 && l.length < 100);
-					details.push(...actionLines.slice(0, 3));
-				}
-				workItems.push({
-					title: summary,
-					details: details.length > 0 ? details : void 0,
-					completed: true
-				});
-			}
-		}
-		const completedMatch = content.match(/COMPLETED:\s*(.+?)(?:\n|$)/i);
-		if (completedMatch && workItems.length === 0) {
-			const completed = completedMatch[1].trim().replace(/\*+/g, "").replace(/\[.*?\]/g, "").trim();
-			if (completed && !seenSummaries.has(completed) && completed.length > 5) {
-				seenSummaries.add(completed);
-				workItems.push({
-					title: completed,
-					completed: true
-				});
-			}
-		}
-	}
-	return workItems;
-}
-
-//#endregion
-export { stopWorker as i, notifyNewWork as n, startWorker as r, enqueueRegistryScan as t };
-//# sourceMappingURL=work-queue-worker-4tLa5gpQ.mjs.map