agendex-cli 0.13.0 → 0.14.0

package/dist/cli.js

@@ -2256,6 +2256,16 @@ async function promptForAdapterSelection(options = {}) {
 
 // ../shared/src/config.ts
 var devModeOverride;
+function getHomeDir() {
+  if (process.env.HOME)
+    return process.env.HOME;
+  if (process.env.USERPROFILE)
+    return process.env.USERPROFILE;
+  if (process.env.HOMEDRIVE && process.env.HOMEPATH) {
+    return `${process.env.HOMEDRIVE}${process.env.HOMEPATH}`;
+  }
+  return homedir7();
+}
 function setDevMode(dev) {
   devModeOverride = dev;
 }
@@ -2265,7 +2275,7 @@ function isDevMode() {
   return process.env.AGENDEX_DEV === "1";
 }
 function getConfigDir() {
-  return join7(homedir7(), isDevMode() ? ".agendex-dev" : ".agendex");
+  return join7(getHomeDir(), isDevMode() ? ".agendex-dev" : ".agendex");
 }
 function ensureConfigDir() {
   const dir = getConfigDir();
@@ -2292,7 +2302,7 @@ function normalizeAdapterIds(input) {
 }
 function expandHomePath(p) {
   if (p.startsWith("~/") || p === "~")
-    return join7(homedir7(), p.slice(1));
+    return join7(getHomeDir(), p.slice(1));
   return p;
 }
 function resolveCustomPlanDirPath(userPath) {
@@ -2440,8 +2450,335 @@ var CLI_DAEMON_STALE_AFTER_MS = CLI_DAEMON_HEARTBEAT_INTERVAL_MS * 5;
 // ../shared/src/services/plan-service.ts
 import { existsSync as existsSync4, readdirSync as readdirSync3, statSync } from "node:fs";
 import { lstat, mkdir, readdir as readdir2, readFile as readFile6, stat as stat6, writeFile as writeFile3 } from "node:fs/promises";
-import { homedir as homedir8 } from "node:os";
 import { join as join8, resolve as resolve3, sep as sep2 } from "node:path";
+
+// ../shared/src/services/plan-value.ts
+function isLowValuePlan(plan) {
+  const metadata = plan.metadata;
+  return typeof metadata === "object" && metadata !== null && !Array.isArray(metadata) && metadata.lowValue === true;
+}
+function isIndexablePlan(plan) {
+  return !isLowValuePlan(plan);
+}
+var PROPOSED_PLAN_TAG_REGEX2 = /<\s*\/?\s*proposed_plan\s*>/gi;
+var ESCAPED_PROPOSED_PLAN_TAG_REGEX2 = /&lt;\s*\/?\s*proposed_plan\s*&gt;/gi;
+var VISIBLE_TEXT_REGEX = /[\p{L}\p{N}]/u;
+var LOW_VALUE_METADATA_KEYS = ["lowValue", "lowValueReasons", "lowValueSignals"];
+function normalizeLineEndings2(text) {
+  return text.replace(/\r\n?/g, `
+`);
+}
+function stripBoundaryHtmlComments(text) {
+  let next = text;
+  let previous = "";
+  while (next !== previous) {
+    previous = next;
+    next = next.replace(/^\s*<!--[\s\S]*?-->\s*/, "").replace(/\s*<!--[\s\S]*?-->\s*$/, "");
+  }
+  return next;
+}
+function normalizePlanContent(content) {
+  return stripBoundaryHtmlComments(normalizeLineEndings2(content).replace(/^\uFEFF/, "").replace(/^---\s*\n[\s\S]*?\n---\s*\n?/, "").replace(ESCAPED_PROPOSED_PLAN_TAG_REGEX2, "").replace(PROPOSED_PLAN_TAG_REGEX2, "")).trim();
+}
+function withoutLowValueMetadata(metadata) {
+  const next = { ...metadata ?? {} };
+  for (const key of LOW_VALUE_METADATA_KEYS)
+    delete next[key];
+  return next;
+}
+function unique(items) {
+  return Array.from(new Set(items));
+}
+function visibleText(text) {
+  return text.replace(/<!--[\s\S]*?-->/g, "").replace(/^---\s*\n[\s\S]*?\n---\s*\n?/, "").replace(ESCAPED_PROPOSED_PLAN_TAG_REGEX2, "").replace(PROPOSED_PLAN_TAG_REGEX2, "").replace(/[`*_#[\](){}<>:|~\-+=.]/g, " ").trim();
+}
+function isSeparatorLine(line) {
+  return /^(?:-{3,}|_{3,}|\*{3,})$/.test(line.trim());
+}
+function isFenceLine(line) {
+  return /^(?:`{3,}|~{3,})/.test(line.trim());
+}
+function meaningfulLines(text) {
+  return text.split(`
+`).map((line) => line.trim()).filter((line) => line && !isSeparatorLine(line) && !isFenceLine(line));
+}
+function cleanMarkdownLine(line) {
+  return line.trim().replace(/^>+\s*/, "").replace(/^#{1,6}\s+/, "").replace(/^[-*+]\s+/, "").replace(/^\d+[.)]\s+/, "").replace(/^\[[ xX]\]\s+/, "").replace(/^\*\*|\*\*$/g, "").replace(/^`|`$/g, "").trim();
+}
+function isHeadingLine(line) {
+  return /^#{1,6}\s+\S/.test(line.trim());
+}
+function isChecklistLine(line) {
+  return /^[-*+]\s+\[[ xX]\]\s+\S/.test(line.trim());
+}
+function isOrderedListLine(line) {
+  return /^\d+[.)]\s+\S/.test(line.trim());
+}
+function isHeadingOnly(lines) {
+  return lines.length > 0 && lines.some(isHeadingLine) && lines.every(isHeadingLine);
+}
+function metadataHasPlanBlocks(metadata) {
+  const planBlocks = metadata?.planBlocks;
+  return typeof planBlocks === "number" && planBlocks > 0;
+}
+function sectionName(line) {
+  return cleanMarkdownLine(line).replace(/:$/, "").toLowerCase().replace(/\s+/g, " ");
+}
+var SECTION_LABELS = new Set([
+  "context",
+  "background",
+  "problem",
+  "goal",
+  "goals",
+  "scope",
+  "approach",
+  "strategy",
+  "design",
+  "implementation plan",
+  "implementation",
+  "plan",
+  "files to modify",
+  "files changed",
+  "affected files",
+  "steps",
+  "step",
+  "tasks",
+  "task",
+  "checklist",
+  "todo",
+  "todos",
+  "verification",
+  "testing",
+  "tests",
+  "test",
+  "validation",
+  "reuse",
+  "existing utilities",
+  "existing code",
+  "acceptance criteria",
+  "success criteria"
+]);
+function hasSectionSyntax(line, section) {
+  const cleaned = cleanMarkdownLine(line);
+  return isHeadingLine(line) || /^[a-z][\w\s/&+-]{1,48}:/i.test(cleaned) || SECTION_LABELS.has(section);
+}
+function collectPositiveSignals(normalized, lines, metadata) {
+  const signals = [];
+  if (metadataHasPlanBlocks(metadata))
+    signals.push("metadata:proposed-plan-block");
+  for (const line of lines) {
+    const section = sectionName(line);
+    if (!hasSectionSyntax(line, section))
+      continue;
+    if (/^(context|background|problem|goal|goals|scope)\b/.test(section)) {
+      signals.push("section:context");
+      continue;
+    }
+    if (/^(approach|strategy|design)\b/.test(section)) {
+      signals.push("section:approach");
+      continue;
+    }
+    if (/^(implementation plan|implementation|plan)\b/.test(section)) {
+      signals.push("section:implementation-plan");
+      continue;
+    }
+    if (/^(files? to modify|files? changed|affected files?)\b/.test(section)) {
+      signals.push("section:files-to-modify");
+      continue;
+    }
+    if (/^(steps?|tasks?|checklist|todo|todos)\b/.test(section)) {
+      signals.push("section:steps");
+      continue;
+    }
+    if (/^(verification|testing|tests?|validation)\b/.test(section)) {
+      signals.push("section:verification");
+      continue;
+    }
+    if (/^(reuse|existing utilities|existing code)\b/.test(section)) {
+      signals.push("section:reuse");
+      continue;
+    }
+    if (/^(acceptance criteria|success criteria)\b/.test(section)) {
+      signals.push("section:acceptance-criteria");
+    }
+  }
+  if (lines.some(isChecklistLine))
+    signals.push("checklist");
+  const orderedStepCount = lines.filter(isOrderedListLine).length;
+  if (orderedStepCount >= 2)
+    signals.push("ordered-steps");
+  const actionBulletCount = lines.filter((line) => {
+    const trimmed = line.trim();
+    if (!/^(?:[-*+]|\d+[.)])\s+/.test(trimmed))
+      return false;
+    const cleaned = cleanMarkdownLine(trimmed);
+    return /^(?:add|implement|update|modify|create|remove|delete|refactor|test|verify|run|wire|persist|handle|ensure|document|rename|move|extract|reuse|validate)\b/i.test(cleaned);
+  }).length;
+  if (actionBulletCount >= 2)
+    signals.push("action-bullets");
+  if (lines.length >= 2 && /\b(?:will|should|need to|needs to|plan to|planned|approach is to|implementation will)\b/i.test(normalized)) {
+    signals.push("future-plan-language");
+  }
+  return unique(signals);
+}
+function isStrongPositiveSignal(signal) {
+  return signal === "metadata:proposed-plan-block" || signal === "checklist" || signal === "ordered-steps" || signal === "action-bullets" || signal === "section:approach" || signal === "section:implementation-plan" || signal === "section:files-to-modify" || signal === "section:steps" || signal === "section:acceptance-criteria";
+}
+function hasStrongPlanSignal(positiveSignals) {
+  const sectionCount = positiveSignals.filter((signal) => signal.startsWith("section:")).length;
+  return positiveSignals.some(isStrongPositiveSignal) || sectionCount >= 2;
+}
+function isPromptLikeOneLiner(line) {
+  if (isHeadingLine(line) || isChecklistLine(line) || isOrderedListLine(line))
+    return false;
+  const cleaned = cleanMarkdownLine(line).toLowerCase();
+  if (!cleaned)
+    return false;
+  return [
+    /^(?:important:\s*)?work in\b/,
+    /^(?:please|pls)\b/,
+    /^(?:can|could|would|will)\s+you\b/,
+    /^(?:i|we)\s+(?:need|want|would like|have to)\b/,
+    /^(?:help|fix|implement|create|add|update|remove|delete|refactor|write|review|investigate|debug|plan)\b/,
+    /\?$/,
+    /\b(?:repository|repo|existing branch|worktree|pull request|pr)\b/
+  ].some((pattern) => pattern.test(cleaned));
+}
+function normalizedTitle(title) {
+  return cleanMarkdownLine(title ?? "").toLowerCase();
+}
+function looksLikeWrapperTitle(title) {
+  return /^<user_(?:action|instructions|prompt)>$/i.test((title ?? "").trim());
+}
+function looksLikePromptTitle(title) {
+  const cleaned = normalizedTitle(title);
+  if (!cleaned)
+    return false;
+  return [
+    /^(?:important:\s*)?work in\b/,
+    /^review the code changes against\b/,
+    /^perform a .*review\b/,
+    /^(?:please|pls)\b/,
+    /^(?:can|could|would|will)\s+you\b/,
+    /^(?:i|we)\s+(?:need|want|would like|have to)\b/,
+    /^(?:help|fix|implement|create|add|update|remove|delete|refactor|write|review|investigate|debug|plan)\b/,
+    /\?$/,
+    /\b(?:repository|repo|existing branch|worktree|pull request|pr)\b/
+  ].some((pattern) => pattern.test(cleaned));
+}
+function looksLikeReviewOutput(normalized, title) {
+  const cleanedTitle = normalizedTitle(title);
+  const lower = normalized.toLowerCase();
+  return /^review the code changes against\b/.test(cleanedTitle) || /^perform a .*review\b/.test(cleanedTitle) || /"findings"\s*:\s*\[/.test(normalized) || /"overall_correctness"\s*:/.test(normalized) || /\bfull review comments\s*:/i.test(normalized) || /\bthe patch (?:currently )?(?:breaks|introduces|regresses)\b/i.test(normalized) || /\bshould not be considered correct\b/i.test(lower);
+}
+function looksLikeSystemContext(normalized, lines) {
+  const lower = normalized.toLowerCase();
+  if (lower.startsWith("# agents.md instructions") || lower.startsWith("<environment_context>") || lower.startsWith("<system-reminder>") || lower.startsWith("<thinking>")) {
+    return true;
+  }
+  const wrapperMatches = normalized.match(/<\/?(?:environment_context|system-reminder|thinking|analysis|reasoning|tool_call|tool_result)\b[^>]*>/gi);
+  if (wrapperMatches && wrapperMatches.length >= 2)
+    return true;
+  const wrapperLineCount = lines.filter((line) => /^(?:analysis|reasoning|thought|assistant thought|system|developer):\b/i.test(line)).length;
+  return wrapperLineCount > 0 && wrapperLineCount / Math.max(lines.length, 1) >= 0.4;
+}
+function looksLikeToolLog(normalized) {
+  return /::[a-z0-9_-]+(?:\{|\[|\s*$)/i.test(normalized) || /<\/?(?:tool_call|tool_result)\b[^>]*>/i.test(normalized) || /\b(?:function_call|tool_calls|tool_result)\b/i.test(normalized);
+}
+function looksLikeExecutionReport(normalized) {
+  const hasPastCompletion = /\b(?:fixed|pushed|committed|completed|done|implemented|updated|changed|patched|merged|deployed|passed|failed|resolved|reverted)\b/i.test(normalized);
+  const hasReportSection = /^\s*(?:summary|result|results|changes|verification|status)\s*:/im.test(normalized);
+  const hasReviewReportMarker = /\b(?:review findings?|review issues?|review comments?)\b/i.test(normalized);
+  const hasCommandMarker = /::[a-z0-9_-]+(?:\{|\[|\s*$)/im.test(normalized) || /`[^`]*(?:bun|npm|pnpm|yarn|git|tsc|biome)[^`]*`/i.test(normalized) || /\b(?:git\s+(?:stage|commit|push|status)|bunx?\s+|npm\s+|pnpm\s+|yarn\s+)\b/i.test(normalized);
+  return hasPastCompletion && (hasReportSection || hasCommandMarker || hasReviewReportMarker);
+}
+function lowValueAssessment(reasons, signals) {
+  return {
+    lowValue: reasons.length > 0,
+    reasons: unique(reasons),
+    signals: unique(signals).slice(0, 20)
+  };
+}
+function assessPlanValue(input) {
+  const metadata = withoutLowValueMetadata(input.metadata);
+  const normalized = normalizePlanContent(input.content);
+  const lines = meaningfulLines(normalized);
+  const positiveSignals = collectPositiveSignals(normalized, lines, metadata);
+  const signals = [...positiveSignals];
+  const reasons = [];
+  if (!VISIBLE_TEXT_REGEX.test(visibleText(normalized))) {
+    return lowValueAssessment(["empty-content"], ["negative:empty-content"]);
+  }
+  if (isHeadingOnly(lines)) {
+    return lowValueAssessment(["heading-only"], [...signals, "negative:heading-only"]);
+  }
+  const explicitPlanBlock = metadataHasPlanBlocks(metadata);
+  const strongPositive = hasStrongPlanSignal(positiveSignals);
+  const systemContext = looksLikeSystemContext(normalized, lines);
+  const toolLog = looksLikeToolLog(normalized);
+  const executionReport = looksLikeExecutionReport(normalized);
+  const wrapperTitle = looksLikeWrapperTitle(input.title);
+  const promptTitle = looksLikePromptTitle(input.title);
+  const reviewOutput = looksLikeReviewOutput(normalized, input.title);
+  if (systemContext)
+    signals.push("negative:system-context");
+  if (toolLog)
+    signals.push("negative:tool-log");
+  if (executionReport)
+    signals.push("negative:execution-report");
+  if (wrapperTitle)
+    signals.push("negative:wrapper-title");
+  if (promptTitle)
+    signals.push("negative:prompt-title");
+  if (reviewOutput)
+    signals.push("negative:review-output");
+  if (lines.length === 1)
+    signals.push("shape:single-line");
+  if (lines.length === 1 && positiveSignals.length === 0) {
+    reasons.push(isPromptLikeOneLiner(lines[0] ?? "") ? "prompt-like" : "no-plan-signals");
+  }
+  if (systemContext && !strongPositive)
+    reasons.push("system-context");
+  if (executionReport && !strongPositive)
+    reasons.push("execution-report");
+  if (wrapperTitle && !explicitPlanBlock)
+    reasons.push("wrapper-title");
+  if (reviewOutput && !explicitPlanBlock)
+    reasons.push("review-output");
+  if (promptTitle && !strongPositive && positiveSignals.length === 0)
+    reasons.push("prompt-like");
+  if (toolLog && !strongPositive && positiveSignals.length === 0)
+    reasons.push("no-plan-signals");
+  if (reasons.length === 0 && positiveSignals.length === 0 && lines.length <= 3) {
+    reasons.push("no-plan-signals");
+  }
+  return lowValueAssessment(reasons, signals);
+}
+function annotatePlanValueMetadata(plan) {
+  const baseMetadata = withoutLowValueMetadata(plan.metadata);
+  const assessment = assessPlanValue({
+    content: plan.content,
+    title: plan.title,
+    metadata: baseMetadata
+  });
+  if (!assessment.lowValue) {
+    return {
+      ...plan,
+      metadata: baseMetadata
+    };
+  }
+  return {
+    ...plan,
+    metadata: {
+      ...baseMetadata,
+      lowValue: true,
+      lowValueReasons: assessment.reasons,
+      lowValueSignals: assessment.signals
+    }
+  };
+}
+
+// ../shared/src/services/plan-service.ts
 function getUserPlansDir() {
   return join8(getConfigDir(), "plans");
 }
@@ -2482,7 +2819,7 @@ var SKIP_DIRS = new Set([
   "iCloud Drive"
 ]);
 function discoverProjectPlanDirs() {
-  const home2 = homedir8();
+  const home2 = getHomeDir();
   const results = [];
   function walk(dir, depth) {
     if (depth > DISCOVERY_MAX_DEPTH)
@@ -2663,7 +3000,8 @@ async function scan() {
           continue;
         const plans = await adapter.parse(file);
         for (const plan of plans) {
-          next.set(plan.id, plan);
+          const annotated = annotatePlanValueMetadata(plan);
+          next.set(annotated.id, annotated);
         }
       }
     }
@@ -2682,7 +3020,8 @@ async function scan() {
         continue;
       const plans = await adapter.parse(file);
       for (const plan of plans) {
-        next.set(plan.id, plan);
+        const annotated = annotatePlanValueMetadata(plan);
+        next.set(annotated.id, annotated);
       }
     }
     coveredPaths.add(resolvedDir);
@@ -2692,11 +3031,17 @@ async function scan() {
   await scanCustomPlanDirs(coveredPaths, next);
   store = next;
   notifyPlansChanged();
-  console.log(`[agendex] indexed ${store.size} plans from ${adapters.length} adapters`);
+  const indexableCount = getIndexablePlans().length;
+  const hiddenCount = store.size - indexableCount;
+  const hiddenSuffix = hiddenCount > 0 ? ` (${hiddenCount} hidden as low-value)` : "";
+  console.log(`[agendex] indexed ${indexableCount} plans${hiddenSuffix} from ${adapters.length} adapters`);
 }
 function getAll() {
   return Array.from(store.values());
 }
+function getIndexablePlans() {
+  return getAll().filter(isIndexablePlan);
+}
 async function rescanFile(filePath) {
   const adapters = getActiveAdapters();
   const normalized = resolve3(filePath);
@@ -2711,7 +3056,7 @@ async function rescanFile(filePath) {
     const isInSearchPath = allSearchPaths.some((sp) => normalized.startsWith(sp + sep2) || normalized === sp);
     if (!isInSearchPath)
       continue;
-    const plans = await adapter.parse(filePath);
+    const plans = (await adapter.parse(filePath)).map(annotatePlanValueMetadata);
     for (const plan of plans) {
       store.set(plan.id, plan);
     }
@@ -2909,6 +3254,22 @@ function getCloudConfig() {
     convexUrl: config.convexUrl
   };
 }
+function parseSyncSuccess(body) {
+  try {
+    const parsed = JSON.parse(body);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return { ok: true };
+    }
+    const result = parsed;
+    return {
+      ok: true,
+      skippedLowValue: result.skippedLowValue === true,
+      deleted: result.deleted === true
+    };
+  } catch {
+    return { ok: true };
+  }
+}
 async function syncPlan(plan) {
   const { token, convexUrl } = getCloudConfig();
   const url = `${convexUrl}/api/cli/sync`;
@@ -2940,7 +3301,7 @@ async function syncPlan(plan) {
   if (res.status < 200 || res.status >= 300) {
     return { ok: false, error: `${res.status}: ${res.body}` };
   }
-  return { ok: true };
+  return parseSyncSuccess(res.body);
 }
 async function refreshStoredToken(currentToken, convexUrl) {
   const refreshed = await refreshToken(currentToken, convexUrl);
@@ -2995,7 +3356,6 @@ async function sendHeartbeat() {
 }
 async function sendShutdown() {
   try {
-    const { token, convexUrl } = getCloudConfig();
     cachedDeviceId ??= loadOrCreateDeviceId();
     await deleteDaemons([cachedDeviceId]);
   } catch {}
@@ -3413,6 +3773,8 @@ async function runWorker() {
     syncing = true;
     const batch = syncQueue.splice(0);
     let syncedCount = 0;
+    let lowValueSkippedCount = 0;
+    let lowValueDeletedCount = 0;
     let failedCount = 0;
     try {
       for (const payload of batch) {
@@ -3433,19 +3795,26 @@ async function runWorker() {
           failedCount++;
           console.error(`[agendex] sync failed for "${payload.title}": ${result.error}`);
         } else {
-          syncedCount++;
+          if (result.skippedLowValue) {
+            lowValueSkippedCount++;
+            if (result.deleted)
+              lowValueDeletedCount++;
+          } else {
+            syncedCount++;
+          }
           syncCache[payload.localPlanId] = computePayloadHash(payload);
         }
       }
     } catch (err) {
       console.error("[agendex] sync error:", err);
-      syncQueue.unshift(...batch.slice(syncedCount + failedCount));
+      syncQueue.unshift(...batch.slice(syncedCount + lowValueSkippedCount + failedCount));
     } finally {
       syncing = false;
     }
-    if (syncedCount > 0 || failedCount > 0) {
+    if (syncedCount > 0 || lowValueSkippedCount > 0 || failedCount > 0) {
       saveSyncCache(syncCache);
-      console.log(`[agendex] sync complete: ${syncedCount} synced, ${failedCount} failed`);
+      const lowValueSuffix2 = lowValueSkippedCount > 0 ? `, ${lowValueSkippedCount} low-value skipped/pruned${lowValueDeletedCount > 0 ? ` (${lowValueDeletedCount} deleted)` : ""}` : "";
+      console.log(`[agendex] sync complete: ${syncedCount} synced${lowValueSuffix2}, ${failedCount} failed`);
     }
     if (syncQueue.length > 0)
       processSyncQueue();
@@ -3454,7 +3823,11 @@ async function runWorker() {
   console.log(`[agendex] initial scan...`);
   await scan();
   const plans = getAll();
+  const syncablePlanCount = plans.filter(isIndexablePlan).length;
+  const lowValuePlanCount = plans.length - syncablePlanCount;
   let initialSkipped = 0;
+  let initialQueuedSyncable = 0;
+  let initialQueuedLowValue = 0;
   for (const plan of plans) {
     const payload = planToPayload(plan);
     const hash = computePayloadHash(payload);
@@ -3462,6 +3835,11 @@ async function runWorker() {
       initialSkipped++;
       continue;
     }
+    if (isLowValuePlan(plan)) {
+      initialQueuedLowValue++;
+    } else {
+      initialQueuedSyncable++;
+    }
     syncQueue.push(payload);
   }
   const activePlanIds = new Set(plans.map((plan) => plan.id));
@@ -3470,7 +3848,8 @@ async function runWorker() {
       delete syncCache[id];
   }
   saveSyncCache(syncCache, { replace: true });
-  console.log(`[agendex] syncing ${syncQueue.length} plans (${initialSkipped} unchanged)...`);
+  const lowValueSuffix = lowValuePlanCount > 0 ? `, ${lowValuePlanCount} low-value hidden/pruned` : "";
+  console.log(`[agendex] syncing ${initialQueuedSyncable} plans${lowValueSuffix} (${initialQueuedLowValue} low-value queued, ${initialSkipped} unchanged)...`);
   await processSyncQueue();
   setInterval(() => void sendHeartbeat(), CLI_DAEMON_HEARTBEAT_INTERVAL_MS);
   startWatching((changedPlans) => {
@@ -3538,33 +3917,41 @@ async function startSupervisor() {
 }
 
 // src/sync.ts
+function planToPayload2(plan) {
+  return {
+    localPlanId: plan.id,
+    agent: plan.agent,
+    title: plan.title,
+    content: plan.content,
+    format: plan.format,
+    filePath: plan.filePath,
+    workspace: plan.workspace,
+    metadata: plan.metadata,
+    createdAt: plan.createdAt.getTime(),
+    updatedAt: plan.updatedAt.getTime()
+  };
+}
 async function syncAll(force = false) {
   const config = await loadOrInitConfig();
   const adapters = resolveAdapters(config.enabledAdapters);
   setActiveAdapters(adapters);
   console.log(`[agendex] Scanning local plans...`);
   await scan();
-  const plans = getAll();
-  console.log(`[agendex] Found ${plans.length} plans. Syncing to cloud...`);
+  const allPlans = getAll();
+  const syncablePlans = allPlans.filter(isIndexablePlan);
+  const lowValuePlans = allPlans.filter(isLowValuePlan);
+  const hiddenSuffix = lowValuePlans.length > 0 ? ` (${lowValuePlans.length} low-value hidden/pruned)` : "";
+  console.log(`[agendex] Found ${syncablePlans.length} syncable plans${hiddenSuffix}. Syncing to cloud...`);
   const cache = force ? {} : loadSyncCache();
   const activePlanIds = new Set;
   let synced = 0;
+  let lowValueSkipped = 0;
+  let lowValueDeleted = 0;
   let skipped = 0;
   let failed = 0;
-  for (const plan of plans) {
+  for (const plan of [...syncablePlans, ...lowValuePlans]) {
     activePlanIds.add(plan.id);
-    const payload = {
-      localPlanId: plan.id,
-      agent: plan.agent,
-      title: plan.title,
-      content: plan.content,
-      format: plan.format,
-      filePath: plan.filePath,
-      workspace: plan.workspace,
-      metadata: plan.metadata,
-      createdAt: plan.createdAt.getTime(),
-      updatedAt: plan.updatedAt.getTime()
-    };
+    const payload = planToPayload2(plan);
     const hash = computePayloadHash(payload);
     if (!force && cache[plan.id] === hash) {
       skipped++;
@@ -3572,7 +3959,13 @@ async function syncAll(force = false) {
     }
     const result = await syncPlan(payload);
     if (result.ok) {
-      synced++;
+      if (result.skippedLowValue) {
+        lowValueSkipped++;
+        if (result.deleted)
+          lowValueDeleted++;
+      } else {
+        synced++;
+      }
       cache[plan.id] = hash;
     } else {
       failed++;
@@ -3584,7 +3977,8 @@ async function syncAll(force = false) {
       delete cache[id];
   }
   saveSyncCache(cache, { replace: true });
-  console.log(`[agendex] Sync complete: ${synced} synced, ${skipped} unchanged, ${failed} failed`);
+  const lowValueSuffix = lowValueSkipped > 0 ? `, ${lowValueSkipped} low-value skipped/pruned${lowValueDeleted > 0 ? ` (${lowValueDeleted} deleted)` : ""}` : "";
+  console.log(`[agendex] Sync complete: ${synced} synced${lowValueSuffix}, ${skipped} unchanged, ${failed} failed`);
 }
 
 // src/version.ts
@@ -3594,7 +3988,7 @@ import { join as join12 } from "node:path";
 // package.json
 var package_default = {
   name: "agendex-cli",
-  version: "0.13.0",
+  version: "0.14.0",
   description: "Agendex CLI for login, sync, and daemon workflows",
   homepage: "https://github.com/Tyru5/Agendex#readme",
   repository: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agendex-cli",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Agendex CLI for login, sync, and daemon workflows",
   "homepage": "https://github.com/Tyru5/Agendex#readme",
   "repository": {