runwork 0.24.1 → 0.25.1

package/dist/index.js

@@ -1380,8 +1380,154 @@ var init_identity = __esm(() => {
   init_subprocess();
 });
 
+// src/utils/ignore-matcher.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { basename, join as join4 } from "path";
+function defaultIgnoreSets() {
+  return {
+    dirs: new Set(DEFAULT_DIR_NAMES),
+    files: new Set(DEFAULT_FILE_NAMES),
+    extensions: new Set(DEFAULT_EXTENSIONS)
+  };
+}
+function parseGitignoreContent(content) {
+  const dirs = new Set;
+  const files = new Set;
+  for (const rawLine of content.split(`
+`)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#"))
+      continue;
+    if (line.startsWith("!"))
+      continue;
+    if (GLOB_CHARS.test(line))
+      continue;
+    let pattern = line;
+    const isDirOnly = pattern.endsWith("/");
+    if (isDirOnly)
+      pattern = pattern.slice(0, -1);
+    if (pattern.startsWith("/"))
+      pattern = pattern.slice(1);
+    if (!pattern)
+      continue;
+    if (pattern.includes("/"))
+      continue;
+    if (isDirOnly) {
+      dirs.add(pattern);
+    } else {
+      dirs.add(pattern);
+      files.add(pattern);
+    }
+  }
+  return { dirs, files };
+}
+function loadGitignoreFromDir(dir) {
+  const path = join4(dir, ".gitignore");
+  if (!existsSync4(path))
+    return { dirs: new Set, files: new Set };
+  try {
+    return parseGitignoreContent(readFileSync4(path, "utf-8"));
+  } catch {
+    return { dirs: new Set, files: new Set };
+  }
+}
+function buildIgnoreSets(dir) {
+  const sets = defaultIgnoreSets();
+  const parsed = loadGitignoreFromDir(dir);
+  for (const name of parsed.dirs)
+    sets.dirs.add(name);
+  for (const name of parsed.files)
+    sets.files.add(name);
+  return sets;
+}
+function isPathIgnored(filePath, sets) {
+  const name = basename(filePath);
+  if (sets.dirs.has(name))
+    return true;
+  if (sets.files.has(name))
+    return true;
+  const dotIndex = name.lastIndexOf(".");
+  if (dotIndex >= 0) {
+    const ext = name.slice(dotIndex);
+    if (sets.extensions.has(ext))
+      return true;
+  }
+  return false;
+}
+function isRelPathIgnored(relPath, sets) {
+  const segments = relPath.split("/");
+  for (let i = 0;i < segments.length - 1; i++) {
+    if (sets.dirs.has(segments[i]))
+      return true;
+  }
+  return isPathIgnored(relPath, sets);
+}
+var ALWAYS_IGNORED_DIRS, DEFAULT_DIR_NAMES, DEFAULT_FILE_NAMES, DEFAULT_EXTENSIONS, GLOB_CHARS;
+var init_ignore_matcher = __esm(() => {
+  ALWAYS_IGNORED_DIRS = [
+    ".git",
+    "node_modules",
+    ".runwork",
+    ".bun-cache",
+    ".npm-cache",
+    ".pnpm-store",
+    ".turbo",
+    ".vite",
+    ".cache",
+    "coverage",
+    "dist"
+  ];
+  DEFAULT_DIR_NAMES = ALWAYS_IGNORED_DIRS;
+  DEFAULT_FILE_NAMES = [
+    ".dev.vars",
+    ".env"
+  ];
+  DEFAULT_EXTENSIONS = [
+    ".log"
+  ];
+  GLOB_CHARS = /[*?\[\]]/;
+});
+
+// src/git/repo-config.ts
+function hardenRepoForRestrictedFs(cwd) {
+  for (const [key, value] of HARDENING) {
+    try {
+      execFileSync("git", ["config", key, value], { cwd, stdio: "pipe" });
+    } catch {}
+  }
+}
+function buildInitialGitignore() {
+  const dirs = ALWAYS_IGNORED_DIRS.filter((dir) => dir !== ".git").map((dir) => `${dir}/`);
+  return [
+    "# Dependencies, caches and build output",
+    ...dirs,
+    "",
+    "# Local secrets. Never commit these.",
+    ".dev.vars",
+    ".dev.vars*",
+    ".env",
+    ".env.*",
+    "",
+    "# Logs and tool state",
+    "*.log",
+    "*.tsbuildinfo",
+    ".eslintcache",
+    ""
+  ].join(`
+`);
+}
+var HARDENING;
+var init_repo_config = __esm(() => {
+  init_subprocess();
+  init_ignore_matcher();
+  HARDENING = [
+    ["gc.auto", "0"],
+    ["maintenance.auto", "false"]
+  ];
+});
+
 // src/git/preflight.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { win32 as winPath } from "path";
 import { homedir as homedir3 } from "os";
 function tryRun(bin) {
@@ -1403,9 +1549,9 @@ function whereGit() {
     const out = buf.toString("utf-8");
     const lines = out.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
     const exe = lines.find((line) => /\.exe$/i.test(line));
-    if (exe && existsSync4(exe))
+    if (exe && existsSync5(exe))
       return exe;
-    const fallback = lines.find((line) => existsSync4(line));
+    const fallback = lines.find((line) => existsSync5(line));
     return fallback ?? null;
   } catch {
     return null;
@@ -1430,7 +1576,7 @@ function registryGit() {
         continue;
       const installRoot = match[1].trim();
       const gitExe = winPath.join(installRoot, "cmd", "git.exe");
-      if (existsSync4(gitExe))
+      if (existsSync5(gitExe))
         return gitExe;
     } catch {}
   }
@@ -1498,7 +1644,7 @@ function probeGit() {
       }
     }
     for (const candidate of canonicalGitCandidates()) {
-      if (!existsSync4(candidate))
+      if (!existsSync5(candidate))
         continue;
       const verify = tryRun(candidate);
       if (verify.ok) {
@@ -1636,106 +1782,6 @@ async function resolveApp(client, nameOrId, workspaceId) {
   process.exit(1);
 }
 
-// src/utils/ignore-matcher.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-import { basename, join as join4 } from "path";
-function defaultIgnoreSets() {
-  return {
-    dirs: new Set(DEFAULT_DIR_NAMES),
-    files: new Set(DEFAULT_FILE_NAMES),
-    extensions: new Set(DEFAULT_EXTENSIONS)
-  };
-}
-function parseGitignoreContent(content) {
-  const dirs = new Set;
-  const files = new Set;
-  for (const rawLine of content.split(`
-`)) {
-    const line = rawLine.trim();
-    if (!line || line.startsWith("#"))
-      continue;
-    if (line.startsWith("!"))
-      continue;
-    if (GLOB_CHARS.test(line))
-      continue;
-    let pattern = line;
-    const isDirOnly = pattern.endsWith("/");
-    if (isDirOnly)
-      pattern = pattern.slice(0, -1);
-    if (pattern.startsWith("/"))
-      pattern = pattern.slice(1);
-    if (!pattern)
-      continue;
-    if (pattern.includes("/"))
-      continue;
-    if (isDirOnly) {
-      dirs.add(pattern);
-    } else {
-      dirs.add(pattern);
-      files.add(pattern);
-    }
-  }
-  return { dirs, files };
-}
-function loadGitignoreFromDir(dir) {
-  const path = join4(dir, ".gitignore");
-  if (!existsSync5(path))
-    return { dirs: new Set, files: new Set };
-  try {
-    return parseGitignoreContent(readFileSync4(path, "utf-8"));
-  } catch {
-    return { dirs: new Set, files: new Set };
-  }
-}
-function buildIgnoreSets(dir) {
-  const sets = defaultIgnoreSets();
-  const parsed = loadGitignoreFromDir(dir);
-  for (const name of parsed.dirs)
-    sets.dirs.add(name);
-  for (const name of parsed.files)
-    sets.files.add(name);
-  return sets;
-}
-function isPathIgnored(filePath, sets) {
-  const name = basename(filePath);
-  if (sets.dirs.has(name))
-    return true;
-  if (sets.files.has(name))
-    return true;
-  const dotIndex = name.lastIndexOf(".");
-  if (dotIndex >= 0) {
-    const ext = name.slice(dotIndex);
-    if (sets.extensions.has(ext))
-      return true;
-  }
-  return false;
-}
-function isRelPathIgnored(relPath, sets) {
-  const segments = relPath.split("/");
-  for (let i = 0;i < segments.length - 1; i++) {
-    if (sets.dirs.has(segments[i]))
-      return true;
-  }
-  return isPathIgnored(relPath, sets);
-}
-var DEFAULT_DIR_NAMES, DEFAULT_FILE_NAMES, DEFAULT_EXTENSIONS, GLOB_CHARS;
-var init_ignore_matcher = __esm(() => {
-  DEFAULT_DIR_NAMES = [
-    ".git",
-    "node_modules",
-    ".runwork",
-    ".bun-cache"
-  ];
-  DEFAULT_FILE_NAMES = [
-    ".dev.vars",
-    ".env"
-  ];
-  DEFAULT_EXTENSIONS = [
-    ".log"
-  ];
-  GLOB_CHARS = /[*?\[\]]/;
-});
-
 // src/template/manifest.ts
 import { createHash } from "crypto";
 import { readFileSync as readFileSync5, writeFileSync as writeFileSync2, existsSync as existsSync6, readdirSync, mkdirSync as mkdirSync2 } from "fs";
@@ -1782,17 +1828,39 @@ async function saveManifest(dir, manifest) {
   }
   writeFileSync2(join5(manifestDir, "template-manifest.json"), JSON.stringify(manifest, null, 2));
 }
+function loadManifestSync(dir) {
+  const manifestPath = join5(dir, ".runwork", "template-manifest.json");
+  if (!existsSync6(manifestPath))
+    return null;
+  try {
+    return normalizeManifest(JSON.parse(readFileSync5(manifestPath, "utf-8")));
+  } catch {
+    return null;
+  }
+}
+function isPristineTemplateFile(dir, relPath, manifest) {
+  const expectedHash = manifest?.files[relPath];
+  if (!expectedHash)
+    return false;
+  try {
+    return sha256(readFileSync5(join5(dir, relPath))) === expectedHash;
+  } catch {
+    return false;
+  }
+}
+function normalizeManifest(manifest) {
+  const files = {};
+  for (const [relPath, hash] of Object.entries(manifest.files)) {
+    files[relPath.split("\\").join("/")] = hash;
+  }
+  return { ...manifest, files };
+}
 async function loadManifest(dir) {
   const manifestPath = join5(dir, ".runwork", "template-manifest.json");
   if (!existsSync6(manifestPath))
     return null;
   try {
-    const manifest = JSON.parse(readFileSync5(manifestPath, "utf-8"));
-    const files = {};
-    for (const [relPath, hash] of Object.entries(manifest.files)) {
-      files[relPath.split("\\").join("/")] = hash;
-    }
-    return { ...manifest, files };
+    return normalizeManifest(JSON.parse(readFileSync5(manifestPath, "utf-8")));
   } catch {
     return null;
   }
@@ -2169,7 +2237,7 @@ var init_agent_guidance = __esm(() => {
     "worker/components.ts": "Reusable UI components other workspace apps can embed.",
     "shared/types.ts": "TypeScript interfaces shared between frontend and backend.",
     "src/pages/": "Frontend React pages. Each file becomes a route.",
-    "blueprint.json": "App feature registry. Update after adding entities, workflows, agents, etc.",
+    "blueprint.json": "App feature registry. Update after adding entities, workflows, agents, etc., including each one's valueProfile (what manual work it replaced).",
     "CLAUDE.md": "Complete framework documentation. Read this before editing anything."
   };
   COMMON_TIPS = [
@@ -2180,6 +2248,7 @@ var init_agent_guidance = __esm(() => {
     "Every workflow MUST have a trigger (API endpoint, scheduled job, or UI button). Workflows without triggers are dead code.",
     "Every conversational agent MUST have a frontend page to access it.",
     "After adding entities, workflows, or agents, update blueprint.json with the new metadata.",
+    "When you add a feature that takes over manual work, ASK your human what they used to do by hand, how often THEY did it, and how long one round took, then record it as a valueProfile on that blueprint element. Set confirmedWithHuman only if they actually agreed to the numbers. If they cannot answer, omit valueProfile rather than guessing. See the valueProfile section in CLAUDE.md.",
     "Never guess integration IDs. Run: runwork integrations search <query>"
   ];
 });
@@ -2250,10 +2319,7 @@ async function execInit(client, appName, workspace, options = {}, creds) {
     execFileSync("git", ["remote", "set-url", "runwork", remoteUrl], { cwd: dir, stdio: "pipe" });
   }
   if (!existsSync7(join8(dir, ".gitignore"))) {
-    writeFileSync4(join8(dir, ".gitignore"), `node_modules/
-.runwork/
-.dev.vars
-`);
+    writeFileSync4(join8(dir, ".gitignore"), buildInitialGitignore());
   }
   execFileSync("git", ["add", "--", ".runwork.json", ".gitignore"], { cwd: dir, stdio: "pipe" });
   try {
@@ -2334,6 +2400,7 @@ var init_init = __esm(() => {
   init_store();
   init_client();
   init_identity();
+  init_repo_config();
   init_preflight();
   init_prompt();
   init_manifest();
@@ -2395,23 +2462,6 @@ var init_remote = __esm(() => {
   init_subprocess();
 });
 
-// src/git/repo-config.ts
-function hardenRepoForRestrictedFs(cwd) {
-  for (const [key, value] of HARDENING) {
-    try {
-      execFileSync("git", ["config", key, value], { cwd, stdio: "pipe" });
-    } catch {}
-  }
-}
-var HARDENING;
-var init_repo_config = __esm(() => {
-  init_subprocess();
-  HARDENING = [
-    ["gc.auto", "0"],
-    ["maintenance.auto", "false"]
-  ];
-});
-
 // src/git/classify-sync-error.ts
 function classifySyncError(raw) {
   if (!raw)
@@ -2419,6 +2469,9 @@ function classifySyncError(raw) {
   const s = raw.toLowerCase();
   if (raw === STASH_CONFLICT)
     return "conflict";
+  if (s.includes("[remote rejected]") || s.includes("[rejected]") || s.includes("pre-receive hook declined") || s.includes("push declined")) {
+    return "rejected";
+  }
   if (s.includes("does not appear to be a git repository") || s.includes("'runwork' does not appear") || s.includes("no such remote") || s.includes("remote") && s.includes("not found")) {
     return "no-remote";
   }
@@ -2466,6 +2519,19 @@ function diagnoseSyncError(raw) {
           "Confirm outbound access to runwork.ai, then run `runwork dev` again"
         ]
       };
+    case "rejected":
+      return {
+        reason,
+        message: "the server refused the push",
+        diagnosis: `The runwork remote rejected this push, so nothing was updated on the server. It said:
+${(raw ?? "").trim()}`,
+        suggestions: [
+          'Read the "remote:" lines above: they name the exact reason and the fix',
+          "If an oversized file was rejected, remove it from the commit and add it to .gitignore",
+          "If the history is reported as damaged, contact support to rebuild it",
+          "Retrying without changing anything will fail the same way"
+        ]
+      };
     case "conflict":
       return {
         reason,
@@ -2941,26 +3007,61 @@ function hasTrackedChanges(cwd) {
   }
 }
 function removeConflictingUntrackedFiles(cwd) {
+  const kept = [];
   try {
     const remoteFiles = execFileSync("git", ["ls-tree", "-r", "--name-only", "runwork/main"], {
       cwd,
       encoding: "utf-8"
     }).trim().split(`
 `);
-    const untrackedOutput = execFileSync("git", ["ls-files", "--others", "--exclude-standard"], {
+    const untrackedOutput = execFileSync("git", ["-c", "core.quotePath=false", "ls-files", "--others", "--exclude-standard"], {
       cwd,
       encoding: "utf-8"
     }).trim();
     const untracked = new Set(untrackedOutput.split(`
 `).filter(Boolean));
+    const manifest = loadManifestSync(cwd);
     for (const file of remoteFiles) {
-      if (untracked.has(file)) {
+      if (!untracked.has(file))
+        continue;
+      if (matchesRemote(cwd, file) || isPristineTemplateFile(cwd, file, manifest)) {
         try {
           unlinkSync2(join11(cwd, file));
         } catch {}
+      } else {
+        kept.push(file);
       }
     }
   } catch {}
+  return { kept };
+}
+function matchesRemote(cwd, file) {
+  try {
+    const remoteOid = execFileSync("git", ["rev-parse", `runwork/main:${file}`], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    const localOid = execFileSync("git", ["hash-object", "--", file], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return Boolean(remoteOid) && remoteOid === localOid;
+  } catch {
+    return false;
+  }
+}
+function conflictedPaths(cwd) {
+  try {
+    return execFileSync("git", ["-c", "core.quotePath=false", "diff", "--name-only", "--diff-filter=U"], {
+      cwd,
+      encoding: "utf-8"
+    }).trim().split(`
+`).filter(Boolean);
+  } catch {
+    return [];
+  }
 }
 function extractGitError(err) {
   if (err && typeof err === "object") {
@@ -2995,9 +3096,11 @@ function syncWithRemote(cwd) {
   }
   let status = "synced";
   let syncError;
+  let keptUntracked = [];
+  let remoteOverwrote = [];
   try {
     execFileSync("git", ["fetch", "runwork", "main"], { cwd, stdio: "pipe" });
-    removeConflictingUntrackedFiles(cwd);
+    keptUntracked = removeConflictingUntrackedFiles(cwd).kept;
     try {
       execFileSync("git", ["rebase", "runwork/main"], { cwd, stdio: "pipe" });
     } catch (rebaseErr) {
@@ -3008,6 +3111,7 @@ function syncWithRemote(cwd) {
         execFileSync("git", ["merge", "runwork/main", "--allow-unrelated-histories", "--no-edit"], { cwd, stdio: "pipe" });
         status = "merged";
       } catch {
+        remoteOverwrote = conflictedPaths(cwd);
         try {
           execFileSync("git", ["merge", "--abort"], { cwd, stdio: "pipe" });
         } catch {}
@@ -3018,6 +3122,7 @@ function syncWithRemote(cwd) {
           try {
             execFileSync("git", ["merge", "--abort"], { cwd, stdio: "pipe" });
           } catch {}
+          remoteOverwrote = [];
           status = "sync-failed";
           syncError = extractGitError(mergeErr);
         }
@@ -3031,21 +3136,25 @@ function syncWithRemote(cwd) {
     try {
       execFileSync("git", ["stash", "pop"], { cwd, stdio: "pipe" });
     } catch {
-      return { status, pushed: false, error: "stash-conflict" };
+      return { status, pushed: false, error: "stash-conflict", keptUntracked, remoteOverwrote };
     }
   }
   if (status === "sync-failed") {
-    return { status, pushed: false, error: syncError };
+    return { status, pushed: false, error: syncError, keptUntracked, remoteOverwrote };
   }
   let pushed = false;
+  let pushError;
   try {
     execFileSync("git", ["push", "runwork", "HEAD:main"], { cwd, stdio: "pipe" });
     pushed = true;
-  } catch {}
-  return { status, pushed };
+  } catch (pushErr) {
+    pushError = extractGitError(pushErr);
+  }
+  return { status, pushed, pushError, keptUntracked, remoteOverwrote };
 }
 var init_sync = __esm(() => {
   init_subprocess();
+  init_manifest();
 });
 
 // src/git/critical-files.ts
@@ -4981,6 +5090,31 @@ export interface ClientErrorReport {
     level?: 'error' | 'warning' | 'info';
     category?: string;
 }
+/**
+ * Decide whether to send the permissive \`Permissions-Policy\` header for an app
+ * that is being embedded in an iframe.
+ *
+ * A document's own Permissions-Policy can only restrict, never grant: the grant
+ * comes from the embedding page's policy plus the iframe \`allow\` attribute. This
+ * header's job is therefore to stop the app self-restricting the features the
+ * platform preview delegates to it, and this predicate decides who is trusted
+ * enough to be handed that.
+ *
+ * Hostnames are parsed and compared exactly, never substring-matched against the
+ * raw header. The difference is not cosmetic: \`origin.endsWith('runwork.ai')\`
+ * also matches \`https://notrunwork.ai\`, and \`origin.includes(domain)\` matches
+ * \`https://evil-acme.com.attacker.net\` against a tenant's \`acme.com\`, which would
+ * hand an attacker's page camera, microphone, geolocation and screen capture over
+ * an embedded app.
+ *
+ * @param origin  The \`Origin\` header, or the \`Referer\` as a fallback. Origin is a
+ *                bare origin and Referer is a full URL; both parse the same way.
+ *                Empty means direct (non-embedded) access.
+ * @param allowedOrigins Comma-separated exact hostnames from \`ALLOWED_ORIGINS\`,
+ *                injected by the platform as the workspace's active custom
+ *                domains. Matched exactly; subdomains are deliberately excluded.
+ */
+export declare function shouldGrantIframePermissions(origin: string, allowedOrigins?: string): boolean;
 /**
  * Mount all core platform routes on the Hono app
  * Called from index.ts before user-defined routes
@@ -7839,7 +7973,7 @@ function createKeyboardListener() {
 }
 
 // src/generated/version.ts
-var VERSION = "0.24.1";
+var VERSION = "0.25.1";
 
 // src/commands/dev.ts
 var exports_dev = {};
@@ -8067,6 +8201,36 @@ async function execDev(options) {
         }
       }
     }
+    if (syncResult.remoteOverwrote && syncResult.remoteOverwrote.length > 0) {
+      if (useJson) {
+        jsonLine({ event: "sync_remote_overwrote", files: syncResult.remoteOverwrote, timestamp: ts() });
+      } else {
+        console.warn(yellow(`  Sync resolved conflicts in the remote's favour; local changes were replaced in: ${syncResult.remoteOverwrote.join(", ")}`));
+        console.warn(dim("  Recover them with `git reflog` / `git diff ORIG_HEAD` if that was wrong."));
+      }
+    }
+    if (syncResult.keptUntracked && syncResult.keptUntracked.length > 0) {
+      if (useJson) {
+        jsonLine({ event: "sync_kept_untracked", files: syncResult.keptUntracked, timestamp: ts() });
+      } else {
+        console.warn(yellow(`  Kept your untracked file(s) over the remote's copy: ${syncResult.keptUntracked.join(", ")}`));
+        console.warn(dim("  Commit or remove them so the sync can reconcile that path."));
+      }
+    }
+    if (!syncResult.pushed && syncResult.pushError) {
+      const diag = diagnoseSyncError(syncResult.pushError);
+      if (useJson) {
+        jsonLine({
+          event: "error",
+          phase: "push",
+          timestamp: ts(),
+          error: { reason: diag.reason, message: diag.message, diagnosis: diag.diagnosis, suggestions: diag.suggestions }
+        });
+      } else {
+        console.warn(yellow(`  Push failed: ${diag.message}`));
+        console.warn(dim(`  ${diag.diagnosis}`));
+      }
+    }
     if (useJson) {
       jsonLine({ event: "startup", phase: "sync", status: syncResult.status, pushed: syncResult.pushed, timestamp: ts() });
       if (syncResult.status === "sync-failed") {
@@ -9747,6 +9911,187 @@ var init_registry = __esm(() => {
 });
 
 // src/agents/utils/session-digest.ts
+function emptyGapBuckets() {
+  return { lt10s: 0, s10to30: 0, s30to2m: 0, m2to5: 0, m5to15: 0, gte15m: 0 };
+}
+function gapBucketKey(seconds) {
+  if (seconds < 10)
+    return "lt10s";
+  if (seconds < 30)
+    return "s10to30";
+  if (seconds < 120)
+    return "s30to2m";
+  if (seconds < 300)
+    return "m2to5";
+  if (seconds < 900)
+    return "m5to15";
+  return "gte15m";
+}
+function buildGapHistogram(epochMs) {
+  const ts = epochMs.filter((n) => Number.isFinite(n)).sort((a, b) => a - b);
+  if (ts.length < 2)
+    return null;
+  const gapCounts = emptyGapBuckets();
+  const gapSeconds = emptyGapBuckets();
+  let longest = 0;
+  for (let i = 1;i < ts.length; i++) {
+    const gap = (ts[i] - ts[i - 1]) / 1000;
+    const key = gapBucketKey(gap);
+    gapCounts[key]++;
+    gapSeconds[key] += gap;
+    if (gap > longest)
+      longest = gap;
+  }
+  for (const key of Object.keys(gapSeconds)) {
+    gapSeconds[key] = Math.round(gapSeconds[key]);
+  }
+  return {
+    gapCounts,
+    gapSeconds,
+    spanMinutes: Math.round((ts[ts.length - 1] - ts[0]) / 6000) / 10,
+    longestGapSeconds: Math.round(longest)
+  };
+}
+function emptySessionSignals() {
+  return {
+    provenance: null,
+    gapCounts: null,
+    gapSeconds: null,
+    spanMinutes: null,
+    longestGapSeconds: null,
+    permissionModes: null,
+    modeEscalations: null,
+    approvalPolicy: null,
+    sandboxPolicy: null,
+    subagentCount: null,
+    planModeUsed: null,
+    slashCommandCount: null,
+    modelInitiatedSkillCount: null,
+    promptLengthBuckets: null,
+    toolFailureStreakMax: null,
+    repeatedCallMax: null,
+    models: null,
+    tokens: null,
+    tokensByModel: null
+  };
+}
+function applyGapHistogram(signals, epochMs) {
+  const h = buildGapHistogram(epochMs);
+  if (!h)
+    return;
+  signals.gapCounts = h.gapCounts;
+  signals.gapSeconds = h.gapSeconds;
+  signals.spanMinutes = h.spanMinutes;
+  signals.longestGapSeconds = h.longestGapSeconds;
+}
+function promptLengthBucket(len) {
+  if (len < 120)
+    return "short";
+  if (len <= 600)
+    return "medium";
+  return "long";
+}
+function classifyClaudeProvenance(obj) {
+  const entrypoint = typeof obj.entrypoint === "string" ? obj.entrypoint : null;
+  const promptSource = typeof obj.promptSource === "string" ? obj.promptSource : null;
+  const originKind = obj.origin?.kind ?? null;
+  if (entrypoint === "sdk-cli" || entrypoint === "sdk-ts")
+    return "headless";
+  if (promptSource === "sdk")
+    return "headless";
+  if (originKind !== null && originKind !== "human")
+    return "agent-spawned";
+  if (entrypoint === "cli" || entrypoint === "claude-desktop" || entrypoint === "local-agent")
+    return "user-driven";
+  if (originKind === "human" || promptSource === "typed")
+    return "user-driven";
+  return null;
+}
+function sumTokenTotals(byModel) {
+  let tokensIn = 0;
+  let tokensOut = 0;
+  let cacheReadTokens = null;
+  let cacheCreationTokens = null;
+  for (const t of byModel.values()) {
+    tokensIn += t.tokensIn;
+    tokensOut += t.tokensOut;
+    if (t.cacheReadTokens !== null)
+      cacheReadTokens = (cacheReadTokens ?? 0) + t.cacheReadTokens;
+    if (t.cacheCreationTokens !== null)
+      cacheCreationTokens = (cacheCreationTokens ?? 0) + t.cacheCreationTokens;
+  }
+  return { tokensIn, tokensOut, cacheReadTokens, cacheCreationTokens };
+}
+function applyTokenMap(signals, byModel) {
+  if (byModel.size === 0)
+    return;
+  signals.models = [...byModel.keys()];
+  signals.tokens = sumTokenTotals(byModel);
+  signals.tokensByModel = Object.fromEntries(byModel);
+}
+function stableStringify(value) {
+  if (Array.isArray(value))
+    return "[" + value.map(stableStringify).join(",") + "]";
+  if (value && typeof value === "object") {
+    return "{" + Object.keys(value).sort().map((k) => JSON.stringify(k) + ":" + stableStringify(value[k])).join(",") + "}";
+  }
+  return JSON.stringify(value) ?? "undefined";
+}
+
+class FrictionCounters {
+  failStreak = 0;
+  failStreakMax = 0;
+  callCounts = new Map;
+  repeatedCallMax = 0;
+  result(failed) {
+    if (failed) {
+      this.failStreak++;
+      if (this.failStreak > this.failStreakMax)
+        this.failStreakMax = this.failStreak;
+    } else {
+      this.failStreak = 0;
+    }
+  }
+  call(name, args) {
+    const key = name + "\x00" + stableStringify(args ?? null);
+    const n = (this.callCounts.get(key) ?? 0) + 1;
+    this.callCounts.set(key, n);
+    if (n > this.repeatedCallMax)
+      this.repeatedCallMax = n;
+  }
+}
+function recordAssetAttempt(acc, rawName, epochMs, turnsBefore, toolCallsBefore) {
+  const existing = acc.get(rawName);
+  if (existing) {
+    existing.attempts++;
+    return;
+  }
+  acc.set(rawName, { firstEpochMs: epochMs, attempts: 1, turnsBefore, toolCallsBefore });
+}
+function buildAssetMarkers(acc, epochMs) {
+  if (acc.size === 0)
+    return;
+  const sorted = epochMs.filter((n) => Number.isFinite(n)).sort((a, b) => a - b);
+  const start = sorted[0];
+  const markers = [];
+  for (const [rawName, m] of acc) {
+    const first = m.firstEpochMs;
+    const histogram = first !== null ? buildGapHistogram(sorted.filter((ms) => ms <= first)) : null;
+    markers.push({
+      kind: "skill",
+      rawName,
+      attempts: m.attempts,
+      turnsBefore: m.turnsBefore,
+      toolCallsBefore: m.toolCallsBefore,
+      wallSecondsToAsset: first !== null && sorted.length > 0 ? Math.round((first - start) / 1000) : null,
+      gapCountsToAsset: histogram?.gapCounts ?? null,
+      gapSecondsToAsset: histogram?.gapSeconds ?? null
+    });
+    if (markers.length >= 8)
+      break;
+  }
+  return markers;
+}
 function extractClaudeJsonlSession(raw, agentSlug, project) {
   const digest = {
     agentSlug,
@@ -9760,6 +10105,21 @@ function extractClaudeJsonlSession(raw, agentSlug, project) {
     errorCount: 0,
     assistantTurns: 0
   };
+  const signals = emptySessionSignals();
+  const epochMs = [];
+  const modeStream = [];
+  let subagentCount = 0;
+  let planToolSeen = false;
+  let slashCommandCount = 0;
+  let modelInitiatedSkillCount = 0;
+  const promptBuckets = { short: 0, medium: 0, long: 0 };
+  const tokensByModel = new Map;
+  const seenUsagePairs = new Set;
+  let provenanceClassified = false;
+  let sidechainUserSeen = false;
+  let toolCallsSeen = 0;
+  const assetAcc = new Map;
+  const friction = new FrictionCounters;
   for (const line of raw.split(`
 `)) {
     if (!line.trim())
@@ -9775,12 +10135,29 @@ function extractClaudeJsonlSession(raw, agentSlug, project) {
       if (!digest.start)
         digest.start = ts;
       digest.end = ts;
+      const ms = Date.parse(ts);
+      if (Number.isFinite(ms))
+        epochMs.push(ms);
     }
     const type = obj.type;
+    if (type === "permission-mode" && typeof obj.permissionMode === "string") {
+      modeStream.push(obj.permissionMode);
+      continue;
+    }
     const message = obj.message;
     if (!message || typeof message !== "object")
       continue;
     if (type === "user" && message.role === "user") {
+      if (obj.isSidechain === true)
+        sidechainUserSeen = true;
+      else if (!provenanceClassified) {
+        provenanceClassified = true;
+        signals.provenance = classifyClaudeProvenance(obj);
+      }
+      if (typeof obj.permissionMode === "string")
+        modeStream.push(obj.permissionMode);
+      const originKind = obj.origin?.kind;
+      const humanLine = obj.isSidechain !== true && (originKind === undefined || originKind === "human");
       const texts = [];
       if (typeof message.content === "string") {
         texts.push(message.content);
@@ -9790,15 +10167,22 @@ function extractClaudeJsonlSession(raw, agentSlug, project) {
             const it = item;
             if (it.type === "text" && typeof it.text === "string")
               texts.push(it.text);
-            if (it.type === "tool_result" && it.is_error === true)
-              digest.errorCount++;
+            if (it.type === "tool_result") {
+              if (it.is_error === true)
+                digest.errorCount++;
+              friction.result(it.is_error === true);
+            }
           }
         }
       }
       for (const text2 of texts) {
         const trimmed = text2.trim();
+        if (trimmed.startsWith("<command-name>"))
+          slashCommandCount++;
         if (!trimmed || SKIP_PREFIXES.some((p) => trimmed.startsWith(p)))
           continue;
+        if (humanLine)
+          promptBuckets[promptLengthBucket(trimmed.length)]++;
         if (digest.userMessages.length >= MAX_MSGS_PER_SESSION) {
           digest.droppedUserMessages++;
           continue;
@@ -9806,15 +10190,47 @@ function extractClaudeJsonlSession(raw, agentSlug, project) {
         digest.userMessages.push(trimmed.length > MAX_MSG_CHARS ? trimmed.slice(0, MAX_MSG_CHARS) + " [...]" : trimmed);
       }
     }
-    if (type === "assistant" && message.role === "assistant" && Array.isArray(message.content)) {
+    if (type === "assistant" && message.role === "assistant") {
+      const am = message;
+      const model = typeof am.model === "string" ? am.model : null;
+      const usage = am.usage;
+      if (usage && typeof usage === "object" && model && model !== "<synthetic>") {
+        const requestId = typeof obj.requestId === "string" ? obj.requestId : null;
+        const pairKey = typeof am.id === "string" && requestId ? `${am.id}:${requestId}` : null;
+        if (!pairKey || !seenUsagePairs.has(pairKey)) {
+          if (pairKey)
+            seenUsagePairs.add(pairKey);
+          const t = tokensByModel.get(model) ?? { tokensIn: 0, tokensOut: 0, cacheReadTokens: 0, cacheCreationTokens: 0 };
+          t.tokensIn += finiteNum(usage.input_tokens);
+          t.tokensOut += finiteNum(usage.output_tokens);
+          t.cacheReadTokens = (t.cacheReadTokens ?? 0) + finiteNum(usage.cache_read_input_tokens);
+          t.cacheCreationTokens = (t.cacheCreationTokens ?? 0) + finiteNum(usage.cache_creation_input_tokens);
+          tokensByModel.set(model, t);
+        }
+      }
+      if (!Array.isArray(message.content))
+        continue;
       digest.assistantTurns++;
       for (const item of message.content) {
         if (item && typeof item === "object") {
           const it = item;
           if (it.type === "tool_use" && typeof it.name === "string") {
             digest.toolCounts[it.name] = (digest.toolCounts[it.name] ?? 0) + 1;
-            if (it.name === "Skill" && it.input?.skill)
-              digest.skillInvocations.push(it.input.skill);
+            friction.call(it.name, it.input);
+            if (it.name === "Agent" || it.name === "Task")
+              subagentCount++;
+            if (it.name === "EnterPlanMode" || it.name === "ExitPlanMode")
+              planToolSeen = true;
+            if (it.name === "Skill") {
+              modelInitiatedSkillCount++;
+              if (it.input?.skill)
+                digest.skillInvocations.push(it.input.skill);
+            }
+            if (it.name.endsWith("__save_skill") && typeof it.input?.name === "string" && it.input.name.trim()) {
+              const ms = ts ? Date.parse(ts) : NaN;
+              recordAssetAttempt(assetAcc, it.input.name.trim(), Number.isFinite(ms) ? ms : null, Math.max(0, digest.assistantTurns - 1), toolCallsSeen);
+            }
+            toolCallsSeen++;
           }
         }
       }
@@ -9822,11 +10238,40 @@ function extractClaudeJsonlSession(raw, agentSlug, project) {
   }
   if (digest.userMessages.length === 0)
     return null;
+  if (!provenanceClassified && sidechainUserSeen)
+    signals.provenance = "agent-spawned";
+  applyGapHistogram(signals, epochMs);
+  const collapsed = modeStream.filter((m, i) => i === 0 || m !== modeStream[i - 1]);
+  signals.permissionModes = collapsed.length > 0 ? [...new Set(collapsed)] : null;
+  signals.modeEscalations = collapsed.length > 0 ? collapsed.length - 1 : null;
+  signals.subagentCount = subagentCount;
+  signals.planModeUsed = planToolSeen || collapsed.includes("plan");
+  signals.slashCommandCount = slashCommandCount;
+  signals.modelInitiatedSkillCount = modelInitiatedSkillCount;
+  signals.promptLengthBuckets = promptBuckets;
+  signals.toolFailureStreakMax = friction.failStreakMax;
+  signals.repeatedCallMax = friction.repeatedCallMax;
+  applyTokenMap(signals, tokensByModel);
+  digest.signals = signals;
+  digest.assetMarkers = buildAssetMarkers(assetAcc, epochMs);
   return digest;
 }
 function decodeProjectDir(encoded) {
   return encoded.replace(/^-/, "/").replace(/-/g, "/");
 }
+function classifyCodexProvenance(meta) {
+  const source = meta.source;
+  const originator = typeof meta.originator === "string" ? meta.originator : null;
+  if (source && typeof source === "object" && "subagent" in source)
+    return "agent-spawned";
+  if (originator === "Claude Code")
+    return "agent-spawned";
+  if (source === "exec")
+    return "headless";
+  if (source === "cli" || source === "vscode")
+    return "user-driven";
+  return null;
+}
 function geminiMessageText(content) {
   if (typeof content === "string")
     return content;
@@ -9862,6 +10307,9 @@ function extractGeminiSession(raw, agentSlug, project) {
     digest.start = session.startTime;
   if (typeof session.lastUpdated === "string")
     digest.end = session.lastUpdated;
+  const signals = emptySessionSignals();
+  const epochMs = [];
+  const tokensByModel = new Map;
   for (const raw2 of session.messages) {
     const m = raw2;
     if (typeof m.timestamp === "string") {
@@ -9869,9 +10317,21 @@ function extractGeminiSession(raw, agentSlug, project) {
         digest.start = m.timestamp;
       if (!digest.end || m.timestamp > digest.end)
         digest.end = m.timestamp;
+      const ms = Date.parse(m.timestamp);
+      if (Number.isFinite(ms))
+        epochMs.push(ms);
     }
     if (m.type === "gemini") {
       digest.assistantTurns++;
+      const tok = m.tokens;
+      if (tok && typeof tok === "object") {
+        const model = typeof m.model === "string" ? m.model : "unknown";
+        const t = tokensByModel.get(model) ?? { tokensIn: 0, tokensOut: 0, cacheReadTokens: 0, cacheCreationTokens: null };
+        t.tokensIn += finiteNum(tok.input);
+        t.tokensOut += finiteNum(tok.output) + finiteNum(tok.thoughts);
+        t.cacheReadTokens = (t.cacheReadTokens ?? 0) + finiteNum(tok.cached);
+        tokensByModel.set(model, t);
+      }
       continue;
     }
     if (m.type === "error") {
@@ -9889,7 +10349,12 @@ function extractGeminiSession(raw, agentSlug, project) {
     }
     digest.userMessages.push(text2.length > MAX_MSG_CHARS ? `${text2.slice(0, MAX_MSG_CHARS)}...` : text2);
   }
-  return digest.userMessages.length > 0 ? digest : null;
+  if (digest.userMessages.length === 0)
+    return null;
+  applyGapHistogram(signals, epochMs);
+  applyTokenMap(signals, tokensByModel);
+  digest.signals = signals;
+  return digest;
 }
 function extractCodexRolloutSession(raw, agentSlug) {
   const digest = {
@@ -9904,6 +10369,14 @@ function extractCodexRolloutSession(raw, agentSlug) {
     errorCount: 0,
     assistantTurns: 0
   };
+  const signals = emptySessionSignals();
+  const epochMs = [];
+  const models = [];
+  let lastTokenTotals = null;
+  let toolCallsSeen = 0;
+  const assetAcc = new Map;
+  const friction = new FrictionCounters;
+  let failureMarkerSeen = false;
   for (const line of raw.split(`
 `)) {
     if (!line.trim())
@@ -9919,12 +10392,49 @@ function extractCodexRolloutSession(raw, agentSlug) {
       if (!digest.start)
         digest.start = ts;
       digest.end = ts;
+      const ms = Date.parse(ts);
+      if (Number.isFinite(ms))
+        epochMs.push(ms);
     }
     const p = o.payload;
     if (!p || typeof p !== "object")
       continue;
-    if (o.type === "session_meta" && typeof p.cwd === "string") {
-      digest.project = p.cwd;
+    if (o.type === "session_meta") {
+      if (typeof p.cwd === "string")
+        digest.project = p.cwd;
+      signals.provenance = classifyCodexProvenance(p);
+      continue;
+    }
+    if (o.type === "turn_context") {
+      const ap = p.approval_policy;
+      if (typeof ap === "string")
+        signals.approvalPolicy = ap;
+      else if (ap && typeof ap === "object")
+        signals.approvalPolicy = Object.keys(ap)[0] ?? signals.approvalPolicy;
+      const sp = p.sandbox_policy;
+      if (sp && typeof sp === "object" && typeof sp.type === "string")
+        signals.sandboxPolicy = sp.type;
+      if (typeof p.model === "string" && !models.includes(p.model))
+        models.push(p.model);
+      continue;
+    }
+    if (o.type === "event_msg") {
+      if (p.type === "token_count") {
+        const info = p.info;
+        if (info && typeof info === "object" && info.total_token_usage && typeof info.total_token_usage === "object") {
+          lastTokenTotals = info.total_token_usage;
+        }
+      } else if (p.type === "exec_command_end") {
+        failureMarkerSeen = true;
+        friction.result(typeof p.exit_code === "number" && p.exit_code !== 0);
+      } else if (p.type === "mcp_tool_call_end") {
+        const result = p.result;
+        failureMarkerSeen = true;
+        friction.result(Boolean(result && typeof result === "object" && "Err" in result));
+      } else if (p.type === "patch_apply_end") {
+        failureMarkerSeen = true;
+        friction.result(p.success === false);
+      }
       continue;
     }
     if (o.type !== "response_item")
@@ -9950,6 +10460,17 @@ function extractCodexRolloutSession(raw, agentSlug) {
       }
     } else if (pt === "function_call" && typeof p.name === "string") {
       digest.toolCounts[p.name] = (digest.toolCounts[p.name] ?? 0) + 1;
+      friction.call(p.name, typeof p.arguments === "string" ? p.arguments : null);
+      if (p.name === "save_skill" && typeof p.arguments === "string") {
+        try {
+          const args = JSON.parse(p.arguments);
+          if (typeof args.name === "string" && args.name.trim()) {
+            const ms = ts ? Date.parse(ts) : NaN;
+            recordAssetAttempt(assetAcc, args.name.trim(), Number.isFinite(ms) ? ms : null, digest.assistantTurns, toolCallsSeen);
+          }
+        } catch {}
+      }
+      toolCallsSeen++;
     } else if (pt === "tool_search_call") {
       digest.toolCounts["tool_search"] = (digest.toolCounts["tool_search"] ?? 0) + 1;
     }
@@ -9958,6 +10479,21 @@ function extractCodexRolloutSession(raw, agentSlug) {
     return null;
   if (!digest.project)
     digest.project = "codex";
+  applyGapHistogram(signals, epochMs);
+  if (models.length > 0)
+    signals.models = models;
+  if (lastTokenTotals) {
+    signals.tokens = {
+      tokensIn: finiteNum(lastTokenTotals.input_tokens),
+      tokensOut: finiteNum(lastTokenTotals.output_tokens),
+      cacheReadTokens: finiteNum(lastTokenTotals.cached_input_tokens),
+      cacheCreationTokens: null
+    };
+  }
+  signals.toolFailureStreakMax = failureMarkerSeen ? friction.failStreakMax : null;
+  signals.repeatedCallMax = friction.repeatedCallMax;
+  digest.signals = signals;
+  digest.assetMarkers = buildAssetMarkers(assetAcc, epochMs);
   return digest;
 }
 function extractCursorSessions(composerRows, bubbleRows, sinceISO) {
@@ -10006,6 +10542,7 @@ function extractCursorSessions(composerRows, bubbleRows, sinceISO) {
       errorCount: 0,
       assistantTurns: 0
     };
+    const friction = new FrictionCounters;
     for (const b of bubbles) {
       if (b.ts) {
         if (!digest.start)
@@ -10016,6 +10553,7 @@ function extractCursorSessions(composerRows, bubbleRows, sinceISO) {
         digest.toolCounts[b.tool] = (digest.toolCounts[b.tool] ?? 0) + 1;
         if (b.status === "error")
           digest.errorCount++;
+        friction.result(b.status === "error");
       } else if (b.type === 2) {
         digest.assistantTurns++;
       }
@@ -10042,6 +10580,9 @@ function extractCursorSessions(composerRows, bubbleRows, sinceISO) {
       continue;
     if (sinceISO && digest.end && digest.end < sinceISO)
       continue;
+    const signals = emptySessionSignals();
+    signals.toolFailureStreakMax = friction.failStreakMax;
+    digest.signals = signals;
     digests.push(digest);
   }
   return digests;
@@ -10085,7 +10626,7 @@ function formatCombinedDigest(sessions, opts = { days: 7 }) {
   return lines.join(`
 `);
 }
-var MAX_MSG_CHARS = 700, MAX_MSGS_PER_SESSION = 40, SKIP_PREFIXES, CODEX_SKIP_PREFIXES;
+var MAX_MSG_CHARS = 700, MAX_MSGS_PER_SESSION = 40, finiteNum = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0, SKIP_PREFIXES, CODEX_SKIP_PREFIXES;
 var init_session_digest = __esm(() => {
   SKIP_PREFIXES = [
     "<system-reminder",
@@ -10424,7 +10965,7 @@ import { createHash as createHash2 } from "crypto";
 function contentHash(content) {
   return "sha256:" + createHash2("sha256").update(content).digest("hex");
 }
-function stableStringify(value) {
+function stableStringify2(value) {
   return JSON.stringify(sortValue(value));
 }
 function sortValue(value) {
@@ -10441,7 +10982,7 @@ function sortValue(value) {
   return value;
 }
 function configHash(value) {
-  return contentHash(stableStringify(value));
+  return contentHash(stableStringify2(value));
 }
 var init_hash = () => {};
 
@@ -15855,10 +16396,104 @@ var init_conversation_registry = __esm(async () => {
 
 // src/reflect/session-summary.ts
 import { createHash as createHash4 } from "crypto";
+import { execFileSync as execFileSync3 } from "child_process";
 import { readFileSync as readFileSync35 } from "fs";
+import { isAbsolute as isAbsolute4 } from "path";
+function validateAssetMarkers(markers, knownSkills) {
+  if (!markers || markers.length === 0)
+    return null;
+  let known = null;
+  if (knownSkills) {
+    known = new Map;
+    for (const skill of knownSkills) {
+      const name = canonicalSkillName(skill.name);
+      if (name)
+        known.set(name, skill.id);
+    }
+  }
+  return markers.map((m) => {
+    const canonical = canonicalSkillName(m.rawName);
+    const validated = Boolean(known && canonical && known.has(canonical));
+    return {
+      assetKind: m.kind,
+      assetKey: validated ? canonical : null,
+      assetKeyId: validated ? known.get(canonical) ?? null : null,
+      saveAttempts: m.attempts,
+      turnsToAsset: m.turnsBefore,
+      toolCallsToAsset: m.toolCallsBefore,
+      wallSecondsToAsset: m.wallSecondsToAsset,
+      gapCountsToAsset: m.gapCountsToAsset,
+      gapSecondsToAsset: m.gapSecondsToAsset
+    };
+  });
+}
+function clampVendorString(value) {
+  if (value === null)
+    return null;
+  return value.length > VENDOR_STRING_MAX_CHARS ? value.slice(0, VENDOR_STRING_MAX_CHARS) : value;
+}
+function clampVendorList(values) {
+  if (values === null)
+    return null;
+  return values.slice(0, VENDOR_LIST_MAX_ITEMS).map((v) => clampVendorString(v));
+}
+function clampTokensByModel(map) {
+  if (map === null)
+    return null;
+  const entries = Object.entries(map).slice(0, VENDOR_LIST_MAX_ITEMS).map(([model, totals]) => [clampVendorString(model), totals]);
+  return Object.fromEntries(entries);
+}
 function hashSessionKey(key) {
   return createHash4("sha256").update(key).digest("hex").slice(0, 32);
 }
+function normalizeGitRemote(url) {
+  let out = url.trim().toLowerCase();
+  if (!out)
+    return null;
+  const hadScheme = /^[a-z+]+:\/\//.test(out);
+  out = out.replace(/^[a-z+]+:\/\//, "");
+  out = out.replace(/^[^@/]+@/, "");
+  if (hadScheme)
+    out = out.replace(/^([^/:]+):(\d+)(?=\/)/, "$1");
+  out = out.replace(":", "/");
+  out = out.replace(/\/+$/, "");
+  out = out.replace(/\.git$/, "");
+  out = out.replace(/\/+$/, "");
+  return out || null;
+}
+function normalizeProjectName(project) {
+  if (!project)
+    return null;
+  const trimmed = project.trim().replace(/[/\\]+$/, "");
+  if (!trimmed)
+    return null;
+  const idx = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
+  const base = (idx >= 0 ? trimmed.slice(idx + 1) : trimmed).toLowerCase();
+  if (!base)
+    return null;
+  if (idx < 0 && PROJECT_PLACEHOLDERS.has(base))
+    return null;
+  return base;
+}
+function resolveProjectHash(project) {
+  const normalized = normalizeProjectName(project);
+  return normalized ? hashSessionKey(normalized) : null;
+}
+function resolveRepoHash(projectDir) {
+  if (!projectDir || !isAbsolute4(projectDir))
+    return null;
+  let url;
+  try {
+    url = execFileSync3("git", ["-C", projectDir, "config", "--get", "remote.origin.url"], {
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 3000
+    }).toString().trim();
+  } catch {
+    return null;
+  }
+  const normalized = url ? normalizeGitRemote(url) : null;
+  return normalized ? hashSessionKey(normalized) : null;
+}
 function digestForEntry(entry) {
   if (!entry.transcriptPath)
     return null;
@@ -15892,9 +16527,10 @@ function deriveMcpUsage(toolCounts) {
   }
   return { mcpCallCount, mcpServers };
 }
-function buildSessionSummary(key, entry, digest) {
+function buildSessionSummary(key, entry, digest, opts = {}) {
   const toolCallCount = digest ? Object.values(digest.toolCounts).reduce((sum, n) => sum + n, 0) : null;
   const userMessageCount = digest ? digest.userMessages.length + digest.droppedUserMessages : null;
+  const sig = digest?.signals;
   return {
     agentSlug: entry.agentSlug,
     sessionIdHash: hashSessionKey(key),
@@ -15907,7 +16543,32 @@ function buildSessionSummary(key, entry, digest) {
     toolCounts: digest ? digest.toolCounts : null,
     ...deriveMcpUsage(digest ? digest.toolCounts : null),
     errorCount: digest?.errorCount ?? null,
-    skillsUsed: [...new Set((digest?.skillInvocations ?? []).map(canonicalSkillName).filter(Boolean))]
+    skillsUsed: clampVendorList([...new Set((digest?.skillInvocations ?? []).map(canonicalSkillName).filter(Boolean))]) ?? [],
+    provenance: sig?.provenance ?? null,
+    gapCounts: sig?.gapCounts ?? null,
+    gapSeconds: sig?.gapSeconds ?? null,
+    spanMinutes: sig?.spanMinutes ?? null,
+    longestGapSeconds: sig?.longestGapSeconds ?? null,
+    permissionModes: clampVendorList(sig?.permissionModes ?? null),
+    modeEscalations: sig?.modeEscalations ?? null,
+    approvalPolicy: clampVendorString(sig?.approvalPolicy ?? null),
+    sandboxPolicy: clampVendorString(sig?.sandboxPolicy ?? null),
+    subagentCount: sig?.subagentCount ?? null,
+    planModeUsed: sig?.planModeUsed ?? null,
+    slashCommandCount: sig?.slashCommandCount ?? null,
+    modelInitiatedSkillCount: sig?.modelInitiatedSkillCount ?? null,
+    promptLengthBuckets: sig?.promptLengthBuckets ?? null,
+    toolFailureStreakMax: sig?.toolFailureStreakMax ?? null,
+    repeatedCallMax: sig?.repeatedCallMax ?? null,
+    models: clampVendorList(sig?.models ?? null),
+    tokensIn: sig?.tokens?.tokensIn ?? null,
+    tokensOut: sig?.tokens?.tokensOut ?? null,
+    cacheReadTokens: sig?.tokens?.cacheReadTokens ?? null,
+    cacheCreationTokens: sig?.tokens?.cacheCreationTokens ?? null,
+    tokensByModel: clampTokensByModel(sig?.tokensByModel ?? null),
+    assetsCreated: validateAssetMarkers(digest?.assetMarkers, opts.knownSkills ?? null),
+    repoHash: opts.repoHash ?? null,
+    projectHash: resolveProjectHash(entry.project)
   };
 }
 function buildSessionSummaryEvent(summary, nowISO) {
@@ -15928,14 +16589,41 @@ function buildSessionSummaryEvent(summary, nowISO) {
         mcpCallCount: summary.mcpCallCount,
         mcpServers: summary.mcpServers,
         errorCount: summary.errorCount,
-        skillsUsed: summary.skillsUsed
+        skillsUsed: summary.skillsUsed,
+        provenance: summary.provenance,
+        gapCounts: summary.gapCounts,
+        gapSeconds: summary.gapSeconds,
+        spanMinutes: summary.spanMinutes,
+        longestGapSeconds: summary.longestGapSeconds,
+        permissionModes: summary.permissionModes,
+        modeEscalations: summary.modeEscalations,
+        approvalPolicy: summary.approvalPolicy,
+        sandboxPolicy: summary.sandboxPolicy,
+        subagentCount: summary.subagentCount,
+        planModeUsed: summary.planModeUsed,
+        slashCommandCount: summary.slashCommandCount,
+        modelInitiatedSkillCount: summary.modelInitiatedSkillCount,
+        promptLengthBuckets: summary.promptLengthBuckets,
+        toolFailureStreakMax: summary.toolFailureStreakMax,
+        repeatedCallMax: summary.repeatedCallMax,
+        models: summary.models,
+        tokensIn: summary.tokensIn,
+        tokensOut: summary.tokensOut,
+        cacheReadTokens: summary.cacheReadTokens,
+        cacheCreationTokens: summary.cacheCreationTokens,
+        tokensByModel: summary.tokensByModel,
+        assetsCreated: summary.assetsCreated,
+        repoHash: summary.repoHash,
+        projectHash: summary.projectHash
       },
       timestamp: nowISO
     }
   };
 }
+var VENDOR_STRING_MAX_CHARS = 64, VENDOR_LIST_MAX_ITEMS = 12, PROJECT_PLACEHOLDERS;
 var init_session_summary = __esm(() => {
   init_session_digest();
+  PROJECT_PLACEHOLDERS = new Set(["codex", "cowork", "cursor"]);
 });
 
 // src/reflect/telemetry-outbox.ts
@@ -15977,6 +16665,222 @@ var init_telemetry_outbox = __esm(() => {
   init_atomic_json();
 });
 
+// src/reflect/active-time.ts
+function isValidActiveTimeCap(capSeconds) {
+  return VALID_ACTIVE_TIME_CAPS_SECONDS.includes(capSeconds);
+}
+function activeSecondsFromBuckets(gapCounts, gapSeconds, capSeconds) {
+  if (!gapCounts || !gapSeconds)
+    return null;
+  if (!isValidActiveTimeCap(capSeconds))
+    return null;
+  let total = 0;
+  for (const { key, lower } of BUCKET_LOWER_EDGES) {
+    if (lower >= capSeconds) {
+      total += capSeconds * (gapCounts[key] ?? 0);
+    } else {
+      total += gapSeconds[key] ?? 0;
+    }
+  }
+  return total;
+}
+var BUCKET_LOWER_EDGES, VALID_ACTIVE_TIME_CAPS_SECONDS;
+var init_active_time = __esm(() => {
+  BUCKET_LOWER_EDGES = [
+    { key: "lt10s", lower: 0 },
+    { key: "s10to30", lower: 10 },
+    { key: "s30to2m", lower: 30 },
+    { key: "m2to5", lower: 120 },
+    { key: "m5to15", lower: 300 },
+    { key: "gte15m", lower: 900 }
+  ];
+  VALID_ACTIVE_TIME_CAPS_SECONDS = [10, 30, 120, 300, 900];
+});
+
+// src/reflect/pattern-store.ts
+import { createHash as createHash5 } from "crypto";
+import { join as join42 } from "path";
+import { homedir as homedir23 } from "os";
+function addBuckets(a, b) {
+  if (!a)
+    return b ? { ...b } : null;
+  if (!b)
+    return { ...a };
+  return {
+    lt10s: a.lt10s + b.lt10s,
+    s10to30: a.s10to30 + b.s10to30,
+    s30to2m: a.s30to2m + b.s30to2m,
+    m2to5: a.m2to5 + b.m2to5,
+    m5to15: a.m5to15 + b.m5to15,
+    gte15m: a.gte15m + b.gte15m
+  };
+}
+function canonicalizeEntities(entities) {
+  const cleaned = entities.map((e) => e.trim().toLowerCase().replace(/\s+/g, " ")).filter((e) => e.length > 0);
+  return [...new Set(cleaned)].sort().slice(0, MAX_KEY_ENTITIES);
+}
+function patternKeyHash(taskType, entities) {
+  const task = taskType.trim().toLowerCase();
+  const canonical = canonicalizeEntities(entities);
+  if (!task || canonical.length === 0)
+    return null;
+  return createHash5("sha256").update(`${task}|${canonical.join(",")}`).digest("hex").slice(0, 32);
+}
+function median(sorted) {
+  if (sorted.length === 0)
+    return 0;
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+function medianOf(values) {
+  return median([...values].sort((a, b) => a - b));
+}
+function modal(values) {
+  const counts = new Map;
+  for (const v of values)
+    counts.set(v, (counts.get(v) ?? 0) + 1);
+  let best = null;
+  let bestCount = 0;
+  for (const [value, count] of counts) {
+    if (count > bestCount) {
+      best = value;
+      bestCount = count;
+    }
+  }
+  return best;
+}
+function emptyPatternStore() {
+  return { version: PATTERN_STORE_VERSION, patterns: {} };
+}
+function recordObservation(state, observation) {
+  const key = patternKeyHash(observation.taskType, observation.keyEntities);
+  if (!key)
+    return { state, key: null };
+  const at = Date.parse(observation.at);
+  if (!Number.isFinite(at))
+    return { state, key: null };
+  const activeSeconds = observation.gapCounts && observation.gapSeconds ? activeSecondsFromBuckets(observation.gapCounts, observation.gapSeconds, ACTIVE_MINUTES_CAP_SECONDS) : null;
+  const existing = state.patterns[key];
+  const occurrences = existing ? [...existing.occurrences] : [];
+  const mergeIndex = occurrences.findIndex((o) => Math.abs(Date.parse(o.at) - at) <= SAME_OCCURRENCE_WINDOW_HOURS * 3600 * 1000);
+  if (mergeIndex >= 0) {
+    const prior = occurrences[mergeIndex];
+    const priorAt = Date.parse(prior.at);
+    occurrences[mergeIndex] = {
+      at: priorAt <= at ? prior.at : observation.at,
+      activeSeconds: prior.activeSeconds === null && activeSeconds === null ? null : (prior.activeSeconds ?? 0) + (activeSeconds ?? 0),
+      gapCounts: addBuckets(prior.gapCounts, observation.gapCounts),
+      gapSeconds: addBuckets(prior.gapSeconds, observation.gapSeconds),
+      confidence: Math.min(prior.confidence, observation.confidence),
+      sessionIdHashes: observation.sessionIdHash && !prior.sessionIdHashes.includes(observation.sessionIdHash) ? [...prior.sessionIdHashes, observation.sessionIdHash] : prior.sessionIdHashes,
+      suggestedCapability: prior.suggestedCapability ?? observation.suggestedCapability ?? null,
+      projectHash: prior.projectHash ?? observation.projectHash ?? null
+    };
+  } else {
+    occurrences.push({
+      at: observation.at,
+      activeSeconds,
+      gapCounts: observation.gapCounts ?? null,
+      gapSeconds: observation.gapSeconds ?? null,
+      confidence: observation.confidence,
+      sessionIdHashes: observation.sessionIdHash ? [observation.sessionIdHash] : [],
+      suggestedCapability: observation.suggestedCapability ?? null,
+      projectHash: observation.projectHash ?? null
+    });
+  }
+  occurrences.sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+  const newest = Date.parse(occurrences[occurrences.length - 1].at);
+  const kept = occurrences.filter((o) => newest - Date.parse(o.at) <= OCCURRENCE_RETENTION_DAYS * 24 * 3600 * 1000);
+  return {
+    state: {
+      ...state,
+      patterns: {
+        ...state.patterns,
+        [key]: {
+          taskType: observation.taskType.trim().toLowerCase(),
+          keyEntities: canonicalizeEntities(observation.keyEntities),
+          occurrences: kept
+        }
+      }
+    },
+    key
+  };
+}
+function evaluateMaturity(key, record) {
+  const sorted = [...record.occurrences].sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+  if (sorted.length < MATURITY_MIN_OCCURRENCES)
+    return null;
+  const newest = Date.parse(sorted[sorted.length - 1].at);
+  const inWindow = sorted.filter((o) => newest - Date.parse(o.at) <= MATURITY_WINDOW_DAYS * 24 * 3600 * 1000);
+  if (inWindow.length < MATURITY_MIN_OCCURRENCES)
+    return null;
+  const gapsDays = [];
+  for (let i = 1;i < inWindow.length; i++) {
+    gapsDays.push((Date.parse(inWindow[i].at) - Date.parse(inWindow[i - 1].at)) / (24 * 3600 * 1000));
+  }
+  const medianGap = medianOf(gapsDays);
+  if (medianGap < MATURITY_MIN_PERIODICITY_DAYS)
+    return null;
+  const mad = medianOf(gapsDays.map((g) => Math.abs(g - medianGap)));
+  if (mad > MATURITY_MAX_MAD_RATIO * medianGap)
+    return null;
+  const activeSecondsValues = inWindow.map((o) => o.activeSeconds).filter((s) => typeof s === "number");
+  let activeGapCounts = null;
+  let activeGapSeconds = null;
+  for (const occurrence of inWindow) {
+    activeGapCounts = addBuckets(activeGapCounts, occurrence.gapCounts);
+    activeGapSeconds = addBuckets(activeGapSeconds, occurrence.gapSeconds);
+  }
+  const projectHashes = inWindow.map((o) => o.projectHash).filter((p) => typeof p === "string" && p.length > 0);
+  const capabilities = inWindow.map((o) => o.suggestedCapability).filter((c) => typeof c === "string" && c.length > 0);
+  return {
+    patternKeyHash: key,
+    taskType: record.taskType,
+    occurrences: inWindow.length,
+    periodicityDays: Math.round(medianGap * 10) / 10,
+    medianActiveMinutes: activeSecondsValues.length > 0 ? Math.round(medianOf(activeSecondsValues) / 60 * 10) / 10 : null,
+    activeMinutesCapSeconds: ACTIVE_MINUTES_CAP_SECONDS,
+    activeGapCounts,
+    activeGapSeconds,
+    suggestedCapability: modal(capabilities),
+    firstSeenAt: inWindow[0].at,
+    lastSeenAt: inWindow[inWindow.length - 1].at,
+    confidence: Math.min(...inWindow.map((o) => o.confidence)),
+    projectHash: modal(projectHashes),
+    distinctProjectHashes: new Set(projectHashes).size
+  };
+}
+function buildPatternEvent(payload, nowISO) {
+  return {
+    dedupeKey: `pattern:${payload.patternKeyHash}`,
+    event: {
+      eventType: "local_agent.repeated_pattern",
+      metadata: { ...payload },
+      timestamp: nowISO
+    }
+  };
+}
+function storePath3() {
+  return join42(homedir23(), ".runwork", "pattern-store.json");
+}
+function loadPatternStore() {
+  const parsed = readJsonOrNull(storePath3());
+  if (!parsed || typeof parsed !== "object" || !parsed.patterns || typeof parsed.patterns !== "object") {
+    return emptyPatternStore();
+  }
+  if (parsed.version !== PATTERN_STORE_VERSION)
+    return emptyPatternStore();
+  return parsed;
+}
+function savePatternStore(state) {
+  writeJsonAtomic(storePath3(), state);
+}
+var SAME_OCCURRENCE_WINDOW_HOURS = 4, MATURITY_MIN_OCCURRENCES = 3, MATURITY_WINDOW_DAYS = 45, MATURITY_MAX_MAD_RATIO = 0.5, MATURITY_MIN_PERIODICITY_DAYS = 1, OCCURRENCE_RETENTION_DAYS = 180, MAX_KEY_ENTITIES = 4, ACTIVE_MINUTES_CAP_SECONDS = 300, PATTERN_STORE_VERSION = 1;
+var init_pattern_store = __esm(() => {
+  init_atomic_json();
+  init_active_time();
+});
+
 // src/reflect/triage.ts
 var exports_triage = {};
 __export(exports_triage, {
@@ -15987,7 +16891,8 @@ __export(exports_triage, {
   packTriageBatches: () => packTriageBatches,
   buildTriagePrompt: () => buildTriagePrompt,
   TRIAGE_ITEM_CHAR_CAP: () => TRIAGE_ITEM_CHAR_CAP,
-  TRIAGE_BATCH_CHAR_BUDGET: () => TRIAGE_BATCH_CHAR_BUDGET
+  TRIAGE_BATCH_CHAR_BUDGET: () => TRIAGE_BATCH_CHAR_BUDGET,
+  TASK_TYPES: () => TASK_TYPES
 });
 function renderTriageItem(id, candidate) {
   const d = candidate.digest;
@@ -16036,12 +16941,17 @@ You are the cheap triage tier of Runwork's reflection engine. At the end of this
 
 Mark a conversation NOT worthy when it is trivial or one-shot, is routine work with no repeated pattern, or would only re-derive something in the already-suggested list. Most conversations are not worthy; be strict. Do not analyze content deeply — skim and judge.
 
+For EACH conversation also label the work itself, which is used to notice the same chore recurring across conversations:
+
+- "taskType": exactly one of ${TASK_TYPES.join(" | ")}.
+- "keyEntities": 1 to 4 short CANONICAL noun phrases naming the OBJECT of the work ("invoice reformatting", "weekly sales report", "hubspot contact cleanup"). Canonical means: singular, lowercase, generic. NO dates, file names, person names, company names, counts, or version numbers. Two conversations doing the same chore in different words MUST produce the same phrases, so prefer the plainest wording of the underlying task over the user's phrasing.
+
 Reply with ONLY a single fenced \`json\` block:
 
 \`\`\`json
 {
   "verdicts": [
-    { "id": "<the conversation id shown in its header>", "worthy": true|false, "confidence": <0..1> }
+    { "id": "<the conversation id shown in its header>", "worthy": true|false, "confidence": <0..1>, "taskType": "<one of the values above>", "keyEntities": ["<canonical phrase>"] }
   ]
 }
 \`\`\`
@@ -16071,9 +16981,13 @@ function parseTriageVerdicts(text2) {
       const v = raw;
       if (typeof v.id !== "string" || typeof v.worthy !== "boolean")
         continue;
+      const taskType = typeof v.taskType === "string" && TASK_TYPES.includes(v.taskType.trim().toLowerCase()) ? v.taskType.trim().toLowerCase() : undefined;
+      const keyEntities = Array.isArray(v.keyEntities) ? v.keyEntities.filter((e) => typeof e === "string" && e.trim().length > 0).map((e) => e.trim()) : [];
       out.set(v.id, {
         worthy: v.worthy,
-        confidence: typeof v.confidence === "number" ? Math.max(0, Math.min(1, v.confidence)) : 0.5
+        confidence: typeof v.confidence === "number" ? Math.max(0, Math.min(1, v.confidence)) : 0.5,
+        ...taskType ? { taskType } : {},
+        ...keyEntities.length > 0 ? { keyEntities } : {}
       });
     }
     return out.size > 0 ? out : null;
@@ -16144,7 +17058,7 @@ async function runTriagePass(candidates, opts) {
   }
   return { verdicts, summary };
 }
-var TRIAGE_ITEM_CHAR_CAP = 12000, TRIAGE_BATCH_CHAR_BUDGET = 150000, TRIAGE_TIMEOUT_MS;
+var TRIAGE_ITEM_CHAR_CAP = 12000, TRIAGE_BATCH_CHAR_BUDGET = 150000, TRIAGE_TIMEOUT_MS, TASK_TYPES;
 var init_triage = __esm(async () => {
   init_which();
   init_session_listing();
@@ -16153,6 +17067,7 @@ var init_triage = __esm(async () => {
     init_conversation_analysis()
   ]);
   TRIAGE_TIMEOUT_MS = 2 * 60 * 1000;
+  TASK_TYPES = ["build", "automate", "analyze", "write", "research", "admin", "debug"];
 });
 
 // src/reflect/conversation-analysis.ts
@@ -16317,6 +17232,48 @@ async function analyzeConversations(opts = {}) {
     releaseRunLock();
   }
 }
+function recordPatternObservations(verdicts, state, progress) {
+  try {
+    let store = loadPatternStore();
+    const touchedKeys = new Set;
+    for (const [key, verdict] of verdicts) {
+      const entry = state.entries[key];
+      if (!entry || !verdict.taskType || !verdict.keyEntities?.length)
+        continue;
+      const stats = entry.stats;
+      const result = recordObservation(store, {
+        taskType: verdict.taskType,
+        keyEntities: verdict.keyEntities,
+        at: entry.lastActivityAt,
+        confidence: verdict.confidence,
+        sessionIdHash: stats?.sessionIdHash,
+        gapCounts: stats?.gapCounts ?? null,
+        gapSeconds: stats?.gapSeconds ?? null,
+        projectHash: stats?.projectHash ?? null
+      });
+      store = result.state;
+      if (result.key)
+        touchedKeys.add(result.key);
+    }
+    if (touchedKeys.size === 0)
+      return;
+    savePatternStore(store);
+    const nowISO = new Date().toISOString();
+    const events = [];
+    for (const key of touchedKeys) {
+      const record = store.patterns[key];
+      if (!record)
+        continue;
+      const payload = evaluateMaturity(key, record);
+      if (payload)
+        events.push(buildPatternEvent(payload, nowISO));
+    }
+    if (events.length > 0) {
+      appendToTelemetryOutbox(events);
+      progress(`${events.length} recurring chore pattern(s) reached the recurrence threshold.`);
+    }
+  } catch {}
+}
 async function analyzeConversationsLocked(opts, outcome, gates) {
   const { cadence, explicitSession, manual } = gates;
   if (!cadence.enabled && !manual && !explicitSession) {
@@ -16453,9 +17410,11 @@ async function analyzeConversationsLocked(opts, outcome, gates) {
         for (const [key, verdict] of pass.verdicts) {
           const entry = state.entries[key];
           if (entry) {
-            state = { entries: { ...state.entries, [key]: { ...entry, triage: { ...verdict, at: entry.lastActivityAt } } } };
+            const { keyEntities: _entities, ...cacheable } = verdict;
+            state = { entries: { ...state.entries, [key]: { ...entry, triage: { ...cacheable, at: entry.lastActivityAt } } } };
           }
         }
+        recordPatternObservations(pass.verdicts, state, progress);
       }
     }
     const ranked = [];
@@ -16675,6 +17634,7 @@ var init_conversation_analysis = __esm(async () => {
   init_session_listing();
   init_insight_store();
   init_telemetry_outbox();
+  init_pattern_store();
   init_run_log();
   init_insight_store();
   await __promiseAll([
@@ -17167,12 +18127,28 @@ var deployCommand = new Command5("deploy").description("Deploy the current app t
       console.error(`  - ${s}`);
     process.exit(1);
   }
+  if (syncResult.remoteOverwrote && syncResult.remoteOverwrote.length > 0) {
+    const files = syncResult.remoteOverwrote.join(", ");
+    if (useJson) {
+      jsonLine({ event: "sync_remote_overwrote", files: syncResult.remoteOverwrote, timestamp: new Date().toISOString() });
+    } else {
+      console.warn(`Sync resolved conflicts in the remote's favour; local changes were replaced in: ${files}`);
+      console.warn("  Recover them with `git reflog` / `git diff ORIG_HEAD` before deploying again if that was wrong.");
+    }
+  }
+  if (syncResult.keptUntracked && syncResult.keptUntracked.length > 0 && !useJson) {
+    console.warn(`Kept your untracked file(s) over the remote's copy: ${syncResult.keptUntracked.join(", ")}`);
+  }
   if (!syncResult.pushed) {
+    const diag = diagnoseSyncError(syncResult.pushError ?? syncResult.error);
     if (useJson) {
-      jsonOut(buildErrorResponse("deploy", "Failed to push before deployment", "Local commits were synced but could not be pushed to the remote.", ["Check your network connection", "Run runwork dev to retry syncing", "Then retry runwork deploy"]));
+      jsonOut(buildErrorResponse("deploy", `Failed to push before deployment: ${diag.message}`, diag.diagnosis, [...diag.suggestions, "Then retry runwork deploy"]));
       process.exit(1);
     }
-    console.error("Push failed. Check your connection and retry `runwork deploy`.");
+    console.error(`Push failed: ${diag.message}`);
+    console.error(diag.diagnosis);
+    for (const suggestion of diag.suggestions)
+      console.error(`  - ${suggestion}`);
     process.exit(1);
   }
   if (!useJson)
@@ -19171,14 +20147,18 @@ init_session_summary();
 init_telemetry_outbox();
 init_insight_store();
 init_atomic_json();
+init_store();
+init_client();
+init_resolve();
+init_workspace_state();
 init_colors();
 await __promiseAll([
   init_conversation_registry(),
   init_conversation_analysis()
 ]);
 import { Command as Command15 } from "commander";
-import { join as join42 } from "path";
-import { homedir as homedir23 } from "os";
+import { join as join43 } from "path";
+import { homedir as homedir24 } from "os";
 var DEFAULT_LOOKBACK_DAYS = 30;
 function sinceFromDays(days) {
   if (days <= 0)
@@ -19191,6 +20171,46 @@ function parseDays(raw) {
     return DEFAULT_LOOKBACK_DAYS;
   return Math.floor(n);
 }
+function bareRegistrySkillId(skill) {
+  if (skill.type !== "external" || typeof skill.id !== "string")
+    return null;
+  return skill.id.startsWith("ext-") ? skill.id.slice("ext-".length) || null : null;
+}
+async function fetchKnownSkills() {
+  const creds = getCredentials();
+  if (!creds)
+    return null;
+  let workspaceId;
+  const client = new ApiClient(creds);
+  try {
+    workspaceId = (await resolveWorkspace2(client, {})).workspaceId;
+  } catch {
+    workspaceId = creds.defaultWorkspaceId;
+  }
+  if (!workspaceId)
+    return null;
+  try {
+    const skills = await client.listWorkspaceSkills(workspaceId);
+    const known = [];
+    const seen = new Set;
+    for (const sk of skills) {
+      if (sk.type === "app")
+        continue;
+      const name = canonicalSkillName(sk.name);
+      if (!name || seen.has(name))
+        continue;
+      seen.add(name);
+      known.push({ name, id: bareRegistrySkillId(sk) });
+    }
+    updateWorkspaceRecord(workspaceId, { knownSkills: known });
+    return known;
+  } catch {
+    const record = loadWorkspaceRecord(workspaceId);
+    if (record.knownSkills)
+      return record.knownSkills;
+    return record.skillNames ? record.skillNames.map((name) => ({ name, id: null })) : null;
+  }
+}
 function projectLabel(project) {
   const trimmed = project.replace(/[/\\]+$/, "");
   const idx = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
@@ -19247,11 +20267,21 @@ conversationsCommand.command("scan").description("Detect finished conversations
   const nowISO = new Date().toISOString();
   const summaryEvents = [];
   const newlyPending = new Set(scan.newlyPendingKeys);
+  const knownSkills = newlyPending.size > 0 ? await fetchKnownSkills() : null;
+  const repoHashByProject = new Map;
+  const repoHashFor = (project) => {
+    if (!repoHashByProject.has(project))
+      repoHashByProject.set(project, resolveRepoHash(project));
+    return repoHashByProject.get(project) ?? null;
+  };
   let statsWritten = 0;
   for (const [key, entry] of Object.entries(scan.state.entries)) {
     if (!newlyPending.has(key) && entry.stats)
       continue;
-    const summary = buildSessionSummary(key, entry, digestForEntry(entry));
+    const summary = buildSessionSummary(key, entry, digestForEntry(entry), {
+      knownSkills,
+      repoHash: repoHashFor(entry.project)
+    });
     scan.state.entries[key] = { ...entry, stats: summary };
     statsWritten++;
     if (newlyPending.has(key))
@@ -19290,7 +20320,7 @@ conversationsCommand.command("scan").description("Detect finished conversations
     idleMinutes,
     conversations: [...listed, ...rescued].sort((a, b) => b.lastActivityAt.localeCompare(a.lastActivityAt))
   };
-  writeJsonAtomic(join42(homedir23(), ".runwork", "conversations.json"), snapshot);
+  writeJsonAtomic(join43(homedir24(), ".runwork", "conversations.json"), snapshot);
   if (json) {
     jsonOut({ queued: scan.queued, reopened: scan.reopened, pruned: scan.pruned, pending, finished: finished.length });
     return;
@@ -19320,8 +20350,8 @@ init_client();
 init_resolve();
 import { Command as Command16 } from "commander";
 import { readFileSync as readFileSync37, existsSync as existsSync48 } from "fs";
-import { join as join43 } from "path";
-import { homedir as homedir24 } from "os";
+import { join as join44 } from "path";
+import { homedir as homedir25 } from "os";
 
 // ../../shared/agent-instructions/runwork-instructions.ts
 function formatList(items, max = 8) {
@@ -19801,8 +20831,8 @@ async function buildInstructionContext(client, workspace) {
 // src/commands/instructions.ts
 function readSetupExtras(workspaceId) {
   for (const path2 of [
-    join43(process.cwd(), ".runwork", "setup.json"),
-    join43(homedir24(), ".runwork", "setup.json")
+    join44(process.cwd(), ".runwork", "setup.json"),
+    join44(homedir25(), ".runwork", "setup.json")
   ]) {
     if (!existsSync48(path2))
       continue;
@@ -21541,8 +22571,8 @@ init_resolve();
 init_prompt();
 await init_detect();
 import { Command as Command27 } from "commander";
-import { join as join47 } from "path";
-import { homedir as homedir26 } from "os";
+import { join as join48 } from "path";
+import { homedir as homedir27 } from "os";
 
 // src/commands/sync.ts
 init_store();
@@ -21554,8 +22584,8 @@ await __promiseAll([
 ]);
 import { Command as Command26 } from "commander";
 import { readFileSync as readFileSync40, existsSync as existsSync51 } from "fs";
-import { join as join46 } from "path";
-import { homedir as homedir25 } from "os";
+import { join as join47 } from "path";
+import { homedir as homedir26 } from "os";
 
 // src/commands/mcp-entries.ts
 init_types();
@@ -22454,13 +23484,13 @@ function readLocalSkills(state) {
     if (!baseDir)
       continue;
     for (const skillName of state.skills) {
-      const skillMdPath = join46(baseDir, skillName, "SKILL.md");
+      const skillMdPath = join47(baseDir, skillName, "SKILL.md");
       if (existsSync51(skillMdPath)) {
         results.push({ name: skillName, content: readFileSync40(skillMdPath, "utf-8") });
         continue;
       }
       const filename = skillName.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-      const flatPath = join46(baseDir, `${filename}.md`);
+      const flatPath = join47(baseDir, `${filename}.md`);
       if (existsSync51(flatPath)) {
         results.push({ name: skillName, content: readFileSync40(flatPath, "utf-8") });
       }
@@ -22942,7 +23972,7 @@ This account is not a member of "${state.workspaceName || state.workspaceId}".`)
   }
   for (const adapter2 of adapters) {
     if (adapter2 instanceof CodexAdapter) {
-      const runworkDir = join46(homedir25(), ".runwork");
+      const runworkDir = join47(homedir26(), ".runwork");
       const result = adapter2.registerDesktopWorkspace(runworkDir, "Runwork");
       if (result === "written") {
         vlog(`  [${adapter2.name}] Registered workspace in Codex desktop app`);
@@ -23084,8 +24114,8 @@ var syncCommand = new Command26("sync").description("Sync skills bidirectionally
     verbose: !!opts.verbose,
     redetect: !!opts.redetect
   };
-  const projectStatePath = join46(process.cwd(), ".runwork", "setup.json");
-  const userStatePath = join46(homedir25(), ".runwork", "setup.json");
+  const projectStatePath = join47(process.cwd(), ".runwork", "setup.json");
+  const userStatePath = join47(homedir26(), ".runwork", "setup.json");
   const projectState = loadSetupState(projectStatePath);
   const userState = loadSetupState(userStatePath);
   if (!projectState && !userState) {
@@ -23154,7 +24184,7 @@ function toSkillFilename(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
 }
 function loadSetupStateForScope(scope) {
-  const path4 = scope === "project" ? join47(process.cwd(), ".runwork", "setup.json") : join47(homedir26(), ".runwork", "setup.json");
+  const path4 = scope === "project" ? join48(process.cwd(), ".runwork", "setup.json") : join48(homedir27(), ".runwork", "setup.json");
   return readJsonOrNull(path4);
 }
 async function parkAndTeardownWorkspace(previous, scopes) {
@@ -23323,8 +24353,8 @@ Re-run without --dry-run to sync workspace data.`);
   }
   persistDefaultWorkspace(workspaceId, workspaceName);
   for (const s of scopes) {
-    const dir = s === "project" ? ".runwork" : join47(homedir26(), ".runwork");
-    writeJsonAtomic(join47(dir, "setup.json"), state);
+    const dir = s === "project" ? ".runwork" : join48(homedir27(), ".runwork");
+    writeJsonAtomic(join48(dir, "setup.json"), state);
   }
   if (restored)
     clearParkedState(workspaceId);
@@ -23332,7 +24362,7 @@ Re-run without --dry-run to sync workspace data.`);
 Syncing workspace data...
 `);
   for (const s of scopes) {
-    const statePath2 = s === "project" ? join47(process.cwd(), ".runwork", "setup.json") : join47(homedir26(), ".runwork", "setup.json");
+    const statePath2 = s === "project" ? join48(process.cwd(), ".runwork", "setup.json") : join48(homedir27(), ".runwork", "setup.json");
     await syncFromState(state, statePath2, credentials, {
       dryRun: false,
       pullOnly: true,
@@ -23353,11 +24383,11 @@ import { Command as Command28 } from "commander";
 
 // src/utils/setup-state.ts
 import { existsSync as existsSync52, readFileSync as readFileSync41 } from "fs";
-import { join as join48 } from "path";
-import { homedir as homedir27 } from "os";
+import { join as join49 } from "path";
+import { homedir as homedir28 } from "os";
 function loadSetupState2() {
-  const projectPath = join48(process.cwd(), ".runwork", "setup.json");
-  const userPath = join48(homedir27(), ".runwork", "setup.json");
+  const projectPath = join49(process.cwd(), ".runwork", "setup.json");
+  const userPath = join49(homedir28(), ".runwork", "setup.json");
   for (const p of [projectPath, userPath]) {
     if (existsSync52(p)) {
       try {
@@ -23421,8 +24451,8 @@ init_types();
 await init_detect();
 import { Command as Command29 } from "commander";
 import { existsSync as existsSync53, readFileSync as readFileSync42 } from "fs";
-import { resolve as resolve3, join as join49 } from "path";
-import { homedir as homedir28 } from "os";
+import { resolve as resolve3, join as join50 } from "path";
+import { homedir as homedir29 } from "os";
 function loadSetupState3(filePath) {
   if (!existsSync53(filePath))
     return null;
@@ -23443,8 +24473,8 @@ var buildPluginCommand = new Command29("build-plugin").description("Build an ins
     process.exit(1);
   }
   const credentials = requireAuth();
-  const projectStatePath = join49(process.cwd(), ".runwork", "setup.json");
-  const userStatePath = join49(homedir28(), ".runwork", "setup.json");
+  const projectStatePath = join50(process.cwd(), ".runwork", "setup.json");
+  const userStatePath = join50(homedir29(), ".runwork", "setup.json");
   const state = loadSetupState3(projectStatePath) ?? loadSetupState3(userStatePath);
   if (!state) {
     console.error("No setup state found. Run `runwork setup` first.");
@@ -23537,8 +24567,8 @@ init_prompt();
 await init_detect();
 import { Command as Command30 } from "commander";
 import { existsSync as existsSync54, readFileSync as readFileSync43, rmSync as rmSync13, unlinkSync as unlinkSync8 } from "fs";
-import { join as join50 } from "path";
-import { homedir as homedir29 } from "os";
+import { join as join51 } from "path";
+import { homedir as homedir30 } from "os";
 function loadSetupState4(filePath) {
   if (!existsSync54(filePath))
     return null;
@@ -23549,8 +24579,8 @@ function loadSetupState4(filePath) {
   }
 }
 var uninstallCommand = new Command30("uninstall").description("Remove all Runwork configuration from local agents (MCP servers, skills, instructions)").option("-y, --yes", "Skip confirmation prompt").option("--keep-auth", "Keep authentication credentials (only remove agent configs)").action(async (opts) => {
-  const projectStatePath = join50(process.cwd(), ".runwork", "setup.json");
-  const userStatePath = join50(homedir29(), ".runwork", "setup.json");
+  const projectStatePath = join51(process.cwd(), ".runwork", "setup.json");
+  const userStatePath = join51(homedir30(), ".runwork", "setup.json");
   const projectState = loadSetupState4(projectStatePath);
   const userState = loadSetupState4(userStatePath);
   if (!projectState && !userState) {
@@ -23630,9 +24660,9 @@ This will remove all Runwork configuration from your local agents:
         }
       }
     }
-    const stateDir = label === "project" ? join50(process.cwd(), ".runwork") : join50(homedir29(), ".runwork");
+    const stateDir = label === "project" ? join51(process.cwd(), ".runwork") : join51(homedir30(), ".runwork");
     if (opts.keepAuth && label === "user") {
-      const setupFile = join50(stateDir, "setup.json");
+      const setupFile = join51(stateDir, "setup.json");
       if (existsSync54(setupFile)) {
         try {
           unlinkSync8(setupFile);
@@ -23883,8 +24913,8 @@ init_credentials();
 await init_detect();
 import { parse as parse2 } from "smol-toml";
 import { existsSync as existsSync55, readFileSync as readFileSync45 } from "fs";
-import { join as join51, sep as sep4 } from "path";
-import { homedir as homedir30, platform as osPlatform2, arch as osArch } from "os";
+import { join as join52, sep as sep4 } from "path";
+import { homedir as homedir31, platform as osPlatform2, arch as osArch } from "os";
 var BASE_URL2 = process.env.RUNWORK_DOWNLOAD_BASE_URL || "https://runwork.ai";
 var LATEST_JSON_URL2 = `${BASE_URL2}/cli/latest.json`;
 function detectPlatform() {
@@ -23912,7 +24942,7 @@ function buildContext() {
   const credentials = getCredentials();
   const client = credentials ? new ApiClient(credentials) : null;
   let config = null;
-  const configPath = join51(process.cwd(), ".runwork.json");
+  const configPath = join52(process.cwd(), ".runwork.json");
   if (existsSync55(configPath)) {
     try {
       config = JSON.parse(readFileSync45(configPath, "utf-8"));
@@ -24016,9 +25046,9 @@ async function checkCliArtifactReachable() {
 }
 async function checkCliInstallLocation() {
   const isWindows2 = osPlatform2() === "win32";
-  const home = homedir30();
-  const canonicalDir = join51(home, ".runwork", "bin");
-  const canonicalBinary = isWindows2 ? join51(canonicalDir, "runwork.exe") : join51(canonicalDir, "runwork");
+  const home = homedir31();
+  const canonicalDir = join52(home, ".runwork", "bin");
+  const canonicalBinary = isWindows2 ? join52(canonicalDir, "runwork.exe") : join52(canonicalDir, "runwork");
   const candidates = [process.execPath, process.argv[1] || ""].filter(Boolean);
   const runsFromCanonical = candidates.some((p) => normalizePath(p) === normalizePath(canonicalBinary));
   if (runsFromCanonical) {
@@ -24150,7 +25180,7 @@ async function checkGitCredentialHelper(ctx) {
   };
 }
 async function checkProjectConfig(ctx) {
-  const configPath = join51(ctx.cwd, ".runwork.json");
+  const configPath = join52(ctx.cwd, ".runwork.json");
   if (!existsSync55(configPath)) {
     if (!ctx.credentials) {
       return { name: "project-config", status: "skip", message: "no project (not logged in)" };
@@ -24213,7 +25243,7 @@ async function checkGitRemote(ctx) {
   if (!ctx.config) {
     return { name: "git-remote", status: "skip", message: "skipped (no project)" };
   }
-  if (!existsSync55(join51(ctx.cwd, ".git"))) {
+  if (!existsSync55(join52(ctx.cwd, ".git"))) {
     return {
       name: "git-remote",
       status: "fail",
@@ -24267,8 +25297,8 @@ async function checkDeployFreshness(ctx) {
   return { name: "deploy-freshness", status: "skip", message: "local HEAD unknown" };
 }
 function loadSetupState5() {
-  const projectPath = join51(process.cwd(), ".runwork", "setup.json");
-  const userPath = join51(homedir30(), ".runwork", "setup.json");
+  const projectPath = join52(process.cwd(), ".runwork", "setup.json");
+  const userPath = join52(homedir31(), ".runwork", "setup.json");
   for (const p of [projectPath, userPath]) {
     if (existsSync55(p)) {
       try {
@@ -24287,7 +25317,7 @@ async function checkCodexNetwork() {
   if (!state || !state.configuredAgents.includes("codex")) {
     return { name, status: "skip", message: "Codex not configured for Runwork" };
   }
-  const configPath = join51(homedir30(), ".codex", "config.toml");
+  const configPath = join52(homedir31(), ".codex", "config.toml");
   if (!existsSync55(configPath)) {
     return { name, status: "skip", message: "no Codex config found" };
   }
@@ -24346,7 +25376,7 @@ async function checkCodexDesktopProject() {
   if (!usesCodex) {
     return { name, status: "skip", message: "Codex not configured for Runwork" };
   }
-  const statePath2 = join51(homedir30(), ".codex", ".codex-global-state.json");
+  const statePath2 = join52(homedir31(), ".codex", ".codex-global-state.json");
   if (!existsSync55(statePath2)) {
     return { name, status: "skip", message: "Codex desktop app not detected" };
   }
@@ -24358,7 +25388,7 @@ async function checkCodexDesktopProject() {
   } catch {
     return { name, status: "warn", message: "could not read Codex desktop state" };
   }
-  const runworkDir = join51(homedir30(), ".runwork");
+  const runworkDir = join52(homedir31(), ".runwork");
   if (savedRoots.includes(runworkDir)) {
     return { name, status: "pass", message: "Runwork project added to Codex desktop sidebar" };
   }
@@ -24436,7 +25466,7 @@ async function checkAgentSetup() {
     if (!skillsDir)
       continue;
     const missingSkills = state.skills.filter((name) => {
-      const skillPath = join51(skillsDir, name, "SKILL.md");
+      const skillPath = join52(skillsDir, name, "SKILL.md");
       return !existsSync55(skillPath);
     });
     if (missingSkills.length > 0) {
@@ -24462,25 +25492,25 @@ async function checkAgentSetup() {
   };
 }
 function getMcpConfigPath2(slug, scope) {
-  const home = homedir30();
+  const home = homedir31();
   switch (slug) {
     case "claude-code":
-      return scope === "project" ? join51(process.cwd(), ".mcp.json") : join51(home, ".claude", "settings.json");
+      return scope === "project" ? join52(process.cwd(), ".mcp.json") : join52(home, ".claude", "settings.json");
     case "cursor":
-      return scope === "project" ? join51(process.cwd(), ".cursor", "mcp.json") : join51(home, ".cursor", "mcp.json");
+      return scope === "project" ? join52(process.cwd(), ".cursor", "mcp.json") : join52(home, ".cursor", "mcp.json");
     case "windsurf":
-      return scope === "project" ? join51(process.cwd(), ".windsurf", "mcp.json") : join51(home, ".windsurf", "mcp.json");
+      return scope === "project" ? join52(process.cwd(), ".windsurf", "mcp.json") : join52(home, ".windsurf", "mcp.json");
     case "codex":
     case "codex-app":
-      return scope === "user" ? join51(home, ".codex", "config.toml") : null;
+      return scope === "user" ? join52(home, ".codex", "config.toml") : null;
     case "gemini":
-      return scope === "user" ? join51(home, ".gemini", "settings.json") : null;
+      return scope === "user" ? join52(home, ".gemini", "settings.json") : null;
     default:
       return null;
   }
 }
 async function checkWorkspacePointers() {
-  const userStatePath = join51(homedir30(), ".runwork", "setup.json");
+  const userStatePath = join52(homedir31(), ".runwork", "setup.json");
   const state = existsSync55(userStatePath) ? (() => {
     try {
       return JSON.parse(readFileSync45(userStatePath, "utf-8"));
@@ -24513,15 +25543,15 @@ async function checkWorkspacePointers() {
   };
 }
 function getSkillsDir(slug, scope) {
-  const home = homedir30();
+  const home = homedir31();
   switch (slug) {
     case "claude-code":
-      return scope === "project" ? join51(process.cwd(), ".claude", "skills") : join51(home, ".claude", "skills");
+      return scope === "project" ? join52(process.cwd(), ".claude", "skills") : join52(home, ".claude", "skills");
     case "codex":
     case "codex-app":
-      return scope === "project" ? join51(process.cwd(), ".agents", "skills") : join51(home, ".agents", "skills");
+      return scope === "project" ? join52(process.cwd(), ".agents", "skills") : join52(home, ".agents", "skills");
     case "gemini":
-      return scope === "project" ? join51(process.cwd(), ".gemini", "skills") : join51(home, ".gemini", "skills");
+      return scope === "project" ? join52(process.cwd(), ".gemini", "skills") : join52(home, ".gemini", "skills");
     default:
       return null;
   }
@@ -24575,7 +25605,7 @@ async function runAllChecks(options) {
 init_credentials();
 init_remote();
 import { existsSync as existsSync56 } from "fs";
-import { join as join52 } from "path";
+import { join as join53 } from "path";
 async function applyDoctorFixes(ctx, failingNames) {
   const failing = new Set(failingNames);
   const outcomes = [];
@@ -24602,7 +25632,7 @@ async function applyDoctorFixes(ctx, failingNames) {
         applied: false,
         message: "no project config -- run inside an app directory"
       });
-    } else if (!existsSync56(join52(ctx.cwd, ".git"))) {
+    } else if (!existsSync56(join53(ctx.cwd, ".git"))) {
       outcomes.push({
         name: "git-remote",
         applied: false,
@@ -24622,9 +25652,9 @@ async function applyDoctorFixes(ctx, failingNames) {
 
 // src/agents/runtime-detection.ts
 import { existsSync as existsSync57, readFileSync as readFileSync46, statSync as statSync10, readdirSync as readdirSync16 } from "fs";
-import { homedir as homedir31 } from "os";
-import { join as join53 } from "path";
-var RUNWORK_SESSIONS_DIR = join53(homedir31(), ".runwork", "sessions");
+import { homedir as homedir32 } from "os";
+import { join as join54 } from "path";
+var RUNWORK_SESSIONS_DIR = join54(homedir32(), ".runwork", "sessions");
 function detectCurrentAgent() {
   const claudeCodeSessionId = process.env.CLAUDE_CODE_SESSION_ID;
   if (claudeCodeSessionId) {
@@ -24687,7 +25717,7 @@ function detectCurrentAgent() {
   return null;
 }
 function readHookSessionInfo(sessionId) {
-  const path4 = join53(RUNWORK_SESSIONS_DIR, `${sessionId}.json`);
+  const path4 = join54(RUNWORK_SESSIONS_DIR, `${sessionId}.json`);
   if (!existsSync57(path4))
     return null;
   try {
@@ -24699,7 +25729,7 @@ function readHookSessionInfo(sessionId) {
   }
 }
 function findClaudeCodeSessionFile(sessionId) {
-  const root = join53(homedir31(), ".claude", "projects");
+  const root = join54(homedir32(), ".claude", "projects");
   if (!existsSync57(root))
     return null;
   let projectDirs;
@@ -24709,14 +25739,14 @@ function findClaudeCodeSessionFile(sessionId) {
     return null;
   }
   for (const dir of projectDirs) {
-    const candidate = join53(root, dir, `${sessionId}.jsonl`);
+    const candidate = join54(root, dir, `${sessionId}.jsonl`);
     if (existsSync57(candidate))
       return candidate;
   }
   return null;
 }
 function findCodexRolloutFile(threadId) {
-  const root = join53(homedir31(), ".codex", "sessions");
+  const root = join54(homedir32(), ".codex", "sessions");
   if (!existsSync57(root))
     return null;
   const stack = [root];
@@ -24729,7 +25759,7 @@ function findCodexRolloutFile(threadId) {
       continue;
     }
     for (const entry of entries) {
-      const full = join53(dir, entry);
+      const full = join54(dir, entry);
       let s;
       try {
         s = statSync10(full);
@@ -24746,7 +25776,7 @@ function findCodexRolloutFile(threadId) {
   return null;
 }
 function findNewestClaudeCodeSession() {
-  const root = join53(homedir31(), ".claude", "projects");
+  const root = join54(homedir32(), ".claude", "projects");
   if (!existsSync57(root))
     return null;
   let projectDirs;
@@ -24757,7 +25787,7 @@ function findNewestClaudeCodeSession() {
   }
   let best = null;
   for (const dir of projectDirs) {
-    const projectPath = join53(root, dir);
+    const projectPath = join54(root, dir);
     let files;
     try {
       files = readdirSync16(projectPath);
@@ -24767,7 +25797,7 @@ function findNewestClaudeCodeSession() {
     for (const file of files) {
       if (!file.endsWith(".jsonl"))
         continue;
-      const full = join53(projectPath, file);
+      const full = join54(projectPath, file);
       try {
         const s = statSync10(full);
         if (!best || s.mtimeMs > best.mtime) {
@@ -24785,7 +25815,7 @@ function findNewestClaudeCodeSession() {
   return best ? { sessionId: best.sessionId, path: best.path } : null;
 }
 function findNewestCodexRollout() {
-  const root = join53(homedir31(), ".codex", "sessions");
+  const root = join54(homedir32(), ".codex", "sessions");
   if (!existsSync57(root))
     return null;
   const stack = [root];
@@ -24799,7 +25829,7 @@ function findNewestCodexRollout() {
       continue;
     }
     for (const entry of entries) {
-      const full = join53(dir, entry);
+      const full = join54(dir, entry);
       let s;
       try {
         s = statSync10(full);
@@ -25032,9 +26062,9 @@ init_client();
 init_resolve();
 import { Command as Command35 } from "commander";
 import { readFileSync as readFileSync47, writeFileSync as writeFileSync31, existsSync as existsSync58, mkdtempSync as mkdtempSync4 } from "fs";
-import { join as join54 } from "path";
+import { join as join55 } from "path";
 import { tmpdir as tmpdir4 } from "os";
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 
 // src/agents/utils/transcript-render.ts
 init_session_digest();
@@ -25159,8 +26189,8 @@ function resolveLocalSessionShare(opts, conversation) {
     console.error("Error: this conversation has no shareable content.");
     process.exit(1);
   }
-  const tempDir = mkdtempSync4(join54(tmpdir4(), "runwork-share-"));
-  const transcriptFile = join54(tempDir, "transcript.md");
+  const tempDir = mkdtempSync4(join55(tmpdir4(), "runwork-share-"));
+  const transcriptFile = join55(tempDir, "transcript.md");
   writeFileSync31(transcriptFile, markdown);
   opts.transcriptFile = transcriptFile;
   opts.nativeFile = opts.nativeFile ?? conversation.transcriptPath;
@@ -25178,7 +26208,7 @@ function nativeBundleFormatForAgent(slug) {
   return null;
 }
 function sha256Hex(content) {
-  return createHash5("sha256").update(content, "utf8").digest("hex");
+  return createHash6("sha256").update(content, "utf8").digest("hex");
 }
 function utf8ByteLength(content) {
   return Buffer.byteLength(content, "utf8");
@@ -25370,8 +26400,8 @@ init_resolve();
 init_registry_data();
 import { Command as Command38 } from "commander";
 import { writeFileSync as writeFileSync32, mkdirSync as mkdirSync28, realpathSync } from "fs";
-import { homedir as homedir32 } from "os";
-import { join as join55 } from "path";
+import { homedir as homedir33 } from "os";
+import { join as join56 } from "path";
 import { spawn as spawn5 } from "child_process";
 init_registry();
 init_which();
@@ -25410,9 +26440,9 @@ function extractCodexUuid(rolloutContent) {
 }
 function placeClaudeJsonl(uuid, content, recipientCwd) {
   const encoded = encodeClaudeCodeCwd(recipientCwd);
-  const projectDir = join55(homedir32(), ".claude", "projects", encoded);
+  const projectDir = join56(homedir33(), ".claude", "projects", encoded);
   mkdirSync28(projectDir, { recursive: true });
-  const placedAt = join55(projectDir, `${uuid}.jsonl`);
+  const placedAt = join56(projectDir, `${uuid}.jsonl`);
   writeFileSync32(placedAt, content);
   return { placedAt, runFromCwd: recipientCwd };
 }
@@ -25421,10 +26451,10 @@ function placeCodexRollout(uuid, content) {
   const yyyy = String(now.getUTCFullYear());
   const mm = String(now.getUTCMonth() + 1).padStart(2, "0");
   const dd = String(now.getUTCDate()).padStart(2, "0");
-  const dir = join55(homedir32(), ".codex", "sessions", yyyy, mm, dd);
+  const dir = join56(homedir33(), ".codex", "sessions", yyyy, mm, dd);
   mkdirSync28(dir, { recursive: true });
   const ts = now.toISOString().replace(/\.\d+Z$/, "").replace(/:/g, "-");
-  const placedAt = join55(dir, `rollout-${ts}-${uuid}.jsonl`);
+  const placedAt = join56(dir, `rollout-${ts}-${uuid}.jsonl`);
   writeFileSync32(placedAt, content);
   return { placedAt };
 }