@hasna/todos 0.11.71 → 0.11.72

package/dist/cli/index.js

@@ -1011,7 +1011,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         this._exitCallback = (err) => {
           if (err.code !== "commander.executeSubCommandAsync") {
             throw err;
-          }
+          } else {}
         };
       }
       return this;
@@ -7215,8 +7215,6 @@ function routeEnabledForTask(task, taskList) {
   const explicit = booleanField(task.metadata.route_enabled);
   if (explicit !== undefined)
     return explicit;
-  if (task.tags.includes("auto:route") || task.tags.includes("route:enabled"))
-    return true;
   const taskListDefault = taskList ? booleanField(taskList.metadata.route_enabled) : undefined;
   if (taskListDefault !== undefined)
     return taskListDefault;
@@ -7238,8 +7236,26 @@ function workflowPointersFromMetadata(metadata) {
 function compactWorkflowPointers(pointers) {
   return Object.fromEntries(Object.entries(pointers).filter(([, value]) => typeof value === "string" && value.length > 0));
 }
-function classifyProjectKind(path) {
-  return path.includes("/hasna/opensource/") ? "open-source" : "unknown";
+function metadataStringField(record, keys) {
+  if (!record)
+    return;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+  }
+  return;
+}
+function projectKindFromMetadata(...records) {
+  for (const record of records) {
+    const value = metadataStringField(record ?? undefined, ["project_kind", "projectKind", "source_kind", "sourceKind"]);
+    if (value)
+      return value;
+  }
+  return null;
+}
+function classifyProjectKind(_path, metadata) {
+  return projectKindFromMetadata(metadata);
 }
 function isWorktreePath(path) {
   return path.includes("/.codewith/worktrees/") || path.includes("/.worktrees/");
@@ -7312,7 +7328,6 @@ function taskEventMetadata(task) {
       metadata.project_canonical_path = projectPath;
     }
     if (projectPath) {
-      metadata.project_kind = classifyProjectKind(projectPath);
       metadata.project_is_worktree = isWorktreePath(projectPath);
       metadata.working_dir = task.working_dir ?? projectPath;
     }
@@ -7324,6 +7339,10 @@ function taskEventMetadata(task) {
       metadata.task_list_project_id = taskList.project_id;
       metadata.task_list_is_project_default = Boolean(project?.task_list_id && taskList.slug === project.task_list_id);
     }
+    const projectKind = projectKindFromMetadata(task.metadata, taskList?.metadata);
+    if (projectKind) {
+      metadata.project_kind = classifyProjectKind(projectPath ?? "", { project_kind: projectKind });
+    }
     const routeEnabled = routeEnabledForTask(task, taskList);
     if (routeEnabled !== undefined) {
       metadata.route_enabled = routeEnabled;
@@ -12742,11 +12761,6 @@ __export(exports_task_routing, {
   setTaskWorkflowPointers: () => setTaskWorkflowPointers,
   getTaskRouteState: () => getTaskRouteState
 });
-function classifyProjectKind2(path) {
-  if (!path)
-    return null;
-  return path.includes("/hasna/opensource/") ? "open-source" : "unknown";
-}
 function machineLocalPath(project, db) {
   const machineId = process.env["TODOS_MACHINE_ID"];
   if (!machineId)
@@ -12794,6 +12808,7 @@ function getTaskRouteState(taskOrId, db) {
   const automation = routingAutomationMetadata(task, taskList) ?? {};
   const routeEnabled = routeEnabledForTask(task, taskList) === true;
   const tagOptIn = task.tags.includes("auto:route") || task.tags.includes("route:enabled");
+  const projectKind = projectKindFromMetadata(task.metadata, taskList?.metadata);
   const locked = Boolean(task.locked_by && !isLockExpired(task.locked_at));
   const blockers = getBlockingDeps(task.id, d);
   const blocked = blockers.length > 0;
@@ -12856,7 +12871,7 @@ function getTaskRouteState(taskOrId, db) {
       project_id: project?.id ?? task.project_id,
       project_path: projectPath,
       working_dir: task.working_dir ?? projectPath,
-      project_kind: classifyProjectKind2(projectPath),
+      project_kind: projectKind,
       task_list_id: taskList?.id ?? task.task_list_id,
       task_list_slug: taskList?.slug ?? null,
       task_list_name: taskList?.name ?? null,
@@ -55219,6 +55234,339 @@ var init_config_serve_commands = __esm(() => {
   init_helpers();
 });
 
+// src/lib/task-route-sources.ts
+var exports_task_route_sources = {};
+__export(exports_task_route_sources, {
+  discoverTaskRouteSources: () => discoverTaskRouteSources,
+  TASK_ROUTE_SOURCE_DISCOVERY_SCHEMA_VERSION: () => TASK_ROUTE_SOURCE_DISCOVERY_SCHEMA_VERSION
+});
+import { Database as Database3 } from "bun:sqlite";
+import { createHash as createHash13 } from "crypto";
+import { existsSync as existsSync21, readdirSync as readdirSync5, statSync as statSync9 } from "fs";
+import { basename as basename9, dirname as dirname12, join as join21, resolve as resolve21 } from "path";
+function normalizePath5(input) {
+  return resolve21(input);
+}
+function sourceStoreId(sourceDbPath) {
+  const digest = createHash13("sha256").update(sourceDbPath).digest("hex").slice(0, 16);
+  return `sqlite:${digest}`;
+}
+function inferSourceRepoPath(sourceDbPath) {
+  const normalized = normalizePath5(sourceDbPath);
+  if (normalized.endsWith(TODO_STORE_RELATIVE_PATH)) {
+    return dirname12(dirname12(dirname12(normalized)));
+  }
+  return dirname12(normalized);
+}
+function createStoreRef(sourceDbPath) {
+  const normalized = normalizePath5(sourceDbPath);
+  return {
+    source_store_id: sourceStoreId(normalized),
+    source_repo_path: inferSourceRepoPath(normalized),
+    source_db_path: normalized
+  };
+}
+function normalizePatterns(patterns) {
+  return (patterns ?? []).map((pattern) => pattern.trim()).filter(Boolean);
+}
+function escapeRegExp(value) {
+  return value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+function globPatternToRegExp(pattern) {
+  let source3 = "";
+  for (const char of pattern) {
+    if (char === "*")
+      source3 += ".*";
+    else if (char === "?")
+      source3 += ".";
+    else
+      source3 += escapeRegExp(char);
+  }
+  return new RegExp(`^${source3}$`);
+}
+function matchesPattern4(value, pattern) {
+  const normalizedValue = value.replace(/\\/g, "/");
+  const normalizedPattern = pattern.replace(/\\/g, "/");
+  if (normalizedPattern.includes("*") || normalizedPattern.includes("?")) {
+    return globPatternToRegExp(normalizedPattern).test(normalizedValue);
+  }
+  return normalizedValue.includes(normalizedPattern);
+}
+function storeMatchesAny(ref, patterns) {
+  if (patterns.length === 0)
+    return false;
+  const paths = [ref.source_db_path, ref.source_repo_path].filter((value) => Boolean(value));
+  const values = paths.flatMap((value) => [value, basename9(value)]);
+  return patterns.some((pattern) => values.some((value) => matchesPattern4(value, pattern)));
+}
+function shouldIncludeStore(ref, include, exclude) {
+  const included = include.length === 0 || storeMatchesAny(ref, include);
+  return included && !storeMatchesAny(ref, exclude);
+}
+function discoverStoresUnderRoot(sourceRoot) {
+  const rootPath = normalizePath5(sourceRoot);
+  const errors2 = [];
+  const stores = [];
+  if (!existsSync21(rootPath)) {
+    const ref = createStoreRef(join21(rootPath, TODO_STORE_RELATIVE_PATH));
+    errors2.push({
+      ...ref,
+      code: "SOURCE_ROOT_MISSING",
+      message: `Source root does not exist: ${rootPath}`
+    });
+    return { stores, errors: errors2 };
+  }
+  let rootStat;
+  try {
+    rootStat = statSync9(rootPath);
+  } catch (error) {
+    const ref = createStoreRef(join21(rootPath, TODO_STORE_RELATIVE_PATH));
+    errors2.push({
+      ...ref,
+      code: "SOURCE_ROOT_UNREADABLE",
+      message: error instanceof Error ? error.message : `Unable to read source root: ${rootPath}`
+    });
+    return { stores, errors: errors2 };
+  }
+  if (rootStat.isFile()) {
+    stores.push(createStoreRef(rootPath));
+    return { stores, errors: errors2 };
+  }
+  function scanDirectory(dir, depth) {
+    const candidate = join21(dir, TODO_STORE_RELATIVE_PATH);
+    if (existsSync21(candidate)) {
+      stores.push(createStoreRef(candidate));
+    }
+    if (depth >= ROOT_SCAN_MAX_DEPTH)
+      return;
+    let entries;
+    try {
+      entries = readdirSync5(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    } catch (error) {
+      const ref = createStoreRef(candidate);
+      errors2.push({
+        ...ref,
+        code: "SOURCE_ROOT_UNREADABLE",
+        message: error instanceof Error ? error.message : `Unable to read source root: ${dir}`
+      });
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory() || SKIPPED_SCAN_DIRS.has(entry.name))
+        continue;
+      scanDirectory(join21(dir, entry.name), depth + 1);
+    }
+  }
+  scanDirectory(rootPath, 0);
+  return { stores, errors: errors2 };
+}
+function collectStoreRefs(input) {
+  const byPath = new Map;
+  const errors2 = [];
+  for (const storePath of input.sourceStores ?? []) {
+    const ref = createStoreRef(storePath);
+    byPath.set(ref.source_db_path, ref);
+  }
+  for (const sourceRoot of input.sourceRoots ?? []) {
+    const discovered = discoverStoresUnderRoot(sourceRoot);
+    for (const ref of discovered.stores) {
+      byPath.set(ref.source_db_path, ref);
+    }
+    errors2.push(...discovered.errors);
+  }
+  return {
+    stores: [...byPath.values()].sort((a, b) => a.source_db_path.localeCompare(b.source_db_path)),
+    errors: errors2.sort((a, b) => a.source_db_path.localeCompare(b.source_db_path))
+  };
+}
+function openReadonlyStore(ref) {
+  if (!existsSync21(ref.source_db_path)) {
+    throw Object.assign(new Error(`Store does not exist: ${ref.source_db_path}`), { code: "STORE_MISSING" });
+  }
+  return new Database3(ref.source_db_path, { readonly: true, create: false });
+}
+function hasTable2(db, tableName) {
+  const row = db.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(tableName);
+  return Boolean(row);
+}
+function tableColumns2(db, tableName) {
+  const rows = db.query(`PRAGMA table_info(${tableName})`).all();
+  return new Set(rows.map((row) => row.name));
+}
+function listPendingTasksReadonly(db) {
+  if (!hasTable2(db, "tasks")) {
+    throw Object.assign(new Error("Store does not contain a tasks table"), { code: "STORE_INVALID" });
+  }
+  const columns = tableColumns2(db, "tasks");
+  const conditions = ["status = 'pending'"];
+  if (columns.has("archived_at"))
+    conditions.push("archived_at IS NULL");
+  const rows = db.query(`SELECT * FROM tasks WHERE ${conditions.join(" AND ")}
+       ORDER BY CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END, created_at DESC`).all();
+  return rows.map(rowToTask);
+}
+function isReadyTask(task2, db) {
+  if (task2.locked_by && !isLockExpired(task2.locked_at))
+    return false;
+  return getBlockingDeps(task2.id, db).length === 0;
+}
+function metadataFingerprint(metadata) {
+  const value = metadata.fingerprint;
+  if (typeof value === "string" && value.trim())
+    return value;
+  if (typeof value === "number" && Number.isFinite(value))
+    return String(value);
+  return null;
+}
+function boundedMetadataValue(value, depth = 0) {
+  if (depth > 6)
+    return "[TRUNCATED]";
+  if (typeof value === "string") {
+    return value.length > 2000 ? `${value.slice(0, 2000)}[TRUNCATED]` : value;
+  }
+  if (Array.isArray(value)) {
+    return value.slice(0, 50).map((item) => boundedMetadataValue(item, depth + 1));
+  }
+  if (value && typeof value === "object") {
+    const result = {};
+    for (const [key, child] of Object.entries(value).slice(0, 80)) {
+      const normalized = key.toLowerCase();
+      if (normalized === "comment" || normalized === "comments" || normalized === "task_comments") {
+        result[key] = "[REDACTED_COMMENT]";
+        continue;
+      }
+      result[key] = boundedMetadataValue(child, depth + 1);
+    }
+    return result;
+  }
+  return value;
+}
+function discoveryMetadata(metadata) {
+  return redactValue(boundedMetadataValue(metadata));
+}
+function sourceCandidate(ref, task2, db) {
+  const routeState = getTaskRouteState(task2, db);
+  const autoRoute = task2.tags.includes("auto:route") || task2.tags.includes("route:enabled");
+  return {
+    source_store_id: ref.source_store_id,
+    source_repo_path: ref.source_repo_path,
+    source_db_path: ref.source_db_path,
+    source_task_key: `${ref.source_store_id}:${task2.id}`,
+    source_selected_by_input: true,
+    task_id: task2.id,
+    task_short_id: task2.short_id,
+    title: task2.title,
+    status: task2.status,
+    priority: task2.priority,
+    project_path: routeState.route.project_path ?? task2.working_dir ?? ref.source_repo_path,
+    task_version: task2.version,
+    task_updated_at: task2.updated_at,
+    task_fingerprint: metadataFingerprint(task2.metadata),
+    tags: task2.tags,
+    task_intent: {
+      auto_route: autoRoute
+    },
+    metadata: discoveryMetadata(task2.metadata),
+    route_state: routeState
+  };
+}
+function discoveryError(ref, code, error) {
+  return {
+    ...ref,
+    code,
+    message: error instanceof Error ? error.message : String(error)
+  };
+}
+function errorCode(error) {
+  if (typeof error === "object" && error !== null && "code" in error && error.code === "STORE_MISSING") {
+    return "STORE_MISSING";
+  }
+  if (typeof error === "object" && error !== null && "code" in error && error.code === "STORE_INVALID") {
+    return "STORE_INVALID";
+  }
+  return "STORE_UNREADABLE";
+}
+function discoverTaskRouteSources(input) {
+  const include = normalizePatterns(input.include);
+  const exclude = normalizePatterns(input.exclude);
+  const sourceRoots = (input.sourceRoots ?? []).map(normalizePath5).sort();
+  const sourceStores = (input.sourceStores ?? []).map(normalizePath5).sort();
+  const limit = Number.isFinite(input.limit ?? NaN) && (input.limit ?? 0) >= 0 ? Math.floor(input.limit ?? 0) : null;
+  const collected = collectStoreRefs(input);
+  const stores = [];
+  const errors2 = [...collected.errors];
+  const candidates = [];
+  let totalCandidateCount = 0;
+  for (const ref of collected.stores) {
+    if (!shouldIncludeStore(ref, include, exclude))
+      continue;
+    const storeErrors = [];
+    let db = null;
+    try {
+      db = openReadonlyStore(ref);
+      const readyTasks = listPendingTasksReadonly(db).filter((task2) => isReadyTask(task2, db));
+      totalCandidateCount += readyTasks.length;
+      const remaining = limit === null ? readyTasks.length : Math.max(0, limit - candidates.length);
+      const selectedTasks = limit === null ? readyTasks : readyTasks.slice(0, remaining);
+      candidates.push(...selectedTasks.map((task2) => sourceCandidate(ref, task2, db)));
+      stores.push({
+        ...ref,
+        status: "ok",
+        candidate_count: readyTasks.length,
+        returned_candidate_count: selectedTasks.length,
+        errors: []
+      });
+    } catch (error) {
+      const storeError = discoveryError(ref, errorCode(error), error);
+      storeErrors.push(storeError);
+      errors2.push(storeError);
+      stores.push({
+        ...ref,
+        status: storeError.code === "STORE_MISSING" ? "missing" : "error",
+        candidate_count: 0,
+        returned_candidate_count: 0,
+        errors: storeErrors
+      });
+    } finally {
+      db?.close();
+    }
+  }
+  return {
+    schema_version: TASK_ROUTE_SOURCE_DISCOVERY_SCHEMA_VERSION,
+    sourceRoots,
+    sourceStores,
+    include,
+    exclude,
+    limit,
+    total_candidate_count: totalCandidateCount,
+    returned_candidate_count: candidates.length,
+    truncated: limit !== null && totalCandidateCount > candidates.length,
+    stores,
+    candidates,
+    errors: errors2
+  };
+}
+var TASK_ROUTE_SOURCE_DISCOVERY_SCHEMA_VERSION = "todos.task_route_sources.v1", TODO_STORE_RELATIVE_PATH, ROOT_SCAN_MAX_DEPTH = 5, SKIPPED_SCAN_DIRS;
+var init_task_route_sources = __esm(() => {
+  init_database();
+  init_task_lifecycle();
+  init_task_crud();
+  init_redaction();
+  init_task_routing();
+  TODO_STORE_RELATIVE_PATH = join21(".hasna", "todos", "todos.db");
+  SKIPPED_SCAN_DIRS = new Set([
+    ".git",
+    ".hg",
+    ".svn",
+    "node_modules",
+    "dist",
+    "build",
+    ".next",
+    ".turbo",
+    ".cache"
+  ]);
+});
+
 // src/lib/tester-issue-reports.ts
 var exports_tester_issue_reports = {};
 __export(exports_tester_issue_reports, {
@@ -55231,7 +55579,7 @@ __export(exports_tester_issue_reports, {
   TESTERS_ISSUE_REPORT_RESULT_SCHEMA_VERSION: () => TESTERS_ISSUE_REPORT_RESULT_SCHEMA_VERSION,
   TESTERS_ISSUE_REPORT_BATCH_RESULT_SCHEMA_VERSION: () => TESTERS_ISSUE_REPORT_BATCH_RESULT_SCHEMA_VERSION
 });
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 function asObject3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
@@ -55403,7 +55751,7 @@ function fingerprintTesterIssueReport(report) {
     normalizeText4(report.failure?.message || report.summary || report.title).slice(0, 240),
     normalizeText4(stackTop).slice(0, 160)
   ].join("::");
-  return `testers:${createHash13("sha256").update(raw).digest("hex").slice(0, 16)}`;
+  return `testers:${createHash14("sha256").update(raw).digest("hex").slice(0, 16)}`;
 }
 function priorityForSeverity(severity, fallback) {
   return PRIORITIES5.includes(severity) ? severity : fallback;
@@ -55722,6 +56070,15 @@ function parseCsvOption(value) {
   const values = value.split(",").map((item) => item.trim()).filter(Boolean);
   return values.length > 0 ? values : undefined;
 }
+function collectOption2(value, previous = []) {
+  return [...previous, value];
+}
+function expandRepeatedCsvOption(value) {
+  if (!value || value.length === 0)
+    return;
+  const values = value.flatMap((item) => item.split(",").map((part) => part.trim()).filter(Boolean));
+  return values.length > 0 ? values : undefined;
+}
 function resolveOptionalId(table, value) {
   if (!value)
     return;
@@ -56360,13 +56717,13 @@ Repairs`));
     try {
       const db = getDatabase();
       const row = db.query("SELECT COUNT(*) as count FROM tasks").get();
-      const { statSync: statSync9 } = await import("fs");
-      const { join: join21 } = await import("path");
+      const { statSync: statSync10 } = await import("fs");
+      const { join: join22 } = await import("path");
       const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
-      const dbPath = process.env["HASNA_TODOS_DB_PATH"] || process.env["TODOS_DB_PATH"] || join21(home, ".hasna", "todos", "todos.db");
+      const dbPath = process.env["HASNA_TODOS_DB_PATH"] || process.env["TODOS_DB_PATH"] || join22(home, ".hasna", "todos", "todos.db");
       let size = "unknown";
       try {
-        size = `${(statSync9(dbPath).size / 1024 / 1024).toFixed(1)} MB`;
+        size = `${(statSync10(dbPath).size / 1024 / 1024).toFixed(1)} MB`;
       } catch {}
       checks.push({ name: "Database", ok: true, message: `${row.count} tasks \xB7 ${size} \xB7 ${chalk7.dim(dbPath)}` });
     } catch (e) {
@@ -56856,8 +57213,42 @@ Repairs`));
       console.log(`  ${chalk7.dim(time2)} ${chalk7.cyan(entry.source)} ${chalk7.dim(ref)} ${entry.event_type}${message}${agent}`);
     }
   });
-  program2.command("ready").description("Show all tasks ready to be claimed (pending, unblocked, unlocked)").option("-j, --json", "Output as JSON").option("--project <id>", "Filter to project").option("--limit <n>", "Max tasks to show", "20").action(async (opts) => {
+  program2.command("ready").description("Show all tasks ready to be claimed (pending, unblocked, unlocked)").option("-j, --json", "Output as JSON").option("--project <id>", "Filter to project").option("--limit <n>", "Max tasks to show", "20").option("--source-root <path>", "Read-only source root to scan for .hasna/todos/todos.db (repeatable)", collectOption2, []).option("--source-store <path>", "Read-only todos SQLite store path to scan (repeatable)", collectOption2, []).option("--include <pattern>", "Include source repo/store paths matching substring or glob (repeatable or comma-separated)", collectOption2, []).option("--exclude <pattern>", "Exclude source repo/store paths matching substring or glob (repeatable or comma-separated)", collectOption2, []).action(async (opts) => {
     const globalOpts = program2.opts();
+    const sourceRoots = expandRepeatedCsvOption(opts.sourceRoot);
+    const sourceStores = expandRepeatedCsvOption(opts.sourceStore);
+    const include = expandRepeatedCsvOption(opts.include);
+    const exclude = expandRepeatedCsvOption(opts.exclude);
+    if (sourceRoots || sourceStores || include || exclude) {
+      const { discoverTaskRouteSources: discoverTaskRouteSources2 } = await Promise.resolve().then(() => (init_task_route_sources(), exports_task_route_sources));
+      const result = discoverTaskRouteSources2({
+        sourceRoots,
+        sourceStores,
+        include,
+        exclude,
+        limit: parseInt(opts.limit, 10)
+      });
+      if (opts.json || globalOpts.json) {
+        console.log(JSON.stringify(result));
+        return;
+      }
+      if (result.candidates.length === 0) {
+        console.log(chalk7.dim("  No source tasks ready to claim."));
+      } else {
+        console.log(chalk7.bold(`Ready source tasks (${result.candidates.length}):
+`));
+        for (const candidate of result.candidates) {
+          const source3 = candidate.source_repo_path ?? candidate.source_db_path;
+          const pri = candidate.priority === "critical" ? chalk7.bgRed.white(" CRIT ") : candidate.priority === "high" ? chalk7.red("[high]") : candidate.priority === "medium" ? chalk7.yellow("[med]") : "";
+          console.log(`  ${chalk7.cyan(candidate.task_short_id || candidate.task_id.slice(0, 8))} ${candidate.title} ${pri}${chalk7.dim(` ${source3}`)}`);
+        }
+      }
+      if (result.errors.length > 0) {
+        console.log(chalk7.yellow(`
+  ${result.errors.length} source error${result.errors.length === 1 ? "" : "s"} isolated; rerun with --json for details.`));
+      }
+      return;
+    }
     const db = getDatabase();
     const { getBlockingDeps: getBlockingDeps2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
     const { isLockExpired: isLockExpired2 } = await Promise.resolve().then(() => (init_database(), exports_database));
@@ -58179,21 +58570,21 @@ __export(exports_mcp_hooks_commands, {
 });
 import chalk8 from "chalk";
 import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync21, readFileSync as readFileSync17, writeFileSync as writeFileSync10, mkdirSync as mkdirSync11, chmodSync as chmodSync2 } from "fs";
-import { dirname as dirname12, join as join21 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync17, writeFileSync as writeFileSync10, mkdirSync as mkdirSync11, chmodSync as chmodSync2 } from "fs";
+import { dirname as dirname13, join as join22 } from "path";
 function getMcpBinaryPath() {
   try {
     const p = execSync3("which todos-mcp", { encoding: "utf-8" }).trim();
     if (p)
       return p;
   } catch {}
-  const bunBin = join21(HOME2, ".bun", "bin", "todos-mcp");
-  if (existsSync21(bunBin))
+  const bunBin = join22(HOME2, ".bun", "bin", "todos-mcp");
+  if (existsSync22(bunBin))
     return bunBin;
   return "todos-mcp";
 }
 function readJsonFile2(path) {
-  if (!existsSync21(path))
+  if (!existsSync22(path))
     return {};
   try {
     return JSON.parse(readFileSync17(path, "utf-8"));
@@ -58202,20 +58593,20 @@ function readJsonFile2(path) {
   }
 }
 function writeJsonFile2(path, data) {
-  const dir = dirname12(path);
-  if (!existsSync21(dir))
+  const dir = dirname13(path);
+  if (!existsSync22(dir))
     mkdirSync11(dir, { recursive: true });
   writeFileSync10(path, JSON.stringify(data, null, 2) + `
 `);
 }
 function readTomlFile(path) {
-  if (!existsSync21(path))
+  if (!existsSync22(path))
     return "";
   return readFileSync17(path, "utf-8");
 }
 function writeTomlFile(path, content) {
-  const dir = dirname12(path);
-  if (!existsSync21(dir))
+  const dir = dirname13(path);
+  if (!existsSync22(dir))
     mkdirSync11(dir, { recursive: true });
   writeFileSync10(path, content);
 }
@@ -58281,7 +58672,7 @@ function unregisterClaude(_global) {
   }
 }
 function registerCodex(binPath) {
-  const configPath = join21(HOME2, ".codex", "config.toml");
+  const configPath = join22(HOME2, ".codex", "config.toml");
   let content = readTomlFile(configPath);
   content = removeTomlBlock(content, "mcp_servers.todos");
   const block = `
@@ -58295,7 +58686,7 @@ args = []
   console.log(chalk8.green(`Codex CLI: registered in ${configPath}`));
 }
 function unregisterCodex() {
-  const configPath = join21(HOME2, ".codex", "config.toml");
+  const configPath = join22(HOME2, ".codex", "config.toml");
   let content = readTomlFile(configPath);
   if (!content.includes("[mcp_servers.todos]")) {
     console.log(chalk8.dim(`Codex CLI: todos not found in ${configPath}`));
@@ -58307,7 +58698,7 @@ function unregisterCodex() {
   console.log(chalk8.green(`Codex CLI: unregistered from ${configPath}`));
 }
 function registerGemini(binPath) {
-  const configPath = join21(HOME2, ".gemini", "settings.json");
+  const configPath = join22(HOME2, ".gemini", "settings.json");
   const config = readJsonFile2(configPath);
   if (!config["mcpServers"]) {
     config["mcpServers"] = {};
@@ -58321,7 +58712,7 @@ function registerGemini(binPath) {
   console.log(chalk8.green(`Gemini CLI: registered in ${configPath}`));
 }
 function unregisterGemini() {
-  const configPath = join21(HOME2, ".gemini", "settings.json");
+  const configPath = join22(HOME2, ".gemini", "settings.json");
   const config = readJsonFile2(configPath);
   const servers = config["mcpServers"];
   if (!servers || !("todos" in servers)) {
@@ -58378,8 +58769,8 @@ function registerMcpHooksCommands(program2) {
       if (p)
         todosBin = p;
     } catch {}
-    const hooksDir = join21(process.cwd(), ".claude", "hooks");
-    if (!existsSync21(hooksDir))
+    const hooksDir = join22(process.cwd(), ".claude", "hooks");
+    if (!existsSync22(hooksDir))
       mkdirSync11(hooksDir, { recursive: true });
     const hookScript = `#!/usr/bin/env bash
 # Auto-generated by: todos hooks install
@@ -58404,11 +58795,11 @@ esac
 
 exit 0
 `;
-    const hookPath = join21(hooksDir, "todos-sync.sh");
+    const hookPath = join22(hooksDir, "todos-sync.sh");
     writeFileSync10(hookPath, hookScript);
     execSync3(`chmod +x "${hookPath}"`);
     console.log(chalk8.green(`Hook script created: ${hookPath}`));
-    const settingsPath = join21(process.cwd(), ".claude", "settings.json");
+    const settingsPath = join22(process.cwd(), ".claude", "settings.json");
     const settings = readJsonFile2(settingsPath);
     if (!settings["hooks"]) {
       settings["hooks"] = {};
@@ -59277,7 +59668,7 @@ Artifacts:`));
       const gitDir = execSync3("git rev-parse --git-dir", { encoding: "utf-8" }).trim();
       const hookPath = `${gitDir}/hooks/post-commit`;
       const marker = "# todos-auto-link";
-      if (existsSync21(hookPath)) {
+      if (existsSync22(hookPath)) {
         const existing = readFileSync17(hookPath, "utf-8");
         if (existing.includes(marker)) {
           console.log(chalk8.yellow("Hook already installed."));
@@ -59305,7 +59696,7 @@ $(dirname "$0")/../../scripts/post-commit-hook.sh
       const gitDir = execSync3("git rev-parse --git-dir", { encoding: "utf-8" }).trim();
       const hookPath = `${gitDir}/hooks/post-commit`;
       const marker = "# todos-auto-link";
-      if (!existsSync21(hookPath)) {
+      if (!existsSync22(hookPath)) {
         console.log(chalk8.dim("No post-commit hook found."));
         return;
       }
@@ -59491,7 +59882,7 @@ import chalk10 from "chalk";
 import { execSync as execSync4 } from "child_process";
 import { readFileSync as readFileSync18, unlinkSync as unlinkSync2, writeFileSync as writeFileSync11 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 function getOrCreateLocalMachineName() {
   return process.env["TODOS_MACHINE_NAME"] || __require("os").hostname() || "unknown";
 }
@@ -59529,7 +59920,7 @@ function remoteTempPath(sshAddress) {
 }
 function readRemoteBridgeBundle(sshAddress) {
   const remotePath = remoteTempPath(sshAddress);
-  const localPath = join22(tmpdir4(), `todos-bridge-pull-${uuid()}.json`);
+  const localPath = join23(tmpdir4(), `todos-bridge-pull-${uuid()}.json`);
   try {
     runSsh(sshAddress, `todos export --format bridge --allow-plaintext-sensitive --output ${shellQuote(remotePath)}`, 120000);
     scpFromRemote(sshAddress, remotePath, localPath);
@@ -59544,7 +59935,7 @@ function readRemoteBridgeBundle(sshAddress) {
   }
 }
 function writeLocalBridgeBundle() {
-  const localPath = join22(tmpdir4(), `todos-bridge-push-${uuid()}.json`);
+  const localPath = join23(tmpdir4(), `todos-bridge-push-${uuid()}.json`);
   writeFileSync11(localPath, JSON.stringify(createLocalBridgeBundle(), null, 2));
   return localPath;
 }
@@ -60608,7 +60999,7 @@ __export(exports_onboarding_commands, {
   registerOnboardingCommands: () => registerOnboardingCommands
 });
 import chalk17 from "chalk";
-import { resolve as resolve21 } from "path";
+import { resolve as resolve22 } from "path";
 function registerOnboardingCommands(program2) {
   program2.command("onboarding").alias("demo-fixtures").description("List, show, write, or import bundled local onboarding fixtures").option("--show <name>", "Show one fixture bridge bundle as JSON").option("--write <dir>", "Write all bundled fixture bridge bundles to a directory").option("--import <name>", "Dry-run or apply an onboarding fixture import").option("--apply", "Apply an onboarding fixture import. Defaults to dry-run.").option("--resolve-conflicts", "Safely merge existing local tasks while preserving divergent fields").action(async (opts) => {
     const globalOpts = program2.opts();
@@ -60624,7 +61015,7 @@ function registerOnboardingCommands(program2) {
         return;
       }
       if (opts.write) {
-        const result = writeOnboardingFixtureFiles2(resolve21(opts.write));
+        const result = writeOnboardingFixtureFiles2(resolve22(opts.write));
         if (globalOpts.json) {
           output(result, true);
           return;
@@ -64073,7 +64464,7 @@ __export(exports_sdk_integration_fixtures, {
   TODOS_SDK_INTEGRATION_FIXTURE_GENERATED_AT: () => TODOS_SDK_INTEGRATION_FIXTURE_GENERATED_AT
 });
 import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync12 } from "fs";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 function source5(version) {
   return {
     packageName: "@hasna/todos",
@@ -64180,7 +64571,7 @@ function writeSdkIntegrationFixtures(directory, options = {}) {
   ];
   const written = [];
   for (const [name, payload] of files) {
-    const file = join23(directory, name);
+    const file = join24(directory, name);
     writeFileSync12(file, `${JSON.stringify(payload, null, 2)}
 `, "utf-8");
     written.push(file);
@@ -64204,7 +64595,7 @@ __export(exports_sdk_fixture_commands, {
   registerSdkFixtureCommands: () => registerSdkFixtureCommands
 });
 import chalk19 from "chalk";
-import { resolve as resolve22 } from "path";
+import { resolve as resolve23 } from "path";
 function registerSdkFixtureCommands(program2) {
   program2.command("sdk-fixtures").description("List, show, or write local SDK integration fixtures").option("--show", "Print the full fixture pack JSON").option("--write <dir>", "Write fixture pack, bridge fixture, contract snapshots, and example index to a directory").action(async (opts) => {
     const globalOpts = program2.opts();
@@ -64215,7 +64606,7 @@ function registerSdkFixtureCommands(program2) {
         writeSdkIntegrationFixtures: writeSdkIntegrationFixtures2
       } = await Promise.resolve().then(() => (init_sdk_integration_fixtures(), exports_sdk_integration_fixtures));
       if (opts.write) {
-        const result = writeSdkIntegrationFixtures2(resolve22(opts.write));
+        const result = writeSdkIntegrationFixtures2(resolve23(opts.write));
         if (globalOpts.json) {
           console.log(JSON.stringify(result));
           return;
@@ -65037,7 +65428,7 @@ __export(exports_local_backup_commands, {
   registerLocalBackupCommands: () => registerLocalBackupCommands
 });
 import chalk26 from "chalk";
-import { resolve as resolve23 } from "path";
+import { resolve as resolve24 } from "path";
 function globalOptions6(program2) {
   const command = program2;
   return command.optsWithGlobals?.() ?? program2.opts();
@@ -65059,10 +65450,10 @@ function registerLocalBackupCommands(program2) {
       const projectId = opts.projectId ?? autoProject(globalOpts);
       const backupBundle = createLocalBackup2({
         project_id: projectId,
-        output_path: opts.output ? resolve23(opts.output) : undefined
+        output_path: opts.output ? resolve24(opts.output) : undefined
       });
       const result = {
-        output_path: opts.output ? resolve23(opts.output) : null,
+        output_path: opts.output ? resolve24(opts.output) : null,
         backup: backupBundle
       };
       if (opts.json || globalOpts.json) {
@@ -66866,7 +67257,7 @@ var init_factory = __esm(() => {
 });
 
 // src/storage/s3-artifacts.ts
-import { createHash as createHash14, createHmac as createHmac2 } from "crypto";
+import { createHash as createHash15, createHmac as createHmac2 } from "crypto";
 function createTodosS3ArtifactStore(options) {
   const requestFetch = options.fetch ?? fetch;
   const now4 = options.now ?? (() => new Date);
@@ -67038,7 +67429,7 @@ function toAmzDate(date) {
   return date.toISOString().replace(/[:-]|\.\d{3}/g, "");
 }
 function sha256Hex(value) {
-  return createHash14("sha256").update(value).digest("hex");
+  return createHash15("sha256").update(value).digest("hex");
 }
 function hmac(key, value) {
   return createHmac2("sha256", key).update(value).digest();