@hasna/todos 0.11.45 → 0.11.46

package/dist/index.js

@@ -1709,6 +1709,10 @@ function ensureSchema(db) {
   ensureColumn("dispatches", "machine_id", "TEXT");
   ensureColumn("dispatches", "synced_at", "TEXT");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_tasks_plan ON tasks(plan_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_tasks_project ON tasks(project_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_tasks_archived_at ON tasks(archived_at)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_tasks_updated_at ON tasks(updated_at)");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_tasks_task_list ON tasks(task_list_id)");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_tasks_due_at ON tasks(due_at)");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_tasks_short_id ON tasks(short_id) WHERE short_id IS NOT NULL");
@@ -2805,7 +2809,9 @@ var MCP_TOOL_GROUPS = {
     "create_risk",
     "create_handoff",
     "capture_environment_snapshot",
+    "check_local_integrity",
     "compare_environment_snapshots",
+    "create_local_backup",
     "create_inbox_item",
     "delete_comment",
     "detect_file_relationships",
@@ -2825,6 +2831,7 @@ var MCP_TOOL_GROUPS = {
     "add_task_run_event",
     "add_task_run_file",
     "acknowledge_handoff",
+    "build_local_report",
     "cancel_agent_run_dispatch",
     "finish_task_run",
     "find_duplicate_tasks",
@@ -2844,9 +2851,11 @@ var MCP_TOOL_GROUPS = {
     "close_risk",
     "get_task_git_refs",
     "get_task_run_ledger",
+    "get_usage_ledger",
     "list_agent_run_adapters",
     "list_agent_run_queue",
     "verify_task_run_artifacts",
+    "verify_local_backup",
     "get_task_traceability",
     "get_task_commits",
     "get_task_dependencies",
@@ -2863,6 +2872,7 @@ var MCP_TOOL_GROUPS = {
     "list_handoffs",
     "list_inbox_items",
     "list_knowledge_records",
+    "list_local_report_types",
     "list_onboarding_fixtures",
     "list_review_routing_rules",
     "list_local_snapshots",
@@ -2874,6 +2884,7 @@ var MCP_TOOL_GROUPS = {
     "queue_agent_run",
     "remove_agent_run_adapter",
     "remove_review_routing_rule",
+    "restore_local_backup",
     "retry_agent_run_dispatch",
     "resolve_mentions",
     "run_next_agent_dispatch",
@@ -2884,6 +2895,7 @@ var MCP_TOOL_GROUPS = {
     "set_review_routing_rule",
     "set_verification_provider",
     "simulate_agent_replay",
+    "discover_local_extensions",
     "inspect_local_extension",
     "install_local_extension",
     "list_local_extensions",
@@ -2951,11 +2963,15 @@ var MCP_TOOL_GROUPS = {
     "get_task_graph",
     "get_task_history",
     "get_task_stats",
+    "list_workflow_states",
     "list_labels",
     "list_tags",
+    "migrate_workflow_states",
+    "query_tasks_by_workflow_state",
     "query_tasks_by_fields",
     "search_tools",
     "describe_tools",
+    "set_task_workflow_state",
     "set_task_fields",
     "update_label",
     "update_tag"
@@ -3445,6 +3461,161 @@ var TODOS_JSON_CONTRACTS = [
     },
     optional: {}
   }),
+  contract({
+    id: "local_usage_ledger",
+    name: "Local Usage Ledger",
+    description: "Aggregate local report for task, project, run, command, cost, duration, storage, and simulated quota usage.",
+    surfaces: ["cli", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      schema_version: field("integer", "Report schema version."),
+      local_only: field("boolean", "Always true; report reads only local todos state."),
+      no_network: field("boolean", "Always true; report does not call hosted services."),
+      generated_at: isoDateField,
+      scope: field("object", "Project, agent, and time filters used for the aggregate."),
+      counts: field("object", "Counts for tasks, projects, runs, commands, artifacts, traces, and usage metadata records."),
+      durations: field("object", "Completed run, open run, trace, and total observed duration in milliseconds."),
+      usage: field("object", "Token and USD aggregates from task cost fields, traces, and agent-provided metadata."),
+      storage: field("object", "Evidence storage byte totals from local run artifacts."),
+      quota: field("object", "Optional local quota simulation with exceeded limits."),
+      redaction: field("object", "Aggregate-only guarantees for command and artifact path omission."),
+      sources: field("array", "Local SQLite tables included in the report.")
+    },
+    optional: {}
+  }),
+  contract({
+    id: "local_report",
+    name: "Local Agent Report",
+    description: "Local-only report composing ready, blocked, overdue, plan, run, verification, and agent summaries.",
+    surfaces: ["cli", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      schema_version: field("integer", "Report schema version."),
+      local_only: field("boolean", "Always true; report reads only local todos state."),
+      no_network: field("boolean", "Always true; report does not call hosted analytics or usage collection."),
+      generated_at: isoDateField,
+      scope: field("object", "Project, plan, agent, and time filters used to build the report."),
+      report_types: field("array", "Stable local report sections included by this package."),
+      views: field("object", "Ready, blocked, and overdue task views."),
+      plans: field("array", "Plan progress summaries with blocked and overdue counts."),
+      runs: field("object", "Run outcome counts and recent run evidence summaries."),
+      verification: field("object", "Verification outcome counts and recent verification evidence summaries."),
+      agents: field("array", "Per-agent task, run, and verification summaries."),
+      exports: field("object", "JSON contract and Markdown support metadata.")
+    },
+    optional: {}
+  }),
+  contract({
+    id: "local_backup_bundle",
+    name: "Local Backup Bundle",
+    description: "Local backup wrapper around a bridge bundle with manifest counts, section checksums, SQLite integrity metadata, and artifact-content coverage.",
+    surfaces: ["cli", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      schema_version: field("integer", "Backup schema version."),
+      kind: field("string", "Backup bundle kind identifier."),
+      local_only: field("boolean", "Always true; backup creation reads only local state."),
+      no_network: field("boolean", "Always true; backup creation performs no network requests."),
+      created_at: isoDateField,
+      package: field("object", "Package source metadata."),
+      manifest: field("object", "Backup manifest with checksums, counts, source scope, and SQLite integrity."),
+      bridge: field("object", "Embedded local bridge bundle containing tasks, projects, plans, runs, comments, evidence, and stored artifact content."),
+      checksum_algorithm: field("string", "Digest algorithm used for backup and bridge checksums."),
+      checksum: field("string", "SHA-256 checksum of the backup payload excluding this field.")
+    },
+    optional: {}
+  }),
+  contract({
+    id: "local_backup_verification",
+    name: "Local Backup Verification",
+    description: "Verification report for a local backup bundle covering backup checksum, bridge checksum, manifest counts, schema compatibility, and current SQLite integrity.",
+    surfaces: ["cli", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      schema_version: field("integer", "Verification schema version."),
+      kind: field("string", "Verification report kind identifier."),
+      local_only: field("boolean", "Always true; verification reads local files and SQLite only."),
+      no_network: field("boolean", "Always true; verification performs no network requests."),
+      verified_at: isoDateField,
+      ok: field("boolean", "True when all checks pass."),
+      checksum_algorithm: field("string", "Digest algorithm used for backup and bridge checksums."),
+      checksum: field("object", "Expected and actual backup checksum status."),
+      bridge_checksum: field("object", "Expected and actual bridge checksum status."),
+      bridge_validation: field("object", "Embedded bridge schema validation result."),
+      sqlite: field(["object", "null"], "Current SQLite integrity check, or null when skipped.", true),
+      counts: field("object", "Manifest expected counts, actual bridge counts, and status."),
+      compatible: field("boolean", "True when embedded bridge schema is compatible with this package."),
+      issues: field("array", "Blocking verification issues."),
+      warnings: field("array", "Non-blocking local warnings.")
+    },
+    optional: {}
+  }),
+  contract({
+    id: "local_backup_restore_result",
+    name: "Local Backup Restore Result",
+    description: "Dry-run or applied local backup restore result with verification and bridge import details.",
+    surfaces: ["cli", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      schema_version: field("integer", "Restore result schema version."),
+      kind: field("string", "Restore result kind identifier."),
+      local_only: field("boolean", "Always true; restore targets only local SQLite state."),
+      no_network: field("boolean", "Always true; restore performs no network requests."),
+      restored_at: isoDateField,
+      dry_run: field("boolean", "True when no local records were written."),
+      ok: field("boolean", "True when verification passes and the import has no blocking issues."),
+      verification: field("object", "Backup verification result run before importing."),
+      import_result: field(["object", "null"], "Bridge import result, or null when verification failed.", true),
+      issues: field("array", "Blocking verification or import issues.")
+    },
+    optional: {}
+  }),
+  contract({
+    id: "local_integrity_report",
+    name: "Local Integrity Report",
+    description: "Local integrity report for SQLite quick_check, foreign keys, bridge validation, backup-relevant counts, and orphan rows.",
+    surfaces: ["cli", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      schema_version: field("integer", "Integrity report schema version."),
+      kind: field("string", "Integrity report kind identifier."),
+      local_only: field("boolean", "Always true; report reads only local SQLite state."),
+      no_network: field("boolean", "Always true; report performs no network requests."),
+      generated_at: isoDateField,
+      database_path: field("string", "Resolved local SQLite database path."),
+      sqlite: field("object", "SQLite quick_check and foreign key integrity summary."),
+      bridge_validation: field("object", "Bridge validation result for a freshly-created local bridge bundle."),
+      counts: field("object", "Backup-relevant record counts by bridge section."),
+      orphaned_rows: field("object", "Detected orphaned local rows by relationship."),
+      ok: field("boolean", "True when no blocking integrity issues are found."),
+      issues: field("array", "Blocking integrity issues."),
+      warnings: field("array", "Non-blocking local warnings.")
+    },
+    optional: {}
+  }),
+  contract({
+    id: "terminal_dashboard_snapshot",
+    name: "Terminal Dashboard Snapshot",
+    description: "Deterministic local snapshot for the keyboard-first terminal dashboard.",
+    surfaces: ["cli", "sdk"],
+    stability: "stable",
+    required: {
+      generated_at: isoDateField,
+      local_only: field("boolean", "Always true; dashboard snapshots read only local todos state."),
+      project_id: field(["string", "null"], "Optional project scope.", true),
+      active_view: field("string", "Active dashboard tab rendered by the TUI or snapshot command."),
+      keymap: field("array", "Keyboard shortcuts exposed by the TUI."),
+      counts: field("object", "Task counts by status and total."),
+      projects: field("array", "Visible projects with open task counts."),
+      tasks: field("array", "Visible pending and in-progress tasks."),
+      plans: field("array", "Visible plans with open task counts."),
+      runs: field("array", "Recent local task runs."),
+      dependencies: field("array", "Local dependency edges and blocking state."),
+      inbox: field("array", "Recent local inbox items."),
+      search: field("object", "Local search query and matching task results.")
+    },
+    optional: {}
+  }),
   contract({
     id: "mention_resolution_report",
     name: "Mention Resolution Report",
@@ -3692,6 +3863,56 @@ var TODOS_JSON_CONTRACTS = [
     },
     optional: {}
   }),
+  contract({
+    id: "workflow_state_config",
+    name: "Workflow State Config",
+    description: "Local workflow state definition mapped onto a canonical task status.",
+    surfaces: ["cli", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      name: field("string", "Local workflow state name."),
+      canonical_status: field("string", "Canonical task status used for storage and compatibility."),
+      aliases: field("array", "Alternate input names for this workflow state."),
+      terminal: field("boolean", "Whether this state represents terminal work.")
+    },
+    optional: {
+      description: field("string", "Optional human description."),
+      transitions: field(["array", "null"], "Allowed destination state names, or null for unrestricted.", true),
+      color: field("string", "Optional display color token.")
+    }
+  }),
+  contract({
+    id: "workflow_state_result",
+    name: "Workflow State Result",
+    description: "Result of setting a task's local workflow state.",
+    surfaces: ["cli", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      task: field("object", "Updated canonical task object."),
+      workflow_state: field("object", "Resolved target workflow state."),
+      previous_workflow_state: field("object", "Resolved prior workflow state."),
+      changed: field("boolean", "Whether the local workflow state changed."),
+      canonical_status_changed: field("boolean", "Whether the task row status changed."),
+      local_only: field("boolean", "Always true; operation uses local state only.")
+    },
+    optional: {}
+  }),
+  contract({
+    id: "workflow_state_migration",
+    name: "Workflow State Migration",
+    description: "Dry-run or applied local migration from canonical statuses to workflow state metadata.",
+    surfaces: ["cli", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      applied: field("boolean", "Whether metadata writes were applied."),
+      migrated_count: field("integer", "Number of tasks written during an applied migration."),
+      pending_count: field("integer", "Number of tasks that would be migrated in dry-run mode."),
+      skipped_count: field("integer", "Number of tasks already carrying matching workflow metadata."),
+      items: field("array", "Per-task migration preview records."),
+      local_only: field("boolean", "Always true; migration uses local state only.")
+    },
+    optional: {}
+  }),
   contract({
     id: "retention_cleanup_report",
     name: "Retention Cleanup Report",
@@ -3713,6 +3934,45 @@ var TODOS_JSON_CONTRACTS = [
     },
     optional: {}
   }),
+  contract({
+    id: "scale_performance_report",
+    name: "Scale Performance Report",
+    description: "Local scale hardening report for query performance, archive readiness, compaction, SQLite integrity, and expected indexes. It performs no network calls.",
+    surfaces: ["cli", "sdk"],
+    stability: "stable",
+    required: {
+      schema_version: field("integer", "Report schema version."),
+      local_only: field("boolean", "Always true; the report reads only local state."),
+      no_network: field("boolean", "Always true; the report performs no network requests."),
+      generated_at: isoDateField,
+      database_path: field("string", "Resolved local SQLite database path."),
+      counts: field("object", "Local task, project, agent, plan, run, event, comment, and dependency counts."),
+      benchmarks: field("array", "Measured local query timings with thresholds."),
+      archive: field("object", "Archive-readiness counts for old terminal tasks and include-archived visibility."),
+      compaction: field("object", "SQLite page and freelist state with recommended maintenance commands."),
+      integrity: field("object", "SQLite quick_check, foreign key, and required-index results."),
+      warnings: field("array", "Non-fatal warnings for slow queries, missing indexes, old archive candidates, or integrity issues.")
+    },
+    optional: {}
+  }),
+  contract({
+    id: "scale_compaction_result",
+    name: "Scale Compaction Result",
+    description: "Dry-run or applied local SQLite optimization and VACUUM compaction result.",
+    surfaces: ["cli", "sdk"],
+    stability: "stable",
+    required: {
+      schema_version: field("integer", "Result schema version."),
+      local_only: field("boolean", "Always true; compaction targets only the local SQLite database."),
+      no_network: field("boolean", "Always true; compaction performs no network requests."),
+      dry_run: field("boolean", "True when commands were only previewed."),
+      database_path: field("string", "Resolved local SQLite database path."),
+      before: field("object", "Page and freelist counts before compaction."),
+      after: field("object", "Page and freelist counts after compaction or dry-run preview."),
+      actions: field("array", "SQLite maintenance actions planned or applied.")
+    },
+    optional: {}
+  }),
   contract({
     id: "duplicate_task_candidate",
     name: "Duplicate Task Candidate",
@@ -3817,12 +4077,30 @@ var TODOS_JSON_CONTRACTS = [
       manifest: field("object", "Normalized extension manifest."),
       validation: field("object", "Schema, compatibility, permission, and sandbox validation details."),
       ok: field("boolean", "Whether the extension passed hard compatibility checks."),
-      summary: field("object", "Counts for commands, MCP tools, hooks, permissions, sandbox checks, and failed dry-runs."),
+      summary: field("object", "Counts for commands, MCP tools, templates, renderers, hooks, permissions, sandbox checks, and failed dry-runs."),
       errors: field("array", "Hard validation or compatibility errors."),
       warnings: field("array", "Non-blocking diagnostics such as sandbox approval requirements.")
     },
     optional: {}
   }),
+  contract({
+    id: "local_extension_discovery",
+    name: "Local Extension Discovery",
+    description: "Local-only discovery report for extension manifests from config, project roots, .todos folders, and installed registry records.",
+    surfaces: ["cli", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      schema_version: field("integer", "Report schema version."),
+      local_only: field("boolean", "Always true; discovery reads only local files and config."),
+      no_network: field("boolean", "Always true; discovery performs no network requests."),
+      project_path: field(["string", "null"], "Project root used for discovery, or null when omitted.", true),
+      config_sources: field("array", "Resolved extension source paths from config and project discovery."),
+      discovered: field("array", "Validated extension source inspections."),
+      installed: field("array", "Installed local extension registry records when included."),
+      warnings: field("array", "Non-fatal source read or validation warnings.")
+    },
+    optional: {}
+  }),
   contract({
     id: "agent",
     name: "Agent",
@@ -5230,6 +5508,15 @@ var DEFAULT_SECRET_PATTERNS = [
   { name: "bearer-token", regex: /\b(bearer)\s+[A-Za-z0-9._~+/=-]{12,}/gi, replacement: "$1 [REDACTED]" }
 ];
 var DEFAULT_SECRET_KEY_PATTERN = /api[_-]?key|token|secret|password/i;
+var NON_SECRET_USAGE_KEYS = new Set([
+  "tokens",
+  "total_tokens",
+  "token_count",
+  "input_tokens",
+  "output_tokens",
+  "prompt_tokens",
+  "completion_tokens"
+]);
 function unique(values) {
   return Array.from(new Set((values || []).map((value) => value.trim()).filter(Boolean)));
 }
@@ -5249,6 +5536,8 @@ function secretPatterns() {
   return [...customPatterns(), ...DEFAULT_SECRET_PATTERNS];
 }
 function isSecretKey(key) {
+  if (NON_SECRET_USAGE_KEYS.has(key.toLowerCase()))
+    return false;
   if (DEFAULT_SECRET_KEY_PATTERN.test(key))
     return true;
   return unique(loadConfig().secret_safety?.redaction_keys).some((pattern) => key.toLowerCase().includes(pattern.toLowerCase()));
@@ -9353,7 +9642,18 @@ function addTaskRunCommand(input, db) {
     run_id: run.id,
     event_type: "command",
     message: `${status}: ${command}`,
-    data: { command, status, exit_code: input.exit_code ?? null, output_summary: outputSummary, artifact_path: artifactPath },
+    data: {
+      command,
+      status,
+      exit_code: input.exit_code ?? null,
+      output_summary: outputSummary,
+      artifact_path: artifactPath,
+      usage: {
+        tokens: input.tokens ?? null,
+        cost_usd: input.cost_usd ?? null,
+        duration_ms: input.duration_ms ?? null
+      }
+    },
     agent_id: input.agent_id ?? run.agent_id ?? undefined,
     created_at: timestamp
   }, d);
@@ -10723,9 +11023,305 @@ function importOnboardingFixture(options = {}) {
     conflictStrategy: options.conflictStrategy
   });
 }
-// src/lib/local-snapshots.ts
+// src/lib/local-backups.ts
 init_database();
 import { createHash as createHash3 } from "crypto";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname6, resolve as resolve7 } from "path";
+import { mkdirSync as mkdirSync6 } from "fs";
+var TODOS_LOCAL_BACKUP_KIND = "hasna.todos.local-backup";
+var TODOS_LOCAL_BACKUP_SCHEMA_VERSION = 1;
+var TODOS_LOCAL_INTEGRITY_KIND = "hasna.todos.local-integrity";
+var TODOS_LOCAL_INTEGRITY_SCHEMA_VERSION = 1;
+var LOCAL_BACKUP_CHECKSUM_ALGORITHM = "sha256";
+function stableJson(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value);
+  if (Array.isArray(value))
+    return `[${value.map(stableJson).join(",")}]`;
+  const record = value;
+  return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableJson(record[key])}`).join(",")}}`;
+}
+function sha2562(value) {
+  return createHash3("sha256").update(stableJson(value)).digest("hex");
+}
+function sqliteIntegrity(db) {
+  let quick = "unknown";
+  try {
+    const row = db.query("PRAGMA quick_check").get();
+    quick = row?.quick_check ?? "unknown";
+  } catch (error) {
+    quick = error instanceof Error ? error.message : String(error);
+  }
+  let foreignKeyViolations = 0;
+  try {
+    foreignKeyViolations = db.query("PRAGMA foreign_key_check").all().length;
+  } catch {
+    foreignKeyViolations = 0;
+  }
+  return {
+    quick_check: quick,
+    foreign_key_violations: foreignKeyViolations,
+    ok: quick === "ok" && foreignKeyViolations === 0
+  };
+}
+function bridgeStats2(data) {
+  return Object.fromEntries(Object.keys(data).map((key) => [key, data[key].length]));
+}
+function sectionChecksums(data) {
+  return Object.fromEntries(Object.keys(data).map((key) => [key, sha2562(data[key])]));
+}
+function checksumPayload(bundle) {
+  return sha2562(bundle);
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function createLocalBackup(options = {}, db) {
+  const d = db || getDatabase();
+  const createdAt2 = options.generated_at ?? now();
+  const bridge = createLocalBridgeBundle({
+    project_id: options.project_id,
+    generatedAt: createdAt2,
+    version: options.version
+  }, d);
+  const integrity = sqliteIntegrity(d);
+  const bridgeChecksum = sha2562(bridge);
+  const warnings = [];
+  if (!integrity.ok)
+    warnings.push("current SQLite integrity check did not pass");
+  const manifest = {
+    schema_version: TODOS_LOCAL_BACKUP_SCHEMA_VERSION,
+    kind: TODOS_LOCAL_BACKUP_KIND,
+    local_only: true,
+    no_network: true,
+    created_at: createdAt2,
+    package: bridge.package,
+    source: bridge.source,
+    bridge: {
+      kind: TODOS_LOCAL_BRIDGE_KIND,
+      schema_version: TODOS_LOCAL_BRIDGE_SCHEMA_VERSION,
+      exported_at: bridge.exportedAt,
+      checksum: bridgeChecksum,
+      stats: bridge.stats,
+      artifact_contents: bridge.artifact_contents?.length ?? 0
+    },
+    database: {
+      path: getDatabasePath(),
+      integrity
+    },
+    checksum_algorithm: LOCAL_BACKUP_CHECKSUM_ALGORITHM,
+    section_checksums: sectionChecksums(bridge.data),
+    warnings
+  };
+  const withoutChecksum = {
+    schema_version: TODOS_LOCAL_BACKUP_SCHEMA_VERSION,
+    kind: TODOS_LOCAL_BACKUP_KIND,
+    local_only: true,
+    no_network: true,
+    created_at: createdAt2,
+    package: bridge.package,
+    manifest,
+    bridge,
+    checksum_algorithm: LOCAL_BACKUP_CHECKSUM_ALGORITHM
+  };
+  const backup = {
+    ...withoutChecksum,
+    checksum: checksumPayload(withoutChecksum)
+  };
+  if (options.output_path)
+    writeLocalBackupFile(backup, options.output_path);
+  return backup;
+}
+function writeLocalBackupFile(backup, outputPath) {
+  const path = resolve7(outputPath);
+  mkdirSync6(dirname6(path), { recursive: true });
+  writeFileSync4(path, `${JSON.stringify(backup, null, 2)}
+`);
+  return path;
+}
+function readLocalBackupFile(path) {
+  return JSON.parse(readFileSync4(resolve7(path), "utf-8"));
+}
+function verifyLocalBackup(value, options = {}, db) {
+  const verifiedAt = options.verified_at ?? now();
+  const record = asRecord(value);
+  const issues = [];
+  const warnings = [];
+  const bridge = record?.bridge;
+  const manifest = asRecord(record?.manifest);
+  const expectedChecksum = typeof record?.checksum === "string" ? record.checksum : null;
+  const expectedBridgeChecksum = typeof manifest?.bridge === "object" && manifest.bridge && "checksum" in manifest.bridge ? String(manifest.bridge.checksum) : null;
+  if (!record)
+    issues.push("backup must be an object");
+  if (record?.kind !== TODOS_LOCAL_BACKUP_KIND)
+    issues.push(`kind must be ${TODOS_LOCAL_BACKUP_KIND}`);
+  if (record?.schema_version !== TODOS_LOCAL_BACKUP_SCHEMA_VERSION) {
+    issues.push(`schema_version must be ${TODOS_LOCAL_BACKUP_SCHEMA_VERSION}`);
+  }
+  if (record?.local_only !== true)
+    issues.push("local_only must be true");
+  if (record?.no_network !== true)
+    issues.push("no_network must be true");
+  if (!manifest)
+    issues.push("manifest must be an object");
+  if (!bridge)
+    issues.push("bridge must be an object");
+  const bridgeValidation = validateLocalBridgeBundle(bridge);
+  if (!bridgeValidation.ok)
+    issues.push(...bridgeValidation.issues.map((issue) => `bridge: ${issue}`));
+  const actualBridgeChecksum = bridge ? sha2562(bridge) : null;
+  if (expectedBridgeChecksum && actualBridgeChecksum && expectedBridgeChecksum !== actualBridgeChecksum) {
+    issues.push("bridge checksum mismatch");
+  }
+  const withoutChecksum = record ? { ...record } : null;
+  if (withoutChecksum)
+    delete withoutChecksum.checksum;
+  const actualChecksum = withoutChecksum ? checksumPayload(withoutChecksum) : null;
+  if (expectedChecksum && actualChecksum && expectedChecksum !== actualChecksum) {
+    issues.push("backup checksum mismatch");
+  }
+  const expectedCounts = manifest?.bridge && typeof manifest.bridge === "object" ? manifest.bridge.stats ?? {} : {};
+  const actualCounts = bridge?.data ? bridgeStats2(bridge.data) : {};
+  const countMismatches = Object.entries(expectedCounts).filter(([key, count]) => {
+    const actual = actualCounts[key];
+    return typeof count === "number" && actual !== count;
+  });
+  if (countMismatches.length > 0) {
+    issues.push(`manifest count mismatch: ${countMismatches.map(([key]) => key).join(", ")}`);
+  }
+  if (manifest?.section_checksums && typeof manifest.section_checksums === "object" && bridge?.data) {
+    const actualSections = sectionChecksums(bridge.data);
+    const mismatches = Object.entries(manifest.section_checksums).filter(([key, expected]) => actualSections[key] !== expected);
+    if (mismatches.length > 0)
+      issues.push(`section checksum mismatch: ${mismatches.map(([key]) => key).join(", ")}`);
+  }
+  if (bridge?.schemaVersion !== TODOS_LOCAL_BRIDGE_SCHEMA_VERSION) {
+    issues.push(`bridge schemaVersion must be ${TODOS_LOCAL_BRIDGE_SCHEMA_VERSION}`);
+  }
+  const sqlite = options.check_sqlite === false ? null : sqliteIntegrity(db || getDatabase());
+  if (sqlite && !sqlite.ok)
+    warnings.push("current SQLite integrity check did not pass");
+  return {
+    schema_version: TODOS_LOCAL_BACKUP_SCHEMA_VERSION,
+    kind: "hasna.todos.local-backup-verification",
+    local_only: true,
+    no_network: true,
+    verified_at: verifiedAt,
+    ok: issues.length === 0,
+    checksum_algorithm: LOCAL_BACKUP_CHECKSUM_ALGORITHM,
+    checksum: {
+      expected: expectedChecksum,
+      actual: actualChecksum,
+      ok: Boolean(expectedChecksum && actualChecksum && expectedChecksum === actualChecksum)
+    },
+    bridge_checksum: {
+      expected: expectedBridgeChecksum,
+      actual: actualBridgeChecksum,
+      ok: Boolean(expectedBridgeChecksum && actualBridgeChecksum && expectedBridgeChecksum === actualBridgeChecksum)
+    },
+    bridge_validation: bridgeValidation,
+    sqlite,
+    counts: {
+      expected: expectedCounts,
+      actual: actualCounts,
+      ok: countMismatches.length === 0
+    },
+    compatible: bridge?.schemaVersion === TODOS_LOCAL_BRIDGE_SCHEMA_VERSION,
+    issues,
+    warnings
+  };
+}
+function restoreLocalBackup(backup, options = {}, db) {
+  const d = db || getDatabase();
+  const verification = verifyLocalBackup(backup, { verified_at: options.verified_at, check_sqlite: true }, d);
+  const issues = [...verification.issues];
+  let importResult = null;
+  if (verification.ok) {
+    importResult = importLocalBridgeBundle(backup.bridge, {
+      dryRun: !options.apply,
+      conflictStrategy: options.conflict_strategy ?? "skip"
+    }, d);
+    if (!importResult.ok)
+      issues.push(...importResult.issues);
+  }
+  return {
+    schema_version: TODOS_LOCAL_BACKUP_SCHEMA_VERSION,
+    kind: "hasna.todos.local-backup-restore",
+    local_only: true,
+    no_network: true,
+    restored_at: options.verified_at ?? now(),
+    dry_run: !options.apply,
+    ok: verification.ok && Boolean(importResult?.ok),
+    verification,
+    import_result: importResult,
+    issues
+  };
+}
+function count(db, table) {
+  const row = db.query(`SELECT COUNT(*) AS count FROM ${table}`).get();
+  return row?.count ?? 0;
+}
+function orphanedRows(db) {
+  return {
+    tasks_missing_project: countQuery(db, "SELECT COUNT(*) AS count FROM tasks t WHERE t.project_id IS NOT NULL AND NOT EXISTS (SELECT 1 FROM projects p WHERE p.id = t.project_id)"),
+    comments_missing_task: countQuery(db, "SELECT COUNT(*) AS count FROM task_comments c WHERE NOT EXISTS (SELECT 1 FROM tasks t WHERE t.id = c.task_id)"),
+    runs_missing_task: countQuery(db, "SELECT COUNT(*) AS count FROM task_runs r WHERE NOT EXISTS (SELECT 1 FROM tasks t WHERE t.id = r.task_id)"),
+    run_events_missing_run: countQuery(db, "SELECT COUNT(*) AS count FROM task_run_events e WHERE NOT EXISTS (SELECT 1 FROM task_runs r WHERE r.id = e.run_id)"),
+    run_commands_missing_run: countQuery(db, "SELECT COUNT(*) AS count FROM task_run_commands c WHERE NOT EXISTS (SELECT 1 FROM task_runs r WHERE r.id = c.run_id)"),
+    run_artifacts_missing_run: countQuery(db, "SELECT COUNT(*) AS count FROM task_run_artifacts a WHERE NOT EXISTS (SELECT 1 FROM task_runs r WHERE r.id = a.run_id)"),
+    dependencies_missing_task: countQuery(db, "SELECT COUNT(*) AS count FROM task_dependencies d WHERE NOT EXISTS (SELECT 1 FROM tasks t WHERE t.id = d.task_id)"),
+    dependencies_missing_dependency: countQuery(db, "SELECT COUNT(*) AS count FROM task_dependencies d WHERE d.depends_on IS NOT NULL AND NOT EXISTS (SELECT 1 FROM tasks t WHERE t.id = d.depends_on)")
+  };
+}
+function countQuery(db, sql) {
+  try {
+    const row = db.query(sql).get();
+    return row?.count ?? 0;
+  } catch {
+    return 0;
+  }
+}
+function checkLocalIntegrity(options = {}, db) {
+  const d = db || getDatabase();
+  const bridge = createLocalBridgeBundle({
+    project_id: options.project_id,
+    generatedAt: options.generated_at,
+    version: options.version ?? getPackageVersion(import.meta.url)
+  }, d);
+  const bridgeValidation = validateLocalBridgeBundle(bridge);
+  const sqlite = sqliteIntegrity(d);
+  const orphans = orphanedRows(d);
+  const issues = [];
+  const warnings = [];
+  if (!sqlite.ok)
+    issues.push("SQLite integrity check failed");
+  if (!bridgeValidation.ok)
+    issues.push(...bridgeValidation.issues.map((issue) => `bridge: ${issue}`));
+  const orphanTotal = Object.values(orphans).reduce((sum, value) => sum + value, 0);
+  if (orphanTotal > 0)
+    issues.push(`${orphanTotal} orphaned local row(s) detected`);
+  if (count(d, "tasks") === 0)
+    warnings.push("no tasks found in local store");
+  return {
+    schema_version: TODOS_LOCAL_INTEGRITY_SCHEMA_VERSION,
+    kind: TODOS_LOCAL_INTEGRITY_KIND,
+    local_only: true,
+    no_network: true,
+    generated_at: options.generated_at ?? now(),
+    database_path: getDatabasePath(),
+    sqlite,
+    bridge_validation: bridgeValidation,
+    counts: bridge.stats,
+    orphaned_rows: orphans,
+    ok: issues.length === 0,
+    issues,
+    warnings
+  };
+}
+// src/lib/local-snapshots.ts
+init_database();
+import { createHash as createHash4 } from "crypto";
 
 // src/lib/activity-timeline.ts
 init_database();
@@ -10999,8 +11595,8 @@ function stable(value) {
     return value;
   return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, stable(item)]));
 }
-function sha2562(value) {
-  return createHash3("sha256").update(JSON.stringify(stable(value))).digest("hex");
+function sha2563(value) {
+  return createHash4("sha256").update(JSON.stringify(stable(value))).digest("hex");
 }
 function latestTimestamp(items, fallback) {
   const timestamps = [];
@@ -11180,7 +11776,7 @@ function getLocalSnapshot(options, db) {
     package: source3(getPackageVersion(import.meta.url)),
     filters: body.filters,
     cursor,
-    fingerprint: sha2562(body),
+    fingerprint: sha2563(body),
     count: items.length,
     items,
     resources: {
@@ -11237,7 +11833,7 @@ function renderLocalSnapshotMarkdown(snapshot) {
 `;
 }
 // src/lib/sdk-integration-fixtures.ts
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync4 } from "fs";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync5 } from "fs";
 import { join as join7 } from "path";
 
 // src/cli-mcp-parity.ts
@@ -11418,6 +12014,56 @@ var TODOS_CLI_MCP_PARITY = [
       mcpTool: "get_agent_reliability_scorecard"
     }
   },
+  {
+    domain: "local-reports",
+    cliCommands: [
+      "todos reports local"
+    ],
+    mcpTools: [
+      "list_local_report_types",
+      "build_local_report"
+    ],
+    jsonContracts: ["local_report", "task", "structured_error", "api_error"],
+    errorContracts: ["structured_error", "api_error"],
+    status: "matched",
+    intentionalGaps: [],
+    example: {
+      cli: "todos reports local --agent codex --format markdown",
+      mcpTool: "build_local_report"
+    }
+  },
+  {
+    domain: "local-backups",
+    cliCommands: [
+      "todos backup create",
+      "todos backup verify",
+      "todos backup restore",
+      "todos backup integrity"
+    ],
+    mcpTools: [
+      "create_local_backup",
+      "verify_local_backup",
+      "restore_local_backup",
+      "check_local_integrity"
+    ],
+    jsonContracts: [
+      "local_backup_bundle",
+      "local_backup_verification",
+      "local_backup_restore_result",
+      "local_integrity_report",
+      "local_bridge_bundle",
+      "local_bridge_import_result",
+      "structured_error",
+      "api_error"
+    ],
+    errorContracts: ["structured_error", "api_error"],
+    status: "matched",
+    intentionalGaps: [],
+    example: {
+      cli: "todos backup create --output todos-backup.json --json",
+      mcpTool: "create_local_backup"
+    }
+  },
   {
     domain: "local-fields",
     cliCommands: [
@@ -11439,6 +12085,29 @@ var TODOS_CLI_MCP_PARITY = [
       mcpTool: "set_task_fields"
     }
   },
+  {
+    domain: "workflow-states",
+    cliCommands: [
+      "todos workflow states",
+      "todos workflow set",
+      "todos workflow tasks",
+      "todos workflow migrate"
+    ],
+    mcpTools: [
+      "list_workflow_states",
+      "set_task_workflow_state",
+      "query_tasks_by_workflow_state",
+      "migrate_workflow_states"
+    ],
+    jsonContracts: ["workflow_state_config", "workflow_state_result", "workflow_state_migration", "task", "structured_error", "api_error"],
+    errorContracts: ["structured_error", "api_error"],
+    status: "matched",
+    intentionalGaps: [],
+    example: {
+      cli: "todos workflow set 1234abcd review --json",
+      mcpTool: "set_task_workflow_state"
+    }
+  },
   {
     domain: "dedupe",
     cliCommands: [
@@ -11634,18 +12303,63 @@ var TODOS_CLI_MCP_PARITY = [
     }
   },
   {
-    domain: "templates",
-    cliCommands: [
-      "todos template-library",
-      "todos template-init",
-      "todos template-preview",
-      "todos templates --use",
-      "todos template-export",
-      "todos template-import",
-      "todos template-history"
-    ],
-    mcpTools: [
-      "list_template_library",
+    domain: "usage-ledger",
+    cliCommands: ["todos usage report"],
+    mcpTools: ["get_usage_ledger"],
+    jsonContracts: ["local_usage_ledger", "structured_error", "api_error"],
+    errorContracts: ["structured_error", "api_error"],
+    status: "matched",
+    intentionalGaps: [],
+    example: {
+      cli: "todos usage report --agent codex --max-tasks 1000 --json",
+      mcpTool: "get_usage_ledger"
+    }
+  },
+  {
+    domain: "terminal-dashboard",
+    cliCommands: ["todos dashboard", "todos dashboard --snapshot"],
+    mcpTools: [],
+    jsonContracts: ["terminal_dashboard_snapshot", "structured_error", "api_error"],
+    errorContracts: ["structured_error", "api_error"],
+    status: "intentional-gap",
+    intentionalGaps: [{
+      cliCommand: "todos dashboard",
+      reason: "The interactive terminal dashboard is a human TUI surface; agents should use the underlying task, project, plan, run, dependency, inbox, and search MCP tools directly."
+    }],
+    gapReason: "Terminal UI keyboard navigation is not an MCP interaction model.",
+    example: {
+      cli: "todos dashboard --snapshot --view tasks --search release --json"
+    }
+  },
+  {
+    domain: "scale-hardening",
+    cliCommands: ["todos scale report", "todos scale compact"],
+    mcpTools: [],
+    jsonContracts: ["scale_performance_report", "scale_compaction_result", "structured_error", "api_error"],
+    errorContracts: ["structured_error", "api_error"],
+    status: "intentional-gap",
+    intentionalGaps: [{
+      cliCommand: "todos scale compact",
+      reason: "SQLite VACUUM is a local maintenance operation that can briefly lock the database; MCP agents should request explicit local CLI maintenance instead of invoking compaction through a remote-facing tool surface."
+    }],
+    gapReason: "Scale diagnostics and compaction are local operator maintenance commands, while MCP tools should use domain-specific task, run, and doctor APIs.",
+    example: {
+      cli: "todos scale report --older-than-days 30 --json"
+    }
+  },
+  {
+    domain: "templates",
+    cliCommands: [
+      "todos template-library",
+      "todos template-init",
+      "todos template-preview",
+      "todos templates --use",
+      "todos template-export",
+      "todos template-import",
+      "todos template-history"
+    ],
+    mcpTools: [
+      "list_template_library",
       "write_template_library",
       "init_templates",
       "preview_template",
@@ -11756,6 +12470,7 @@ var TODOS_CLI_MCP_PARITY = [
     domain: "extensions",
     cliCommands: [
       "todos extensions list",
+      "todos extensions discover",
       "todos extensions inspect",
       "todos extensions compat",
       "todos extensions install",
@@ -11764,12 +12479,13 @@ var TODOS_CLI_MCP_PARITY = [
     ],
     mcpTools: [
       "list_local_extensions",
+      "discover_local_extensions",
       "inspect_local_extension",
       "test_local_extension_compatibility",
       "install_local_extension",
       "remove_local_extension"
     ],
-    jsonContracts: ["local_extension_compatibility", "structured_error", "api_error"],
+    jsonContracts: ["local_extension_compatibility", "local_extension_discovery", "structured_error", "api_error"],
     errorContracts: ["structured_error", "api_error"],
     status: "matched",
     example: {
@@ -13055,7 +13771,7 @@ function createSdkIntegrationFixturePack(options = {}) {
   };
 }
 function writeSdkIntegrationFixtures(directory, options = {}) {
-  mkdirSync6(directory, { recursive: true });
+  mkdirSync7(directory, { recursive: true });
   const pack = createSdkIntegrationFixturePack(options);
   const bundle = getOnboardingFixtureBundle("agent-project-demo");
   const files = [
@@ -13067,7 +13783,7 @@ function writeSdkIntegrationFixtures(directory, options = {}) {
   const written = [];
   for (const [name, payload] of files) {
     const file = join7(directory, name);
-    writeFileSync4(file, `${JSON.stringify(payload, null, 2)}
+    writeFileSync5(file, `${JSON.stringify(payload, null, 2)}
 `, "utf-8");
     written.push(file);
   }
@@ -14053,7 +14769,7 @@ function renderRoadmapMarkdown(idOrName, db) {
 }
 // src/lib/audit-ledger.ts
 init_database();
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 var LOCAL_AUDIT_LEDGER_SCHEMA_VERSION = 1;
 var LOCAL_AUDIT_LEDGER_HASH_ALGORITHM = "sha256";
 var LOCAL_AUDIT_LEDGER_INITIAL_HASH = "0".repeat(64);
@@ -14066,7 +14782,7 @@ function canonicalize(value) {
   return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${canonicalize(object[key])}`).join(",")}}`;
 }
 function hash(value) {
-  return createHash4("sha256").update(value).digest("hex");
+  return createHash5("sha256").update(value).digest("hex");
 }
 function parsePayload(value) {
   if (!value)
@@ -14325,15 +15041,15 @@ function renderLocalAuditLedgerMarkdown(ledger) {
     `Scope: ${ledger.run_id ?? ledger.task_id ?? ledger.project_id ?? "all local evidence"}`,
     `Root hash: ${ledger.root_hash}`,
     `Entries: ${ledger.entry_count}`,
-    `Sources: ${Object.entries(ledger.source_counts).map(([source6, count]) => `${source6}=${count}`).join(", ") || "none"}`
+    `Sources: ${Object.entries(ledger.source_counts).map(([source6, count2]) => `${source6}=${count2}`).join(", ") || "none"}`
   ].join(`
 `);
 }
 // src/lib/release-compatibility.ts
 init_migrations();
 init_schema();
-import { readFileSync as readFileSync4 } from "fs";
-import { join as join8, resolve as resolve7 } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join8, resolve as resolve8 } from "path";
 import { Database as Database2 } from "bun:sqlite";
 var LOCAL_RELEASE_COMPATIBILITY_SCHEMA_VERSION = 1;
 var EXPECTED_PACKAGE_NAME = "@hasna/todos";
@@ -14379,7 +15095,7 @@ function warn(id, message, details) {
   return { id, status: "warning", message, details };
 }
 function readPackageJson(root) {
-  return JSON.parse(readFileSync4(join8(root, "package.json"), "utf8"));
+  return JSON.parse(readFileSync5(join8(root, "package.json"), "utf8"));
 }
 function sortedKeys(value) {
   return Object.keys(value ?? {}).sort((left, right) => left.localeCompare(right));
@@ -14475,7 +15191,7 @@ function checkChangelog() {
   ];
 }
 function createReleaseCompatibilityReport(options = {}) {
-  const root = resolve7(options.root ?? process.cwd());
+  const root = resolve8(options.root ?? process.cwd());
   const packageJson = readPackageJson(root);
   const simulatedLevels = options.simulated_levels ?? defaultSimulationLevels();
   const checks = [
@@ -14586,7 +15302,7 @@ function renderReleaseCompatibilityMarkdown(report) {
 `);
 }
 // src/db/inbox.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 
 // src/lib/github.ts
 import { execFileSync } from "child_process";
@@ -14669,7 +15385,7 @@ function compactWhitespace(value) {
 function fingerprintInboxInput(input) {
   const sourceType = input.source_type || detectInboxSourceType(input.body, input.source_url);
   const normalized = compactWhitespace(redactEvidenceText(input.body)).slice(0, 8000);
-  return createHash5("sha256").update(`${sourceType}
+  return createHash6("sha256").update(`${sourceType}
 ${input.source_url || ""}
 ${normalized}`).digest("hex");
 }
@@ -16199,120 +16915,867 @@ async function checkLocalNotifications(input = {}, db) {
     warnings
   };
 }
-// src/lib/local-encryption.ts
-import { createCipheriv, createDecipheriv, createHash as createHash6, randomBytes, scryptSync, timingSafeEqual } from "crypto";
-var TODOS_ENCRYPTED_VALUE_KIND = "hasna.todos.encrypted-value";
-var TODOS_ENCRYPTED_BRIDGE_KIND = "hasna.todos.encrypted-bridge";
-var TODOS_ENCRYPTION_SCHEMA_VERSION = 1;
-var DEFAULT_ENCRYPTION_PROFILE = "default";
-var DEFAULT_ENCRYPTION_KEY_ENV = "TODOS_ENCRYPTION_KEY";
-
-class EncryptionKeyUnavailableError extends Error {
-  keyEnv;
-  profile;
-  constructor(keyEnv, profile) {
-    super(`Encryption key is locked: set ${keyEnv} to use profile ${profile}`);
-    this.keyEnv = keyEnv;
-    this.profile = profile;
+// src/lib/usage-ledger.ts
+init_database();
+var LOCAL_USAGE_LEDGER_SCHEMA_VERSION = 1;
+function numberValue(value) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed))
+      return parsed;
   }
+  return 0;
 }
-
-class EncryptedPayloadError extends Error {
-  constructor(message) {
-    super(message);
+function sumDirectNumber(record, keys) {
+  let value = 0;
+  for (const [rawKey, rawValue] of Object.entries(record)) {
+    const key = rawKey.toLowerCase();
+    if (keys.includes(key))
+      value += Math.max(0, numberValue(rawValue));
   }
+  return value;
 }
-function now2() {
-  return new Date().toISOString();
+function maxDirectNumber(record, keys) {
+  let value = 0;
+  for (const [rawKey, rawValue] of Object.entries(record)) {
+    const key = rawKey.toLowerCase();
+    if (keys.includes(key))
+      value = Math.max(value, numberValue(rawValue));
+  }
+  return Math.max(0, value);
 }
-function sha2563(value) {
-  return createHash6("sha256").update(value).digest("hex");
+function extractUsage(value) {
+  if (!value || typeof value !== "object")
+    return { tokens: 0, cost_usd: 0, duration_ms: 0, records: 0 };
+  if (Array.isArray(value)) {
+    return value.reduce((acc, item) => {
+      const usage = extractUsage(item);
+      acc.tokens += usage.tokens;
+      acc.cost_usd += usage.cost_usd;
+      acc.duration_ms += usage.duration_ms;
+      acc.records += usage.records;
+      return acc;
+    }, { tokens: 0, cost_usd: 0, duration_ms: 0, records: 0 });
+  }
+  const record = value;
+  const explicitTokens = maxDirectNumber(record, ["tokens", "total_tokens", "token_count"]);
+  const splitTokens2 = sumDirectNumber(record, ["input_tokens", "output_tokens", "prompt_tokens", "completion_tokens"]);
+  const cost = maxDirectNumber(record, ["cost_usd", "usd", "price_usd", "amount_usd", "cost"]);
+  const duration = maxDirectNumber(record, ["duration_ms", "elapsed_ms", "latency_ms"]);
+  const own = {
+    tokens: explicitTokens || splitTokens2,
+    cost_usd: cost,
+    duration_ms: duration,
+    records: explicitTokens || splitTokens2 || cost || duration ? 1 : 0
+  };
+  for (const [key, child] of Object.entries(record)) {
+    if (["tokens", "total_tokens", "token_count", "input_tokens", "output_tokens", "prompt_tokens", "completion_tokens", "cost_usd", "usd", "price_usd", "amount_usd", "cost", "duration_ms", "elapsed_ms", "latency_ms"].includes(key.toLowerCase())) {
+      continue;
+    }
+    const nested = extractUsage(child);
+    own.tokens += nested.tokens;
+    own.cost_usd += nested.cost_usd;
+    own.duration_ms += nested.duration_ms;
+    own.records += nested.records;
+  }
+  return own;
 }
-function normalizeProfileName(value) {
-  const name = (value || DEFAULT_ENCRYPTION_PROFILE).trim();
-  if (!/^[a-zA-Z0-9._-]+$/.test(name))
-    throw new Error("encryption profile names may only contain letters, numbers, dots, underscores, and dashes");
-  return name;
+function parseJsonObject4(value) {
+  if (!value)
+    return {};
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
 }
-function randomBase64(bytes) {
-  return randomBytes(bytes).toString("base64");
+function millisBetween(start, end) {
+  if (!start || !end)
+    return 0;
+  const startMs = Date.parse(start);
+  const endMs = Date.parse(end);
+  if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || endMs < startMs)
+    return 0;
+  return endMs - startMs;
 }
-function deriveKey(secret, salt) {
-  if (secret.length < 12)
-    throw new Error("encryption key must be at least 12 characters");
-  return scryptSync(secret, Buffer.from(salt, "base64"), 32);
+function addTaskScope(where, params, options, alias = "t") {
+  if (options.project_id) {
+    where.push(`${alias}.project_id = ?`);
+    params.push(options.project_id);
+  }
+  if (options.agent_id) {
+    where.push(`(${alias}.agent_id = ? OR ${alias}.assigned_to = ?)`);
+    params.push(options.agent_id, options.agent_id);
+  }
+  if (options.since) {
+    where.push(`${alias}.created_at >= ?`);
+    params.push(options.since);
+  }
+  if (options.until) {
+    where.push(`${alias}.created_at <= ?`);
+    params.push(options.until);
+  }
 }
-function profileFromConfig(name) {
-  return loadConfig().encryption_profiles?.[name] ?? null;
+function addRunScope(where, params, options, runAlias = "r", taskAlias = "t") {
+  if (options.project_id) {
+    where.push(`${taskAlias}.project_id = ?`);
+    params.push(options.project_id);
+  }
+  if (options.agent_id) {
+    where.push(`(${runAlias}.agent_id = ? OR ${taskAlias}.agent_id = ? OR ${taskAlias}.assigned_to = ?)`);
+    params.push(options.agent_id, options.agent_id, options.agent_id);
+  }
+  if (options.since) {
+    where.push(`${runAlias}.started_at >= ?`);
+    params.push(options.since);
+  }
+  if (options.until) {
+    where.push(`${runAlias}.started_at <= ?`);
+    params.push(options.until);
+  }
 }
-function ensureEncryptionProfile(name = DEFAULT_ENCRYPTION_PROFILE) {
-  const normalized = normalizeProfileName(name);
-  const existing = profileFromConfig(normalized);
-  if (existing)
-    return existing;
-  return upsertEncryptionProfile({ name: normalized });
+function addTraceScope(where, params, options, traceAlias = "tr", taskAlias = "t") {
+  if (options.project_id) {
+    where.push(`${taskAlias}.project_id = ?`);
+    params.push(options.project_id);
+  }
+  if (options.agent_id) {
+    where.push(`(${traceAlias}.agent_id = ? OR ${taskAlias}.agent_id = ? OR ${taskAlias}.assigned_to = ?)`);
+    params.push(options.agent_id, options.agent_id, options.agent_id);
+  }
+  if (options.since) {
+    where.push(`${traceAlias}.created_at >= ?`);
+    params.push(options.since);
+  }
+  if (options.until) {
+    where.push(`${traceAlias}.created_at <= ?`);
+    params.push(options.until);
+  }
 }
-function listEncryptionProfiles() {
-  return Object.values(loadConfig().encryption_profiles ?? {}).sort((left, right) => left.name.localeCompare(right.name));
+function queryOne(db, sql, params) {
+  return db.query(sql).get(...params);
 }
-function upsertEncryptionProfile(input) {
-  const name = normalizeProfileName(input.name);
-  const config = loadConfig();
-  const existing = config.encryption_profiles?.[name];
-  const timestamp2 = now2();
-  const profile = {
+function queryAll(db, sql, params) {
+  return db.query(sql).all(...params);
+}
+function rounded(value, places = 6) {
+  if (!Number.isFinite(value))
+    return 0;
+  const factor = 10 ** places;
+  return Math.round(value * factor) / factor;
+}
+function quotaLimit(name, limit, used) {
+  if (limit === undefined || !Number.isFinite(limit) || limit < 0)
+    return null;
+  const normalized = name === "max_cost_usd" ? rounded(limit) : Math.floor(limit);
+  const roundedUsed = name === "max_cost_usd" ? rounded(used) : Math.floor(used);
+  return {
     name,
-    algorithm: "aes-256-gcm",
-    kdf: "scrypt",
-    key_env: input.key_env?.trim() || existing?.key_env || DEFAULT_ENCRYPTION_KEY_ENV,
-    salt: input.salt || existing?.salt || randomBase64(16),
-    description: input.description ?? existing?.description,
-    created_at: existing?.created_at || timestamp2,
-    updated_at: timestamp2
+    limit: normalized,
+    used: roundedUsed,
+    remaining: rounded(normalized - roundedUsed),
+    exceeded: roundedUsed > normalized
+  };
+}
+function buildQuota(options, report) {
+  const quotas = options.quotas || {};
+  const limits2 = [
+    quotaLimit("max_tasks", quotas.max_tasks, report.counts.tasks),
+    quotaLimit("max_projects", quotas.max_projects, report.counts.projects),
+    quotaLimit("max_runs", quotas.max_runs, report.counts.runs),
+    quotaLimit("max_commands", quotas.max_commands, report.counts.commands),
+    quotaLimit("max_tokens", quotas.max_tokens, report.usage.total_tokens),
+    quotaLimit("max_cost_usd", quotas.max_cost_usd, report.usage.total_cost_usd),
+    quotaLimit("max_storage_bytes", quotas.max_storage_bytes, report.storage.evidence_bytes)
+  ].filter((item) => Boolean(item));
+  const exceeded = limits2.filter((item) => item.exceeded).map((item) => item.name);
+  return {
+    simulated: limits2.length > 0,
+    limits: limits2,
+    exceeded,
+    allowed: exceeded.length === 0
   };
-  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(profile.key_env))
-    throw new Error("key_env must be a valid environment variable name");
-  saveConfig({
-    ...config,
-    encryption_profiles: {
-      ...config.encryption_profiles ?? {},
-      [name]: profile
+}
+function createLocalUsageLedger(options = {}, db) {
+  const d = db || getDatabase();
+  const generatedAt = options.generated_at || new Date().toISOString();
+  const taskWhere = [];
+  const taskParams = [];
+  addTaskScope(taskWhere, taskParams, options);
+  const taskClause = taskWhere.length ? `WHERE ${taskWhere.join(" AND ")}` : "";
+  const taskTotals = queryOne(d, `SELECT COUNT(*) as tasks, COALESCE(SUM(cost_tokens), 0) as task_tokens, COALESCE(SUM(cost_usd), 0) as task_cost_usd FROM tasks t ${taskClause}`, taskParams);
+  let projectCount = 0;
+  if (options.project_id) {
+    projectCount = queryOne(d, "SELECT COUNT(*) as count FROM projects WHERE id = ?", [options.project_id]).count;
+  } else if (options.agent_id) {
+    const projectWhere = ["t.project_id IS NOT NULL"];
+    const projectParams = [];
+    addTaskScope(projectWhere, projectParams, options);
+    projectCount = queryOne(d, `SELECT COUNT(DISTINCT t.project_id) as count FROM tasks t WHERE ${projectWhere.join(" AND ")}`, projectParams).count;
+  } else {
+    projectCount = queryOne(d, "SELECT COUNT(*) as count FROM projects", []).count;
+  }
+  const runWhere = [];
+  const runParams = [];
+  addRunScope(runWhere, runParams, options);
+  const runClause = runWhere.length ? `WHERE ${runWhere.join(" AND ")}` : "";
+  const runs = queryAll(d, `SELECT r.id, r.started_at, r.completed_at, r.metadata
+       FROM task_runs r JOIN tasks t ON t.id = r.task_id
+       ${runClause}`, runParams);
+  const commandTotals = queryOne(d, `SELECT COUNT(*) as commands
+       FROM task_run_commands c
+       JOIN task_runs r ON r.id = c.run_id
+       JOIN tasks t ON t.id = c.task_id
+       ${runClause}`, runParams);
+  const artifactTotals = queryOne(d, `SELECT COUNT(*) as artifacts, COALESCE(SUM(a.size_bytes), 0) as bytes
+       FROM task_run_artifacts a
+       JOIN task_runs r ON r.id = a.run_id
+       JOIN tasks t ON t.id = a.task_id
+       ${runClause}`, runParams);
+  const traceWhere = [];
+  const traceParams = [];
+  addTraceScope(traceWhere, traceParams, options);
+  const traceClause = traceWhere.length ? `WHERE ${traceWhere.join(" AND ")}` : "";
+  const traceTotals = queryOne(d, `SELECT COUNT(*) as traces,
+            COALESCE(SUM(tr.tokens), 0) as tokens,
+            COALESCE(SUM(tr.cost_usd), 0) as cost_usd,
+            COALESCE(SUM(tr.duration_ms), 0) as duration_ms
+       FROM task_traces tr
+       JOIN tasks t ON t.id = tr.task_id
+       ${traceClause}`, traceParams);
+  let completedRunMs = 0;
+  let openRunMs = 0;
+  let metadataUsage = { tokens: 0, cost_usd: 0, duration_ms: 0, records: 0 };
+  for (const run of runs) {
+    if (run.completed_at)
+      completedRunMs += millisBetween(run.started_at, run.completed_at);
+    else
+      openRunMs += millisBetween(run.started_at, generatedAt);
+    const usage = extractUsage(parseJsonObject4(run.metadata));
+    metadataUsage.tokens += usage.tokens;
+    metadataUsage.cost_usd += usage.cost_usd;
+    metadataUsage.duration_ms += usage.duration_ms;
+    metadataUsage.records += usage.records;
+  }
+  const eventRows = queryAll(d, `SELECT e.data
+       FROM task_run_events e
+       JOIN task_runs r ON r.id = e.run_id
+       JOIN tasks t ON t.id = e.task_id
+       ${runClause}`, runParams);
+  for (const event of eventRows) {
+    const usage = extractUsage(parseJsonObject4(event.data));
+    metadataUsage.tokens += usage.tokens;
+    metadataUsage.cost_usd += usage.cost_usd;
+    metadataUsage.duration_ms += usage.duration_ms;
+    metadataUsage.records += usage.records;
+  }
+  const taskTokens = Number(taskTotals.task_tokens || 0);
+  const traceTokens = Number(traceTotals.tokens || 0);
+  const metadataTokens = metadataUsage.tokens;
+  const taskCost = Number(taskTotals.task_cost_usd || 0);
+  const traceCost = Number(traceTotals.cost_usd || 0);
+  const metadataCost = metadataUsage.cost_usd;
+  const traceMs = Number(traceTotals.duration_ms || 0);
+  const baseReport = {
+    schema_version: LOCAL_USAGE_LEDGER_SCHEMA_VERSION,
+    local_only: true,
+    no_network: true,
+    generated_at: generatedAt,
+    scope: {
+      project_id: options.project_id || null,
+      agent_id: options.agent_id || null,
+      since: options.since || null,
+      until: options.until || null
+    },
+    counts: {
+      tasks: Number(taskTotals.tasks || 0),
+      projects: Number(projectCount || 0),
+      runs: runs.length,
+      commands: Number(commandTotals.commands || 0),
+      artifacts: Number(artifactTotals.artifacts || 0),
+      traces: Number(traceTotals.traces || 0),
+      metadata_records: metadataUsage.records
+    },
+    durations: {
+      completed_run_ms: completedRunMs,
+      open_run_ms: openRunMs,
+      trace_ms: traceMs,
+      total_observed_ms: completedRunMs + openRunMs + traceMs + metadataUsage.duration_ms
+    },
+    usage: {
+      task_tokens: taskTokens,
+      trace_tokens: traceTokens,
+      metadata_tokens: metadataTokens,
+      total_tokens: taskTokens + traceTokens + metadataTokens,
+      task_cost_usd: rounded(taskCost),
+      trace_cost_usd: rounded(traceCost),
+      metadata_cost_usd: rounded(metadataCost),
+      total_cost_usd: rounded(taskCost + traceCost + metadataCost)
+    },
+    storage: {
+      artifact_bytes: Number(artifactTotals.bytes || 0),
+      evidence_bytes: Number(artifactTotals.bytes || 0)
+    },
+    redaction: {
+      raw_commands_included: false,
+      raw_artifact_paths_included: false,
+      aggregate_only: true
+    },
+    sources: ["tasks", "projects", "task_runs", "task_run_commands", "task_run_artifacts", "task_run_events", "task_traces"]
+  };
+  return {
+    ...baseReport,
+    quota: buildQuota(options, baseReport)
+  };
+}
+function renderLocalUsageLedgerMarkdown(report) {
+  const minutes2 = (report.durations.total_observed_ms / 60000).toFixed(1);
+  const lines = [
+    "# Local Usage Ledger",
+    "",
+    `Generated: ${report.generated_at}`,
+    `Scope: project=${report.scope.project_id || "all"} agent=${report.scope.agent_id || "all"}`,
+    "",
+    "## Counts",
+    `- Tasks: ${report.counts.tasks}`,
+    `- Projects: ${report.counts.projects}`,
+    `- Runs: ${report.counts.runs}`,
+    `- Commands: ${report.counts.commands}`,
+    `- Artifacts: ${report.counts.artifacts}`,
+    `- Traces: ${report.counts.traces}`,
+    "",
+    "## Usage",
+    `- Tokens: ${report.usage.total_tokens}`,
+    `- Cost USD: ${report.usage.total_cost_usd}`,
+    `- Observed duration minutes: ${minutes2}`,
+    `- Evidence bytes: ${report.storage.evidence_bytes}`,
+    "",
+    "## Quota"
+  ];
+  if (!report.quota.simulated) {
+    lines.push("- No local quota limits supplied.");
+  } else {
+    for (const limit of report.quota.limits) {
+      lines.push(`- ${limit.name}: ${limit.used}/${limit.limit}${limit.exceeded ? " exceeded" : ""}`);
     }
-  });
-  return profile;
+    lines.push(`- Allowed: ${report.quota.allowed ? "yes" : "no"}`);
+  }
+  lines.push("", "Raw commands and artifact paths are not included in this aggregate report.");
+  return lines.join(`
+`);
 }
-function removeEncryptionProfile(name) {
-  const normalized = normalizeProfileName(name);
-  const config = loadConfig();
-  if (!config.encryption_profiles?.[normalized])
+// src/lib/local-reports.ts
+init_database();
+init_database();
+var LOCAL_REPORT_SCHEMA_VERSION = 1;
+var LOCAL_REPORT_TYPES = [
+  "ready",
+  "blocked",
+  "overdue",
+  "standup",
+  "sprint",
+  "progress",
+  "run_outcomes",
+  "verification_evidence",
+  "agent_summary"
+];
+function limitValue(value) {
+  if (value === undefined || !Number.isFinite(value))
+    return 20;
+  return Math.max(1, Math.min(500, Math.trunc(value)));
+}
+function isTerminal(task2) {
+  return task2.status === "completed" || task2.status === "failed" || task2.status === "cancelled";
+}
+function sameAgent(task2, agentId) {
+  if (!agentId)
+    return true;
+  return task2.assigned_to === agentId || task2.agent_id === agentId;
+}
+function withinTaskWindow(task2, options) {
+  const time = Date.parse(task2.updated_at);
+  if (!Number.isFinite(time))
+    return true;
+  if (options.since && time < Date.parse(options.since))
+    return false;
+  if (options.until && time > Date.parse(options.until))
     return false;
-  const next = { ...config.encryption_profiles };
-  delete next[normalized];
-  saveConfig({ ...config, encryption_profiles: next });
   return true;
 }
-function encryptionProfileStatus(name = DEFAULT_ENCRYPTION_PROFILE, env = process.env) {
-  const profile = ensureEncryptionProfile(name);
+function scopedTasks(options, db) {
+  return listTasks({
+    project_id: options.project_id,
+    plan_id: options.plan_id,
+    include_archived: false
+  }, db).filter((task2) => sameAgent(task2, options.agent_id) && withinTaskWindow(task2, options));
+}
+function summarizeTask(task2) {
   return {
-    profile: redactValue(profile),
-    locked: !env[profile.key_env],
-    key_env: profile.key_env,
-    key_present: Boolean(env[profile.key_env])
+    id: task2.id,
+    short_id: task2.short_id,
+    title: task2.title,
+    status: task2.status,
+    priority: task2.priority,
+    project_id: task2.project_id,
+    plan_id: task2.plan_id,
+    assigned_to: task2.assigned_to,
+    due_at: task2.due_at,
+    updated_at: task2.updated_at
   };
 }
-function keyForProfile(profile, env) {
-  const secret = env[profile.key_env];
-  if (!secret)
-    throw new EncryptionKeyUnavailableError(profile.key_env, profile.name);
-  return deriveKey(secret, profile.salt);
+function overdueTasks(tasks, nowIso) {
+  const now2 = Date.parse(nowIso);
+  return tasks.filter((task2) => {
+    if (isTerminal(task2) || !task2.due_at)
+      return false;
+    const due = Date.parse(task2.due_at);
+    return Number.isFinite(due) && due < now2;
+  });
 }
-function encryptString(plaintext, options = {}) {
-  const profile = ensureEncryptionProfile(options.profile);
-  const key = keyForProfile(profile, options.env ?? process.env);
-  const iv = randomBytes(12);
-  const cipher = createCipheriv("aes-256-gcm", key, iv);
-  const ciphertext = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
-  const authTag = cipher.getAuthTag();
+function isReady(task2, db) {
+  if (task2.status !== "pending")
+    return false;
+  if (task2.locked_by && !isLockExpired(task2.locked_at))
+    return false;
+  return getBlockingDeps(task2.id, db).length === 0;
+}
+function pushTaskCounts(summary, task2, blockedIds, overdueIds) {
+  summary.task_counts.total += 1;
+  summary.task_counts[task2.status] += 1;
+  if (blockedIds.has(task2.id))
+    summary.task_counts.blocked += 1;
+  if (overdueIds.has(task2.id))
+    summary.task_counts.overdue += 1;
+}
+function initialAgentSummary(agentId) {
+  return {
+    agent_id: agentId,
+    task_counts: {
+      total: 0,
+      pending: 0,
+      in_progress: 0,
+      completed: 0,
+      failed: 0,
+      cancelled: 0,
+      blocked: 0,
+      overdue: 0
+    },
+    run_outcomes: {
+      running: 0,
+      completed: 0,
+      failed: 0,
+      cancelled: 0
+    },
+    verification_outcomes: {
+      passed: 0,
+      failed: 0,
+      unknown: 0
+    }
+  };
+}
+function addScopeClauses(where, params, options, timeColumn) {
+  if (options.project_id) {
+    where.push("t.project_id = ?");
+    params.push(options.project_id);
+  }
+  if (options.plan_id) {
+    where.push("t.plan_id = ?");
+    params.push(options.plan_id);
+  }
+  if (options.agent_id) {
+    where.push("(r.agent_id = ? OR t.agent_id = ? OR t.assigned_to = ?)");
+    params.push(options.agent_id, options.agent_id, options.agent_id);
+  }
+  if (options.since) {
+    where.push(`${timeColumn} >= ?`);
+    params.push(options.since);
+  }
+  if (options.until) {
+    where.push(`${timeColumn} <= ?`);
+    params.push(options.until);
+  }
+}
+function loadRuns(options, db) {
+  const where = ["t.archived_at IS NULL"];
+  const params = [];
+  addScopeClauses(where, params, options, "r.started_at");
+  return db.query(`
+    SELECT
+      r.id,
+      r.task_id,
+      t.title AS task_title,
+      t.project_id,
+      t.plan_id,
+      t.agent_id AS task_agent_id,
+      t.assigned_to,
+      r.agent_id,
+      r.status,
+      r.summary,
+      r.started_at,
+      r.completed_at,
+      SUM(CASE WHEN c.status = 'passed' THEN 1 ELSE 0 END) AS passed_commands,
+      SUM(CASE WHEN c.status = 'failed' THEN 1 ELSE 0 END) AS failed_commands,
+      SUM(CASE WHEN c.status = 'unknown' THEN 1 ELSE 0 END) AS unknown_commands,
+      COUNT(DISTINCT a.id) AS artifacts
+    FROM task_runs r
+    JOIN tasks t ON t.id = r.task_id
+    LEFT JOIN task_run_commands c ON c.run_id = r.id
+    LEFT JOIN task_run_artifacts a ON a.run_id = r.id
+    WHERE ${where.join(" AND ")}
+    GROUP BY r.id
+    ORDER BY r.started_at DESC, r.created_at DESC
+  `).all(...params);
+}
+function loadVerifications(options, db) {
+  const where = ["t.archived_at IS NULL"];
+  const params = [];
+  if (options.project_id) {
+    where.push("t.project_id = ?");
+    params.push(options.project_id);
+  }
+  if (options.plan_id) {
+    where.push("t.plan_id = ?");
+    params.push(options.plan_id);
+  }
+  if (options.agent_id) {
+    where.push("(v.agent_id = ? OR t.agent_id = ? OR t.assigned_to = ?)");
+    params.push(options.agent_id, options.agent_id, options.agent_id);
+  }
+  if (options.since) {
+    where.push("v.run_at >= ?");
+    params.push(options.since);
+  }
+  if (options.until) {
+    where.push("v.run_at <= ?");
+    params.push(options.until);
+  }
+  return db.query(`
+    SELECT
+      v.id,
+      v.task_id,
+      t.title AS task_title,
+      t.project_id,
+      t.plan_id,
+      t.agent_id AS task_agent_id,
+      t.assigned_to,
+      v.agent_id,
+      v.status,
+      v.command,
+      v.output_summary,
+      v.run_at
+    FROM task_verifications v
+    JOIN tasks t ON t.id = v.task_id
+    WHERE ${where.join(" AND ")}
+    ORDER BY v.run_at DESC, v.created_at DESC
+  `).all(...params);
+}
+function agentKey(value) {
+  return value || "unassigned";
+}
+function listLocalReportTypes() {
+  return [...LOCAL_REPORT_TYPES];
+}
+function createLocalReport(options = {}, db) {
+  const d = db || getDatabase();
+  const limit = limitValue(options.limit);
+  const generatedAt = options.generated_at ?? new Date().toISOString();
+  const nowIso = options.now ?? generatedAt;
+  const tasks = scopedTasks(options, d);
+  const overdue = overdueTasks(tasks, nowIso);
+  const overdueIds = new Set(overdue.map((task2) => task2.id));
+  const blocked = tasks.filter((task2) => task2.status === "pending").map((task2) => ({ task: task2, blockers: getBlockingDeps(task2.id, d) })).filter((item) => item.blockers.length > 0);
+  const blockedIds = new Set(blocked.map((item) => item.task.id));
+  const ready = tasks.filter((task2) => isReady(task2, d));
+  const runs = loadRuns(options, d);
+  const verifications = loadVerifications(options, d);
+  const planSummaries = listPlans(options.project_id, d).filter((plan) => !options.plan_id || plan.id === options.plan_id).map((plan) => {
+    const planTasks = tasks.filter((task2) => task2.plan_id === plan.id);
+    const completed = planTasks.filter((task2) => task2.status === "completed").length;
+    const total = planTasks.length;
+    return {
+      id: plan.id,
+      name: plan.name,
+      status: plan.status,
+      project_id: plan.project_id,
+      agent_id: plan.agent_id,
+      counts: {
+        total,
+        pending: planTasks.filter((task2) => task2.status === "pending").length,
+        in_progress: planTasks.filter((task2) => task2.status === "in_progress").length,
+        completed,
+        failed: planTasks.filter((task2) => task2.status === "failed").length,
+        cancelled: planTasks.filter((task2) => task2.status === "cancelled").length,
+        blocked: planTasks.filter((task2) => blockedIds.has(task2.id)).length,
+        overdue: planTasks.filter((task2) => overdueIds.has(task2.id)).length
+      },
+      progress_percent: total === 0 ? 0 : Math.round(completed / total * 100)
+    };
+  }).filter((plan) => plan.counts.total > 0 || options.plan_id === plan.id);
+  const runOutcomes = { running: 0, completed: 0, failed: 0, cancelled: 0 };
+  for (const run of runs)
+    runOutcomes[run.status] += 1;
+  const verificationOutcomes = { passed: 0, failed: 0, unknown: 0 };
+  for (const verification of verifications)
+    verificationOutcomes[verification.status] += 1;
+  const agents = new Map;
+  function getAgent(id) {
+    if (!agents.has(id))
+      agents.set(id, initialAgentSummary(id));
+    return agents.get(id);
+  }
+  for (const task2 of tasks) {
+    const summary = getAgent(agentKey(task2.assigned_to || task2.agent_id));
+    pushTaskCounts(summary, task2, blockedIds, overdueIds);
+  }
+  for (const run of runs) {
+    const summary = getAgent(agentKey(run.agent_id || run.assigned_to || run.task_agent_id));
+    summary.run_outcomes[run.status] += 1;
+  }
+  for (const verification of verifications) {
+    const summary = getAgent(agentKey(verification.agent_id || verification.assigned_to || verification.task_agent_id));
+    summary.verification_outcomes[verification.status] += 1;
+  }
+  return {
+    schema_version: LOCAL_REPORT_SCHEMA_VERSION,
+    local_only: true,
+    no_network: true,
+    generated_at: generatedAt,
+    scope: {
+      project_id: options.project_id ?? null,
+      plan_id: options.plan_id ?? null,
+      agent_id: options.agent_id ?? null,
+      since: options.since ?? null,
+      until: options.until ?? null
+    },
+    report_types: listLocalReportTypes(),
+    views: {
+      ready: {
+        type: "ready",
+        total: ready.length,
+        items: ready.slice(0, limit).map(summarizeTask)
+      },
+      blocked: {
+        type: "blocked",
+        total: blocked.length,
+        items: blocked.slice(0, limit).map(({ task: task2, blockers }) => ({
+          ...summarizeTask(task2),
+          blocked_by: blockers.map(summarizeTask)
+        }))
+      },
+      overdue: {
+        type: "overdue",
+        total: overdue.length,
+        items: overdue.slice(0, limit).map(summarizeTask)
+      }
+    },
+    plans: planSummaries,
+    runs: {
+      outcomes: runOutcomes,
+      recent: runs.slice(0, limit).map((run) => ({
+        id: run.id,
+        task_id: run.task_id,
+        task_title: run.task_title,
+        agent_id: run.agent_id,
+        status: run.status,
+        summary: run.summary,
+        started_at: run.started_at,
+        completed_at: run.completed_at,
+        command_outcomes: {
+          passed: Number(run.passed_commands || 0),
+          failed: Number(run.failed_commands || 0),
+          unknown: Number(run.unknown_commands || 0)
+        },
+        artifacts: Number(run.artifacts || 0)
+      }))
+    },
+    verification: {
+      outcomes: verificationOutcomes,
+      recent: verifications.slice(0, limit).map((verification) => ({
+        id: verification.id,
+        task_id: verification.task_id,
+        task_title: verification.task_title,
+        agent_id: verification.agent_id,
+        status: verification.status,
+        command: verification.command,
+        output_summary: verification.output_summary,
+        run_at: verification.run_at
+      }))
+    },
+    agents: [...agents.values()].sort((left, right) => left.agent_id.localeCompare(right.agent_id)),
+    exports: {
+      json_contract: "local_report",
+      markdown_supported: true
+    }
+  };
+}
+function taskLine(task2) {
+  const due = task2.due_at ? ` due ${task2.due_at.slice(0, 10)}` : "";
+  const assignee = task2.assigned_to ? ` @${task2.assigned_to}` : "";
+  return `- ${task2.short_id || task2.id.slice(0, 8)} ${task2.title} [${task2.status}/${task2.priority}]${assignee}${due}`;
+}
+function outcomeLine(values) {
+  return Object.entries(values).map(([key, value]) => `${key}: ${value}`).join(", ");
+}
+function renderLocalReportMarkdown(report) {
+  const lines = [
+    "# Local Agent Report",
+    "",
+    `Generated: ${report.generated_at}`,
+    `Scope: project ${report.scope.project_id ?? "all"}; plan ${report.scope.plan_id ?? "all"}; agent ${report.scope.agent_id ?? "all"}`,
+    "",
+    "## Task Views",
+    "",
+    `Ready (${report.views.ready.total})`,
+    ...report.views.ready.items.length ? report.views.ready.items.map(taskLine) : ["- none"],
+    "",
+    `Blocked (${report.views.blocked.total})`,
+    ...report.views.blocked.items.length ? report.views.blocked.items.map((task2) => `${taskLine(task2)}; blocked by ${task2.blocked_by.map((item) => item.short_id || item.id.slice(0, 8)).join(", ")}`) : ["- none"],
+    "",
+    `Overdue (${report.views.overdue.total})`,
+    ...report.views.overdue.items.length ? report.views.overdue.items.map(taskLine) : ["- none"],
+    "",
+    "## Plans"
+  ];
+  if (report.plans.length === 0)
+    lines.push("- none");
+  for (const plan of report.plans) {
+    lines.push(`- ${plan.name}: ${plan.progress_percent}% complete, ${plan.counts.blocked} blocked, ${plan.counts.overdue} overdue`);
+  }
+  lines.push("", "## Runs", outcomeLine(report.runs.outcomes));
+  for (const run of report.runs.recent) {
+    lines.push(`- ${run.id.slice(0, 8)} ${run.status} ${run.task_title}${run.summary ? `: ${run.summary}` : ""}`);
+  }
+  lines.push("", "## Verification", outcomeLine(report.verification.outcomes));
+  for (const verification of report.verification.recent) {
+    lines.push(`- ${verification.status} ${verification.task_title}: ${verification.output_summary || verification.command}`);
+  }
+  lines.push("", "## Agents");
+  if (report.agents.length === 0)
+    lines.push("- none");
+  for (const agent of report.agents) {
+    lines.push(`- ${agent.agent_id}: ${agent.task_counts.total} tasks, ${agent.task_counts.blocked} blocked, ${agent.task_counts.overdue} overdue, runs ${outcomeLine(agent.run_outcomes)}, verification ${outcomeLine(agent.verification_outcomes)}`);
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+// src/lib/local-encryption.ts
+import { createCipheriv, createDecipheriv, createHash as createHash7, randomBytes, scryptSync, timingSafeEqual } from "crypto";
+var TODOS_ENCRYPTED_VALUE_KIND = "hasna.todos.encrypted-value";
+var TODOS_ENCRYPTED_BRIDGE_KIND = "hasna.todos.encrypted-bridge";
+var TODOS_ENCRYPTION_SCHEMA_VERSION = 1;
+var DEFAULT_ENCRYPTION_PROFILE = "default";
+var DEFAULT_ENCRYPTION_KEY_ENV = "TODOS_ENCRYPTION_KEY";
+
+class EncryptionKeyUnavailableError extends Error {
+  keyEnv;
+  profile;
+  constructor(keyEnv, profile) {
+    super(`Encryption key is locked: set ${keyEnv} to use profile ${profile}`);
+    this.keyEnv = keyEnv;
+    this.profile = profile;
+  }
+}
+
+class EncryptedPayloadError extends Error {
+  constructor(message) {
+    super(message);
+  }
+}
+function now2() {
+  return new Date().toISOString();
+}
+function sha2564(value) {
+  return createHash7("sha256").update(value).digest("hex");
+}
+function normalizeProfileName(value) {
+  const name = (value || DEFAULT_ENCRYPTION_PROFILE).trim();
+  if (!/^[a-zA-Z0-9._-]+$/.test(name))
+    throw new Error("encryption profile names may only contain letters, numbers, dots, underscores, and dashes");
+  return name;
+}
+function randomBase64(bytes) {
+  return randomBytes(bytes).toString("base64");
+}
+function deriveKey(secret, salt) {
+  if (secret.length < 12)
+    throw new Error("encryption key must be at least 12 characters");
+  return scryptSync(secret, Buffer.from(salt, "base64"), 32);
+}
+function profileFromConfig(name) {
+  return loadConfig().encryption_profiles?.[name] ?? null;
+}
+function ensureEncryptionProfile(name = DEFAULT_ENCRYPTION_PROFILE) {
+  const normalized = normalizeProfileName(name);
+  const existing = profileFromConfig(normalized);
+  if (existing)
+    return existing;
+  return upsertEncryptionProfile({ name: normalized });
+}
+function listEncryptionProfiles() {
+  return Object.values(loadConfig().encryption_profiles ?? {}).sort((left, right) => left.name.localeCompare(right.name));
+}
+function upsertEncryptionProfile(input) {
+  const name = normalizeProfileName(input.name);
+  const config = loadConfig();
+  const existing = config.encryption_profiles?.[name];
+  const timestamp2 = now2();
+  const profile = {
+    name,
+    algorithm: "aes-256-gcm",
+    kdf: "scrypt",
+    key_env: input.key_env?.trim() || existing?.key_env || DEFAULT_ENCRYPTION_KEY_ENV,
+    salt: input.salt || existing?.salt || randomBase64(16),
+    description: input.description ?? existing?.description,
+    created_at: existing?.created_at || timestamp2,
+    updated_at: timestamp2
+  };
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(profile.key_env))
+    throw new Error("key_env must be a valid environment variable name");
+  saveConfig({
+    ...config,
+    encryption_profiles: {
+      ...config.encryption_profiles ?? {},
+      [name]: profile
+    }
+  });
+  return profile;
+}
+function removeEncryptionProfile(name) {
+  const normalized = normalizeProfileName(name);
+  const config = loadConfig();
+  if (!config.encryption_profiles?.[normalized])
+    return false;
+  const next = { ...config.encryption_profiles };
+  delete next[normalized];
+  saveConfig({ ...config, encryption_profiles: next });
+  return true;
+}
+function encryptionProfileStatus(name = DEFAULT_ENCRYPTION_PROFILE, env = process.env) {
+  const profile = ensureEncryptionProfile(name);
+  return {
+    profile: redactValue(profile),
+    locked: !env[profile.key_env],
+    key_env: profile.key_env,
+    key_present: Boolean(env[profile.key_env])
+  };
+}
+function keyForProfile(profile, env) {
+  const secret = env[profile.key_env];
+  if (!secret)
+    throw new EncryptionKeyUnavailableError(profile.key_env, profile.name);
+  return deriveKey(secret, profile.salt);
+}
+function encryptString(plaintext, options = {}) {
+  const profile = ensureEncryptionProfile(options.profile);
+  const key = keyForProfile(profile, options.env ?? process.env);
+  const iv = randomBytes(12);
+  const cipher = createCipheriv("aes-256-gcm", key, iv);
+  const ciphertext = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+  const authTag = cipher.getAuthTag();
   return {
     schemaVersion: TODOS_ENCRYPTION_SCHEMA_VERSION,
     kind: TODOS_ENCRYPTED_VALUE_KIND,
@@ -16325,7 +17788,7 @@ function encryptString(plaintext, options = {}) {
     iv: iv.toString("base64"),
     auth_tag: authTag.toString("base64"),
     ciphertext: ciphertext.toString("base64"),
-    plaintext_sha256: sha2563(plaintext)
+    plaintext_sha256: sha2564(plaintext)
   };
 }
 function isEncryptedValue(value) {
@@ -16350,7 +17813,7 @@ function decryptString(envelope, env = process.env) {
     decipher.final()
   ]).toString("utf8");
   const expected = Buffer.from(envelope.plaintext_sha256, "hex");
-  const actual = Buffer.from(sha2563(plaintext), "hex");
+  const actual = Buffer.from(sha2564(plaintext), "hex");
   if (expected.length !== actual.length || !timingSafeEqual(expected, actual)) {
     throw new EncryptedPayloadError("decrypted payload checksum mismatch");
   }
@@ -17056,10 +18519,63 @@ var NICE_AGENT_NAMES = [
   "vesper",
   "zephyr"
 ];
+var EXTENDED_AGENT_NAMES = [
+  "agrippa",
+  "antonius",
+  "aurelian",
+  "aurelius",
+  "camillus",
+  "cassius",
+  "celer",
+  "cincinnatus",
+  "corvus",
+  "drusus",
+  "fabius",
+  "faustus",
+  "flaccus",
+  "gallus",
+  "gaius",
+  "horatius",
+  "lucius",
+  "lucullus",
+  "marius",
+  "marcellus",
+  "maximus",
+  "nerva",
+  "pompey",
+  "quintus",
+  "regulus",
+  "romulus",
+  "scipio",
+  "seneca",
+  "sertorius",
+  "sulla",
+  "tacitus",
+  "varro",
+  "vitruvius",
+  "plato",
+  "socrates",
+  "aristotle",
+  "heraclitus",
+  "democritus",
+  "pythagoras",
+  "hipparchus",
+  "euclid",
+  "archimedes",
+  "zeno",
+  "anaximander",
+  "epictetus",
+  "aeschylus",
+  "sophocles",
+  "euripides",
+  "xenophon",
+  "diogenes"
+];
 var PREFERRED_AGENT_NAMES = [
   ...ROMAN_AGENT_NAMES,
   ...GREEK_AGENT_NAMES,
-  ...NICE_AGENT_NAMES
+  ...NICE_AGENT_NAMES,
+  ...EXTENDED_AGENT_NAMES
 ];
 var RESERVED_GENERIC_NAMES = new Set([
   "agent",
@@ -17101,29 +18617,93 @@ function isBlockedAgentName(name) {
   const normalized = normalizeAgentNameInput(name);
   return isGenericAgentName(normalized) || hasGeneratedNumericSuffix(normalized) || !ONE_WORD_NAME_RE.test(normalized);
 }
-function alphabeticSuffix(index) {
-  const letters = "abcdefghijklmnopqrstuvwxyz";
-  let value = index;
-  let suffix = "";
-  do {
-    suffix = letters[value % letters.length] + suffix;
-    value = Math.floor(value / letters.length) - 1;
-  } while (value >= 0);
-  return suffix;
+var FALLBACK_PREFIXES = [
+  "arv",
+  "bel",
+  "cyr",
+  "dax",
+  "elun",
+  "feno",
+  "gavor",
+  "hiro",
+  "ivar",
+  "jaro",
+  "kavo",
+  "lumo",
+  "myr",
+  "navo",
+  "prax",
+  "quor",
+  "riven",
+  "sovan",
+  "tavor",
+  "ulmor",
+  "vexo",
+  "wiro",
+  "yaro",
+  "zel"
+];
+var FALLBACK_STEMS = [
+  "al",
+  "ber",
+  "cor",
+  "dren",
+  "el",
+  "far",
+  "gor",
+  "hal",
+  "ion",
+  "jor",
+  "kel",
+  "lor",
+  "mor",
+  "nel",
+  "or",
+  "per",
+  "quil",
+  "ron",
+  "ser",
+  "tor",
+  "um",
+  "ver",
+  "wyn",
+  "xil"
+];
+var FALLBACK_ENDINGS = [
+  "a",
+  "en",
+  "ia",
+  "is",
+  "on",
+  "or",
+  "um",
+  "us",
+  "yn",
+  "ar",
+  "el",
+  "ir"
+];
+function generatedFallbackAgentName(index) {
+  const perPrefix = FALLBACK_STEMS.length * FALLBACK_ENDINGS.length;
+  const total = FALLBACK_PREFIXES.length * perPrefix;
+  if (index >= total)
+    return null;
+  const prefix = FALLBACK_PREFIXES[Math.floor(index / perPrefix)];
+  const rest = index % perPrefix;
+  const stem = FALLBACK_STEMS[Math.floor(rest / FALLBACK_ENDINGS.length)];
+  const ending = FALLBACK_ENDINGS[rest % FALLBACK_ENDINGS.length];
+  return `${prefix}${stem}${ending}`;
 }
 function suggestAgentNames(existingNames = []) {
   const existing = new Set([...existingNames].map(normalizeAgentNameInput));
   const suggestions = PREFERRED_AGENT_NAMES.filter((name) => !existing.has(name));
-  for (let suffixIndex = 0;suggestions.length < 20 && suffixIndex < 1000; suffixIndex++) {
-    const suffix = alphabeticSuffix(suffixIndex);
-    for (const base of PREFERRED_AGENT_NAMES) {
-      const candidate = `${base}${suffix}`;
-      if (existing.has(candidate) || suggestions.includes(candidate))
-        continue;
-      suggestions.push(candidate);
-      if (suggestions.length >= 20)
-        break;
-    }
+  for (let index = 0;suggestions.length < 20; index++) {
+    const candidate = generatedFallbackAgentName(index);
+    if (!candidate)
+      break;
+    if (existing.has(candidate) || suggestions.includes(candidate))
+      continue;
+    suggestions.push(candidate);
   }
   return suggestions;
 }
@@ -18124,7 +19704,7 @@ class TodosClient {
     return this._fetchWithRetry(path, { method: "DELETE" });
   }
   _sleep(ms) {
-    return new Promise((resolve8) => setTimeout(resolve8, ms));
+    return new Promise((resolve9) => setTimeout(resolve9, ms));
   }
   async getHealth() {
     return this._get("/api/health");
@@ -19376,8 +20956,8 @@ function renderRetrospectiveMarkdown(record) {
 }
 // src/lib/project-bootstrap.ts
 init_database();
-import { existsSync as existsSync7, readFileSync as readFileSync5, statSync as statSync3 } from "fs";
-import { basename, dirname as dirname6, resolve as resolve8 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync6, statSync as statSync3 } from "fs";
+import { basename, dirname as dirname7, resolve as resolve9 } from "path";
 function safeStat(path) {
   try {
     return statSync3(path);
@@ -19386,18 +20966,18 @@ function safeStat(path) {
   }
 }
 function canonicalPath(input) {
-  const resolved = resolve8(input);
+  const resolved = resolve9(input);
   const stats2 = safeStat(resolved);
   if (stats2?.isFile())
-    return dirname6(resolved);
+    return dirname7(resolved);
   return resolved;
 }
 function findUp(start, marker) {
   let current = canonicalPath(start);
   while (true) {
-    if (existsSync7(resolve8(current, marker)))
+    if (existsSync7(resolve9(current, marker)))
       return current;
-    const parent = dirname6(current);
+    const parent = dirname7(current);
     if (parent === current)
       return null;
     current = parent;
@@ -19406,11 +20986,11 @@ function findUp(start, marker) {
 function readPackageJson2(path) {
   if (!path)
     return null;
-  const file = resolve8(path, "package.json");
+  const file = resolve9(path, "package.json");
   if (!existsSync7(file))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync5(file, "utf-8"));
+    const parsed = JSON.parse(readFileSync6(file, "utf-8"));
     return parsed && typeof parsed === "object" ? parsed : null;
   } catch {
     return null;
@@ -19429,7 +21009,7 @@ function workspaceMarker(root, rootPackage) {
   if (rootPackage?.workspaces)
     markers.push("package.json#workspaces");
   for (const marker of ["pnpm-workspace.yaml", "turbo.json", "nx.json", "lerna.json", "rush.json", "bun.lock", "bun.lockb"]) {
-    if (existsSync7(resolve8(root, marker)))
+    if (existsSync7(resolve9(root, marker)))
       markers.push(marker);
   }
   const kind = markers.find((marker) => marker !== "bun.lock" && marker !== "bun.lockb") ?? null;
@@ -19537,7 +21117,7 @@ function getProjectByPathForBootstrap(path, db) {
 }
 // src/db/api-keys.ts
 init_database();
-import { createHash as createHash7, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual2 } from "crypto";
+import { createHash as createHash8, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual2 } from "crypto";
 function rowToRecord(row) {
   return {
     id: row.id,
@@ -19551,7 +21131,7 @@ function rowToRecord(row) {
   };
 }
 function hashApiKey(key) {
-  return createHash7("sha256").update(key).digest("hex");
+  return createHash8("sha256").update(key).digest("hex");
 }
 function safeEqualHex(a, b) {
   if (a.length !== b.length)
@@ -19741,7 +21321,7 @@ var gatherTrainingData = async (options = {}) => {
   };
 };
 // src/lib/model-config.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
 import { homedir } from "os";
 import { join as join9 } from "path";
 var DEFAULT_MODEL = "gpt-4o-mini";
@@ -19759,7 +21339,7 @@ function readConfig() {
   if (!existsSync8(CONFIG_PATH))
     return {};
   try {
-    const raw = readFileSync6(CONFIG_PATH, "utf-8");
+    const raw = readFileSync7(CONFIG_PATH, "utf-8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -19767,9 +21347,9 @@ function readConfig() {
 }
 function writeConfig(config) {
   if (!existsSync8(CONFIG_DIR)) {
-    mkdirSync7(CONFIG_DIR, { recursive: true });
+    mkdirSync8(CONFIG_DIR, { recursive: true });
   }
-  writeFileSync5(CONFIG_PATH, JSON.stringify(config, null, 2) + `
+  writeFileSync6(CONFIG_PATH, JSON.stringify(config, null, 2) + `
 `, "utf-8");
 }
 function getActiveModel() {
@@ -19788,7 +21368,7 @@ function clearActiveModel() {
 }
 // src/db/builtin-templates.ts
 init_database();
-import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync6 } from "fs";
+import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync7 } from "fs";
 import { join as join10 } from "path";
 var BUILTIN_TEMPLATE_LIBRARY_VERSION = "2026-05-21";
 var BUILTIN_TEMPLATE_LIBRARY_SOURCE = "bundled-local-template-library";
@@ -19999,11 +21579,11 @@ function exportBuiltinTemplateFiles() {
   }));
 }
 function writeBuiltinTemplateFiles(directory) {
-  mkdirSync8(directory, { recursive: true });
+  mkdirSync9(directory, { recursive: true });
   const files = [];
   for (const entry of exportBuiltinTemplateFiles()) {
     const path = join10(directory, entry.filename);
-    writeFileSync6(path, `${JSON.stringify(entry.template, null, 2)}
+    writeFileSync7(path, `${JSON.stringify(entry.template, null, 2)}
 `, "utf-8");
     files.push(path);
   }
@@ -20692,8 +22272,8 @@ function patrolTasks(opts, db) {
       detail: `Completed with confidence ${task2.confidence} (threshold: ${confidenceThreshold})`
     });
   }
-  const orphanedRows = d.query(`SELECT * FROM tasks WHERE status = 'pending' AND project_id IS NULL AND agent_id IS NULL AND assigned_to IS NULL ORDER BY created_at ASC`).all();
-  for (const row of orphanedRows) {
+  const orphanedRows2 = d.query(`SELECT * FROM tasks WHERE status = 'pending' AND project_id IS NULL AND agent_id IS NULL AND assigned_to IS NULL ORDER BY created_at ASC`).all();
+  for (const row of orphanedRows2) {
     const task2 = rowToTask3(row);
     issues.push({
       type: "orphaned",
@@ -20790,18 +22370,18 @@ function getAgentMetrics(agentId, opts, db) {
   let reviewScoreAvg = null;
   if (reviewTasks.length > 0) {
     let total2 = 0;
-    let count = 0;
+    let count2 = 0;
     for (const row of reviewTasks) {
       try {
         const meta = JSON.parse(row.metadata);
         if (typeof meta._review_score === "number") {
           total2 += meta._review_score;
-          count++;
+          count2++;
         }
       } catch {}
     }
-    if (count > 0)
-      reviewScoreAvg = total2 / count;
+    if (count2 > 0)
+      reviewScoreAvg = total2 / count2;
   }
   const speedScore = avgTime?.avg_minutes != null ? Math.max(0, 1 - avgTime.avg_minutes / (60 * 24)) : 0.5;
   const confidenceScore = avgConf?.avg_confidence ?? 0.5;
@@ -21422,7 +23002,7 @@ function likePattern(query) {
     return null;
   return `%${trimmed}%`;
 }
-function parseJsonObject4(value) {
+function parseJsonObject5(value) {
   if (!value)
     return {};
   if (typeof value === "object" && !Array.isArray(value))
@@ -21437,7 +23017,7 @@ function parseJsonObject4(value) {
   }
 }
 function rowToTaskRun(row) {
-  return { ...row, metadata: parseJsonObject4(row.metadata) };
+  return { ...row, metadata: parseJsonObject5(row.metadata) };
 }
 function taskMatchesSavedFilters(task2, filters, db) {
   if (filters.plan_id && task2.plan_id !== filters.plan_id)
@@ -21689,7 +23269,7 @@ function runSearchView(idOrName, db) {
   return { ...runSavedSearch(view.filters, view.scope, d), view };
 }
 // src/lib/claude-tasks.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7, readdirSync as readdirSync2, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync8, readdirSync as readdirSync2, writeFileSync as writeFileSync8 } from "fs";
 import { join as join11 } from "path";
 function getTaskListDir(taskListId) {
   return join11(HOME, ".claude", "tasks", taskListId);
@@ -21713,11 +23293,11 @@ function readPrefixCounter(dir) {
   const path = join11(dir, ".prefix-counter");
   if (!existsSync9(path))
     return 0;
-  const val = parseInt(readFileSync7(path, "utf-8").trim(), 10);
+  const val = parseInt(readFileSync8(path, "utf-8").trim(), 10);
   return isNaN(val) ? 0 : val;
 }
 function writePrefixCounter(dir, value) {
-  writeFileSync7(join11(dir, ".prefix-counter"), String(value));
+  writeFileSync8(join11(dir, ".prefix-counter"), String(value));
 }
 function formatPrefixedSubject(title, prefix, counter) {
   const padded = String(counter).padStart(5, "0");
@@ -22212,9 +23792,9 @@ function syncWithAgents(agents, taskListIdByAgent, projectId, direction = "both"
   return { pushed, pulled, errors };
 }
 // src/lib/extract.ts
-import { existsSync as existsSync11, readFileSync as readFileSync8, statSync as statSync4 } from "fs";
-import { createHash as createHash8 } from "crypto";
-import { relative as relative3, resolve as resolve9, join as join13 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync9, statSync as statSync4 } from "fs";
+import { createHash as createHash9 } from "crypto";
+import { relative as relative3, resolve as resolve10, join as join13 } from "path";
 var EXTRACT_TAGS = ["TODO", "FIXME", "HACK", "XXX", "BUG", "NOTE"];
 var DEFAULT_EXTENSIONS = new Set([
   ".ts",
@@ -22278,18 +23858,18 @@ var SKIP_DIRS = new Set([
   ".parcel-cache"
 ]);
 function stableHash(value) {
-  return createHash8("sha256").update(value).digest("hex");
+  return createHash9("sha256").update(value).digest("hex");
 }
 function normalizePathForMatch(value) {
   return value.replace(/\\/g, "/").replace(/^\.\//, "");
 }
 function readGitignorePatterns(basePath) {
-  const root = statSync4(basePath).isFile() ? resolve9(basePath, "..") : basePath;
+  const root = statSync4(basePath).isFile() ? resolve10(basePath, "..") : basePath;
   const gitignorePath = join13(root, ".gitignore");
   if (!existsSync11(gitignorePath))
     return [];
   try {
-    return readFileSync8(gitignorePath, "utf-8").split(`
+    return readFileSync9(gitignorePath, "utf-8").split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#") && !line.startsWith("!"));
   } catch {
     return [];
@@ -22420,7 +24000,7 @@ function collectFiles(basePath, extensions, excludes, respectGitignore) {
   return files.sort();
 }
 function buildCodebaseIndex(options) {
-  const basePath = resolve9(options.path);
+  const basePath = resolve10(options.path);
   const tags = options.patterns || [...EXTRACT_TAGS];
   const extensions = options.extensions ? new Set(options.extensions.map((e) => e.startsWith(".") ? e : `.${e}`)) : DEFAULT_EXTENSIONS;
   const excludes = options.exclude || [];
@@ -22430,8 +24010,8 @@ function buildCodebaseIndex(options) {
   for (const file of files) {
     const fullPath = statSync4(basePath).isFile() ? basePath : join13(basePath, file);
     try {
-      const source9 = readFileSync8(fullPath, "utf-8");
-      const relPath = statSync4(basePath).isFile() ? relative3(resolve9(basePath, ".."), fullPath) : file;
+      const source9 = readFileSync9(fullPath, "utf-8");
+      const relPath = statSync4(basePath).isFile() ? relative3(resolve10(basePath, ".."), fullPath) : file;
       indexed.push({
         file: relPath,
         checksum: stableHash(source9).slice(0, 24),
@@ -22451,7 +24031,7 @@ function buildCodebaseIndex(options) {
   };
 }
 function extractTodos(options, db) {
-  const basePath = resolve9(options.path);
+  const basePath = resolve10(options.path);
   const tags = options.patterns || [...EXTRACT_TAGS];
   const extensions = options.extensions ? new Set(options.extensions.map((e) => e.startsWith(".") ? e : `.${e}`)) : DEFAULT_EXTENSIONS;
   const excludes = options.exclude || [];
@@ -22461,8 +24041,8 @@ function extractTodos(options, db) {
   for (const file of files) {
     const fullPath = statSync4(basePath).isFile() ? basePath : join13(basePath, file);
     try {
-      const source9 = readFileSync8(fullPath, "utf-8");
-      const relPath = statSync4(basePath).isFile() ? relative3(resolve9(basePath, ".."), fullPath) : file;
+      const source9 = readFileSync9(fullPath, "utf-8");
+      const relPath = statSync4(basePath).isFile() ? relative3(resolve10(basePath, ".."), fullPath) : file;
       const comments = extractFromSource(source9, relPath, tags);
       allComments.push(...comments);
     } catch {}
@@ -22556,7 +24136,7 @@ async function watchSourceTodos(options, onRun) {
   const interval = Math.max(100, options.interval_ms || 2000);
   const once = options.once !== false && (!options.max_runs || options.max_runs <= 1);
   const maxRuns = options.max_runs ?? (once ? 1 : Number.POSITIVE_INFINITY);
-  const root = resolve9(options.path);
+  const root = resolve10(options.path);
   const runs = [];
   let previous = new Map;
   for (let runNumber = 1;runNumber <= maxRuns; runNumber++) {
@@ -22949,10 +24529,10 @@ async function runNextAgentDispatch(input = {}, db) {
   return { run_id: next.run.id, task_id: next.run.task_id, command, dry_run: false, status, exit_code: exitCode, output_summary: outputSummary };
 }
 // src/lib/policy-packs.ts
-import { relative as relative4, resolve as resolve10 } from "path";
+import { relative as relative4, resolve as resolve11 } from "path";
 init_database();
 function normalizePath3(path) {
-  return resolve10(path);
+  return resolve11(path);
 }
 function unique4(values) {
   return Array.from(new Set((values || []).map((value) => value.trim()).filter(Boolean)));
@@ -23007,7 +24587,7 @@ function commandMatches(commands, pattern) {
 }
 function pathMatches(paths, pattern, root) {
   return paths.filter((path) => {
-    const candidate = path.startsWith("/") ? path : resolve10(root, path);
+    const candidate = path.startsWith("/") ? path : resolve11(root, path);
     if (!isPathInside3(root, candidate))
       return matchesPattern3(path, pattern);
     return matchesPattern3(path, pattern) || matchesPattern3(relative4(root, candidate), pattern);
@@ -23825,8 +25405,8 @@ ${line}`,
   };
 }
 // src/lib/mention-resolver.ts
-import { existsSync as existsSync12, readdirSync as readdirSync3, readFileSync as readFileSync9, statSync as statSync5 } from "fs";
-import { basename as basename2, isAbsolute, join as join14, relative as relative5, resolve as resolve11, sep } from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync3, readFileSync as readFileSync10, statSync as statSync5 } from "fs";
+import { basename as basename2, isAbsolute, join as join14, relative as relative5, resolve as resolve12, sep } from "path";
 init_database();
 var PREFIXES = {
   file: "file",
@@ -23902,7 +25482,7 @@ function backlink(kind, key, label, target = key) {
   return { kind, key, label, target };
 }
 function normalizeWorkspace(workspace) {
-  return resolve11(workspace || process.cwd());
+  return resolve12(workspace || process.cwd());
 }
 function isInside(root, absolutePath) {
   const rel = relative5(root, absolutePath);
@@ -23970,7 +25550,7 @@ function resolveFile(parsed, workspace) {
     resolution.warnings.push("path is empty or escapes the workspace");
     return resolution;
   }
-  const absolutePath = resolve11(workspace, relPath);
+  const absolutePath = resolve12(workspace, relPath);
   if (!isInside(workspace, absolutePath)) {
     resolution.path = relPath;
     resolution.warnings.push("path escapes the workspace");
@@ -23987,7 +25567,7 @@ function resolveFile(parsed, workspace) {
     return resolution;
   }
   if (parsed.line !== undefined) {
-    const lineCount = readFileSync9(absolutePath, "utf-8").split(/\r?\n/).length;
+    const lineCount = readFileSync10(absolutePath, "utf-8").split(/\r?\n/).length;
     if (parsed.line < 1 || parsed.line > lineCount) {
       resolution.warnings.push(`line ${parsed.line} is outside the file range 1-${lineCount}`);
       return resolution;
@@ -24040,7 +25620,7 @@ function resolveSymbol(parsed, workspace, maxMatches) {
   const pattern = symbolPattern(name);
   const matches = [];
   for (const file of walkSourceFiles(workspace)) {
-    const lines = readFileSync9(file, "utf-8").split(/\r?\n/);
+    const lines = readFileSync10(file, "utf-8").split(/\r?\n/);
     for (let index = 0;index < lines.length; index += 1) {
       const line = lines[index];
       const found = pattern.exec(line);
@@ -24253,24 +25833,225 @@ function resolveMentions(input, db) {
     warnings
   };
 }
-// src/lib/verification-providers.ts
-import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
+// src/lib/workflow-states.ts
+init_types();
 init_database();
-var DEFAULT_RETRY = {
-  attempts: 1,
-  backoff_ms: 0
-};
-var DEFAULT_CAPABILITIES = {
-  command: ["command", "retry", "evidence"],
-  testbox: ["testbox", "command", "retry", "evidence"],
-  ci_log: ["ci_log", "log_import", "evidence"],
-  browser: ["browser", "screenshot", "artifact", "evidence"],
-  script: ["script", "command", "retry", "evidence"]
-};
-function normalizeName2(name) {
-  const normalized = name.trim().toLowerCase();
-  if (!/^[a-z0-9][a-z0-9_-]{0,63}$/.test(normalized)) {
-    throw new Error("verification provider name must use lowercase letters, numbers, dashes, or underscores");
+var LOCAL_FIELDS_KEY2 = "local_fields";
+var WORKFLOW_STATE_KEY = "workflow_state";
+var DEFAULT_WORKFLOW_STATES = [
+  { name: "pending", canonical_status: "pending", aliases: ["todo", "backlog"], transitions: null, terminal: false },
+  { name: "in_progress", canonical_status: "in_progress", aliases: ["doing", "started"], transitions: null, terminal: false },
+  { name: "completed", canonical_status: "completed", aliases: ["done", "complete"], transitions: null, terminal: true },
+  { name: "failed", canonical_status: "failed", aliases: [], transitions: null, terminal: true },
+  { name: "cancelled", canonical_status: "cancelled", aliases: ["canceled"], transitions: null, terminal: true }
+];
+function normalizeName2(value) {
+  return value.trim().toLowerCase().replace(/[\s-]+/g, "_");
+}
+function isTaskStatus(value) {
+  return TASK_STATUSES.includes(value);
+}
+function normalizeState(input) {
+  const name = normalizeName2(input.name || "");
+  if (!name || !isTaskStatus(input.canonical_status))
+    return null;
+  const aliases = [...new Set((input.aliases || []).map(normalizeName2).filter((alias) => alias && alias !== name))].sort();
+  const transitions = input.transitions ? [...new Set(input.transitions.map(normalizeName2).filter(Boolean))].sort() : null;
+  return {
+    name,
+    canonical_status: input.canonical_status,
+    aliases,
+    description: input.description,
+    transitions,
+    terminal: input.terminal ?? (input.canonical_status === "completed" || input.canonical_status === "failed" || input.canonical_status === "cancelled"),
+    color: input.color
+  };
+}
+function mergeWorkflowConfig(config) {
+  const states = new Map(DEFAULT_WORKFLOW_STATES.map((state) => [state.name, state]));
+  for (const input of config?.states || []) {
+    const state = normalizeState(input);
+    if (state)
+      states.set(state.name, state);
+  }
+  return [...states.values()];
+}
+function getWorkflowConfig(projectPath) {
+  const config = loadConfig();
+  return projectPath && config.project_overrides?.[projectPath]?.workflow_states ? config.project_overrides[projectPath].workflow_states : config.workflow_states;
+}
+function listWorkflowStates(projectPath) {
+  const workflowConfig = getWorkflowConfig(projectPath);
+  return mergeWorkflowConfig(workflowConfig);
+}
+function resolveWorkflowState(input, projectPath) {
+  const normalized = normalizeName2(input);
+  const states = listWorkflowStates(projectPath);
+  const byName = states.find((state) => state.name === normalized);
+  if (byName)
+    return { input, state: byName, matched_by: "name" };
+  const byAlias = states.find((state) => state.aliases.includes(normalized));
+  if (byAlias)
+    return { input, state: byAlias, matched_by: "alias" };
+  const byCanonical = states.find((state) => state.canonical_status === normalized);
+  if (byCanonical)
+    return { input, state: byCanonical, matched_by: "canonical_status" };
+  throw new Error(`Unknown workflow state: ${input}`);
+}
+function stateForCanonicalStatus(status, projectPath) {
+  const configured = (getWorkflowConfig(projectPath)?.states || []).map(normalizeState).find((state) => Boolean(state && state.canonical_status === status));
+  if (configured)
+    return configured;
+  return listWorkflowStates(projectPath).find((state) => state.canonical_status === status) || resolveWorkflowState(status, projectPath).state;
+}
+function getTaskWorkflowState(taskId, db, projectPath) {
+  const d = db || getDatabase();
+  const task2 = getTask(taskId, d);
+  if (!task2)
+    throw new TaskNotFoundError(taskId);
+  const fields = getTaskLocalFields(taskId, d);
+  const stored = fields.custom[WORKFLOW_STATE_KEY];
+  if (typeof stored === "string") {
+    try {
+      const state = resolveWorkflowState(stored, projectPath).state;
+      if (state.canonical_status === task2.status)
+        return state;
+    } catch {}
+  }
+  return stateForCanonicalStatus(task2.status, projectPath);
+}
+function assertAllowedTransition(from, to, force) {
+  if (force || from.name === to.name)
+    return;
+  if (from.transitions === null)
+    return;
+  if (from.transitions.includes(to.name))
+    return;
+  throw new Error(`Cannot transition workflow state from ${from.name} to ${to.name}`);
+}
+function metadataWithWorkflowState(task2, stateName, db) {
+  const fields = getTaskLocalFields(task2.id, db);
+  return {
+    ...task2.metadata,
+    [LOCAL_FIELDS_KEY2]: {
+      ...fields,
+      custom: {
+        ...fields.custom,
+        [WORKFLOW_STATE_KEY]: stateName
+      }
+    }
+  };
+}
+function setTaskWorkflowState(taskId, stateInput, options = {}, db) {
+  const d = db || getDatabase();
+  const target = resolveWorkflowState(stateInput, options.project_path).state;
+  for (let attempt = 0;attempt < 3; attempt++) {
+    const task2 = getTask(taskId, d);
+    if (!task2)
+      throw new TaskNotFoundError(taskId);
+    const previous = getTaskWorkflowState(task2.id, d, options.project_path);
+    assertAllowedTransition(previous, target, options.force);
+    const metadata = metadataWithWorkflowState(task2, target.name, d);
+    try {
+      const updated = updateTask(task2.id, {
+        version: task2.version,
+        status: target.canonical_status,
+        metadata: {
+          ...metadata,
+          workflow_state_updated_by: options.actor || null
+        }
+      }, d);
+      return {
+        task: updated,
+        workflow_state: target,
+        previous_workflow_state: previous,
+        changed: previous.name !== target.name,
+        canonical_status_changed: task2.status !== target.canonical_status,
+        local_only: true
+      };
+    } catch (error) {
+      if (error instanceof VersionConflictError && attempt < 2)
+        continue;
+      throw error;
+    }
+  }
+  throw new Error("Failed to set workflow state after 3 attempts");
+}
+function queryTasksByWorkflowState(query, db) {
+  const d = db || getDatabase();
+  const target = resolveWorkflowState(query.state, query.project_path).state;
+  const tasks = listTasks({
+    project_id: query.project_id,
+    task_list_id: query.task_list_id,
+    status: target.canonical_status,
+    limit: 1e4
+  }, d).filter((task2) => getTaskWorkflowState(task2.id, d, query.project_path).name === target.name).slice(0, query.limit || 100);
+  return { state: target, tasks, count: tasks.length, local_only: true };
+}
+function migrateWorkflowStates(options = {}, db) {
+  const d = db || getDatabase();
+  const tasks = listTasks({
+    project_id: options.project_id,
+    task_list_id: options.task_list_id,
+    limit: options.limit || 1e4,
+    include_archived: true
+  }, d);
+  const items = [];
+  let migrated = 0;
+  for (const task2 of tasks) {
+    const target = stateForCanonicalStatus(task2.status, options.project_path);
+    const current = getTaskWorkflowState(task2.id, d, options.project_path);
+    const changed = current.name !== target.name || getTaskLocalFields(task2.id, d).custom[WORKFLOW_STATE_KEY] !== target.name;
+    items.push({
+      task_id: task2.id,
+      short_id: task2.short_id,
+      title: task2.title,
+      canonical_status: task2.status,
+      workflow_state: target.name,
+      changed
+    });
+    if (options.apply && changed) {
+      setTaskWorkflowState(task2.id, target.name, { project_path: options.project_path, force: true }, d);
+      migrated += 1;
+    }
+  }
+  return {
+    applied: Boolean(options.apply),
+    migrated_count: migrated,
+    pending_count: options.apply ? 0 : items.filter((item) => item.changed).length,
+    skipped_count: items.filter((item) => !item.changed).length,
+    items,
+    local_only: true
+  };
+}
+function renderWorkflowStatesMarkdown(states = listWorkflowStates()) {
+  return [
+    "# Workflow States",
+    "",
+    "| State | Canonical status | Aliases | Transitions | Terminal |",
+    "| --- | --- | --- | --- | --- |",
+    ...states.map((state) => `| ${state.name} | ${state.canonical_status} | ${state.aliases.join(", ") || "-"} | ${state.transitions?.join(", ") || "any"} | ${state.terminal ? "yes" : "no"} |`)
+  ].join(`
+`);
+}
+// src/lib/verification-providers.ts
+import { existsSync as existsSync13, readFileSync as readFileSync11 } from "fs";
+init_database();
+var DEFAULT_RETRY = {
+  attempts: 1,
+  backoff_ms: 0
+};
+var DEFAULT_CAPABILITIES = {
+  command: ["command", "retry", "evidence"],
+  testbox: ["testbox", "command", "retry", "evidence"],
+  ci_log: ["ci_log", "log_import", "evidence"],
+  browser: ["browser", "screenshot", "artifact", "evidence"],
+  script: ["script", "command", "retry", "evidence"]
+};
+function normalizeName3(name) {
+  const normalized = name.trim().toLowerCase();
+  if (!/^[a-z0-9][a-z0-9_-]{0,63}$/.test(normalized)) {
+    throw new Error("verification provider name must use lowercase letters, numbers, dashes, or underscores");
   }
   return normalized;
 }
@@ -24286,10 +26067,10 @@ function timeoutMs(value) {
   return Math.max(1, Math.min(24 * 60 * 60000, Math.floor(value)));
 }
 function getProvider(name) {
-  return loadConfig().verification_providers?.[normalizeName2(name)] || null;
+  return loadConfig().verification_providers?.[normalizeName3(name)] || null;
 }
 function upsertVerificationProvider(input) {
-  const name = normalizeName2(input.name);
+  const name = normalizeName3(input.name);
   const config = loadConfig();
   const existing = config.verification_providers?.[name];
   const timestamp2 = new Date().toISOString();
@@ -24319,7 +26100,7 @@ function listVerificationProviders() {
   return Object.values(loadConfig().verification_providers || {}).sort((a, b) => a.name.localeCompare(b.name));
 }
 function removeVerificationProvider(name) {
-  const normalized = normalizeName2(name);
+  const normalized = normalizeName3(name);
   const config = loadConfig();
   if (!config.verification_providers?.[normalized])
     return false;
@@ -24363,7 +26144,7 @@ function classifyLog(text) {
 async function sleep3(ms) {
   if (ms <= 0)
     return;
-  await new Promise((resolve12) => setTimeout(resolve12, ms));
+  await new Promise((resolve13) => setTimeout(resolve13, ms));
 }
 async function runCommandProvider(provider, input) {
   const commandTemplate = input.command || provider.command;
@@ -24418,7 +26199,7 @@ Timed out after ${provider.timeout_ms}ms`);
   };
 }
 function runCiLogProvider(input) {
-  const text = input.log_text ?? (input.log_path && existsSync13(input.log_path) ? readFileSync10(input.log_path, "utf-8") : "");
+  const text = input.log_text ?? (input.log_path && existsSync13(input.log_path) ? readFileSync11(input.log_path, "utf-8") : "");
   return {
     status: classifyLog(text),
     attempts: 1,
@@ -24656,8 +26437,8 @@ function renderReleaseNotesMarkdown(document) {
 `;
 }
 // src/lib/agent-replay-simulator.ts
-import { createHash as createHash9 } from "crypto";
-import { readFileSync as readFileSync11 } from "fs";
+import { createHash as createHash10 } from "crypto";
+import { readFileSync as readFileSync12 } from "fs";
 function isObject(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -24678,7 +26459,7 @@ function stable2(value) {
   return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stable2(value[key])]));
 }
 function fingerprint2(value) {
-  return createHash9("sha256").update(JSON.stringify(stable2(value))).digest("hex");
+  return createHash10("sha256").update(JSON.stringify(stable2(value))).digest("hex");
 }
 function unpackFixture(input) {
   if (!isObject(input))
@@ -24890,7 +26671,7 @@ function simulateAgentReplay(input, options = {}) {
   };
 }
 function simulateAgentReplayFile(path, options = {}) {
-  const parsed = JSON.parse(readFileSync11(path, "utf8"));
+  const parsed = JSON.parse(readFileSync12(path, "utf8"));
   return simulateAgentReplay(parsed, options);
 }
 function renderAgentReplaySimulationMarkdown(simulation) {
@@ -24916,13 +26697,13 @@ function renderAgentReplaySimulationMarkdown(simulation) {
 `);
 }
 // src/lib/local-extensions.ts
-import { createHash as createHash10, createVerify } from "crypto";
-import { existsSync as existsSync14, readFileSync as readFileSync12, statSync as statSync6 } from "fs";
-import { basename as basename3, join as join15, resolve as resolve12 } from "path";
+import { createHash as createHash11, createVerify } from "crypto";
+import { existsSync as existsSync14, readdirSync as readdirSync4, readFileSync as readFileSync13, statSync as statSync6 } from "fs";
+import { basename as basename3, join as join15, resolve as resolve13 } from "path";
 function isObject2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
-function normalizeName3(name) {
+function normalizeName4(name) {
   const normalized = name.trim().toLowerCase();
   if (!/^[a-z0-9][a-z0-9_.-]{0,63}$/.test(normalized)) {
     throw new Error("extension name must use lowercase letters, numbers, dots, dashes, or underscores");
@@ -24940,7 +26721,7 @@ function permissionList(value) {
 function normalizeManifest(input) {
   if (!isObject2(input))
     throw new Error("extension manifest must be a JSON object");
-  const name = normalizeName3(String(input["name"] || ""));
+  const name = normalizeName4(String(input["name"] || ""));
   const version = String(input["version"] || "").trim();
   if (!version)
     throw new Error("extension manifest requires version");
@@ -24948,7 +26729,7 @@ function normalizeManifest(input) {
     todos: typeof input["compatibility"]["todos"] === "string" ? input["compatibility"]["todos"] : undefined
   } : undefined;
   const commands = Array.isArray(input["commands"]) ? input["commands"].filter(isObject2).map((command) => ({
-    name: normalizeName3(String(command["name"] || "")),
+    name: normalizeName4(String(command["name"] || "")),
     command: typeof command["command"] === "string" ? command["command"] : undefined,
     description: typeof command["description"] === "string" ? command["description"] : undefined,
     permissions: permissionList(command["permissions"]),
@@ -24957,10 +26738,30 @@ function normalizeManifest(input) {
     network: typeof command["network"] === "boolean" ? command["network"] : undefined
   })) : [];
   const mcpTools = Array.isArray(input["mcp_tools"]) ? input["mcp_tools"].filter(isObject2).map((tool) => ({
-    name: normalizeName3(String(tool["name"] || "")),
+    name: normalizeName4(String(tool["name"] || "")),
     description: typeof tool["description"] === "string" ? tool["description"] : undefined,
     permissions: permissionList(tool["permissions"])
   })) : [];
+  const templates = Array.isArray(input["templates"]) ? input["templates"].filter(isObject2).map((template) => ({
+    name: normalizeName4(String(template["name"] || "")),
+    kind: typeof template["kind"] === "string" ? template["kind"] : undefined,
+    description: typeof template["description"] === "string" ? template["description"] : undefined,
+    path: typeof template["path"] === "string" ? template["path"] : undefined,
+    content: typeof template["content"] === "string" ? template["content"] : undefined,
+    variables: unique5(template["variables"]),
+    permissions: permissionList(template["permissions"])
+  })) : [];
+  const renderers = Array.isArray(input["renderers"]) ? input["renderers"].filter(isObject2).map((renderer) => ({
+    name: normalizeName4(String(renderer["name"] || "")),
+    target: typeof renderer["target"] === "string" ? renderer["target"] : "",
+    description: typeof renderer["description"] === "string" ? renderer["description"] : undefined,
+    command: typeof renderer["command"] === "string" ? renderer["command"] : undefined,
+    template: typeof renderer["template"] === "string" ? renderer["template"] : undefined,
+    permissions: permissionList(renderer["permissions"]),
+    write_paths: unique5(renderer["write_paths"]),
+    env: unique5(renderer["env"]),
+    network: typeof renderer["network"] === "boolean" ? renderer["network"] : undefined
+  })) : [];
   return {
     schema_version: typeof input["schema_version"] === "number" ? input["schema_version"] : 1,
     name,
@@ -24970,6 +26771,8 @@ function normalizeManifest(input) {
     permissions: unique5(input["permissions"]),
     commands,
     mcp_tools: mcpTools,
+    templates,
+    renderers,
     hooks: unique5(input["hooks"]),
     checksum: typeof input["checksum"] === "string" ? input["checksum"] : undefined,
     signature: typeof input["signature"] === "string" ? input["signature"] : undefined,
@@ -24977,10 +26780,10 @@ function normalizeManifest(input) {
   };
 }
 function parseJson(path) {
-  return JSON.parse(readFileSync12(path, "utf8"));
+  return JSON.parse(readFileSync13(path, "utf8"));
 }
-function sha2564(bytes) {
-  return `sha256:${createHash10("sha256").update(bytes).digest("hex")}`;
+function sha2565(bytes) {
+  return `sha256:${createHash11("sha256").update(bytes).digest("hex")}`;
 }
 function compareVersions(a, b) {
   const left = a.split(".").map((part) => Number.parseInt(part, 10) || 0);
@@ -25053,7 +26856,7 @@ function duplicateChecks(surface, names) {
   const counts = new Map;
   for (const name of names)
     counts.set(name, (counts.get(name) || 0) + 1);
-  return [...counts.entries()].filter(([, count]) => count > 1).map(([name]) => ({
+  return [...counts.entries()].filter(([, count2]) => count2 > 1).map(([name]) => ({
     surface,
     name,
     ok: false,
@@ -25065,9 +26868,13 @@ function compatibilityChecks(manifest) {
   const checks = [];
   const commands = manifest.commands || [];
   const tools = manifest.mcp_tools || [];
+  const templates = manifest.templates || [];
+  const renderers = manifest.renderers || [];
   const hooks = manifest.hooks || [];
   checks.push(...duplicateChecks("cli", commands.map((command) => command.name)));
   checks.push(...duplicateChecks("mcp", tools.map((tool) => tool.name)));
+  checks.push(...duplicateChecks("template", templates.map((template) => template.name)));
+  checks.push(...duplicateChecks("renderer", renderers.map((renderer) => renderer.name)));
   checks.push(...duplicateChecks("hook", hooks));
   for (const command of commands) {
     checks.push({
@@ -25088,16 +26895,43 @@ function compatibilityChecks(manifest) {
       warnings: []
     });
   }
+  for (const template of templates) {
+    checks.push({
+      surface: "template",
+      name: template.name,
+      ok: Boolean(template.path || template.content),
+      errors: template.path || template.content ? [] : [`template ${template.name} needs path or inline content`],
+      warnings: []
+    });
+  }
+  const templateNames = new Set(templates.map((template) => template.name));
+  for (const renderer of renderers) {
+    const missingTarget = !renderer.target;
+    const missingImplementation = !renderer.command && !renderer.template;
+    checks.push({
+      surface: "renderer",
+      name: renderer.name,
+      ok: !missingTarget && !missingImplementation && (!renderer.template || templateNames.has(renderer.template)),
+      errors: [
+        ...missingTarget ? [`renderer ${renderer.name} needs a target`] : [],
+        ...missingImplementation ? [`renderer ${renderer.name} needs command or template`] : [],
+        ...renderer.template && !templateNames.has(renderer.template) ? [`renderer ${renderer.name} references unknown template ${renderer.template}`] : []
+      ],
+      warnings: renderer.command ? ["renderer command will be checked by the local runner sandbox"] : []
+    });
+  }
   const permissions = [
     ...manifest.permissions || [],
     ...commands.flatMap((command) => command.permissions || []),
-    ...tools.flatMap((tool) => tool.permissions || [])
+    ...tools.flatMap((tool) => tool.permissions || []),
+    ...templates.flatMap((template) => template.permissions || []),
+    ...renderers.flatMap((renderer) => renderer.permissions || [])
   ];
   checks.push(...permissions.map(validatePermission));
   return checks;
 }
 function sandboxChecks(manifest, source9) {
-  return (manifest.commands || []).filter((command) => Boolean(command.command)).map((command) => {
+  const commandChecks = (manifest.commands || []).filter((command) => Boolean(command.command)).map((command) => {
     const check = checkRunnerSandbox({
       path: source9,
       cwd: source9,
@@ -25115,6 +26949,25 @@ function sandboxChecks(manifest, source9) {
       audit_evidence: check.audit_evidence
     };
   });
+  const rendererChecks = (manifest.renderers || []).filter((renderer) => Boolean(renderer.command)).map((renderer) => {
+    const check = checkRunnerSandbox({
+      path: source9,
+      cwd: source9,
+      command: renderer.command,
+      write_paths: renderer.write_paths,
+      env: Object.fromEntries((renderer.env || []).map((key) => [key, "declared"])),
+      network: renderer.network
+    });
+    return {
+      command_name: `renderer:${renderer.name}`,
+      command: renderer.command,
+      allowed: check.allowed,
+      requires_approval: check.requires_approval,
+      reasons: check.reasons,
+      audit_evidence: check.audit_evidence
+    };
+  });
+  return [...commandChecks, ...rendererChecks];
 }
 function verifyExtensionSignature(input) {
   if (!input.signature || !input.public_key)
@@ -25125,19 +26978,19 @@ function verifyExtensionSignature(input) {
   return verifier.verify(input.public_key, decodeSignature(input.signature));
 }
 function inspectExtensionSource(source9) {
-  const resolved = resolve12(source9);
+  const resolved = resolve13(source9);
   if (!existsSync14(resolved))
     throw new Error(`extension source not found: ${source9}`);
   const stat = statSync6(resolved);
   const manifestPath = stat.isDirectory() ? [join15(resolved, "todos.extension.json"), join15(resolved, "extension.json")].find(existsSync14) : resolved;
   if (!manifestPath)
     throw new Error(`extension directory ${source9} is missing todos.extension.json`);
-  const raw = readFileSync12(manifestPath);
+  const raw = readFileSync13(manifestPath);
   const parsed = parseJson(manifestPath);
   const bundle = isObject2(parsed) && isObject2(parsed["manifest"]);
   const manifest = normalizeManifest(bundle ? parsed["manifest"] : parsed);
   const sourceType = stat.isDirectory() ? "directory" : bundle ? "bundle" : "manifest";
-  const checksum = sha2564(raw);
+  const checksum = sha2565(raw);
   return {
     source: resolved,
     source_type: sourceType,
@@ -25165,8 +27018,8 @@ function validateExtensionManifest(manifest) {
     errors.push(`extension requires @hasna/todos ${compatibilityRange}, current version is ${todosVersion}`);
   if ((candidate.permissions || []).length === 0)
     warnings.push("extension declares no permissions");
-  if ((candidate.commands || []).length === 0 && (candidate.mcp_tools || []).length === 0 && (candidate.hooks || []).length === 0) {
-    warnings.push("extension declares no commands, MCP tools, or hooks");
+  if ((candidate.commands || []).length === 0 && (candidate.mcp_tools || []).length === 0 && (candidate.templates || []).length === 0 && (candidate.renderers || []).length === 0 && (candidate.hooks || []).length === 0) {
+    warnings.push("extension declares no commands, MCP tools, templates, renderers, or hooks");
   }
   const cliMcpChecks = compatibilityChecks(candidate);
   for (const check of cliMcpChecks) {
@@ -25209,6 +27062,8 @@ function testExtensionCompatibility(sourceOrManifest) {
     summary: {
       commands: manifest.commands?.length || 0,
       mcp_tools: manifest.mcp_tools?.length || 0,
+      templates: manifest.templates?.length || 0,
+      renderers: manifest.renderers?.length || 0,
       hooks: manifest.hooks?.length || 0,
       permissions: validation.permission_declarations.length,
       sandbox_checks: validation.sandbox_checks.length,
@@ -25218,6 +27073,57 @@ function testExtensionCompatibility(sourceOrManifest) {
     warnings
   };
 }
+function projectExtensionSources(projectPath) {
+  if (!projectPath)
+    return [];
+  const root = resolve13(projectPath);
+  const candidates = [
+    join15(root, "todos.extension.json"),
+    join15(root, ".todos", "todos.extension.json")
+  ];
+  const extensionDir = join15(root, ".todos", "extensions");
+  if (existsSync14(extensionDir)) {
+    for (const entry of readdirSync4(extensionDir)) {
+      if (entry.startsWith("."))
+        continue;
+      const full = join15(extensionDir, entry);
+      if (statSync6(full).isDirectory() || entry.endsWith(".json"))
+        candidates.push(full);
+    }
+  }
+  return candidates.filter(existsSync14);
+}
+function discoverLocalExtensions(options = {}) {
+  const config = loadConfig();
+  const projectPath = options.project_path ? resolve13(options.project_path) : null;
+  const configuredSources = [
+    ...config.extension_sources || [],
+    ...projectPath ? config.project_overrides?.[projectPath]?.extension_sources || [] : []
+  ];
+  const sources = Array.from(new Set([
+    ...configuredSources,
+    ...projectExtensionSources(projectPath || undefined)
+  ])).map((source9) => projectPath && !source9.startsWith("/") ? resolve13(projectPath, source9) : resolve13(source9));
+  const warnings = [];
+  const discovered = [];
+  for (const source9 of sources) {
+    try {
+      discovered.push(inspectExtensionSource(source9));
+    } catch (error) {
+      warnings.push(`${source9}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return {
+    schema_version: 1,
+    local_only: true,
+    no_network: true,
+    project_path: projectPath,
+    config_sources: sources,
+    discovered,
+    installed: options.include_installed === false ? [] : listLocalExtensions(),
+    warnings
+  };
+}
 function installLocalExtension(input) {
   const inspected = inspectExtensionSource(input.source);
   const expectedChecksum = input.checksum || inspected.manifest.checksum;
@@ -25266,10 +27172,10 @@ function listLocalExtensions() {
   return Object.values(loadConfig().extension_registry || {}).sort((a, b) => a.name.localeCompare(b.name));
 }
 function getLocalExtension(name) {
-  return loadConfig().extension_registry?.[normalizeName3(name)] || null;
+  return loadConfig().extension_registry?.[normalizeName4(name)] || null;
 }
 function removeLocalExtension(name) {
-  const normalized = normalizeName3(name);
+  const normalized = normalizeName4(name);
   const config = loadConfig();
   if (!config.extension_registry?.[normalized])
     return false;
@@ -25599,14 +27505,14 @@ async function executeDispatch(dispatch, opts = {}, db) {
 async function runDueDispatches(opts = {}, db) {
   const _db2 = db ?? getDatabase();
   const due = getDueDispatches(_db2);
-  let count = 0;
+  let count2 = 0;
   for (const dispatch of due) {
     try {
       await executeDispatch(dispatch, opts, _db2);
-      count++;
+      count2++;
     } catch {}
   }
-  return count;
+  return count2;
 }
 async function dispatchToMultiple(input, opts = {}, db) {
   const _db2 = db ?? getDatabase();
@@ -25849,6 +27755,227 @@ function applyRetentionCleanup(input, db) {
   }
   return report;
 }
+// src/lib/scale-hardening.ts
+init_database();
+var REQUIRED_INDEXES = [
+  "idx_tasks_project",
+  "idx_tasks_status",
+  "idx_tasks_archived_at",
+  "idx_tasks_updated_at",
+  "idx_task_runs_task",
+  "idx_task_run_events_run",
+  "idx_comments_task",
+  "idx_task_dependencies_task",
+  "idx_task_dependencies_depends_on"
+];
+function count2(db, sql) {
+  const row = db.query(sql).get();
+  return row?.count ?? 0;
+}
+function pragmaNumber(db, name) {
+  const row = db.query(`PRAGMA ${name}`).get();
+  const value = row ? Object.values(row)[0] : 0;
+  return typeof value === "number" ? value : 0;
+}
+function quickCheck(db) {
+  try {
+    const row = db.query("PRAGMA quick_check").get();
+    return row?.quick_check ?? "unknown";
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+function foreignKeyViolations(db) {
+  try {
+    return db.query("PRAGMA foreign_key_check").all().length;
+  } catch {
+    return 0;
+  }
+}
+function missingIndexes(db) {
+  const rows = db.query("SELECT name FROM sqlite_master WHERE type='index'").all();
+  const existing = new Set(rows.map((row) => row.name));
+  return REQUIRED_INDEXES.filter((index) => !existing.has(index));
+}
+function benchmark(name, thresholdMs, fn) {
+  const start = performance.now();
+  const rows = fn();
+  const elapsed = Math.max(0, performance.now() - start);
+  const elapsed_ms = Math.round(elapsed * 1000) / 1000;
+  return {
+    name,
+    rows,
+    elapsed_ms,
+    threshold_ms: thresholdMs,
+    ok: elapsed_ms <= thresholdMs
+  };
+}
+function cutoffDate(days) {
+  return new Date(Date.now() - days * 86400000).toISOString();
+}
+function normalizedPositiveDays(value) {
+  if (value === undefined)
+    return 30;
+  if (!Number.isFinite(value))
+    return 30;
+  return Math.max(1, Math.trunc(value));
+}
+function formatNumber(value) {
+  return new Intl.NumberFormat("en-US").format(value);
+}
+function formatMs(value) {
+  return `${value.toFixed(value >= 10 ? 1 : 3)}ms`;
+}
+function createScalePerformanceReport(options = {}, db) {
+  const d = db || getDatabase();
+  const olderThanDays = normalizedPositiveDays(options.older_than_days);
+  const pageCount = pragmaNumber(d, "page_count");
+  const freelistCount = pragmaNumber(d, "freelist_count");
+  const freelistRatio = pageCount > 0 ? Math.round(freelistCount / pageCount * 1000) / 1000 : 0;
+  const quick = quickCheck(d);
+  const fkViolations = foreignKeyViolations(d);
+  const missing = missingIndexes(d);
+  const oldCutoff = cutoffDate(olderThanDays);
+  const terminalUnarchived = count2(d, "SELECT COUNT(*) AS count FROM tasks WHERE archived_at IS NULL AND status IN ('completed', 'failed', 'cancelled')");
+  const oldTerminalUnarchived = count2(d, `SELECT COUNT(*) AS count FROM tasks WHERE archived_at IS NULL AND status IN ('completed', 'failed', 'cancelled') AND updated_at < '${oldCutoff}'`);
+  const archivedCount = count2(d, "SELECT COUNT(*) AS count FROM tasks WHERE archived_at IS NOT NULL");
+  const benchmarks = [
+    benchmark("open_task_list", 50, () => listTasks({ status: ["pending", "in_progress"], limit: 100 }, d).length),
+    benchmark("search_recent_tasks", 75, () => searchTasks({ query: "*", status: ["pending", "in_progress"] }, undefined, undefined, d).length),
+    benchmark("archived_task_scan", 75, () => listTasks({ include_archived: true, limit: 100 }, d).length),
+    benchmark("run_ledger_recent", 75, () => count2(d, "SELECT COUNT(*) AS count FROM (SELECT id FROM task_runs ORDER BY started_at DESC LIMIT 100)")),
+    benchmark("dependency_blockers", 75, () => count2(d, "SELECT COUNT(*) AS count FROM task_dependencies td JOIN tasks dep ON dep.id = td.depends_on WHERE dep.status != 'completed'"))
+  ];
+  const warnings = [];
+  if (freelistRatio >= 0.2 && freelistCount >= 100)
+    warnings.push("database has enough free pages to consider VACUUM during a maintenance window");
+  if (oldTerminalUnarchived > 0)
+    warnings.push(`${oldTerminalUnarchived} old terminal tasks can be archived without deleting evidence`);
+  if (missing.length > 0)
+    warnings.push(`missing expected index(es): ${missing.join(", ")}`);
+  if (fkViolations > 0)
+    warnings.push(`${fkViolations} foreign key violation(s) detected`);
+  for (const item of benchmarks) {
+    if (!item.ok)
+      warnings.push(`${item.name} exceeded ${item.threshold_ms}ms threshold`);
+  }
+  return {
+    schema_version: 1,
+    local_only: true,
+    no_network: true,
+    generated_at: options.generated_at ?? new Date().toISOString(),
+    database_path: getDatabasePath(),
+    counts: {
+      tasks: count2(d, "SELECT COUNT(*) AS count FROM tasks"),
+      archived_tasks: archivedCount,
+      projects: count2(d, "SELECT COUNT(*) AS count FROM projects"),
+      agents: count2(d, "SELECT COUNT(*) AS count FROM agents"),
+      plans: count2(d, "SELECT COUNT(*) AS count FROM plans"),
+      runs: count2(d, "SELECT COUNT(*) AS count FROM task_runs"),
+      run_events: count2(d, "SELECT COUNT(*) AS count FROM task_run_events"),
+      comments: count2(d, "SELECT COUNT(*) AS count FROM task_comments"),
+      dependencies: count2(d, "SELECT COUNT(*) AS count FROM task_dependencies")
+    },
+    benchmarks,
+    archive: {
+      terminal_unarchived_tasks: terminalUnarchived,
+      older_than_days: olderThanDays,
+      older_terminal_unarchived_tasks: oldTerminalUnarchived,
+      archived_tasks_visible_with_include_archived: archivedCount === 0 || listTasks({ include_archived: true, limit: 5000 }, d).some((task2) => Boolean(task2.archived_at))
+    },
+    compaction: {
+      page_count: pageCount,
+      freelist_count: freelistCount,
+      freelist_ratio: freelistRatio,
+      recommended: freelistRatio >= 0.2 && freelistCount >= 100,
+      commands: ["PRAGMA optimize", "VACUUM"]
+    },
+    integrity: {
+      quick_check: quick,
+      foreign_key_violations: fkViolations,
+      missing_indexes: missing,
+      ok: quick === "ok" && fkViolations === 0 && missing.length === 0
+    },
+    warnings
+  };
+}
+function compactScaleStorage(options = {}, db) {
+  const d = db || getDatabase();
+  const before = {
+    page_count: pragmaNumber(d, "page_count"),
+    freelist_count: pragmaNumber(d, "freelist_count")
+  };
+  const actions = ["PRAGMA optimize", "VACUUM"];
+  if (options.apply) {
+    d.run("PRAGMA optimize");
+    d.run("VACUUM");
+  }
+  const after = {
+    page_count: pragmaNumber(d, "page_count"),
+    freelist_count: pragmaNumber(d, "freelist_count")
+  };
+  return {
+    schema_version: 1,
+    local_only: true,
+    no_network: true,
+    dry_run: !options.apply,
+    database_path: getDatabasePath(),
+    before,
+    after,
+    actions
+  };
+}
+function renderScalePerformanceReportMarkdown(report) {
+  const lines = [
+    "# todos scale hardening report",
+    "",
+    `Generated: ${report.generated_at}`,
+    `Database: ${report.database_path}`,
+    `Local only: ${report.local_only ? "yes" : "no"}`,
+    "",
+    "## Counts",
+    "",
+    `- Tasks: ${formatNumber(report.counts.tasks)} (${formatNumber(report.counts.archived_tasks)} archived)`,
+    `- Projects: ${formatNumber(report.counts.projects)}`,
+    `- Agents: ${formatNumber(report.counts.agents)}`,
+    `- Plans: ${formatNumber(report.counts.plans)}`,
+    `- Runs: ${formatNumber(report.counts.runs)} with ${formatNumber(report.counts.run_events)} events`,
+    `- Comments: ${formatNumber(report.counts.comments)}`,
+    `- Dependencies: ${formatNumber(report.counts.dependencies)}`,
+    "",
+    "## Benchmarks",
+    "",
+    "| Query | Rows | Time | Threshold | Status |",
+    "| --- | ---: | ---: | ---: | --- |",
+    ...report.benchmarks.map((item) => `| ${item.name} | ${formatNumber(item.rows)} | ${formatMs(item.elapsed_ms)} | ${formatMs(item.threshold_ms)} | ${item.ok ? "ok" : "slow"} |`),
+    "",
+    "## Archive Readiness",
+    "",
+    `- Terminal unarchived tasks: ${formatNumber(report.archive.terminal_unarchived_tasks)}`,
+    `- Older than ${report.archive.older_than_days} days: ${formatNumber(report.archive.older_terminal_unarchived_tasks)}`,
+    `- Include-archived listing exposes archived tasks: ${report.archive.archived_tasks_visible_with_include_archived ? "yes" : "no"}`,
+    "",
+    "## Compaction",
+    "",
+    `- Pages: ${formatNumber(report.compaction.page_count)}`,
+    `- Free pages: ${formatNumber(report.compaction.freelist_count)} (${Math.round(report.compaction.freelist_ratio * 100)}%)`,
+    `- Maintenance recommended: ${report.compaction.recommended ? "yes" : "no"}`,
+    `- Commands: ${report.compaction.commands.map((command) => `\`${command}\``).join(", ")}`,
+    "",
+    "## Integrity",
+    "",
+    `- Quick check: ${report.integrity.quick_check}`,
+    `- Foreign key violations: ${formatNumber(report.integrity.foreign_key_violations)}`,
+    `- Missing indexes: ${report.integrity.missing_indexes.length === 0 ? "none" : report.integrity.missing_indexes.join(", ")}`,
+    `- Overall: ${report.integrity.ok ? "ok" : "needs attention"}`
+  ];
+  if (report.warnings.length > 0) {
+    lines.push("", "## Warnings", "", ...report.warnings.map((warning) => `- ${warning}`));
+  }
+  return `${lines.join(`
+`)}
+`;
+}
 // src/lib/todos-md.ts
 init_database();
 var TODOS_MARKDOWN_SCHEMA = "hasna.todos.md/v1";
@@ -26048,9 +28175,9 @@ function importTodosMarkdown(markdown, options = {}, db) {
     inserted.projects = parsed.projectName ? 1 : 0;
     inserted.plans = parsed.plans.length;
     inserted.tasks = parsed.tasks.length;
-    inserted.comments = parsed.tasks.reduce((count, task2) => count + task2.comments.length, 0);
-    inserted.runs = parsed.tasks.reduce((count, task2) => count + task2.run_summaries.length, 0);
-    inserted.task_dependencies = parsed.tasks.reduce((count, task2) => count + task2.depends_on_titles.length, 0);
+    inserted.comments = parsed.tasks.reduce((count3, task2) => count3 + task2.comments.length, 0);
+    inserted.runs = parsed.tasks.reduce((count3, task2) => count3 + task2.run_summaries.length, 0);
+    inserted.task_dependencies = parsed.tasks.reduce((count3, task2) => count3 + task2.depends_on_titles.length, 0);
     return { ok: issues.length === 0, dry_run: true, mode: "plain_markdown", inserted, merged: emptyCounts2(), skipped, conflicts: [], issues };
   }
   const project = parsed.projectName ? createProject({ name: parsed.projectName, path: `todos-md://${parsed.projectName}` }, d) : null;
@@ -26108,8 +28235,8 @@ function importTodosMarkdown(markdown, options = {}, db) {
 init_database();
 init_migrations();
 init_schema();
-import { chmodSync, copyFileSync, existsSync as existsSync16, mkdirSync as mkdirSync9, statSync as statSync7 } from "fs";
-import { basename as basename4, dirname as dirname7, join as join16 } from "path";
+import { chmodSync, copyFileSync, existsSync as existsSync16, mkdirSync as mkdirSync10, statSync as statSync7 } from "fs";
+import { basename as basename4, dirname as dirname8, join as join16 } from "path";
 var REQUIRED_TABLES2 = [
   "_migrations",
   "projects",
@@ -26137,7 +28264,7 @@ function getTableColumns(db, table) {
     return new Set;
   }
 }
-function countQuery(db, sql) {
+function countQuery2(db, sql) {
   try {
     const row = db.query(sql).get();
     return row?.count ?? 0;
@@ -26227,7 +28354,7 @@ function addTaskStateChecks(db, checks) {
   const columns = getTableColumns(db, "tasks");
   const staleCutoff = new Date(Date.now() - 30 * 60 * 1000).toISOString();
   if (columns.has("updated_at") && columns.has("status")) {
-    const staleTasks = countQuery(db, `SELECT COUNT(*) as count FROM tasks WHERE status = 'in_progress' AND updated_at < '${staleCutoff}'`);
+    const staleTasks = countQuery2(db, `SELECT COUNT(*) as count FROM tasks WHERE status = 'in_progress' AND updated_at < '${staleCutoff}'`);
     if (staleTasks > 0) {
       addCheck(checks, {
         severity: "warn",
@@ -26279,9 +28406,9 @@ function createBackup(dbPath) {
   if (!existsSync16(dbPath))
     return;
   const stamp = now().replace(/[:.]/g, "-");
-  const backupDir = join16(dirname7(dbPath), `${basename4(dbPath)}.backup-${stamp}`);
+  const backupDir = join16(dirname8(dbPath), `${basename4(dbPath)}.backup-${stamp}`);
   const files = [];
-  mkdirSync9(backupDir, { recursive: true });
+  mkdirSync10(backupDir, { recursive: true });
   for (const source9 of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
     if (!existsSync16(source9))
       continue;
@@ -26291,8 +28418,8 @@ function createBackup(dbPath) {
   }
   return files.length > 0 ? { path: backupDir, files } : undefined;
 }
-function pushRepair(repairs, type, message, applied, count) {
-  repairs.push({ type, message, applied, count });
+function pushRepair(repairs, type, message, applied, count3) {
+  repairs.push({ type, message, applied, count: count3 });
 }
 function summarize3(checks, repairs) {
   return {
@@ -26304,7 +28431,7 @@ function summarize3(checks, repairs) {
   };
 }
 function deleteOrphans(db, table, where) {
-  const before = countQuery(db, `SELECT COUNT(*) as count FROM ${table} WHERE ${where}`);
+  const before = countQuery2(db, `SELECT COUNT(*) as count FROM ${table} WHERE ${where}`);
   if (before > 0)
     db.run(`DELETE FROM ${table} WHERE ${where}`);
   return before;
@@ -26341,7 +28468,7 @@ function runTodosDoctor(options = {}) {
       repairable: true
     });
   }
-  const orphanedParents = tableExists(db, "tasks") ? countQuery(db, "SELECT COUNT(*) as count FROM tasks t WHERE t.parent_id IS NOT NULL AND NOT EXISTS (SELECT 1 FROM tasks p WHERE p.id = t.parent_id)") : 0;
+  const orphanedParents = tableExists(db, "tasks") ? countQuery2(db, "SELECT COUNT(*) as count FROM tasks t WHERE t.parent_id IS NOT NULL AND NOT EXISTS (SELECT 1 FROM tasks p WHERE p.id = t.parent_id)") : 0;
   if (orphanedParents > 0) {
     addCheck(checks, {
       severity: "error",
@@ -26351,7 +28478,7 @@ function runTodosDoctor(options = {}) {
       repairable: true
     });
   }
-  const orphanedDependencies = tableExists(db, "task_dependencies") && tableExists(db, "tasks") ? countQuery(db, "SELECT COUNT(*) as count FROM task_dependencies d WHERE NOT EXISTS (SELECT 1 FROM tasks t WHERE t.id = d.task_id) OR NOT EXISTS (SELECT 1 FROM tasks t WHERE t.id = d.depends_on)") : 0;
+  const orphanedDependencies = tableExists(db, "task_dependencies") && tableExists(db, "tasks") ? countQuery2(db, "SELECT COUNT(*) as count FROM task_dependencies d WHERE NOT EXISTS (SELECT 1 FROM tasks t WHERE t.id = d.task_id) OR NOT EXISTS (SELECT 1 FROM tasks t WHERE t.id = d.depends_on)") : 0;
   if (orphanedDependencies > 0) {
     addCheck(checks, {
       severity: "error",
@@ -26368,18 +28495,18 @@ function runTodosDoctor(options = {}) {
     ["task_run_commands", "NOT EXISTS (SELECT 1 FROM tasks t WHERE t.id = task_run_commands.task_id) OR NOT EXISTS (SELECT 1 FROM task_runs r WHERE r.id = task_run_commands.run_id)"],
     ["task_run_artifacts", "NOT EXISTS (SELECT 1 FROM tasks t WHERE t.id = task_run_artifacts.task_id) OR NOT EXISTS (SELECT 1 FROM task_runs r WHERE r.id = task_run_artifacts.run_id)"]
   ];
-  let orphanedRows = 0;
+  let orphanedRows2 = 0;
   for (const [table, where] of orphanTables) {
     if (!tableExists(db, table))
       continue;
-    orphanedRows += countQuery(db, `SELECT COUNT(*) as count FROM ${table} WHERE ${where}`);
+    orphanedRows2 += countQuery2(db, `SELECT COUNT(*) as count FROM ${table} WHERE ${where}`);
   }
-  if (orphanedRows > 0) {
+  if (orphanedRows2 > 0) {
     addCheck(checks, {
       severity: "error",
       type: "orphaned_child_rows",
-      message: `${orphanedRows} child rows reference missing tasks or runs`,
-      count: orphanedRows,
+      message: `${orphanedRows2} child rows reference missing tasks or runs`,
+      count: orphanedRows2,
       repairable: true
     });
   }
@@ -26443,15 +28570,15 @@ function runTodosDoctor(options = {}) {
       pushRepair(repairs, "orphaned_task_parents", "Cleared missing parent references", true, orphanedParents);
     }
     if (orphanedDependencies > 0 && tableExists(db, "task_dependencies")) {
-      const count = deleteOrphans(db, "task_dependencies", "NOT EXISTS (SELECT 1 FROM tasks t WHERE t.id = task_dependencies.task_id) OR NOT EXISTS (SELECT 1 FROM tasks t WHERE t.id = task_dependencies.depends_on)");
-      pushRepair(repairs, "orphaned_task_dependencies", "Deleted dependency rows referencing missing tasks", true, count);
+      const count3 = deleteOrphans(db, "task_dependencies", "NOT EXISTS (SELECT 1 FROM tasks t WHERE t.id = task_dependencies.task_id) OR NOT EXISTS (SELECT 1 FROM tasks t WHERE t.id = task_dependencies.depends_on)");
+      pushRepair(repairs, "orphaned_task_dependencies", "Deleted dependency rows referencing missing tasks", true, count3);
     }
     for (const [table, where] of orphanTables) {
       if (!tableExists(db, table))
         continue;
-      const count = deleteOrphans(db, table, where);
-      if (count > 0)
-        pushRepair(repairs, "orphaned_child_rows", `Deleted orphaned rows from ${table}`, true, count);
+      const count3 = deleteOrphans(db, table, where);
+      if (count3 > 0)
+        pushRepair(repairs, "orphaned_child_rows", `Deleted orphaned rows from ${table}`, true, count3);
     }
     if (corruptJson.length > 0) {
       for (const cell of corruptJson) {
@@ -26490,10 +28617,10 @@ function runTodosDoctor(options = {}) {
   };
 }
 // src/lib/environment-snapshots.ts
-import { createHash as createHash11 } from "crypto";
-import { existsSync as existsSync17, readFileSync as readFileSync13, statSync as statSync8 } from "fs";
+import { createHash as createHash12 } from "crypto";
+import { existsSync as existsSync17, readFileSync as readFileSync14, statSync as statSync8 } from "fs";
 import { hostname, platform, arch } from "os";
-import { dirname as dirname8, join as join17, resolve as resolve13 } from "path";
+import { dirname as dirname9, join as join17, resolve as resolve14 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 init_database();
 var MANIFEST_FILES = ["package.json", "dashboard/package.json", "sdk/package.json"];
@@ -26512,8 +28639,8 @@ var CONFIG_FILES = [
   "vite.config.ts",
   "dashboard/vite.config.ts"
 ];
-function sha2565(value) {
-  return createHash11("sha256").update(value).digest("hex");
+function sha2566(value) {
+  return createHash12("sha256").update(value).digest("hex");
 }
 function fileRecord(root, relativePath) {
   const path = join17(root, relativePath);
@@ -26522,8 +28649,8 @@ function fileRecord(root, relativePath) {
   const stat = statSync8(path);
   if (!stat.isFile())
     return null;
-  const content = readFileSync13(path);
-  return { path: relativePath, sha256: sha2565(content), size_bytes: content.length };
+  const content = readFileSync14(path);
+  return { path: relativePath, sha256: sha2566(content), size_bytes: content.length };
 }
 function manifestRecord(root, relativePath) {
   const base = fileRecord(root, relativePath);
@@ -26625,14 +28752,14 @@ function defaultSnapshotDir() {
   const dbPath = getDatabasePath();
   if (dbPath === ":memory:" || dbPath.startsWith("file::memory:"))
     return join17(tmpdir2(), "hasna-todos", "environment-snapshots");
-  return join17(dirname8(resolve13(dbPath)), "environment-snapshots");
+  return join17(dirname9(resolve14(dbPath)), "environment-snapshots");
 }
 function snapshotWithId(snapshot) {
-  const digest = sha2565(JSON.stringify(snapshot)).slice(0, 24);
+  const digest = sha2566(JSON.stringify(snapshot)).slice(0, 24);
   return { id: `env_${digest}`, ...snapshot };
 }
 function captureEnvironmentSnapshot(input = {}) {
-  const root = resolve13(input.root || process.cwd());
+  const root = resolve14(input.root || process.cwd());
   const env = input.env || process.env;
   const warnings = [];
   const manifests = MANIFEST_FILES.map((file) => manifestRecord(root, file)).filter((file) => Boolean(file));
@@ -26672,13 +28799,13 @@ function captureEnvironmentSnapshot(input = {}) {
   });
 }
 function writeEnvironmentSnapshot(snapshot, outputPath) {
-  const path = outputPath ? resolve13(outputPath) : join17(defaultSnapshotDir(), `${snapshot.id}.json`);
-  ensureDir2(dirname8(path));
+  const path = outputPath ? resolve14(outputPath) : join17(defaultSnapshotDir(), `${snapshot.id}.json`);
+  ensureDir2(dirname9(path));
   writeJsonFile(path, snapshot);
   return path;
 }
 function readEnvironmentSnapshot(path) {
-  const snapshot = readJsonFile(resolve13(path));
+  const snapshot = readJsonFile(resolve14(path));
   if (!snapshot || snapshot.schema_version !== 1 || typeof snapshot.id !== "string") {
     throw new Error(`Invalid environment snapshot: ${path}`);
   }
@@ -26971,14 +29098,391 @@ function renderPlanningForecastMarkdown(forecast) {
   return lines.join(`
 `);
 }
+// src/lib/cli-help.ts
+var COMPLETION_SHELLS = ["bash", "zsh", "fish"];
+var CORE_EXAMPLES = [
+  "todos project-bootstrap . --json",
+  'todos add "Ship CLI help" --priority high --json',
+  "todos ready --json",
+  "todos usage report --max-tasks 1000 --max-projects 10 --json",
+  'todos runs command <run-id> "bun test" --status passed --summary "1836 pass, 0 fail"',
+  "todos mcp"
+];
+var JSON_CONTRACTS = [
+  "local_task",
+  "local_project",
+  "task_run",
+  "local_usage_ledger",
+  "structured_error",
+  "api_error"
+];
+var ERROR_CODES = [
+  { code: "0", meaning: "Command completed successfully." },
+  { code: "1", meaning: 'Validation, lookup, database, or runtime failure. In JSON mode the CLI prints {"error":"message"}.' },
+  { code: "structured_error", meaning: "Machine-readable error contract used by local MCP and SDK surfaces." },
+  { code: "api_error", meaning: "HTTP API error envelope for the optional local server." }
+];
+function optionEntry(option) {
+  return {
+    flags: option.flags,
+    description: option.description || "",
+    longFlag: option.long || null,
+    shortFlag: option.short || null
+  };
+}
+function collectCliCommandEntries(program, prefix = []) {
+  const entries = [];
+  for (const command of program.commands) {
+    const path = [...prefix, command.name()];
+    entries.push({
+      path,
+      command: path.join(" "),
+      description: command.description() || "",
+      aliases: command.aliases(),
+      usage: command.usage(),
+      options: command.options.map(optionEntry)
+    });
+    entries.push(...collectCliCommandEntries(command, path));
+  }
+  return entries;
+}
+function createCliManual(program) {
+  return {
+    title: "todos(1)",
+    synopsis: "todos [global options] <command> [command options]",
+    package_name: "@hasna/todos",
+    local_only: true,
+    install: ["bun install -g @hasna/todos"],
+    update: ["bun install -g @hasna/todos", "todos upgrade"],
+    completion_shells: COMPLETION_SHELLS,
+    examples: CORE_EXAMPLES,
+    json_contracts: JSON_CONTRACTS,
+    error_codes: ERROR_CODES,
+    commands: collectCliCommandEntries(program)
+  };
+}
+function escapeMarkdownCell(value) {
+  return value.replaceAll("|", "\\|").replaceAll(`
+`, " ");
+}
+function renderCliManualMarkdown(manual) {
+  const lines = [
+    `# ${manual.title}`,
+    "",
+    "## Name",
+    "",
+    "todos - local task, plan, run, and MCP workflows for AI coding agents",
+    "",
+    "## Synopsis",
+    "",
+    "```bash",
+    manual.synopsis,
+    "```",
+    "",
+    "## Install",
+    "",
+    "```bash",
+    ...manual.install,
+    "```",
+    "",
+    "## Update",
+    "",
+    "```bash",
+    ...manual.update,
+    "```",
+    "",
+    "## Shell Completions",
+    "",
+    "```bash",
+    "todos completions bash > ~/.local/share/bash-completion/completions/todos",
+    "todos completions zsh > ~/.zsh/completions/_todos",
+    "todos completions fish > ~/.config/fish/completions/todos.fish",
+    "```",
+    "",
+    "## Examples",
+    "",
+    "```bash",
+    ...manual.examples,
+    "```",
+    "",
+    "## JSON Output Contracts",
+    "",
+    "The CLI keeps JSON output stable for scripts and MCP adapters. Use `--json` or `-j` when a command supports machine output.",
+    "",
+    ...manual.json_contracts.map((contract2) => `- \`${contract2}\``),
+    "",
+    "## Error Codes",
+    "",
+    "| Code | Meaning |",
+    "| --- | --- |",
+    ...manual.error_codes.map((error) => `| \`${escapeMarkdownCell(error.code)}\` | ${escapeMarkdownCell(error.meaning)} |`),
+    "",
+    "## Command Catalog",
+    "",
+    "| Command | Description | Options |",
+    "| --- | --- | --- |",
+    ...manual.commands.map((command) => {
+      const options = command.options.map((option) => `\`${option.flags}\``).join("<br>");
+      return `| \`todos ${escapeMarkdownCell(command.command)}\` | ${escapeMarkdownCell(command.description)} | ${options || "-"} |`;
+    }),
+    ""
+  ];
+  return lines.join(`
+`);
+}
+function shellWords(values) {
+  return values.map((value) => value.replaceAll("'", "'\\''")).join(" ");
+}
+function zshEntry(name, description) {
+  return `'${name.replaceAll("'", "'\\''")}:${description.replaceAll("'", "'\\''")}'`;
+}
+function fishEscape(value) {
+  return value.replaceAll("\\", "\\\\").replaceAll('"', "\\\"");
+}
+function rootCommandNames(entries) {
+  return entries.filter((entry) => entry.path.length === 1).map((entry) => entry.path[0]).filter((value) => Boolean(value));
+}
+function optionFlags(options) {
+  const flags = new Set;
+  for (const option of options) {
+    if (option.longFlag)
+      flags.add(option.longFlag);
+    if (option.shortFlag)
+      flags.add(option.shortFlag);
+  }
+  return [...flags].sort();
+}
+function commandOptions(program, entry) {
+  return optionFlags([...program.options.map(optionEntry), ...entry.options]);
+}
+function generateCompletionScript(program, shell) {
+  const entries = collectCliCommandEntries(program);
+  const roots = rootCommandNames(entries);
+  if (shell === "bash") {
+    const rootCases = entries.filter((entry) => entry.path.length === 1).map((entry) => {
+      const children = entries.filter((child) => child.path.length === 2 && child.path[0] === entry.path[0]).map((child) => child.path[1]).filter((value) => Boolean(value));
+      const options = commandOptions(program, entry);
+      return `    ${entry.path[0]})
+      COMPREPLY=($(compgen -W '${shellWords([...children, ...options])}' -- "$cur"))
+      return
+      ;;`;
+    }).join(`
+`);
+    return [
+      "# todos bash completion. Generated by `todos completions bash`.",
+      "_todos_completion() {",
+      "  local cur",
+      "  COMPREPLY=()",
+      '  cur="${COMP_WORDS[COMP_CWORD]}"',
+      '  if [[ "$cur" == -* ]]; then',
+      `    COMPREPLY=($(compgen -W '${shellWords(optionFlags(program.options.map(optionEntry)))}' -- "$cur"))`,
+      "    return",
+      "  fi",
+      '  case "${COMP_WORDS[1]}" in',
+      rootCases,
+      "  esac",
+      `  COMPREPLY=($(compgen -W '${shellWords(roots)}' -- "$cur"))`,
+      "}",
+      "complete -F _todos_completion todos",
+      ""
+    ].join(`
+`);
+  }
+  if (shell === "zsh") {
+    const commandEntries = entries.filter((entry) => entry.path.length === 1).map((entry) => zshEntry(entry.path[0] || "", entry.description));
+    const optionEntries = optionFlags(program.options.map(optionEntry)).map((flag) => `'${flag}'`);
+    const childCases = entries.filter((entry) => entry.path.length === 1).map((entry) => {
+      const children = entries.filter((child) => child.path.length === 2 && child.path[0] === entry.path[0]);
+      if (children.length === 0)
+        return "";
+      const childEntries = children.map((child) => zshEntry(child.path[1] || "", child.description)).join(" ");
+      return `    ${entry.path[0]}) local -a subcommands; subcommands=(${childEntries}); _describe 'subcommand' subcommands ;;`;
+    }).filter(Boolean).join(`
+`);
+    return [
+      "#compdef todos",
+      "# todos zsh completion. Generated by `todos completions zsh`.",
+      "_todos() {",
+      `  local -a commands; commands=(${commandEntries.join(" ")})`,
+      `  local -a global_options; global_options=(${optionEntries.join(" ")})`,
+      "  if (( CURRENT == 2 )); then",
+      "    _describe 'command' commands",
+      "    return",
+      "  fi",
+      "  case $words[2] in",
+      childCases,
+      "  esac",
+      "  _arguments $global_options '*::arg:->args'",
+      "}",
+      '_todos "$@"',
+      ""
+    ].join(`
+`);
+  }
+  const fishLines = [
+    "# todos fish completion. Generated by `todos completions fish`.",
+    "complete -c todos -f"
+  ];
+  for (const option of program.options.map(optionEntry)) {
+    const parts = ["complete -c todos"];
+    if (option.longFlag)
+      parts.push(`-l ${option.longFlag.replace(/^--/, "")}`);
+    if (option.shortFlag)
+      parts.push(`-s ${option.shortFlag.replace(/^-/, "")}`);
+    parts.push(`-d "${fishEscape(option.description)}"`);
+    fishLines.push(parts.join(" "));
+  }
+  for (const entry of entries) {
+    if (entry.path.length === 1) {
+      fishLines.push(`complete -c todos -n "__fish_use_subcommand" -a "${entry.path[0]}" -d "${fishEscape(entry.description)}"`);
+    } else if (entry.path.length === 2) {
+      fishLines.push(`complete -c todos -n "__fish_seen_subcommand_from ${entry.path[0]}" -a "${entry.path[1]}" -d "${fishEscape(entry.description)}"`);
+    }
+  }
+  fishLines.push("");
+  return fishLines.join(`
+`);
+}
+// src/lib/tui-dashboard.ts
+init_database();
+var TUI_DASHBOARD_VIEWS = ["overview", "projects", "tasks", "plans", "runs", "dependencies", "inbox", "search"];
+var TASK_STATUSES2 = ["pending", "in_progress", "completed", "failed", "cancelled"];
+var DEFAULT_LIMIT = 8;
+function limited(value) {
+  const parsed = Number.isFinite(value) ? value : DEFAULT_LIMIT;
+  return Math.max(1, Math.min(parsed || DEFAULT_LIMIT, 25));
+}
+function projectFilter(projectId) {
+  return projectId ? { project_id: projectId } : {};
+}
+function dependencyRows(projectId, limit, db) {
+  const where = ["t.archived_at IS NULL", "dep.archived_at IS NULL"];
+  const params = [];
+  if (projectId) {
+    where.push("t.project_id = ?");
+    params.push(projectId);
+  }
+  params.push(limit);
+  return db.query(`SELECT
+       td.task_id,
+       t.title AS task_title,
+       t.status AS task_status,
+       td.depends_on,
+       dep.title AS depends_on_title,
+       dep.status AS depends_on_status
+     FROM task_dependencies td
+     JOIN tasks t ON t.id = td.task_id
+     JOIN tasks dep ON dep.id = td.depends_on
+     WHERE ${where.join(" AND ")}
+     ORDER BY CASE WHEN dep.status = 'completed' THEN 1 ELSE 0 END, t.priority, t.created_at DESC
+     LIMIT ?`).all(...params).map((row) => {
+    const item = row;
+    return { ...item, blocking: item.depends_on_status !== "completed" };
+  });
+}
+function createTuiDashboardSnapshot(options = {}, db) {
+  const d = db || getDatabase();
+  const limit = limited(options.limit);
+  const filter = projectFilter(options.project_id);
+  const counts = TASK_STATUSES2.reduce((acc, status) => {
+    acc[status] = countTasks({ ...filter, status }, d);
+    return acc;
+  }, { total: 0 });
+  counts.total = TASK_STATUSES2.reduce((sum, status) => sum + counts[status], 0);
+  const projectRows = listProjects(d).filter((project) => !options.project_id || project.id === options.project_id).slice(0, limit).map((project) => ({
+    id: project.id,
+    name: project.name,
+    path: project.path,
+    open_tasks: countTasks({ project_id: project.id, status: ["pending", "in_progress"] }, d)
+  }));
+  const plans = listPlans(options.project_id, d).slice(0, limit).map((plan) => ({
+    id: plan.id,
+    name: plan.name,
+    status: plan.status,
+    project_id: plan.project_id,
+    open_tasks: countTasks({ plan_id: plan.id, status: ["pending", "in_progress"] }, d)
+  }));
+  const taskRows = listTasks({ ...filter, status: ["pending", "in_progress"], limit }, d);
+  const projectTaskIds = new Set(options.project_id ? listTasks({ project_id: options.project_id, include_archived: true }, d).map((task2) => task2.id) : []);
+  const runs = listTaskRuns(undefined, d).filter((run) => !options.project_id || projectTaskIds.has(run.task_id)).slice(0, limit);
+  const inbox = listInboxItems({ limit }, d);
+  const searchResults = options.search ? searchTasks({ query: options.search, project_id: options.project_id }, undefined, undefined, d).slice(0, limit) : [];
+  return {
+    generated_at: new Date().toISOString(),
+    local_only: true,
+    project_id: options.project_id ?? null,
+    active_view: options.active_view || "overview",
+    keymap: [
+      "q quit",
+      "r refresh",
+      "h/left previous tab",
+      "l/right next tab",
+      "1-8 jump tabs",
+      "/ search"
+    ],
+    counts,
+    projects: projectRows,
+    tasks: taskRows,
+    plans,
+    runs,
+    dependencies: dependencyRows(options.project_id, limit, d),
+    inbox,
+    search: {
+      query: options.search || "",
+      total: searchResults.length,
+      results: searchResults
+    }
+  };
+}
+function lineId(id) {
+  return id.slice(0, 8);
+}
+function renderTuiDashboardSnapshot(snapshot) {
+  const lines = [
+    "# todos terminal dashboard",
+    "",
+    `View: ${snapshot.active_view}`,
+    `Local only: ${snapshot.local_only}`,
+    `Keys: ${snapshot.keymap.join(" | ")}`,
+    "",
+    `Tasks: ${snapshot.counts.pending} pending | ${snapshot.counts.in_progress} active | ${snapshot.counts.completed} done | ${snapshot.counts.failed} failed | ${snapshot.counts.total} total`,
+    "",
+    "## Projects",
+    ...snapshot.projects.map((project) => `- ${lineId(project.id)} ${project.name} (${project.open_tasks} open) ${project.path}`),
+    "",
+    "## Tasks",
+    ...snapshot.tasks.map((task2) => `- ${lineId(task2.id)} [${task2.status}] ${task2.priority} ${task2.title}`),
+    "",
+    "## Plans",
+    ...snapshot.plans.map((plan) => `- ${lineId(plan.id)} [${plan.status}] ${plan.name} (${plan.open_tasks} open)`),
+    "",
+    "## Runs",
+    ...snapshot.runs.map((run) => `- ${lineId(run.id)} [${run.status}] ${run.title || run.task_id}`),
+    "",
+    "## Dependencies",
+    ...snapshot.dependencies.map((dep) => `- ${lineId(dep.task_id)} waits on ${lineId(dep.depends_on)} [${dep.depends_on_status}]${dep.blocking ? " blocking" : ""}`),
+    "",
+    "## Inbox",
+    ...snapshot.inbox.map((item) => `- ${lineId(item.id)} [${item.status}] ${item.title}`),
+    "",
+    "## Search",
+    snapshot.search.query ? `Query: ${snapshot.search.query}` : "Query: (none)",
+    ...snapshot.search.results.map((task2) => `- ${lineId(task2.id)} [${task2.status}] ${task2.title}`),
+    ""
+  ];
+  return lines.join(`
+`);
+}
 export {
   writeSdkIntegrationFixtures,
   writeOnboardingFixtureFiles,
+  writeLocalBackupFile,
   writeEnvironmentSnapshot,
   writeBuiltinTemplateFiles,
   watchSourceTodos,
   verifyTaskRunArtifacts,
   verifyStoredArtifact,
+  verifyLocalBackup,
   verifyLocalAuditLedger,
   verifyExtensionSignature,
   verifyApiKey,
@@ -27043,6 +29547,7 @@ export {
   simulateAgentReplayFile,
   simulateAgentReplay,
   shouldRegisterToolForProfile,
+  setTaskWorkflowState,
   setTaskStatus,
   setTaskPriority,
   setTaskLocalFields,
@@ -27069,6 +29574,8 @@ export {
   returnReviewItem,
   retryAgentRunDispatch,
   resumeFocusSession,
+  restoreLocalBackup,
+  resolveWorkflowState,
   resolveVariables,
   resolveTaskRunId,
   resolvePartialId,
@@ -27079,20 +29586,26 @@ export {
   requestReviewQueue,
   requestApprovalGate,
   reopenReviewItem,
+  renderWorkflowStatesMarkdown,
   renderWorkflowPromptMarkdown,
   renderWorkflowPrompt,
+  renderTuiDashboardSnapshot,
   renderTerminalNotification,
   renderTaskBoard,
+  renderScalePerformanceReportMarkdown,
   renderRoadmapMarkdown,
   renderRiskRegisterMarkdown,
   renderRetrospectiveMarkdown,
   renderReleaseNotesMarkdown,
   renderReleaseCompatibilityMarkdown,
   renderPlanningForecastMarkdown,
+  renderLocalUsageLedgerMarkdown,
   renderLocalSnapshotMarkdown,
+  renderLocalReportMarkdown,
   renderLocalAuditLedgerMarkdown,
   renderKnowledgeExportMarkdown,
   renderExtensionSummary,
+  renderCliManualMarkdown,
   renderAgentReplaySimulationMarkdown,
   renderAgentReliabilityMarkdown,
   renderAgentContextPackMarkdown,
@@ -27128,8 +29641,10 @@ export {
   redactEvidenceText,
   recordTaskReview,
   recordEnvironmentSnapshot,
+  readLocalBackupFile,
   readEnvironmentSnapshot,
   queueAgentRun,
+  queryTasksByWorkflowState,
   queryTasksByLocalFields,
   previewTemplate,
   previewRetentionCleanup,
@@ -27148,6 +29663,7 @@ export {
   nextOccurrence,
   moveTask,
   moveBoardCard,
+  migrateWorkflowStates,
   mergeDuplicateTask,
   matchCapabilities,
   logTrace,
@@ -27158,6 +29674,7 @@ export {
   lockTask,
   loadConfig,
   listWorkspaceTrustProfiles,
+  listWorkflowStates,
   listWorkflowPrompts,
   listWebhooks,
   listVerificationProviders,
@@ -27191,6 +29708,7 @@ export {
   listMachines,
   listMachineLocalPaths,
   listLocalSnapshotResources,
+  listLocalReportTypes,
   listLocalExtensions,
   listLocalEventHooks,
   listLocalAuditLedgerCheckpoints,
@@ -27247,6 +29765,7 @@ export {
   getTemplateTasks,
   getTemplate,
   getTasksChangedSince,
+  getTaskWorkflowState,
   getTaskWithRelations,
   getTaskTraces,
   getTaskStats,
@@ -27345,6 +29864,7 @@ export {
   getActiveModel,
   generateReleaseNotes,
   generateCycles,
+  generateCompletionScript,
   gatherTrainingData,
   formatTmuxTarget,
   formatSingleTask,
@@ -27386,6 +29906,7 @@ export {
   dispatchToMultiple,
   discoverVerificationProviderCapabilities,
   discoverProjectWorkspace,
+  discoverLocalExtensions,
   detectInboxSourceType,
   describeTerminalNotificationRule,
   deriveInboxTitle,
@@ -27411,6 +29932,7 @@ export {
   decryptBridgeBundle,
   decomposeTasks,
   createWebhook,
+  createTuiDashboardSnapshot,
   createTodosRegistry,
   createTemplate,
   createTaskList,
@@ -27419,6 +29941,7 @@ export {
   createSessionRecoveryHandoff,
   createSession,
   createSdkIntegrationFixturePack,
+  createScalePerformanceReport,
   createRoadmap,
   createRiskRegisterExport,
   createRisk,
@@ -27430,8 +29953,11 @@ export {
   createOrg,
   createMilestone,
   createMcpManifest,
+  createLocalUsageLedger,
   createLocalSqliteTodosStorageAdapter,
+  createLocalReport,
   createLocalBridgeBundle,
+  createLocalBackup,
   createKnowledgeSnapshot,
   createKnowledgeRecord,
   createKnowledgeExportReport,
@@ -27445,6 +29971,7 @@ export {
   createContractsManifest,
   createClient,
   createCliMcpParityManifest,
+  createCliManual,
   createCapabilityManifest,
   createCalendarItem,
   createBranchWorkPlan,
@@ -27455,6 +29982,8 @@ export {
   completeTask,
   compareEnvironmentSnapshots,
   compareEnvironmentSnapshotFiles,
+  compactScaleStorage,
+  collectCliCommandEntries,
   closeRisk,
   closeDatabase,
   cloneTask,
@@ -27469,6 +29998,7 @@ export {
   checkRunnerSandbox,
   checkLock,
   checkLocalNotifications,
+  checkLocalIntegrity,
   checkCompletionGuard,
   checkChecklistItem,
   checkBudget,
@@ -27512,6 +30042,7 @@ export {
   TodosClient,
   TaskNotFoundError,
   TaskListNotFoundError,
+  TUI_DASHBOARD_VIEWS,
   TODOS_SDK_INTEGRATION_FIXTURE_SCHEMA_VERSION,
   TODOS_SDK_INTEGRATION_FIXTURE_GENERATED_AT,
   TODOS_REGISTRY,
@@ -27522,8 +30053,12 @@ export {
   TODOS_MARKDOWN_SCHEMA,
   TODOS_MARKDOWN_BRIDGE_MARKER,
   TODOS_LOCAL_SNAPSHOT_SCHEMA_VERSION,
+  TODOS_LOCAL_INTEGRITY_SCHEMA_VERSION,
+  TODOS_LOCAL_INTEGRITY_KIND,
   TODOS_LOCAL_BRIDGE_SCHEMA_VERSION,
   TODOS_LOCAL_BRIDGE_KIND,
+  TODOS_LOCAL_BACKUP_SCHEMA_VERSION,
+  TODOS_LOCAL_BACKUP_KIND,
   TODOS_JSON_CONTRACTS_MANIFEST,
   TODOS_JSON_CONTRACTS,
   TODOS_ERROR_CODES,
@@ -27545,11 +30080,15 @@ export {
   MCP_TOOL_GROUPS,
   MCP_PROFILE_GROUPS,
   LockError,
+  LOCAL_USAGE_LEDGER_SCHEMA_VERSION,
   LOCAL_ROADMAP_SCHEMA_VERSION,
+  LOCAL_REPORT_TYPES,
+  LOCAL_REPORT_SCHEMA_VERSION,
   LOCAL_RELEASE_COMPATIBILITY_SCHEMA_VERSION,
   LOCAL_NOTIFICATION_SCHEMA_VERSION,
   LOCAL_EVENT_TYPES,
   LOCAL_CAPACITY_SCHEMA_VERSION,
+  LOCAL_BACKUP_CHECKSUM_ALGORITHM,
   LOCAL_AUDIT_LEDGER_SCHEMA_VERSION,
   LOCAL_AUDIT_LEDGER_HASH_ALGORITHM,
   EXTRACT_TAGS,
@@ -27564,6 +30103,7 @@ export {
   DEFAULT_ENCRYPTION_KEY_ENV,
   CompletionGuardError,
   CORE_MCP_TOOLS,
+  COMPLETION_SHELLS,
   BUILTIN_TEMPLATE_LIBRARY_VERSION,
   BUILTIN_TEMPLATE_LIBRARY_SOURCE,
   BUILTIN_TEMPLATES,