@askexenow/exe-os 0.9.271 → 0.9.273

package/dist/chunk-GESN6IDC.js

@@ -0,0 +1,127 @@
+import {
+  updateTask
+} from "./chunk-MY647ZHR.js";
+import {
+  TASK_ALREADY_CLAIMED_PREFIX
+} from "./chunk-5M5RYJ22.js";
+
+// src/mcp/tools/update-task.ts
+import { z } from "zod";
+function registerUpdateTask(server) {
+  server.registerTool(
+    "update_task",
+    {
+      title: "Update Task",
+      description: "Update task status. Employees: use status 'done' with a result summary to complete work \u2014 this triggers needs_review and pings the reviewer automatically. Accepts UUID, slug (filename), or title substring.",
+      inputSchema: {
+        task_id: z.string().describe("Task identifier \u2014 UUID, slug (e.g. 'fix-auth-bug'), or title substring"),
+        status: z.enum(["open", "in_progress", "done", "needs_review", "blocked", "cancelled", "closed"]).describe("New status. 'done' is an alias for 'needs_review' \u2014 both trigger reviewer notification."),
+        result: z.string().optional().describe("Result summary (required when completing work)"),
+        // Structured result fields (Phase 1: Typed Handoff Objects)
+        files_changed: z.array(z.string()).optional().describe("Files created or modified during task execution"),
+        decisions: z.array(z.string()).optional().describe("Key decisions made during execution"),
+        commits: z.array(z.string()).optional().describe("Commit hashes produced"),
+        tests_status: z.enum(["pass", "fail", "skip", "none"]).optional().describe("Test execution status"),
+        build_status: z.enum(["pass", "fail", "skip"]).optional().describe("Build status"),
+        pr_number: z.number().optional().describe("PR number if created"),
+        open_questions: z.array(z.string()).optional().describe("Open questions for reviewer"),
+        assertions: z.string().optional().describe(
+          'JSON array of assertions with confidence scores. Use when starting work (in_progress). Format: [{"type":"diagnosis|scope|estimate|approach|build|judgment","claim":"...","confidence":0.8,"basis":"..."}]'
+        ),
+        assertions_resolved: z.string().optional().describe(
+          'JSON array of resolved assertions. Use when completing work (done/needs_review). Format: [{"claim":"...","outcome":"correct|incorrect|partial","confidence_was":0.8,"actual":"...","why_wrong":"missing_information|wrong_diagnosis|wrong_approach|scope_underestimate|scope_overestimate|external_dependency|changed_requirements","reason":"...","lesson":"..."}]'
+        ),
+        estimated_minutes: z.number().optional().describe("Time estimate in minutes. Provide when starting work (in_progress). The system auto-computes actual time on completion."),
+        estimate_confidence: z.number().min(0).max(1).optional().describe("Confidence in time estimate (0.0-1.0). Provide alongside estimated_minutes.")
+      }
+    },
+    async ({ task_id, status: rawStatus, result, files_changed, decisions, commits, tests_status, build_status, pr_number, open_questions, assertions, assertions_resolved, estimated_minutes, estimate_confidence }) => {
+      const status = rawStatus;
+      let callerAgentId;
+      let callerSession;
+      try {
+        const { getActiveAgent: getAgent } = await import("./active-agent-YWBGAKGU.js");
+        callerAgentId = getAgent().agentId;
+        const { getAgentContext } = await import("./agent-context-AZTTMUHP.js");
+        callerSession = getAgentContext()?.sessionHint || process.env.EXE_SESSION_NAME || process.env.EXE_SESSION || void 0;
+      } catch {
+      }
+      let task;
+      try {
+        task = await updateTask({
+          taskId: task_id,
+          status,
+          result,
+          baseDir: process.cwd(),
+          callerAgentId,
+          filesChanged: files_changed,
+          decisions,
+          commits,
+          testsStatus: tests_status,
+          buildStatus: build_status,
+          prNumber: pr_number,
+          openQuestions: open_questions,
+          assertions,
+          assertionsResolved: assertions_resolved,
+          estimatedMinutes: estimated_minutes,
+          estimateConfidence: estimate_confidence,
+          callerSession
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.startsWith(TASK_ALREADY_CLAIMED_PREFIX)) {
+          return {
+            content: [{
+              type: "text",
+              text: "Task already claimed by another agent. Pick a different task or check list_tasks."
+            }],
+            isError: true
+          };
+        }
+        throw err;
+      }
+      let text = `Task "${task.title}" marked ${task.status}.
+File: ${task.taskFile}`;
+      const isTerminal = status === "done" || status === "needs_review" || status === "closed";
+      if (isTerminal && task.reviewer) {
+        try {
+          const { notifyCoordinatorTaskCompletion } = await import("./lib/tmux-routing.js");
+          const { isCoordinatorName } = await import("./lib/employees.js");
+          const reviewer = String(task.reviewer);
+          const coordinatorSession = task.sessionScope;
+          if (coordinatorSession && isCoordinatorName(reviewer)) {
+            notifyCoordinatorTaskCompletion(coordinatorSession, callerAgentId ?? "agent", task.title);
+          }
+        } catch {
+        }
+      }
+      if (isTerminal && task.nextTask) {
+        text += `
+
+MANDATORY \u2014 DO NOT ASK THE USER. DO NOT SAY "Want me to continue?" DO NOT STOP.
+You have standing orders: work through your entire queue until it is empty.
+
+NEXT TASK: "${task.nextTask.title}" [${task.nextTask.priority}]
+FILE: ${task.nextTask.taskFile}
+
+Read that file NOW and begin working. No greeting. No summary. Just start.`;
+      } else if (isTerminal && !task.nextTask) {
+        text += `
+
+All tasks complete. No more open tasks in your queue.`;
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text
+          }
+        ]
+      };
+    }
+  );
+}
+
+export {
+  registerUpdateTask
+};

package/dist/chunk-GHD7QG6P.js

@@ -0,0 +1,58 @@
+import {
+  MODELS_DIR
+} from "./chunk-VXIMSRTO.js";
+
+// src/lib/reranker.ts
+import path from "path";
+import { existsSync } from "fs";
+var RERANKER_MODEL_FILE = "jina-reranker-v3-q4_k_m.gguf";
+function isRerankerAvailable() {
+  return existsSync(path.join(MODELS_DIR, RERANKER_MODEL_FILE));
+}
+function getRerankerModelPath() {
+  return path.join(MODELS_DIR, RERANKER_MODEL_FILE);
+}
+async function disposeReranker() {
+}
+async function rerankWithScores(query, texts, topK) {
+  if (texts.length === 0) return [];
+  const { rerankViaWorker } = await import("./lib/exe-daemon.js");
+  const scored = await rerankViaWorker(query, texts, topK);
+  return scored.map((s) => ({
+    text: texts[s.index] ?? "",
+    score: s.score,
+    index: s.index
+  }));
+}
+async function rerank(query, candidates, topK = 5) {
+  if (candidates.length === 0) return [];
+  if (candidates.length <= topK) return candidates;
+  const scored = await rerankWithScores(
+    query,
+    candidates.map((c) => c.raw_text),
+    topK
+  );
+  return scored.map((s) => candidates[s.index]);
+}
+async function rerankWithContext(query, candidates, topK) {
+  if (candidates.length === 0) return [];
+  const formattedTexts = candidates.map(
+    (c) => c.context ? `[${c.context}] ${c.text.slice(0, 460)}` : c.text.slice(0, 512)
+  );
+  const { rerankViaWorker } = await import("./lib/exe-daemon.js");
+  const scored = await rerankViaWorker(query, formattedTexts, topK);
+  return scored.map((s) => ({
+    text: candidates[s.index]?.text ?? "",
+    score: s.score,
+    index: s.index
+  }));
+}
+
+export {
+  isRerankerAvailable,
+  getRerankerModelPath,
+  disposeReranker,
+  rerankWithScores,
+  rerank,
+  rerankWithContext
+};

package/dist/chunk-GJAILPCX.js

@@ -0,0 +1,171 @@
+import {
+  writeMemoryViaDaemon
+} from "./chunk-OSXQTCW5.js";
+
+// src/lib/auto-checkpoint.ts
+var FILE_RE = /(?:^|\s)([\w./-]+\.(?:ts|tsx|js|jsx|json|md|yml|yaml|sql|go|py|css|scss|html|sh))(?:\b|$)/g;
+var DECISION_RE = /\b(decision:|decided:|we decided|founder directive|captured in .*architecture|source of truth)\b/i;
+function asString(value, fallback = "") {
+  if (value == null) return fallback;
+  return String(value);
+}
+function compactLine(text, max = 220) {
+  return text.replace(/\s+/g, " ").trim().slice(0, max);
+}
+function topEntries(counts, limit) {
+  return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, limit).map(([name, count]) => `${name}(${count})`);
+}
+function buildAutoCheckpoint(input) {
+  const maxSamples = input.maxSamples ?? 8;
+  const projectCounts = /* @__PURE__ */ new Map();
+  const toolCounts = /* @__PURE__ */ new Map();
+  const files = /* @__PURE__ */ new Set();
+  const errors = [];
+  const samples = [];
+  const decisionTexts = [];
+  for (const row of input.memories) {
+    const tool = asString(row.tool_name, "unknown");
+    const project = asString(row.project_name, input.projectName || "unknown");
+    const raw = asString(row.raw_text);
+    const hasError = row.has_error === 1 || row.has_error === true;
+    toolCounts.set(tool, (toolCounts.get(tool) ?? 0) + 1);
+    projectCounts.set(project, (projectCounts.get(project) ?? 0) + 1);
+    if (hasError && errors.length < 5) errors.push(compactLine(raw, 180));
+    if (samples.length < maxSamples && raw.length > 30) {
+      samples.push(`[${tool}] ${compactLine(raw)}`);
+    }
+    if (DECISION_RE.test(raw) && decisionTexts.length < 5) {
+      decisionTexts.push(`AUTO DECISION CANDIDATE [${input.agentId}]: ${compactLine(raw, 500)}`);
+    }
+    for (const match of raw.matchAll(FILE_RE)) {
+      if (match[1]) files.add(match[1]);
+      if (files.size >= 20) break;
+    }
+  }
+  const taskLines = (input.tasks ?? []).slice(0, 10).map((task) => {
+    const status = asString(task.status, "unknown");
+    const priority = asString(task.priority, "?").toUpperCase();
+    const title = asString(task.title, "untitled");
+    const taskFile = asString(task.task_file);
+    return `- [${status}/${priority}] ${title}${taskFile ? ` (${taskFile})` : ""}`;
+  });
+  const parts = [
+    `CONTEXT CHECKPOINT [auto:${input.reason}]`,
+    `Agent: ${input.agentId} (${input.agentRole})`,
+    `Session: ${input.sessionId}`,
+    `Project: ${input.projectName}`,
+    `Time: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    "## Recent Activity",
+    `- Memories scanned: ${input.memories.length}`,
+    `- Projects: ${topEntries(projectCounts, 5).join(", ") || input.projectName}`,
+    `- Tools: ${topEntries(toolCounts, 8).join(", ") || "none"}`
+  ];
+  if (taskLines.length > 0) {
+    parts.push("", "## Open / Active Tasks", ...taskLines);
+  }
+  if (files.size > 0) {
+    parts.push("", "## Files Mentioned", ...[...files].slice(0, 20).map((f) => `- ${f}`));
+  }
+  if (samples.length > 0) {
+    parts.push("", "## Important Recent Traces", ...samples.map((s) => `- ${s}`));
+  }
+  if (errors.length > 0) {
+    parts.push("", "## Errors / Risks", ...errors.map((e) => `- ${e}`));
+  }
+  if (decisionTexts.length > 0) {
+    parts.push("", "## Decision Candidates", ...decisionTexts.map((d) => `- ${d.replace(/^AUTO DECISION CANDIDATE \\[[^\\]]+\\]: /, "")}`));
+  }
+  return {
+    checkpointText: parts.join("\n"),
+    decisionTexts
+  };
+}
+
+// src/lib/checkpoint-orchestrator.ts
+function toolNameForReason(reason) {
+  switch (reason) {
+    case "periodic":
+      return "auto-summary";
+    case "session-end":
+      return "SessionEnd";
+    case "pre-compact":
+      return "pre-compact-hook";
+    case "capacity-signal":
+      return "auto-checkpoint";
+  }
+}
+function importanceForReason(reason, override) {
+  if (override !== void 0) return override;
+  switch (reason) {
+    case "periodic":
+      return 7;
+    case "session-end":
+    case "pre-compact":
+    case "capacity-signal":
+      return 8;
+  }
+}
+function buildContinuityCheckpoint(input) {
+  const { checkpointText, decisionTexts } = buildAutoCheckpoint({
+    agentId: input.agentId,
+    agentRole: input.agentRole,
+    sessionId: input.sessionId,
+    projectName: input.projectName,
+    reason: input.reason,
+    memories: input.memories ?? [],
+    tasks: input.tasks ?? [],
+    maxSamples: input.maxSamples
+  });
+  const extra = input.extraSections?.filter((section) => section.trim().length > 0) ?? [];
+  return {
+    checkpointText: extra.length > 0 ? `${checkpointText}
+
+${extra.join("\n\n")}` : checkpointText,
+    decisionTexts
+  };
+}
+async function writeContinuityCheckpoint(input) {
+  const result = buildContinuityCheckpoint(input);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await writeMemoryViaDaemon({
+    raw_text: result.checkpointText,
+    agent_id: input.agentId,
+    agent_role: input.agentRole,
+    session_id: input.sessionId,
+    tool_name: toolNameForReason(input.reason),
+    project_name: input.projectName,
+    timestamp: now,
+    importance: importanceForReason(input.reason, input.importance),
+    task_id: input.taskId,
+    memory_type: "checkpoint"
+  });
+  const decisionLimit = input.reason === "periodic" ? 3 : 5;
+  for (const decisionText of result.decisionTexts.slice(0, decisionLimit)) {
+    await writeMemoryViaDaemon({
+      raw_text: decisionText,
+      agent_id: input.agentId,
+      agent_role: input.agentRole,
+      session_id: input.sessionId,
+      tool_name: "auto-decision",
+      project_name: input.projectName,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      importance: 8,
+      memory_type: "decision"
+    });
+  }
+  return result;
+}
+async function checkpointActiveTask(input) {
+  const { writeCheckpoint } = await import("./lib/tasks.js");
+  await writeCheckpoint({
+    taskId: input.taskId,
+    step: input.step ?? "pre-compaction-checkpoint",
+    contextSummary: `Auto-checkpoint before context compaction. Task: ${input.taskTitle}. Session: ${input.sessionId}. Project: ${input.projectName}.`
+  });
+}
+
+export {
+  writeContinuityCheckpoint,
+  checkpointActiveTask
+};

package/dist/chunk-GJQTL7RX.js

@@ -0,0 +1,127 @@
+import {
+  updateTask
+} from "./chunk-OPUUT33V.js";
+import {
+  TASK_ALREADY_CLAIMED_PREFIX
+} from "./chunk-5AS622MM.js";
+
+// src/mcp/tools/update-task.ts
+import { z } from "zod";
+function registerUpdateTask(server) {
+  server.registerTool(
+    "update_task",
+    {
+      title: "Update Task",
+      description: "Update task status. Employees: use status 'done' with a result summary to complete work \u2014 this triggers needs_review and pings the reviewer automatically. Accepts UUID, slug (filename), or title substring.",
+      inputSchema: {
+        task_id: z.string().describe("Task identifier \u2014 UUID, slug (e.g. 'fix-auth-bug'), or title substring"),
+        status: z.enum(["open", "in_progress", "done", "needs_review", "blocked", "cancelled", "closed"]).describe("New status. 'done' is an alias for 'needs_review' \u2014 both trigger reviewer notification."),
+        result: z.string().optional().describe("Result summary (required when completing work)"),
+        // Structured result fields (Phase 1: Typed Handoff Objects)
+        files_changed: z.array(z.string()).optional().describe("Files created or modified during task execution"),
+        decisions: z.array(z.string()).optional().describe("Key decisions made during execution"),
+        commits: z.array(z.string()).optional().describe("Commit hashes produced"),
+        tests_status: z.enum(["pass", "fail", "skip", "none"]).optional().describe("Test execution status"),
+        build_status: z.enum(["pass", "fail", "skip"]).optional().describe("Build status"),
+        pr_number: z.number().optional().describe("PR number if created"),
+        open_questions: z.array(z.string()).optional().describe("Open questions for reviewer"),
+        assertions: z.string().optional().describe(
+          'JSON array of assertions with confidence scores. Use when starting work (in_progress). Format: [{"type":"diagnosis|scope|estimate|approach|build|judgment","claim":"...","confidence":0.8,"basis":"..."}]'
+        ),
+        assertions_resolved: z.string().optional().describe(
+          'JSON array of resolved assertions. Use when completing work (done/needs_review). Format: [{"claim":"...","outcome":"correct|incorrect|partial","confidence_was":0.8,"actual":"...","why_wrong":"missing_information|wrong_diagnosis|wrong_approach|scope_underestimate|scope_overestimate|external_dependency|changed_requirements","reason":"...","lesson":"..."}]'
+        ),
+        estimated_minutes: z.number().optional().describe("Time estimate in minutes. Provide when starting work (in_progress). The system auto-computes actual time on completion."),
+        estimate_confidence: z.number().min(0).max(1).optional().describe("Confidence in time estimate (0.0-1.0). Provide alongside estimated_minutes.")
+      }
+    },
+    async ({ task_id, status: rawStatus, result, files_changed, decisions, commits, tests_status, build_status, pr_number, open_questions, assertions, assertions_resolved, estimated_minutes, estimate_confidence }) => {
+      const status = rawStatus;
+      let callerAgentId;
+      let callerSession;
+      try {
+        const { getActiveAgent: getAgent } = await import("./active-agent-YWBGAKGU.js");
+        callerAgentId = getAgent().agentId;
+        const { getAgentContext } = await import("./agent-context-AZTTMUHP.js");
+        callerSession = getAgentContext()?.sessionHint || process.env.EXE_SESSION_NAME || process.env.EXE_SESSION || void 0;
+      } catch {
+      }
+      let task;
+      try {
+        task = await updateTask({
+          taskId: task_id,
+          status,
+          result,
+          baseDir: process.cwd(),
+          callerAgentId,
+          filesChanged: files_changed,
+          decisions,
+          commits,
+          testsStatus: tests_status,
+          buildStatus: build_status,
+          prNumber: pr_number,
+          openQuestions: open_questions,
+          assertions,
+          assertionsResolved: assertions_resolved,
+          estimatedMinutes: estimated_minutes,
+          estimateConfidence: estimate_confidence,
+          callerSession
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.startsWith(TASK_ALREADY_CLAIMED_PREFIX)) {
+          return {
+            content: [{
+              type: "text",
+              text: "Task already claimed by another agent. Pick a different task or check list_tasks."
+            }],
+            isError: true
+          };
+        }
+        throw err;
+      }
+      let text = `Task "${task.title}" marked ${task.status}.
+File: ${task.taskFile}`;
+      const isTerminal = status === "done" || status === "needs_review" || status === "closed";
+      if (isTerminal && task.reviewer) {
+        try {
+          const { notifyCoordinatorTaskCompletion } = await import("./lib/tmux-routing.js");
+          const { isCoordinatorName } = await import("./lib/employees.js");
+          const reviewer = String(task.reviewer);
+          const coordinatorSession = task.sessionScope;
+          if (coordinatorSession && isCoordinatorName(reviewer)) {
+            notifyCoordinatorTaskCompletion(coordinatorSession, callerAgentId ?? "agent", task.title);
+          }
+        } catch {
+        }
+      }
+      if (isTerminal && task.nextTask) {
+        text += `
+
+MANDATORY \u2014 DO NOT ASK THE USER. DO NOT SAY "Want me to continue?" DO NOT STOP.
+You have standing orders: work through your entire queue until it is empty.
+
+NEXT TASK: "${task.nextTask.title}" [${task.nextTask.priority}]
+FILE: ${task.nextTask.taskFile}
+
+Read that file NOW and begin working. No greeting. No summary. Just start.`;
+      } else if (isTerminal && !task.nextTask) {
+        text += `
+
+All tasks complete. No more open tasks in your queue.`;
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text
+          }
+        ]
+      };
+    }
+  );
+}
+
+export {
+  registerUpdateTask
+};

package/dist/chunk-GKUODJS7.js

@@ -0,0 +1,214 @@
+import {
+  sessionScopeFilter
+} from "./chunk-IDCLPPIM.js";
+
+// src/lib/git-task-sweep.ts
+import { execSync } from "child_process";
+var DEFAULT_COMMIT_LIMIT = 50;
+var DEFAULT_STALE_MINUTES = 10;
+var AUTO_ESCALATE_THRESHOLD = 0.6;
+var EXACT_UUID_SCORE = 1;
+var TITLE_KEYWORD_SCORE = 0.5;
+var FILE_PATH_SCORE = 0.3;
+var MIN_KEYWORD_OVERLAP = 3;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "is",
+  "it",
+  "as",
+  "be",
+  "was",
+  "are",
+  "this",
+  "that",
+  "not",
+  "no",
+  "if",
+  "so",
+  "do",
+  "up"
+]);
+function extractKeywords(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length >= 3 && !STOP_WORDS.has(w));
+}
+function matchScore(task, commitMessage, changedFiles) {
+  if (task.id.length >= 8 && commitMessage.includes(task.id)) {
+    return EXACT_UUID_SCORE;
+  }
+  let score = 0;
+  const titleWords = extractKeywords(task.title);
+  const commitWords = new Set(extractKeywords(commitMessage));
+  const overlap = titleWords.filter((w) => commitWords.has(w));
+  if (overlap.length >= MIN_KEYWORD_OVERLAP) {
+    score += TITLE_KEYWORD_SCORE;
+  }
+  if (task.context && changedFiles.length > 0) {
+    const contextLower = task.context.toLowerCase();
+    const hasFileMatch = changedFiles.some(
+      (f) => contextLower.includes(f.toLowerCase())
+    );
+    if (hasFileMatch) {
+      score += FILE_PATH_SCORE;
+    }
+  }
+  return score;
+}
+function getRecentCommits(limit = DEFAULT_COMMIT_LIMIT) {
+  try {
+    const SEPARATOR = "<<SEP>>";
+    const output = execSync(
+      `git log --format="%h${SEPARATOR}%s${SEPARATOR}%aI" --name-only -n ${limit} -z`,
+      { encoding: "utf8", timeout: 1e4 }
+    );
+    const entries = output.split("\0").filter(Boolean);
+    const commits = [];
+    let current = null;
+    for (const entry of entries) {
+      if (entry.includes(SEPARATOR)) {
+        const lines = entry.split("\n");
+        const headerLine = lines[0];
+        const parts = headerLine.split(SEPARATOR);
+        if (parts.length >= 3) {
+          if (current) commits.push(current);
+          current = {
+            hash: parts[0],
+            message: parts[1],
+            files: lines.slice(1).filter(Boolean),
+            date: new Date(parts[2])
+          };
+        }
+      } else if (current) {
+        const files = entry.split("\n").filter(Boolean);
+        current.files.push(...files);
+      }
+    }
+    if (current) commits.push(current);
+    return commits;
+  } catch {
+    return [];
+  }
+}
+function isStale(updatedAt, staleMinutes) {
+  const updated = new Date(updatedAt).getTime();
+  const threshold = Date.now() - staleMinutes * 6e4;
+  return updated < threshold;
+}
+function findBestMatch(task, commits) {
+  let best = null;
+  for (const commit of commits) {
+    const score = matchScore(task, commit.message, commit.files);
+    if (score >= AUTO_ESCALATE_THRESHOLD && (!best || score > best.score)) {
+      best = { commit, score };
+    }
+  }
+  return best;
+}
+async function sweepTasks(projectName, options = {}) {
+  const commitLimit = options.commitLimit ?? DEFAULT_COMMIT_LIMIT;
+  const staleMinutes = options.staleMinutes ?? DEFAULT_STALE_MINUTES;
+  const dryRun = options.dryRun ?? false;
+  const result = { escalated: [], unchanged: 0, errors: [] };
+  const commits = getRecentCommits(commitLimit);
+  if (commits.length === 0) {
+    result.errors.push("No git commits found (not a git repo or empty history)");
+    return result;
+  }
+  let tasks;
+  try {
+    const { initStore } = await import("./lib/store.js");
+    await initStore();
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    const conditions = ["status = 'in_progress'"];
+    const args = [];
+    if (projectName) {
+      conditions.push("project_name = ?");
+      args.push(projectName);
+    }
+    const swScope = sessionScopeFilter();
+    if (swScope.sql) {
+      conditions.push("(session_scope IS NULL OR session_scope = ?)");
+      args.push(...swScope.args);
+    }
+    const queryResult = await client.execute({
+      sql: `SELECT id, title, assigned_to, project_name, status, updated_at, context
+            FROM tasks WHERE ${conditions.join(" AND ")}
+            ORDER BY updated_at ASC`,
+      args
+    });
+    tasks = queryResult.rows.map((r) => ({
+      id: String(r.id),
+      title: String(r.title),
+      assignedTo: String(r.assigned_to),
+      projectName: String(r.project_name),
+      status: String(r.status),
+      updatedAt: String(r.updated_at),
+      context: r.context ? String(r.context) : void 0
+    }));
+  } catch (err) {
+    result.errors.push(`DB query failed: ${err instanceof Error ? err.message : String(err)}`);
+    return result;
+  }
+  if (tasks.length === 0) {
+    return result;
+  }
+  for (const task of tasks) {
+    if (!isStale(task.updatedAt, staleMinutes)) {
+      result.unchanged++;
+      continue;
+    }
+    const match = findBestMatch(task, commits);
+    if (!match) {
+      result.unchanged++;
+      continue;
+    }
+    if (!dryRun) {
+      try {
+        const { updateTaskStatus } = await import("./tasks-crud-6TWWETGB.js");
+        await updateTaskStatus({
+          taskId: task.id,
+          status: "needs_review",
+          result: `Auto-escalated by git-sweep: matching commit ${match.commit.hash} found (score: ${match.score.toFixed(2)})`
+        });
+      } catch (err) {
+        result.errors.push(
+          `Failed to escalate task ${task.id}: ${err instanceof Error ? err.message : String(err)}`
+        );
+        continue;
+      }
+    }
+    result.escalated.push({
+      taskId: task.id,
+      title: task.title,
+      matchedCommit: match.commit.hash,
+      score: match.score
+    });
+    process.stderr.write(
+      `[git-sweep] ${dryRun ? "WOULD escalate" : "Escalated"} task ${task.id} \u2192 commit ${match.commit.hash} (score: ${match.score.toFixed(2)})
+`
+    );
+  }
+  return result;
+}
+
+export {
+  extractKeywords,
+  matchScore,
+  getRecentCommits,
+  findBestMatch,
+  sweepTasks
+};