skillwiki 0.6.2-beta.1 → 0.8.0

package/dist/cli.js

@@ -8,7 +8,7 @@ import {
 } from "./chunk-TPS5XD2J.js";
 
 // src/cli.ts
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 import { join as join41 } from "path";
 import { Command as Command2 } from "commander";
 
@@ -2364,7 +2364,7 @@ Chronological action log. Newest entries last. Skill writes append entries; lint
 
 // src/commands/lint.ts
 import { existsSync as existsSync3 } from "fs";
-import { readFile as readFile15 } from "fs/promises";
+import { readFile as readFile15, rename as rename5 } from "fs/promises";
 import { join as join19 } from "path";
 
 // src/commands/topic-map-check.ts
@@ -2607,6 +2607,60 @@ async function runRawBodyDedup(vault) {
   };
 }
 
+// src/commands/path-too-long.ts
+var MAX_PATH_LENGTH = 240;
+async function runPathTooLong(input) {
+  const scan = await scanVault(input.vault);
+  if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
+  const allPages = [...scan.data.typedKnowledge, ...scan.data.raw, ...scan.data.workItems, ...scan.data.compound];
+  const violations = [];
+  for (const page of allPages) {
+    if (page.relPath.length > MAX_PATH_LENGTH) {
+      violations.push({ relPath: page.relPath, length: page.relPath.length });
+    }
+  }
+  if (violations.length > 0) {
+    return {
+      exitCode: ExitCode.LINT_HAS_ERRORS,
+      result: ok({
+        violations,
+        humanHint: violations.map((v) => `${v.relPath}: ${v.length} chars (max ${MAX_PATH_LENGTH})`).join("\n")
+      })
+    };
+  }
+  return { exitCode: ExitCode.OK, result: ok({ violations, humanHint: "all paths within length limit" }) };
+}
+function truncateFilename(relPath, maxLength = MAX_PATH_LENGTH) {
+  if (relPath.length <= maxLength) return relPath;
+  const lastSlash = relPath.lastIndexOf("/");
+  const dir = lastSlash >= 0 ? relPath.slice(0, lastSlash) : "";
+  const filename = lastSlash >= 0 ? relPath.slice(lastSlash + 1) : relPath;
+  const hash = computeShortHash(relPath);
+  const ext = filename.endsWith(".md") ? ".md" : "";
+  const base = filename.endsWith(".md") ? filename.slice(0, -3) : filename;
+  const suffix = `-${hash}${ext}`;
+  const dirPrefix = dir ? dir + "/" : "";
+  const maxPrefixLen = maxLength - dirPrefix.length - suffix.length;
+  if (maxPrefixLen <= 0) {
+    const fallback = dirPrefix + hash + ext;
+    if (fallback.length > maxLength) {
+      const dirBudget = maxLength - suffix.length;
+      return dirPrefix.slice(0, Math.max(0, dirBudget)) + suffix;
+    }
+    return fallback;
+  }
+  const prefix = base.slice(0, maxPrefixLen).replace(/[-_\s]+$/, "");
+  return dirPrefix + prefix + suffix;
+}
+function computeShortHash(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0").slice(0, 8);
+}
+
 // src/utils/cli-surface.ts
 import { Command } from "commander";
 function buildCliSurface() {
@@ -2779,7 +2833,7 @@ function extractSourceEntries(rawFm) {
   }
   return entries;
 }
-var ERROR_ORDER = ["broken_wikilinks", "invalid_frontmatter", "raw_dedup", "broken_sources", "tag_not_in_taxonomy"];
+var ERROR_ORDER = ["broken_wikilinks", "invalid_frontmatter", "raw_dedup", "broken_sources", "tag_not_in_taxonomy", "path_too_long"];
 var WARNING_ORDER = ["raw_body_duplicate", "raw_subdirectory_duplicate", "file_source_url", "index_incomplete", "index_link_format", "stale_page", "page_too_large", "log_rotate_needed", "orphans", "compound_refs", "legacy_citation_style", "orphaned_citations", "duplicate_frontmatter", "work_item_health", "orphaned_project_pages", "missing_overview", "missing_diagram"];
 var INFO_ORDER = ["bridges", "page_structure", "topic_map_recommended", "frontmatter_wikilink", "wikilink_citation", "missing_tldr", "stale_sections", "cli_refs"];
 async function runLint(input) {
@@ -2839,6 +2893,8 @@ async function runLint(input) {
   }
   const compoundRefs = await validateCompoundReferences(input.vault);
   if (compoundRefs.ok && compoundRefs.data.length > 0) buckets.compound_refs = compoundRefs.data;
+  const pathCheck = await runPathTooLong({ vault: input.vault });
+  if (pathCheck.result.ok && pathCheck.result.data.violations.length > 0) buckets.path_too_long = pathCheck.result.data.violations;
   const scan = await scanVault(input.vault);
   const allPages = scan.ok ? [...scan.data.typedKnowledge, ...scan.data.raw, ...scan.data.workItems, ...scan.data.compound] : [];
   const slugs = scan.ok ? buildSlugMap(allPages) : /* @__PURE__ */ new Map();
@@ -3353,6 +3409,45 @@ ${newBody}`;
         else delete buckets.file_source_url;
       }
     }
+    const pathViolations = buckets.path_too_long;
+    if (input.fix && pathViolations && pathViolations.length > 0) {
+      const pathFixed = [];
+      for (const v of pathViolations) {
+        try {
+          const absPath = `${input.vault}/${v.relPath}`;
+          const newRelPath = truncateFilename(v.relPath);
+          const newAbsPath = `${input.vault}/${newRelPath}`;
+          await rename5(absPath, newAbsPath);
+          const oldPathEscaped = v.relPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+          for (const page of allPages) {
+            if (page.relPath === v.relPath) continue;
+            const content = await readFile15(page.absPath, "utf8");
+            if (!content.includes(v.relPath)) continue;
+            let updated = content;
+            const citationRe = new RegExp(`\\^\\[${oldPathEscaped}\\]`, "g");
+            updated = updated.replace(citationRe, `^[${newRelPath}]`);
+            const wikilinkRe = new RegExp(`\\[\\[${oldPathEscaped}(\\|[^\\]]*)?\\]\\]`, "g");
+            updated = updated.replace(wikilinkRe, (_m, alias) => `[[${newRelPath}${alias ?? ""}]]`);
+            if (updated !== content) {
+              const w = await safeWritePage(page.absPath, updated);
+              if (!w.ok) {
+                unresolved.push(`${page.relPath} (rewire)`);
+              }
+            }
+          }
+          pathFixed.push(v.relPath);
+        } catch {
+          unresolved.push(v.relPath);
+        }
+      }
+      fixed.push(...pathFixed);
+      if (pathFixed.length > 0) {
+        const fixedSet = new Set(pathFixed);
+        const remaining = pathViolations.filter((v) => !fixedSet.has(v.relPath));
+        if (remaining.length > 0) buckets.path_too_long = remaining;
+        else delete buckets.path_too_long;
+      }
+    }
   }
   const errorOut = ERROR_ORDER.flatMap((k) => buckets[k] ? [{ kind: k, items: buckets[k] }] : []);
   const warningOut = WARNING_ORDER.flatMap((k) => buckets[k] ? [{ kind: k, items: buckets[k] }] : []);
@@ -3489,9 +3584,10 @@ async function runConfigPath(input) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync7, lstatSync, readlinkSync, readdirSync, statSync as statSync2 } from "fs";
+import { existsSync as existsSync7, lstatSync, readlinkSync, readdirSync, statSync as statSync2, readFileSync as readFileSync7 } from "fs";
 import { join as join24, resolve as resolve4 } from "path";
 import { execSync as execSync2 } from "child_process";
+import { platform as platform2 } from "os";
 
 // src/utils/auto-update.ts
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
@@ -4209,12 +4305,12 @@ function checkRcloneFlagAudit(resolvedPath) {
   }
   return check("pass", "rclone_flags", "rclone VFS flags", `PID ${pid}: all critical flags at safe values`);
 }
-function checkRcloneVersion(resolvedPath) {
-  if (!resolvedPath) {
+function checkRcloneVersion(resolvedPath, vaultSyncInstalled) {
+  if (!resolvedPath && !vaultSyncInstalled) {
     return check("pass", "rclone_version", "rclone version", "No vault path \u2014 check skipped");
   }
-  const fuse = detectFuseMount(resolvedPath);
-  if (!fuse) {
+  const fuse = resolvedPath ? detectFuseMount(resolvedPath) : null;
+  if (!fuse && !vaultSyncInstalled) {
     return check("pass", "rclone_version", "rclone version", "local disk \u2014 check skipped");
   }
   const ver = getRcloneVersion();
@@ -4326,6 +4422,301 @@ function checkVfsCacheHealth(resolvedPath) {
     `${stats.files} files, ${(stats.bytesUsed / 1024 / 1024).toFixed(1)}MB \u2014 clean (0 errored, 0 pending)`
   );
 }
+function readVaultSyncConfig(home) {
+  try {
+    const content = readFileSync7(join24(home, ".skillwiki", ".env"), "utf8");
+    let installed = false;
+    let role;
+    for (const line of content.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (trimmed.length === 0 || trimmed.startsWith("#")) continue;
+      const eq = trimmed.indexOf("=");
+      if (eq <= 0) continue;
+      const k = trimmed.slice(0, eq).trim();
+      const v = trimmed.slice(eq + 1).trim();
+      if (v.length === 0) continue;
+      if (k === "vault_sync.installed" && v === "true") installed = true;
+      if (k === "vault_sync.role") role = v;
+    }
+    return { installed, role };
+  } catch {
+    return { installed: false };
+  }
+}
+function vaultSyncChecks(input) {
+  const os = input.os ?? platform2();
+  const home = input.home;
+  if (!input.vaultSyncInstalled) {
+    const skip = (id, label) => check("pass", id, label, "vault-sync not installed \u2014 check skipped");
+    return [
+      skip("vault_sync_installed", "Vault sync installed"),
+      skip("vault_sync_jobs_enabled", "Vault sync jobs enabled"),
+      skip("vault_sync_last_push_age", "Vault sync last push recency"),
+      skip("vault_sync_last_fetch_status", "Vault sync last fetch status"),
+      skip("vault_sync_filter_present", "Vault sync filter file present"),
+      skip("vault_sync_snapshot_guard", "Snapshot script guard")
+    ];
+  }
+  const isMac = os === "darwin";
+  const logDir = input.logDir ?? (isMac ? join24(home, "Library", "Logs") : join24(home, ".local", "state", "vault-sync", "log"));
+  const shareDir = input.shareDir ?? (isMac ? join24(home, "Library", "Application Support", "vault-sync", "bin") : join24(home, ".local", "share", "vault-sync", "bin"));
+  const filterPath = input.filterPath ?? join24(home, ".config", "rclone", "wiki-push-filters.txt");
+  const snapshotPath = input.snapshotScriptPath ?? "/root/.hermes/scripts/wiki-snapshot-v3.sh";
+  const pushScriptPath = join24(shareDir, "wiki-push.sh");
+  const c1 = existsSync7(pushScriptPath) ? check("pass", "vault_sync_installed", "Vault sync installed", `Found: ${pushScriptPath}`) : check("error", "vault_sync_installed", "Vault sync installed", `Script not found at ${pushScriptPath} \u2014 run vault-sync-install`);
+  let c2;
+  try {
+    if (isMac) {
+      const uidStr = execSync2("id -u", {
+        encoding: "utf8",
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      const uid = parseInt(uidStr, 10);
+      execSync2(`launchctl print gui/${uid}/com.karlchow.wiki-push`, {
+        encoding: "utf8",
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      c2 = check(
+        "pass",
+        "vault_sync_jobs_enabled",
+        "Vault sync jobs enabled",
+        "launchd: com.karlchow.wiki-push loaded"
+      );
+    } else {
+      const out = execSync2("systemctl --user is-enabled wiki-push.timer", {
+        encoding: "utf8",
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      if (out === "enabled") {
+        c2 = check(
+          "pass",
+          "vault_sync_jobs_enabled",
+          "Vault sync jobs enabled",
+          "systemd: wiki-push.timer enabled"
+        );
+      } else {
+        c2 = check(
+          "error",
+          "vault_sync_jobs_enabled",
+          "Vault sync jobs enabled",
+          `systemd: wiki-push.timer is ${out} \u2014 run vault-sync-install`
+        );
+      }
+    }
+  } catch {
+    c2 = check(
+      "error",
+      "vault_sync_jobs_enabled",
+      "Vault sync jobs enabled",
+      "Scheduler check failed \u2014 run vault-sync-install"
+    );
+  }
+  const logFile = join24(logDir, "wiki-push.log");
+  let c3;
+  try {
+    const logContent = readFileSync7(logFile, "utf8");
+    const lines = logContent.trim().split("\n").filter(Boolean);
+    if (lines.length === 0) {
+      c3 = check(
+        "warn",
+        "vault_sync_last_push_age",
+        "Vault sync last push recency",
+        "Log file is empty"
+      );
+    } else {
+      const lastLine = lines[lines.length - 1];
+      if (/FAIL/.test(lastLine)) {
+        c3 = check(
+          "error",
+          "vault_sync_last_push_age",
+          "Vault sync last push recency",
+          `Last push failed: ${lastLine}`
+        );
+      } else if (/OK push/.test(lastLine)) {
+        const tsMatch = lastLine.match(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z)/);
+        if (tsMatch) {
+          const lastPush = new Date(tsMatch[1]).getTime();
+          const ageSec = (Date.now() - lastPush) / 1e3;
+          if (ageSec <= 180) {
+            c3 = check(
+              "pass",
+              "vault_sync_last_push_age",
+              "Vault sync last push recency",
+              `Last push ${ageSec.toFixed(0)}s ago`
+            );
+          } else {
+            c3 = check(
+              "warn",
+              "vault_sync_last_push_age",
+              "Vault sync last push recency",
+              `Last push ${Math.round(ageSec)}s ago (>3 min)`
+            );
+          }
+        } else {
+          c3 = check(
+            "warn",
+            "vault_sync_last_push_age",
+            "Vault sync last push recency",
+            `Unparseable push line: ${lastLine.slice(0, 80)}`
+          );
+        }
+      } else {
+        c3 = check(
+          "warn",
+          "vault_sync_last_push_age",
+          "Vault sync last push recency",
+          `Last log entry: ${lastLine.slice(0, 80)}`
+        );
+      }
+    }
+  } catch {
+    c3 = existsSync7(logDir) ? check(
+      "warn",
+      "vault_sync_last_push_age",
+      "Vault sync last push recency",
+      `Log file not found at ${logFile}`
+    ) : check(
+      "error",
+      "vault_sync_last_push_age",
+      "Vault sync last push recency",
+      `Log directory not found at ${logDir}`
+    );
+  }
+  const fetchLogFile = join24(logDir, "wiki-fetch.log");
+  let cFetch;
+  try {
+    const logContent = readFileSync7(fetchLogFile, "utf8");
+    const lines = logContent.trim().split("\n").filter(Boolean);
+    if (lines.length === 0) {
+      cFetch = check(
+        "warn",
+        "vault_sync_last_fetch_status",
+        "Vault sync last fetch status",
+        "Fetch log file is empty"
+      );
+    } else {
+      const lastLine = lines[lines.length - 1];
+      if (/fetch failed/i.test(lastLine)) {
+        cFetch = check(
+          "error",
+          "vault_sync_last_fetch_status",
+          "Vault sync last fetch status",
+          `Last fetch failed: ${lastLine.slice(0, 100)}`
+        );
+      } else if (/OK/.test(lastLine)) {
+        cFetch = check(
+          "pass",
+          "vault_sync_last_fetch_status",
+          "Vault sync last fetch status",
+          lastLine.slice(0, 100)
+        );
+      } else {
+        cFetch = check(
+          "warn",
+          "vault_sync_last_fetch_status",
+          "Vault sync last fetch status",
+          `Last fetch log entry: ${lastLine.slice(0, 80)}`
+        );
+      }
+    }
+  } catch {
+    cFetch = check(
+      "warn",
+      "vault_sync_last_fetch_status",
+      "Vault sync last fetch status",
+      `Fetch log not found at ${fetchLogFile}`
+    );
+  }
+  let c4;
+  try {
+    if (!existsSync7(filterPath)) {
+      c4 = check(
+        "error",
+        "vault_sync_filter_present",
+        "Vault sync filter file present",
+        `Filter file not found at ${filterPath}`
+      );
+    } else {
+      const content = readFileSync7(filterPath, "utf8");
+      const requiredExcludes = [
+        "remotely-save/data.json",
+        ".skillwiki/sync.lock",
+        ".claude/settings.local.json"
+      ];
+      const missing = requiredExcludes.filter((ex) => !content.includes(ex));
+      if (missing.length > 0) {
+        c4 = check(
+          "warn",
+          "vault_sync_filter_present",
+          "Vault sync filter file present",
+          `Missing required excludes: ${missing.join(", ")}`
+        );
+      } else {
+        c4 = check(
+          "pass",
+          "vault_sync_filter_present",
+          "Vault sync filter file present",
+          `Found with required excludes at ${filterPath}`
+        );
+      }
+    }
+  } catch {
+    c4 = check(
+      "error",
+      "vault_sync_filter_present",
+      "Vault sync filter file present",
+      `Cannot read filter file at ${filterPath}`
+    );
+  }
+  let c5;
+  if (input.vaultSyncRole !== "snapshotter") {
+    c5 = check(
+      "pass",
+      "vault_sync_snapshot_guard",
+      "Snapshot script guard",
+      "Not a snapshotter host \u2014 check skipped"
+    );
+  } else {
+    try {
+      if (!existsSync7(snapshotPath)) {
+        c5 = check(
+          "error",
+          "vault_sync_snapshot_guard",
+          "Snapshot script guard",
+          `Snapshot script not found at ${snapshotPath}`
+        );
+      } else {
+        const content = readFileSync7(snapshotPath, "utf8");
+        if (!content.includes("--max-delete")) {
+          c5 = check(
+            "error",
+            "vault_sync_snapshot_guard",
+            "Snapshot script guard",
+            `${snapshotPath} is missing --max-delete guard \u2014 dangerous without it`
+          );
+        } else {
+          c5 = check(
+            "pass",
+            "vault_sync_snapshot_guard",
+            "Snapshot script guard",
+            `--max-delete present in ${snapshotPath}`
+          );
+        }
+      }
+    } catch {
+      c5 = check(
+        "error",
+        "vault_sync_snapshot_guard",
+        "Snapshot script guard",
+        `Cannot read ${snapshotPath}`
+      );
+    }
+  }
+  return [c1, c2, c3, cFetch, c4, c5];
+}
 function findSkillMd(dir) {
   const results = [];
   let entries;
@@ -4360,6 +4751,7 @@ function findSkillNames(dir) {
 }
 async function runDoctor(input) {
   const checks = [];
+  const vsConfig = readVaultSyncConfig(input.home);
   checks.push(checkNodeVersion());
   checks.push(checkCliChannels(input.argv, input.home));
   checks.push(await checkConfigFile(input.home));
@@ -4380,13 +4772,18 @@ async function runDoctor(input) {
   checks.push(checkDotStoreClean(resolvedPath));
   checks.push(checkS3MountPerf(resolvedPath));
   checks.push(checkRcloneFlagAudit(resolvedPath));
-  checks.push(checkRcloneVersion(resolvedPath));
+  checks.push(checkRcloneVersion(resolvedPath, vsConfig.installed));
   checks.push(checkWriteTest(resolvedPath));
   checks.push(checkVfsCacheHealth(resolvedPath));
   checks.push(checkSkillsInstalled(input.home, input.cwd));
   checks.push(checkDuplicateSkills(input.home));
   checks.push(checkNpmUpdate(input.home, input.currentVersion));
   checks.push(checkPluginVersionDrift(input.home, input.currentVersion));
+  checks.push(...vaultSyncChecks({
+    home: input.home,
+    vaultSyncInstalled: vsConfig.installed,
+    vaultSyncRole: vsConfig.role
+  }));
   const summary = {
     pass: checks.filter((c) => c.status === "pass").length,
     info: checks.filter((c) => c.status === "info").length,
@@ -4410,7 +4807,7 @@ async function runDoctor(input) {
 }
 
 // src/commands/archive.ts
-import { rename as rename5, mkdir as mkdir8, readFile as readFile18, writeFile as writeFile9 } from "fs/promises";
+import { rename as rename6, mkdir as mkdir8, readFile as readFile18, writeFile as writeFile9 } from "fs/promises";
 import { join as join25, dirname as dirname9 } from "path";
 function countWikilinks(body, slug) {
   const escaped = slug.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -4523,7 +4920,7 @@ ${fmRewritten}
       if (e instanceof Error && "code" in e && e.code !== "ENOENT") throw e;
     }
   }
-  await rename5(join25(input.vault, relPath), join25(input.vault, archivePath));
+  await rename6(join25(input.vault, relPath), join25(input.vault, archivePath));
   appendLastOp(input.vault, {
     operation: input.cascade ? "archive-cascade" : "archive",
     summary: `moved ${relPath} to ${archivePath}${input.cascade ? ` (cascade: ${cascade?.source_array_refs.length ?? 0} source arrays updated)` : ""}`,
@@ -4909,7 +5306,7 @@ ${newBody}`;
 
 // src/commands/update.ts
 import { execSync as execSync3 } from "child_process";
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 import { join as join26 } from "path";
 function resolveGlobalSkillsRoot() {
   try {
@@ -4939,7 +5336,7 @@ async function refreshInstalledSkills(target) {
 }
 async function runUpdate(input) {
   const pkg2 = JSON.parse(
-    readFileSync7(new URL("../../package.json", import.meta.url), "utf8")
+    readFileSync8(new URL("../../package.json", import.meta.url), "utf8")
   );
   const currentVersion = pkg2.version;
   const tag = input.distTag ?? "latest";
@@ -5013,12 +5410,12 @@ async function runUpdate(input) {
 
 // src/commands/self-update.ts
 import { execSync as execSync4 } from "child_process";
-import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
 import { join as join27 } from "path";
 var DEFAULT_SOURCE_ROOT_SUFFIX = "/Desktop/code/llm-wiki";
 async function runSelfUpdate(input) {
   const currentVersion = JSON.parse(
-    readFileSync8(new URL("../../package.json", import.meta.url), "utf8")
+    readFileSync9(new URL("../../package.json", import.meta.url), "utf8")
   ).version;
   const sourceRoot = input.sourceRoot ?? `${input.home}${DEFAULT_SOURCE_ROOT_SUFFIX}`;
   const localPkgPath = join27(sourceRoot, "packages", "cli", "package.json");
@@ -5029,7 +5426,7 @@ async function runSelfUpdate(input) {
     if (hasLocalSource) {
       source = "local";
       try {
-        availableVersion = JSON.parse(readFileSync8(localPkgPath, "utf8")).version ?? null;
+        availableVersion = JSON.parse(readFileSync9(localPkgPath, "utf8")).version ?? null;
       } catch {
         availableVersion = null;
       }
@@ -5087,7 +5484,7 @@ async function runSelfUpdate(input) {
     }
     const newVersion = (() => {
       try {
-        return JSON.parse(readFileSync8(localPkgPath, "utf8")).version ?? "unknown";
+        return JSON.parse(readFileSync9(localPkgPath, "utf8")).version ?? "unknown";
       } catch {
         return "unknown";
       }
@@ -6127,7 +6524,7 @@ import { existsSync as existsSync12 } from "fs";
 import { join as join34 } from "path";
 
 // src/utils/sync-lock.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync3, readFileSync as readFileSync9, renameSync, unlinkSync as unlinkSync4, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync3, readFileSync as readFileSync10, renameSync, unlinkSync as unlinkSync4, writeFileSync as writeFileSync5 } from "fs";
 import { join as join33 } from "path";
 import { createHash as createHash6 } from "crypto";
 function getSessionId() {
@@ -6142,7 +6539,7 @@ function readLock(vault) {
   const path = lockPath(vault);
   if (!existsSync11(path)) return null;
   try {
-    const raw = readFileSync9(path, "utf8");
+    const raw = readFileSync10(path, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -6430,6 +6827,7 @@ async function runSyncPull(input) {
   let pulled = false;
   let conflicts = 0;
   let filesUpdated = 0;
+  let autoResolved = 0;
   try {
     const pullOutput = gitStrict(vault, ["pull", "--rebase", "origin", "HEAD"]);
     pulled = true;
@@ -6438,25 +6836,71 @@ async function runSyncPull(input) {
   } catch (e) {
     const errString = String(e);
     if (errString.includes("conflict")) {
-      const porcelain = git(vault, ["diff", "--name-only", "--diff-filter=U"]);
-      conflicts = porcelain ? porcelain.split("\n").filter((l) => l.trim().length > 0).length : 0;
+      let inConflict = true;
+      while (inConflict) {
+        const stoppedSha = git(vault, ["rev-parse", "--verify", "REBASE_HEAD"]);
+        let commitMsg = "";
+        if (stoppedSha) {
+          commitMsg = git(vault, ["log", "--format=%s", "-1", stoppedSha]);
+        }
+        const isArchiveOrSnapshot = commitMsg.startsWith("archive: moved") || commitMsg.startsWith("Snapshot ");
+        const conflictedFiles = git(vault, ["diff", "--name-only", "--diff-filter=U"]);
+        const conflictedList = conflictedFiles ? conflictedFiles.split("\n").filter((l) => l.trim().length > 0) : [];
+        if (conflictedList.length === 0) {
+          try {
+            gitStrict(vault, ["rebase", "--continue"]);
+            inConflict = true;
+          } catch {
+            inConflict = false;
+          }
+          continue;
+        }
+        if (isArchiveOrSnapshot) {
+          for (const f of conflictedList) {
+            try {
+              gitStrict(vault, ["checkout", "--ours", f]);
+              gitStrict(vault, ["add", f]);
+            } catch {
+            }
+          }
+          autoResolved += conflictedList.length;
+          try {
+            gitStrict(vault, ["rebase", "--continue"]);
+          } catch (continueErr) {
+            continue;
+          }
+        } else {
+          conflicts = conflictedList.length;
+          return {
+            exitCode: ExitCode.SYNC_PULL_FAILED,
+            result: ok({
+              fetched,
+              pulled: false,
+              files_updated: 0,
+              conflicts,
+              auto_resolved: 0,
+              lint_errors: 0,
+              lint_warnings: 0,
+              humanHint: `pull failed with ${conflicts} conflict(s) on non-archive commit "${commitMsg}" \u2014 resolve manually`
+            })
+          };
+        }
+      }
+      if (autoResolved > 0) {
+        const diffOutput = git(vault, ["diff", "--stat", "HEAD@{1}..HEAD"]);
+        if (diffOutput) {
+          const fileMatch = diffOutput.match(/(\d+) file[s]? changed/);
+          if (fileMatch) filesUpdated = parseInt(fileMatch[1], 10);
+        }
+        pulled = true;
+        conflicts = 0;
+      }
+    } else {
       return {
         exitCode: ExitCode.SYNC_PULL_FAILED,
-        result: ok({
-          fetched,
-          pulled: false,
-          files_updated: 0,
-          conflicts,
-          lint_errors: 0,
-          lint_warnings: 0,
-          humanHint: `pull failed with ${conflicts} conflict(s) \u2014 resolve manually`
-        })
+        result: err("GIT_PULL_FAILED", { message: errString })
       };
     }
-    return {
-      exitCode: ExitCode.SYNC_PULL_FAILED,
-      result: err("GIT_PULL_FAILED", { message: errString })
-    };
   }
   let lintErrors = 0;
   let lintWarnings = 0;
@@ -6468,6 +6912,7 @@ async function runSyncPull(input) {
   const hintParts = [];
   if (filesUpdated > 0) hintParts.push(`updated ${filesUpdated} file(s)`);
   else hintParts.push("already up to date");
+  if (autoResolved > 0) hintParts.push(`${autoResolved} conflict(s) auto-resolved`);
   if (lintErrors > 0) hintParts.push(`${lintErrors} lint error(s)`);
   if (lintWarnings > 0) hintParts.push(`${lintWarnings} lint warning(s)`);
   const exitCode = lintErrors > 0 ? ExitCode.LINT_HAS_ERRORS : lintWarnings > 0 ? ExitCode.LINT_HAS_WARNINGS : ExitCode.OK;
@@ -6478,6 +6923,7 @@ async function runSyncPull(input) {
       pulled,
       files_updated: filesUpdated,
       conflicts,
+      auto_resolved: autoResolved,
       lint_errors: lintErrors,
       lint_warnings: lintWarnings,
       humanHint: hintParts.join(", ")
@@ -6598,7 +7044,7 @@ function runSyncUnlock(input) {
 }
 
 // src/commands/backup.ts
-import { statSync as statSync4, readdirSync as readdirSync2, readFileSync as readFileSync10, mkdirSync as mkdirSync4, writeFileSync as writeFileSync6 } from "fs";
+import { statSync as statSync4, readdirSync as readdirSync2, readFileSync as readFileSync11, mkdirSync as mkdirSync4, writeFileSync as writeFileSync6 } from "fs";
 import { join as join35, relative as relative3, dirname as dirname11 } from "path";
 import { PutObjectCommand, HeadObjectCommand, ListObjectsV2Command, GetObjectCommand, DeleteObjectsCommand } from "@aws-sdk/client-s3";
 
@@ -6665,7 +7111,7 @@ async function runBackupSync(input) {
       continue;
     }
     try {
-      const body = readFileSync10(absPath);
+      const body = readFileSync11(absPath);
       await client.send(new PutObjectCommand({ Bucket: input.bucket, Key: relPath, Body: body }));
       uploaded++;
     } catch {
@@ -7292,7 +7738,7 @@ async function postCommit(vault, exitCode) {
 }
 
 // src/cli.ts
-var pkg = JSON.parse(readFileSync11(new URL("../package.json", import.meta.url), "utf8"));
+var pkg = JSON.parse(readFileSync12(new URL("../package.json", import.meta.url), "utf8"));
 var program = new Command2();
 program.name("skillwiki").description("Deterministic helpers for CodeWiki skills").version(pkg.version);
 program.option("--human", "render terminal-readable output instead of JSON");
@@ -7440,7 +7886,7 @@ program.command("log-rotate [vault]").description("rotate or trim the vault log
   if (!v.ok) emit({ exitCode: v.exitCode, result: v.payload });
   else emit(await runLogRotate({ vault: v.vault, threshold: opts.threshold, apply: !!opts.apply }), v.vault);
 });
-program.command("lint [vault]").description("run all vault health checks").option("--days <n>", "stale threshold", (s) => parseInt(s, 10), 90).option("--lines <n>", "pagesize threshold", (s) => parseInt(s, 10), 200).option("--log-threshold <n>", "log rotation threshold", (s) => parseInt(s, 10), 500).option("--fix", "auto-fix legacy_citation_style violations").option("--only <bucket>", "run only the specified lint bucket").option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
+program.command("lint [vault]").description("run all vault health checks").option("--days <n>", "stale threshold", (s) => parseInt(s, 10), 90).option("--lines <n>", "pagesize threshold", (s) => parseInt(s, 10), 200).option("--log-threshold <n>", "log rotation threshold", (s) => parseInt(s, 10), 500).option("--fix", "auto-fix supported lint violations").option("--only <bucket>", "run only the specified lint bucket").option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
   const v = await resolveVaultArg(vault, opts.wiki);
   if (!v.ok) emit({ exitCode: v.exitCode, result: v.payload });
   else emit(await runLint({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skillwiki",
-  "version": "0.6.2-beta.1",
+  "version": "0.8.0",
   "type": "module",
   "bin": {
     "skillwiki": "dist/cli.js"

package/skills/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "skillwiki",
-  "version": "0.6.2-beta.1",
+  "version": "0.8.0",
   "skills": "./",
   "description": "Project-aware Karpathy-style knowledge base for Claude Code: 18 prompt-only skills (wiki-*, proj-*, using-skillwiki) backed by the deterministic `skillwiki` CLI.",
   "author": {

package/skills/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "skillwiki",
-  "version": "0.6.2-beta.1",
+  "version": "0.8.0",
   "description": "Project-aware Karpathy-style knowledge base for Codex with 18 prompt-only skills backed by the deterministic skillwiki CLI.",
   "author": {
     "name": "karlorz",

package/skills/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skillwiki/skills",
-  "version": "0.6.2-beta.1",
+  "version": "0.8.0",
   "private": true,
   "files": [
     "wiki-*",

package/skills/wiki-add-task/SKILL.md

@@ -8,7 +8,7 @@ Capture ad-hoc ideas, bugs, tasks, and notes into the vault. Three entry points
 | Entry | When | What happens |
 |-------|------|-------------|
 | `/wiki-add-task <text>` | You're in a Claude Code session (NOT Hermes compact) | Creates `raw/transcripts/YYYY-MM-DD-{type}-{slug}.md` with ad-hoc capture frontmatter |
-| `skillwiki add-task <text>` | Hermes Agent compact mode | Same as above — compact-compatible CLI trigger |
+| Filesystem drop | Hermes Agent compact mode (no slash commands available) | Same as above — create `.md` in `raw/transcripts/`, dev-loop discovers it |
 | Filesystem drop | You're NOT in a Claude session (Obsidian, editor, sync) | Create any `.md` file in `raw/transcripts/` using the vault template — dev-loop discovers it on next cycle |
 | Dev-loop discovery | Automatic, next cycle | Scans `raw/transcripts/` for new files since last cycle, surfaces as claimable work |
 **Path Rule:** Captures ALWAYS go to `$(skillwiki path)/raw/transcripts/` (Layer 1). Never under `projects/{slug}/raw/` — that violates SCHEMA.md Layer 1 immutability.