offhands 0.1.10 → 0.1.12

package/dist/daemon.mjs

@@ -4777,7 +4777,7 @@ var require_main = __commonJS({
 
 // ../daemon/src/index.ts
 import { resolve as resolve5 } from "node:path";
-import { existsSync as existsSync10 } from "node:fs";
+import { existsSync as existsSync11 } from "node:fs";
 
 // ../daemon/src/runners/claude-code.ts
 import { spawn } from "node:child_process";
@@ -6015,8 +6015,8 @@ function sleep(ms) {
 // ../daemon/src/session-manager.ts
 import { randomUUID } from "node:crypto";
 import { hostname, platform as platform2, tmpdir } from "node:os";
-import { existsSync as existsSync7, mkdirSync as mkdirSync2, readdirSync as readdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname3, join as join6, basename as basename3, parse as parse2, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync2, readdirSync as readdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname3, join as join7, basename as basename3, parse as parse2, resolve as resolve3 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { execFile as execFile4 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
@@ -6209,10 +6209,10 @@ function dedupeDropName(desiredName, existingNames) {
   const existing = new Set([...existingNames].map((n2) => n2.toLowerCase()));
   if (!existing.has(safe.toLowerCase())) return safe;
   const parsed = parse(safe);
-  const stem = parsed.name || "drop";
+  const stem2 = parsed.name || "drop";
   const ext = parsed.ext;
   for (let i2 = 1; ; i2++) {
-    const candidate = `${stem}-${i2}${ext}`;
+    const candidate = `${stem2}-${i2}${ext}`;
     if (!existing.has(candidate.toLowerCase())) return candidate;
   }
 }
@@ -6626,6 +6626,10 @@ async function probeWolCapability() {
   }
 }
 
+// ../daemon/src/intelligence/context-inject.ts
+import { existsSync as existsSync7, realpathSync, statSync as statSync3 } from "node:fs";
+import { isAbsolute, join as join6, relative, sep } from "node:path";
+
 // ../daemon/src/intelligence/ripgrep.ts
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
@@ -6758,6 +6762,62 @@ function extractTerms(prompt, maxTerms = 8) {
   }
   return deduped.slice().sort((a2, b2) => b2.length - a2.length).slice(0, maxTerms);
 }
+var SECRET_BASENAMES = /* @__PURE__ */ new Set([".npmrc", ".netrc", "id_rsa", "id_dsa", "id_ecdsa", "id_ed25519", "credentials.json", "secrets.json"]);
+var SECRET_EXTS = [".pem", ".key", ".p12", ".pfx", ".keystore", ".jks", ".env"];
+var ENV_TEMPLATE_SUFFIXES = [".example", ".sample", ".template", ".dist"];
+function isSecretLike(path) {
+  const base = (path.split(/[\\/]/).pop() ?? "").toLowerCase();
+  if (base === ".env" || base.startsWith(".env.")) return !ENV_TEMPLATE_SUFFIXES.some((s2) => base.endsWith(s2));
+  if (SECRET_BASENAMES.has(base)) return true;
+  return SECRET_EXTS.some((e) => base.endsWith(e));
+}
+function parsePorcelainZ(out) {
+  const parts = out.split("\0");
+  const paths = [];
+  for (let i2 = 0; i2 < parts.length; i2++) {
+    const p2 = parts[i2];
+    if (p2.length < 4) continue;
+    const x2 = p2[0];
+    const y2 = p2[1];
+    if (x2 === "R" || x2 === "C" || y2 === "R" || y2 === "C") i2++;
+    paths.push(p2.slice(3));
+  }
+  return paths;
+}
+function isDirectory(abs) {
+  try {
+    return statSync3(abs).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function realOrSame(p2) {
+  try {
+    return realpathSync.native(p2);
+  } catch {
+    return p2;
+  }
+}
+function stem(word) {
+  let w2 = word.toLowerCase();
+  if (w2.length > 4) w2 = w2.replace(/(ing|ed|es|s)$/, "");
+  if (w2.length > 3) w2 = w2.replace(/e$/, "");
+  return w2;
+}
+function pathWords(path) {
+  const split = (s2) => s2.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter(Boolean).map(stem);
+  const slash = path.lastIndexOf("/");
+  const base = new Set(split(path.slice(slash + 1)));
+  const all = /* @__PURE__ */ new Set([...split(path.slice(0, Math.max(slash, 0))), ...base]);
+  return { all, base };
+}
+var NOISE_FILES = /* @__PURE__ */ new Set(["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock", "composer.lock", "cargo.lock", "poetry.lock"]);
+var isNoise = (p2) => NOISE_FILES.has((p2.split("/").pop() ?? "").toLowerCase());
+var MAX_UNMATCHED_WITH_MATCHES = 3;
+var MAX_NAME_MATCHES = 10;
+var MAX_DIRTY_ONLY = 8;
+var MAX_RECENT = 6;
+var MAX_LS_FILES = 6e4;
 async function buildContext(workspace, prompt, opts = {}) {
   const startedAt = Date.now();
   const maxChars = opts.maxChars ?? (Number(process.env.OFFHAND_INTEL_MAX_CHARS) || DEFAULT_MAX_CHARS);
@@ -6782,8 +6842,13 @@ async function buildContext(workspace, prompt, opts = {}) {
   }
   const { findings, retrievalOpsRun, ripgrepAvailable, gitState } = result;
   if (findings.length === 0) return null;
-  findings.sort((a2, b2) => b2.priority - a2.priority);
-  const { text: block, selectedCount } = formatBlock(prompt, findings, gitState, maxChars);
+  const rank = (f2) => f2.matchScore > 0 ? f2.dirty ? 5 : 4 : f2.dirty ? 2 : 1;
+  findings.sort((a2, b2) => rank(b2) - rank(a2) || b2.matchScore - a2.matchScore);
+  const strongMatches = findings.filter((f2) => f2.matchScore > 0).length;
+  const unmatchedCap = strongMatches >= 3 ? MAX_UNMATCHED_WITH_MATCHES : Infinity;
+  let unmatched = 0;
+  const shown = findings.filter((f2) => f2.matchScore > 0 || ++unmatched <= unmatchedCap);
+  const { text: block, selectedCount } = formatBlock(prompt, shown, gitState, maxChars);
   if (selectedCount === 0) return null;
   return {
     block,
@@ -6802,41 +6867,141 @@ async function buildContext(workspace, prompt, opts = {}) {
 async function gatherFindings(workspace, prompt) {
   let retrievalOpsRun = 0;
   const byPath = /* @__PURE__ */ new Map();
-  const add = (path, reason, priority) => {
-    const existing = byPath.get(path);
-    if (existing) {
-      if (!existing.reasons.includes(reason)) existing.reasons.push(reason);
-      existing.priority = Math.max(existing.priority, priority);
-    } else {
-      byPath.set(path, { path, reasons: [reason], priority });
+  const touch = (path) => {
+    let f2 = byPath.get(path);
+    if (!f2) {
+      f2 = { path, reasons: [], dirty: false, matchScore: 0 };
+      byPath.set(path, f2);
     }
+    return f2;
+  };
+  const note = (f2, reason) => {
+    if (!f2.reasons.includes(reason)) f2.reasons.push(reason);
   };
-  const statusOut = await git(workspace, "status", "--porcelain");
+  const wsReal = realOrSame(workspace);
+  const rootOut = await git(workspace, "rev-parse", "--show-toplevel");
+  retrievalOpsRun++;
+  const gitRoot = realOrSame(rootOut?.trim() || workspace);
+  const liveRel = (rootRelative) => {
+    const abs = join6(gitRoot, rootRelative);
+    const rel = relative(wsReal, abs);
+    if (!rel || rel.startsWith("..") || isAbsolute(rel)) return null;
+    if (!existsSync7(abs)) return null;
+    return rel.split(sep).join("/");
+  };
+  const statusOut = await git(workspace, "status", "--porcelain", "-z");
   retrievalOpsRun++;
   let gitState = null;
+  const dirtySet = /* @__PURE__ */ new Set();
+  const dirtyDirs = [];
+  const isDirty2 = (p2) => dirtySet.has(p2) || dirtyDirs.some((d2) => p2.startsWith(d2));
   if (statusOut !== null) {
-    const dirtyFiles = statusOut.split("\n").filter((l2) => l2.length > 3).map((l2) => l2.slice(3).trim()).filter(Boolean);
-    for (const f2 of dirtyFiles.slice(0, 15)) add(f2, "currently dirty", 3);
-    gitState = dirtyFiles.length > 0 ? `${dirtyFiles.length} file(s) with uncommitted changes` : "clean working tree";
+    const entries = parsePorcelainZ(statusOut);
+    let missing = 0;
+    for (const p2 of entries) {
+      const rel = liveRel(p2);
+      if (rel === null) {
+        missing++;
+        continue;
+      }
+      if (isSecretLike(rel)) continue;
+      if (rel.endsWith("/") || isDirectory(join6(gitRoot, p2))) dirtyDirs.push(rel.replace(/\/?$/, "/"));
+      else dirtySet.add(rel);
+    }
+    let dirtyOnly = 0;
+    for (const rel of dirtySet) {
+      if (dirtyOnly >= MAX_DIRTY_ONLY) break;
+      if (isNoise(rel)) continue;
+      const f2 = touch(rel);
+      f2.dirty = true;
+      note(f2, "currently dirty");
+      dirtyOnly++;
+    }
+    gitState = entries.length === 0 ? "clean working tree" : `${entries.length - missing} modified/new file(s)${missing > 0 ? ` and ${missing} deleted` : ""}, uncommitted`;
   }
   const ripgrepAvailable = await detectRipgrep();
   retrievalOpsRun++;
   const terms = extractTerms(prompt);
+  if (terms.length > 0) {
+    const listing = await git(workspace, "ls-files", "-co", "--exclude-standard", "-z");
+    retrievalOpsRun++;
+    const all = (listing ?? "").split("\0").filter(Boolean);
+    if (all.length > 0 && all.length <= MAX_LS_FILES) {
+      const stems = /* @__PURE__ */ new Map();
+      const literals = [];
+      for (const t2 of terms) {
+        if (/[._-]/.test(t2)) literals.push(t2);
+        else if (!stems.has(stem(t2))) stems.set(stem(t2), t2);
+      }
+      const words = all.map(pathWords);
+      const lowered = literals.length > 0 ? all.map((p2) => p2.toLowerCase()) : [];
+      const idf = /* @__PURE__ */ new Map();
+      const wording = /* @__PURE__ */ new Map();
+      const idfOf = (key, df) => {
+        if (df > 0 && df < all.length) idf.set(key, Math.log(1 + all.length / df));
+      };
+      for (const [s2, original] of stems) {
+        wording.set(s2, original);
+        idfOf(s2, words.reduce((n2, w2) => w2.all.has(s2) ? n2 + 1 : n2, 0));
+      }
+      for (const lit of literals) {
+        wording.set(lit, lit);
+        idfOf(lit, lowered.reduce((n2, p2) => p2.includes(lit) ? n2 + 1 : n2, 0));
+      }
+      if (idf.size > 0) {
+        const scored = [];
+        for (let i2 = 0; i2 < all.length; i2++) {
+          let score = 0;
+          const matched = [];
+          for (const [key, weight] of idf) {
+            const isLiteral = literals.includes(key);
+            if (isLiteral ? lowered[i2].includes(key) : words[i2].base.has(key)) score += weight * 2;
+            else if (!isLiteral && words[i2].all.has(key)) score += weight;
+            else continue;
+            matched.push(wording.get(key));
+          }
+          if (score > 0) scored.push({ path: all[i2], score, matched });
+        }
+        scored.sort((a2, b2) => b2.score - a2.score);
+        let taken = 0;
+        for (const s2 of scored) {
+          if (taken >= MAX_NAME_MATCHES) break;
+          if (isSecretLike(s2.path) || !existsSync7(join6(workspace, s2.path))) continue;
+          const f2 = touch(s2.path);
+          f2.matchScore += s2.score;
+          if (isDirty2(s2.path)) f2.dirty = true;
+          note(f2, `path matches ${s2.matched.map((m3) => `"${m3}"`).join(", ")}`);
+          taken++;
+        }
+      }
+    }
+  }
   if (ripgrepAvailable && terms.length > 0) {
     const hits = await searchTerms(workspace, terms);
     retrievalOpsRun++;
     for (const hit of hits) {
+      const file = hit.file.replace(/\\/g, "/").replace(/^\.\//, "");
+      if (isSecretLike(file)) continue;
       const term = terms.find((t2) => hit.text.toLowerCase().includes(t2));
-      add(hit.file, term ? `matched "${term}"` : "matched search terms", 2);
+      const f2 = touch(file);
+      f2.matchScore += 1;
+      if (isDirty2(file)) f2.dirty = true;
+      note(f2, term ? `matched "${term}"` : "matched search terms");
     }
   }
-  const logOut = await git(workspace, "log", "-n", "15", "--name-only", "--pretty=format:");
+  const logOut = await git(workspace, "-c", "core.quotepath=off", "log", "-n", "15", "--name-only", "--relative", "--pretty=format:");
   retrievalOpsRun++;
   if (logOut !== null) {
-    const recentFiles = [...new Set(logOut.split("\n").map((l2) => l2.trim()).filter(Boolean))];
-    for (const f2 of recentFiles.slice(0, 10)) add(f2, "recently changed", 1);
+    const recent = [...new Set(logOut.split("\n").map((l2) => l2.trim()).filter((l2) => l2 && !l2.startsWith('"')))];
+    let taken = 0;
+    for (const p2 of recent) {
+      if (taken >= MAX_RECENT) break;
+      if (isSecretLike(p2) || isNoise(p2) || !existsSync7(join6(workspace, p2))) continue;
+      note(touch(p2), "recently changed");
+      taken++;
+    }
   }
-  return { findings: [...byPath.values()], retrievalOpsRun, ripgrepAvailable, gitState };
+  return { findings: [...byPath.values()].filter((f2) => f2.reasons.length > 0), retrievalOpsRun, ripgrepAvailable, gitState };
 }
 function formatBlock(prompt, rankedFindings, gitState, maxChars) {
   const header = `TASK
@@ -6866,7 +7031,7 @@ OFFHAND REPOSITORY CONTEXT
 // ../daemon/src/session-manager.ts
 function resolveDaemonVersion() {
   try {
-    const pkgPath = join6(dirname3(fileURLToPath3(import.meta.url)), "..", "package.json");
+    const pkgPath = join7(dirname3(fileURLToPath3(import.meta.url)), "..", "package.json");
     const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
@@ -7211,7 +7376,7 @@ var SessionManager = class {
       case "fs-create-folder": {
         try {
           const safeName = safeDropName(msg.name);
-          mkdirSync2(join6(resolve3(msg.path), safeName), { recursive: false });
+          mkdirSync2(join7(resolve3(msg.path), safeName), { recursive: false });
         } catch (e) {
           reply({
             type: "fs-response",
@@ -7352,9 +7517,9 @@ var SessionManager = class {
     let out = prompt + "\n\nAttached files (read them from disk):";
     for (const a2 of attachments) {
       const bytes = await this.attachmentFetcher(a2.blobId);
-      const dir = join6(tmpdir(), "offhand-attachments");
+      const dir = join7(tmpdir(), "offhand-attachments");
       mkdirSync2(dir, { recursive: true });
-      const path = join6(dir, `${a2.blobId.slice(0, 8)}-${basename3(a2.name)}`);
+      const path = join7(dir, `${a2.blobId.slice(0, 8)}-${basename3(a2.name)}`);
       writeFileSync2(path, bytes);
       out += `
 - ${path} (${a2.mime})`;
@@ -7574,17 +7739,17 @@ function listFolders(path) {
   if (!path) return { path: "", parent: null, dirs: driveRoots() };
   const current = resolve3(path);
   const dirs = safeReadDir2(current).filter((entry) => entry.isDirectory() && !skipDir(entry.name)).map((entry) => {
-    const full = join6(current, entry.name);
-    return { name: entry.name, path: full, isGit: existsSync7(join6(full, ".git")) };
+    const full = join7(current, entry.name);
+    return { name: entry.name, path: full, isGit: existsSync8(join7(full, ".git")) };
   }).sort((a2, b2) => Number(b2.isGit) - Number(a2.isGit) || a2.name.localeCompare(b2.name)).slice(0, 200);
   return { path: current, parent: isRoot(current) ? null : dirname3(current), dirs };
 }
 function driveRoots() {
-  if (process.platform !== "win32") return [{ name: "/", path: "/", isGit: existsSync7("/.git") }];
+  if (process.platform !== "win32") return [{ name: "/", path: "/", isGit: existsSync8("/.git") }];
   const roots = [];
   for (let code = 67; code <= 90; code++) {
     const name = `${String.fromCharCode(code)}:\\`;
-    if (existsSync7(name)) roots.push({ name, path: name, isGit: existsSync7(join6(name, ".git")) });
+    if (existsSync8(name)) roots.push({ name, path: name, isGit: existsSync8(join7(name, ".git")) });
   }
   return roots.sort((a2, b2) => a2.name.localeCompare(b2.name)).slice(0, 200);
 }
@@ -7618,13 +7783,13 @@ function stripTrailing(path) {
 import { DatabaseSync } from "node:sqlite";
 import { mkdirSync as mkdirSync3 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { join as join7, basename as basename4 } from "node:path";
+import { join as join8, basename as basename4 } from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
 var Store = class {
   db;
-  constructor(dir = process.env.OFFHAND_HOME ?? join7(homedir6(), ".offhand")) {
+  constructor(dir = process.env.OFFHAND_HOME ?? join8(homedir6(), ".offhand")) {
     mkdirSync3(dir, { recursive: true });
-    this.db = new DatabaseSync(join7(dir, "offhand.db"));
+    this.db = new DatabaseSync(join8(dir, "offhand.db"));
     this.db.exec(`
       PRAGMA journal_mode = WAL;
       CREATE TABLE IF NOT EXISTS sessions (
@@ -43350,17 +43515,17 @@ var RelayClient = class {
 };
 
 // ../daemon/src/pairing.ts
-import { existsSync as existsSync8, readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "node:fs";
+import { existsSync as existsSync9, readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 import { randomInt } from "node:crypto";
-var PAIRING_DIR = process.env.OFFHAND_HOME ?? join8(homedir7(), ".offhand");
-var PAIRING_PATH = join8(PAIRING_DIR, "pairing.json");
+var PAIRING_DIR = process.env.OFFHAND_HOME ?? join9(homedir7(), ".offhand");
+var PAIRING_PATH = join9(PAIRING_DIR, "pairing.json");
 var POLL_MS = 2e3;
 var POLL_TIMEOUT_MS = 10 * 60 * 1e3;
 async function ensurePairing(relayUrl2, forceNew = false, webUrl2 = "https://offhand-web.onrender.com") {
   await ready;
-  if (!forceNew && existsSync8(PAIRING_PATH)) {
+  if (!forceNew && existsSync9(PAIRING_PATH)) {
     const f2 = JSON.parse(readFileSync4(PAIRING_PATH, "utf8"));
     const kp2 = { publicKey: fromB64u(f2.daemonPublicKey), secretKey: fromB64u(f2.daemonSecretKey) };
     const phonePk = fromB64u(f2.phonePublicKey);
@@ -43433,7 +43598,7 @@ async function ensurePairing(relayUrl2, forceNew = false, webUrl2 = "https://off
 // ../daemon/src/approvals.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 var ApprovalBroker = class {
   constructor(timeoutMs) {
     this.timeoutMs = timeoutMs;
@@ -43457,7 +43622,7 @@ var ApprovalBroker = class {
     }
     const risk = classifyRisk(toolName, input);
     const filePath = input?.file_path;
-    if (toolName === "Read" && typeof filePath === "string" && filePath.toLowerCase().startsWith(join9(tmpdir2(), "offhand-attachments").toLowerCase())) {
+    if (toolName === "Read" && typeof filePath === "string" && filePath.toLowerCase().startsWith(join10(tmpdir2(), "offhand-attachments").toLowerCase())) {
       return Promise.resolve({ approve: true });
     }
     if (this.policyProvider() === "trusting" && risk === "low" && toolName !== "AskUserQuestion") {
@@ -43610,27 +43775,27 @@ async function downloadArtifact(relayUrl2, sessionId, blobId, keys) {
 
 // ../daemon/src/autostart.ts
 import { homedir as homedir8 } from "node:os";
-import { join as join10, resolve as resolve4, dirname as dirname4 } from "node:path";
-import { existsSync as existsSync9, readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, rmSync } from "node:fs";
+import { join as join11, resolve as resolve4, dirname as dirname4 } from "node:path";
+import { existsSync as existsSync10, readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, rmSync } from "node:fs";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { spawnSync } from "node:child_process";
 import { tmpdir as tmpdir3 } from "node:os";
 var __dirname2 = dirname4(fileURLToPath4(import.meta.url));
 var SHORTCUT_NAME = "OffhandDaemon.lnk";
-var OFFHAND_HOME = process.env.OFFHAND_HOME ?? join10(homedir8(), ".offhand");
+var OFFHAND_HOME = process.env.OFFHAND_HOME ?? join11(homedir8(), ".offhand");
 function getStartupDir() {
   if (process.platform !== "win32") {
-    return join10(homedir8(), ".config", "autostart");
+    return join11(homedir8(), ".config", "autostart");
   }
-  return join10(process.env.APPDATA ?? "", "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
+  return join11(process.env.APPDATA ?? "", "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
 }
 function getWrapperPath() {
-  const wrapperDir = join10(OFFHAND_HOME, "autostart");
+  const wrapperDir = join11(OFFHAND_HOME, "autostart");
   mkdirSync5(wrapperDir, { recursive: true });
-  return join10(wrapperDir, "start-daemon.bat");
+  return join11(wrapperDir, "start-daemon.bat");
 }
 function getShortcutPath() {
-  return join10(getStartupDir(), SHORTCUT_NAME);
+  return join11(getStartupDir(), SHORTCUT_NAME);
 }
 function buildWrapperScript(config2, entry = process.argv[1] ?? "", execPath = process.execPath) {
   const wsArgs2 = config2.workspaces.map((w2) => `--workspace "${w2}"`).join(" ");
@@ -43659,7 +43824,7 @@ $Shortcut.Arguments = "/c ${targetPath}"
 $Shortcut.WorkingDirectory = "${resolve4(__dirname2, "..", "..")}"
 $Shortcut.Description = "Offhand Daemon - Auto-start on login"
 $Shortcut.Save()`;
-  const scriptPath = join10(tmpdir3(), "offhand-create-shortcut.ps1");
+  const scriptPath = join11(tmpdir3(), "offhand-create-shortcut.ps1");
   writeFileSync4(scriptPath, psScript);
   const result = spawnSync("powershell", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", scriptPath], { encoding: "utf8", shell: true });
   try {
@@ -43669,7 +43834,7 @@ $Shortcut.Save()`;
   return { success: result.status === 0, output: result.stdout + result.stderr };
 }
 function checkShortcutExists(shortcutPath) {
-  return existsSync9(shortcutPath);
+  return existsSync10(shortcutPath);
 }
 function installAutostart(config2) {
   const wrapperPath = getWrapperPath();
@@ -43689,7 +43854,7 @@ function getAutostartStatus() {
   const shortcutPath = getShortcutPath();
   const installed = checkShortcutExists(shortcutPath);
   const wrapperPath = getWrapperPath();
-  const wrapperExists = existsSync9(wrapperPath);
+  const wrapperExists = existsSync10(wrapperPath);
   let details = `Shortcut: ${shortcutPath} (${installed ? "EXISTS" : "MISSING"})`;
   if (wrapperExists) {
     details += `
@@ -43698,7 +43863,7 @@ Wrapper: ${wrapperPath} (EXISTS)`;
   return { installed, details };
 }
 function saveConfig(config2) {
-  const configPath = join10(OFFHAND_HOME, "autostart.json");
+  const configPath = join11(OFFHAND_HOME, "autostart.json");
   writeFileSync4(configPath, JSON.stringify(config2, null, 2));
 }
 function getConfigFromStore() {
@@ -43746,7 +43911,7 @@ var devUrl = argValue("--dev-url");
 var store = new Store();
 var wsArgs = argValues("--workspace").map((w2) => resolve5(w2));
 for (const w2 of wsArgs) {
-  if (!existsSync10(w2)) {
+  if (!existsSync11(w2)) {
     console.error(`workspace does not exist: ${w2}`);
     process.exit(1);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "offhands",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Phone → coding-agent relay. Daemon runs on your laptop, PWA on your phone. E2E encrypted.",
   "license": "UNLICENSED",
   "type": "module",
@@ -23,4 +23,4 @@
   "devDependencies": {
     "esbuild": "^0.24.0"
   }
-}
+}