@skein-code/cli 0.3.20 → 0.3.21

package/README.md

@@ -94,7 +94,7 @@ To build, verify, and install a local package artifact from this checkout:
 
 ```bash
 npm run verify:package -- --output-dir artifacts/package
-npm install -g ./artifacts/package/skein-code-cli-0.3.16.tgz
+npm install -g ./artifacts/package/skein-code-cli-0.3.21.tgz
 ```
 
 To install the published package from npm:
@@ -449,14 +449,18 @@ command instead of allowing a retrieval change to lower the quality bar.
 The persisted local index now stores content-addressed TypeScript compiler AST
 facts for definitions, calls, and relative imports. Matching definitions can
 expand a query and import/call neighbors may receive a bounded graph score;
-Python and SQL continue to use explicit syntax-aware fallbacks. Git recency is
-collected through a bounded, isolated read-only history scan and contributes
-only a small tie-break score; missing Git, timeouts, output limits, and
-non-repository workspaces degrade to lexical/graph retrieval. Search and
-context JSON expose the index generation, file hash, matched/expanded terms,
-and bm25/path/symbol/phrase/graph/recency breakdown without persisting the
-query or an additional copy of source. Index schema v2 artifacts rebuild as v3
-rather than being trusted after the parser contract changes.
+Python module imports and SQL definitions/references use explicit syntax-aware
+offline fallbacks. Git recency is collected through a bounded, isolated
+read-only history scan and contributes only a small tie-break score; missing
+Git, timeouts, output limits, and non-repository workspaces degrade to
+lexical/graph retrieval. A failed configured verification may add a bounded
+diagnostic tie-break for paths parsed from non-truncated process output. Those
+hints are current-run only, clear on success or the next run, and cannot create
+a zero-relevance hit. Search and context JSON expose the index generation, file
+hash, matched/expanded terms, and bm25/path/symbol/phrase/graph/recency/
+diagnostic breakdown without persisting the query, diagnostic path, or another
+copy of source. Index schema v2 artifacts rebuild as v3 rather than being
+trusted after the parser contract changes.
 
 The included fixture is a deterministic regression gate, not evidence for
 performance on every production repository. `--fresh-index` deletes and

package/dist/cli.js

@@ -4,7 +4,7 @@
 import { createInterface as createInterface2 } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { writeFile as writeFile3 } from "node:fs/promises";
-import { basename as basename13, resolve as resolve24 } from "node:path";
+import { basename as basename13, resolve as resolve25 } from "node:path";
 import { Command, Option } from "commander";
 import chalk4 from "chalk";
 
@@ -220,7 +220,7 @@ function isSqliteBusy(error) {
 // package.json
 var package_default = {
   name: "@skein-code/cli",
-  version: "0.3.20",
+  version: "0.3.21",
   description: "A context-first, model-agnostic coding agent with an auditable terminal workspace.",
   type: "module",
   license: "MIT",
@@ -236,6 +236,10 @@ var package_default = {
   },
   skein: {
     releaseNotes: [
+      "Failed configured verification output yields bounded current-run diagnostic ranking without persisting paths",
+      "Diagnostic hints cannot create zero-relevance hits and are cleared on success or the next agent run",
+      "Python absolute and relative module imports now contribute deterministic offline graph adjacency",
+      "Context provenance exposes the diagnostic score alongside graph and isolated Git recency signals",
       "Local index v3 records TypeScript AST definitions, calls, and relative import adjacency for graph-assisted retrieval",
       "Context hits expose generation, content hash, matched terms, and bm25/path/symbol/phrase/graph score provenance",
       "Context benchmark v2 locks multilingual recall, MRR, useful-token, stale-hit, incremental-index, and warm-latency gates",
@@ -3113,7 +3117,7 @@ function executableNames(command2) {
   return [command2, ...extensions.map((extension) => `${command2}${extension}`)];
 }
 function runProcess(command2, args, options) {
-  return new Promise((resolve25, reject) => {
+  return new Promise((resolve26, reject) => {
     const started = Date.now();
     const environment = options.inheritEnv === false ? {} : { ...process.env };
     for (const name of options.unsetEnv ?? []) delete environment[name];
@@ -3205,7 +3209,7 @@ function runProcess(command2, args, options) {
         reject(callbackError);
         return;
       }
-      resolve25({
+      resolve26({
         command: [command2, ...args].join(" "),
         exitCode: code ?? (timedOut ? 124 : 1),
         stdout,
@@ -3474,6 +3478,8 @@ var MAX_QUERY_CACHE_ENTRIES = 64;
 var CHUNK_LINES = 100;
 var CHUNK_OVERLAP = 15;
 var MIN_STRUCTURAL_CHUNK_LINES = 12;
+var MAX_DIAGNOSTIC_SCORE = 0.05;
+var MAX_DIAGNOSTIC_HINTS_PER_COMMAND = 16;
 var LocalContextIndex = class {
   constructor(roots) {
     this.roots = roots;
@@ -3487,6 +3493,8 @@ var LocalContextIndex = class {
   workspace;
   queryCache = /* @__PURE__ */ new Map();
   gitRecency;
+  diagnosticsByCommand = /* @__PURE__ */ new Map();
+  diagnosticScores = /* @__PURE__ */ new Map();
   queryCacheHits = 0;
   queryCacheMisses = 0;
   fingerprintCache;
@@ -3605,6 +3613,23 @@ var LocalContextIndex = class {
     if (paths.length) this.queryCache.clear();
     if (this.dirtyPaths.size) this.refreshState = "dirty";
   }
+  recordDiagnostics(update) {
+    const paths = /* @__PURE__ */ new Set();
+    for (const candidate of update.paths.slice(0, MAX_DIAGNOSTIC_HINTS_PER_COMMAND)) {
+      const path = this.resolveDiagnosticPath(candidate);
+      if (path) paths.add(path);
+    }
+    if (paths.size) this.diagnosticsByCommand.set(update.commandKey, paths);
+    else this.diagnosticsByCommand.delete(update.commandKey);
+    this.refreshDiagnosticScores();
+    this.queryCache.clear();
+  }
+  resetDiagnostics() {
+    if (!this.diagnosticsByCommand.size) return;
+    this.diagnosticsByCommand.clear();
+    this.diagnosticScores.clear();
+    this.queryCache.clear();
+  }
   async flushDirty() {
     if (!this.dirtyPaths.size) {
       return {
@@ -3690,6 +3715,7 @@ var LocalContextIndex = class {
       queryCacheEntries: this.queryCache.size,
       queryCacheHits: this.queryCacheHits,
       queryCacheMisses: this.queryCacheMisses,
+      diagnosticHints: this.diagnosticScores.size,
       refreshState: this.refreshState,
       dirtyPaths: this.dirtyPaths.size,
       ...this.refreshError ? { refreshError: this.refreshError } : {},
@@ -3939,11 +3965,12 @@ var LocalContextIndex = class {
       );
       const graph = graphBoosts.get(chunk.absolutePath)?.score ?? 0;
       const recency = recencyScores.get(chunk.absolutePath) ?? 0;
-      const score = lexical.bm25 + lexical.path + lexical.symbol + lexical.phrase + graph + recency;
-      return { chunk, lexical, graph, recency, score };
+      const diagnostic = this.diagnosticScores.get(chunk.absolutePath) ?? 0;
+      const score = lexical.bm25 + lexical.path + lexical.symbol + lexical.phrase + graph + recency + diagnostic;
+      return { chunk, lexical, graph, recency, diagnostic, score };
     }).filter(({ lexical, graph }) => lexical.bm25 + lexical.path + lexical.symbol + lexical.phrase + graph > 0).sort((left, right) => right.score - left.score || left.chunk.absolutePath.localeCompare(right.chunk.absolutePath));
     const covered = scored.filter(({ lexical, graph }) => graph > 0 || hasSufficientQueryCoverage(lexical.matchedTerms, coverageTerms));
-    return (covered.length ? covered : scored).slice(0, topK).map(({ chunk, lexical, graph, recency, score }) => {
+    return (covered.length ? covered : scored).slice(0, topK).map(({ chunk, lexical, graph, recency, diagnostic, score }) => {
       const file = filesByPath.get(chunk.absolutePath);
       const breakdown = {
         bm25: roundScore(lexical.bm25),
@@ -3952,6 +3979,7 @@ var LocalContextIndex = class {
         phrase: roundScore(lexical.phrase),
         graph: roundScore(graph),
         recency: roundScore(recency),
+        diagnostic: roundScore(diagnostic),
         total: roundScore(score)
       };
       const provenance = {
@@ -3967,7 +3995,7 @@ var LocalContextIndex = class {
         endLine: chunk.endLine,
         content: chunk.content,
         score,
-        source: "local-bm25+path+symbol+graph+recency",
+        source: "local-bm25+path+symbol+graph+recency+diagnostic",
         ...chunk.symbol ? { symbol: chunk.symbol } : {},
         provenance
       };
@@ -4023,6 +4051,22 @@ var LocalContextIndex = class {
       this.queryCache.delete(oldest);
     }
   }
+  resolveDiagnosticPath(candidate) {
+    if (!candidate || candidate.includes("\0")) return void 0;
+    const absolute = isAbsolute4(candidate) ? resolve10(candidate) : void 0;
+    if (absolute && this.roots.some((root) => isWithinRoot(root, absolute))) return absolute;
+    for (const root of this.roots) {
+      const path = resolve10(root, candidate);
+      if (isWithinRoot(root, path)) return path;
+    }
+    return void 0;
+  }
+  refreshDiagnosticScores() {
+    this.diagnosticScores.clear();
+    for (const paths of this.diagnosticsByCommand.values()) {
+      for (const path of paths) this.diagnosticScores.set(path, MAX_DIAGNOSTIC_SCORE);
+    }
+  }
 };
 function isWithinRoot(root, path) {
   const offset = relative5(root, path);
@@ -4158,7 +4202,7 @@ function packContextHits(hits, roots, maxTokens, engine) {
   const text = selected.map((hit) => {
     const shownPath = workspaceAliasPath(hit.path, roots);
     const symbol = hit.symbol ? ` symbol="${escapeAttribute(hit.symbol)}"` : "";
-    const provenance = hit.provenance ? ` source="${escapeAttribute(hit.source)}" hash="${hit.provenance.contentHash.slice(0, 12)}" graph-score="${hit.provenance.score.graph.toFixed(3)}" recency-score="${hit.provenance.score.recency.toFixed(6)}"` : "";
+    const provenance = hit.provenance ? ` source="${escapeAttribute(hit.source)}" hash="${hit.provenance.contentHash.slice(0, 12)}" graph-score="${hit.provenance.score.graph.toFixed(3)}" recency-score="${hit.provenance.score.recency.toFixed(6)}" diagnostic-score="${hit.provenance.score.diagnostic.toFixed(3)}"` : "";
     return `<code path="${escapeAttribute(shownPath)}" lines="${hit.startLine}-${hit.endLine}" score="${hit.score.toFixed(3)}"${symbol}${provenance}>
 ${hit.content}
 </code>`;
@@ -4485,18 +4529,37 @@ function definitionMatchesQuery(definitionTerms, queryTerms) {
   return shared.length >= required;
 }
 function resolveImportTargets(importer, specifier, files) {
-  if (!specifier.startsWith(".")) return [];
-  const base = posix.normalize(posix.join(posix.dirname(importer.path), specifier));
-  const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
-  const importedExtension = posix.extname(base);
-  const extensionless = extensions.includes(importedExtension) ? base.slice(0, -importedExtension.length) : base;
-  const candidates = /* @__PURE__ */ new Set([
-    base,
-    ...extensions.map((extension) => `${extensionless}${extension}`),
-    ...extensions.map((extension) => posix.join(extensionless, `index${extension}`))
-  ]);
+  const candidates = /* @__PURE__ */ new Set();
+  const extension = extname2(importer.path).toLocaleLowerCase();
+  if (specifier.startsWith(".")) {
+    const base = posix.normalize(posix.join(posix.dirname(importer.path), specifier));
+    const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+    const importedExtension = posix.extname(base);
+    const extensionless = extensions.includes(importedExtension) ? base.slice(0, -importedExtension.length) : base;
+    candidates.add(base);
+    for (const candidateExtension of extensions) {
+      candidates.add(`${extensionless}${candidateExtension}`);
+      candidates.add(posix.join(extensionless, `index${candidateExtension}`));
+    }
+  }
+  if (extension === ".py") {
+    const modulePath = resolvePythonModulePath(importer.path, specifier);
+    if (modulePath) {
+      candidates.add(`${modulePath}.py`);
+      candidates.add(posix.join(modulePath, "__init__.py"));
+    }
+  }
   return files.filter((file) => file.root === importer.root && candidates.has(file.path)).map((file) => file.absolutePath);
 }
+function resolvePythonModulePath(importerPath, specifier) {
+  const match = specifier.match(/^(\.+)(.*)$/u);
+  if (!match) return specifier.split(".").filter(Boolean).join("/");
+  const [, dots, remainder] = match;
+  if (!dots || !remainder) return void 0;
+  let base = posix.dirname(importerPath);
+  for (let level = 1; level < dots.length; level += 1) base = posix.dirname(base);
+  return posix.normalize(posix.join(base, remainder.split(".").filter(Boolean).join("/")));
+}
 function scoreChunk(chunk, terms, rawQuery, documentFrequency, documentCount, averageLength) {
   const frequencies = /* @__PURE__ */ new Map();
   for (const token of chunk.tokens) frequencies.set(token, (frequencies.get(token) ?? 0) + 1);
@@ -4587,6 +4650,12 @@ var ContextEngine = class {
   invalidate(paths) {
     this.local.invalidate(paths);
   }
+  recordDiagnostics(update) {
+    this.local.recordDiagnostics(update);
+  }
+  resetDiagnostics() {
+    this.local.resetDiagnostics();
+  }
   async flushDirty() {
     try {
       const result = await this.local.flushDirty();
@@ -4633,7 +4702,7 @@ function formatContextHits(hits, roots) {
     const path = workspaceAliasPath(hit.path, roots);
     const symbol = hit.symbol ? ` ${hit.symbol}` : "";
     const score = hit.provenance?.score;
-    const breakdown = score ? ` bm25=${score.bm25.toFixed(2)} path=${score.path.toFixed(2)} symbol=${score.symbol.toFixed(2)} graph=${score.graph.toFixed(2)} recency=${score.recency.toFixed(6)}` : "";
+    const breakdown = score ? ` bm25=${score.bm25.toFixed(2)} path=${score.path.toFixed(2)} symbol=${score.symbol.toFixed(2)} graph=${score.graph.toFixed(2)} recency=${score.recency.toFixed(6)} diagnostic=${score.diagnostic.toFixed(3)}` : "";
     const hash4 = hit.provenance?.contentHash.slice(0, 12);
     return `[${hit.source} ${hit.score.toFixed(3)}${breakdown}${hash4 ? ` hash=${hash4}` : ""}]${symbol} ${path}:${hit.startLine}-${hit.endLine}`;
   }).join("\n");
@@ -8585,6 +8654,7 @@ function compact(value, limit) {
 
 // src/agent/completion-gate.ts
 import { createHash as createHash12 } from "node:crypto";
+import { isAbsolute as isAbsolute6, resolve as resolve17 } from "node:path";
 
 // src/tools/permissions.ts
 import { createHash as createHash11, createHmac, randomBytes } from "node:crypto";
@@ -8788,6 +8858,37 @@ function captureVerification(call, result, changeSequence, configuredCommands) {
     commandKey: createHash12("sha256").update(normalized).digest("hex")
   };
 }
+function verificationDiagnosticPaths(result, workspaceRoots) {
+  if (result.ok || result.metadata?.sourceTruncated === true || typeof result.metadata?.exitCode !== "number" || result.metadata.exitCode === 0) return [];
+  const roots = workspaceRoots.map((root) => resolve17(root));
+  const cwd = typeof result.metadata.cwd === "string" ? resolve17(result.metadata.cwd) : void 0;
+  const bases = cwd ? [cwd, ...roots] : roots;
+  const candidates = /* @__PURE__ */ new Set();
+  const pathPattern = String.raw`((?:[./][^\s():]+|[^\s():]+)\.[A-Za-z0-9]{1,10})`;
+  const patterns = [
+    new RegExp(`${pathPattern}\\(\\d+,\\d+\\):\\s*(?:error|warning|fatal)\\b`, "gimu"),
+    new RegExp(`${pathPattern}:\\d+:\\d+:\\s*(?:error|warning|fatal)\\b`, "gimu"),
+    new RegExp(`^\\s*(?:FAIL|ERROR)\\s+${pathPattern}`, "gimu")
+  ];
+  const output2 = result.content.slice(0, 2e5).split(/\r?\n/u).filter((line) => !/^\s*Command:/u.test(line)).join("\n");
+  for (const pattern of patterns) {
+    for (const match of output2.matchAll(pattern)) {
+      const candidate = match[1];
+      if (!candidate) continue;
+      const path = resolveDiagnosticPath(candidate, bases, roots);
+      if (path) candidates.add(path);
+      if (candidates.size >= 16) return [...candidates];
+    }
+  }
+  return [...candidates];
+}
+function resolveDiagnosticPath(candidate, bases, roots) {
+  for (const base of bases) {
+    const path = isAbsolute6(candidate) ? resolve17(candidate) : resolve17(base, candidate);
+    if (roots.some((root) => isInside(root, path))) return path;
+  }
+  return void 0;
+}
 function buildRunCompletion(changedFiles, evidence, currentChangeSequence, mutationTracking = "complete", taskContract, audit = [], duplication) {
   const files = [...new Set(changedFiles)];
   const acceptance = taskContract ? buildAcceptance(taskContract, audit, evidence, currentChangeSequence) : void 0;
@@ -10500,6 +10601,7 @@ var AgentRunner = class {
       throw new Error("User input is too large; pass a focused request or attach files with @path.");
     }
     this.running = true;
+    this.contextEngine.resetDiagnostics?.();
     const emit = async (event) => {
       await options.onEvent?.(event);
     };
@@ -10526,7 +10628,13 @@ var AgentRunner = class {
         this.changeSequence,
         this.config.agent.verifyCommands
       );
-      if (evidence) verificationEvidence.push(evidence);
+      if (evidence) {
+        verificationEvidence.push(evidence);
+        this.contextEngine.recordDiagnostics?.({
+          commandKey: evidence.commandKey,
+          paths: verificationDiagnosticPaths(result, this.workspace.roots)
+        });
+      }
     };
     const completionReport = () => {
       const completion = buildRunCompletion(
@@ -11843,7 +11951,7 @@ function numeric(...values) {
 // src/agent/team-store.ts
 import { createHash as createHash16, randomUUID as randomUUID13 } from "node:crypto";
 import { lstat as lstat18, readFile as readFile17, readdir as readdir7, rm as rm3 } from "node:fs/promises";
-import { join as join16, resolve as resolve17 } from "node:path";
+import { join as join16, resolve as resolve18 } from "node:path";
 import { z as z18 } from "zod";
 var runIdSchema = z18.string().uuid();
 var hashSchema = z18.string().regex(/^[a-f0-9]{64}$/u);
@@ -11927,9 +12035,9 @@ var TeamRunStore = class {
   managedDirectory;
   writes = Promise.resolve();
   constructor(workspace, directory) {
-    this.workspace = resolve17(workspace);
+    this.workspace = resolve18(workspace);
     this.managedDirectory = directory === void 0;
-    this.directory = directory ? resolve17(directory) : join16(resolveProjectNamespaceSync(this.workspace).active, "team-runs");
+    this.directory = directory ? resolve18(directory) : join16(resolveProjectNamespaceSync(this.workspace).active, "team-runs");
   }
   async create(input2) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -12016,7 +12124,7 @@ var TeamRunStore = class {
     const path = join16(this.runDirectory(runId), "manifest.json");
     await this.assertRegularFile(path);
     const manifest = manifestSchema2.parse(JSON.parse(await readFile17(path, "utf8")));
-    if (manifest.id !== runId || resolve17(manifest.workspace) !== this.workspace) {
+    if (manifest.id !== runId || resolve18(manifest.workspace) !== this.workspace) {
       throw new Error("Team run manifest identity does not match its location.");
     }
     if (verify) {
@@ -12147,7 +12255,7 @@ var TeamRunStore = class {
     if (!info.isDirectory() || info.isSymbolicLink()) throw new Error("Team run storage is not a regular directory.");
   }
   async assertRegularFile(path) {
-    await assertNoSymlinkPath(this.workspace, resolve17(path, ".."));
+    await assertNoSymlinkPath(this.workspace, resolve18(path, ".."));
     const info = await lstat18(path);
     if (!info.isFile() || info.isSymbolicLink()) throw new Error(`Team run file is not a regular file: ${path}`);
   }
@@ -12195,7 +12303,7 @@ function resolveAgentModelRoute(team, parent, profile) {
 import { createHash as createHash17 } from "node:crypto";
 import { lstat as lstat19, mkdtemp, realpath as realpath7, rm as rm4 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { isAbsolute as isAbsolute6, join as join17, resolve as resolve18 } from "node:path";
+import { isAbsolute as isAbsolute7, join as join17, resolve as resolve19 } from "node:path";
 var WriterLaneApplyError = class extends Error {
   constructor(message2, attempted, cause) {
     super(message2, cause === void 0 ? void 0 : { cause });
@@ -12208,8 +12316,8 @@ var WriterLane = class {
   workspace;
   constructor(workspace, workspaceRoots) {
     this.workspace = new WorkspaceAccess([
-      resolve18(workspace),
-      ...workspaceRoots.map((root) => resolve18(root))
+      resolve19(workspace),
+      ...workspaceRoots.map((root) => resolve19(root))
     ]);
   }
   async createDraft(maxPatchBytes, operation, signal) {
@@ -12414,7 +12522,7 @@ var WriterLane = class {
     const files = unique2(parseNumstatPaths(numstat.stdout));
     if (!files.length) throw new Error("Writer patch contains no file changes.");
     for (const file of files) {
-      if (isAbsolute6(file) || file === ".git" || file.startsWith(".git/") || file.includes("\0")) {
+      if (isAbsolute7(file) || file === ".git" || file.startsWith(".git/") || file.includes("\0")) {
         throw new Error(`Writer patch contains an unsafe path: ${file}`);
       }
       await this.workspace.resolvePath(join17(repository.root, file), { allowMissing: true });
@@ -12432,7 +12540,7 @@ var WriterLane = class {
     if (topLevel.exitCode !== 0 || !topLevel.stdout.trim()) {
       throw new Error("The primary workspace must be a Git repository root for writer lanes.");
     }
-    const discoveredRoot = resolve18(topLevel.stdout.trim());
+    const discoveredRoot = resolve19(topLevel.stdout.trim());
     if (await realpath7(discoveredRoot) !== await realpath7(root)) {
       throw new Error("The primary workspace must be the Git repository root for writer lanes.");
     }
@@ -12441,7 +12549,7 @@ var WriterLane = class {
     if (common.exitCode !== 0 || !common.stdout.trim()) {
       throw new Error(`Unable to resolve the Git common directory: ${processDetail(common)}`);
     }
-    const commonDirectory = await realpath7(isAbsolute6(common.stdout.trim()) ? common.stdout.trim() : resolve18(repositoryRoot, common.stdout.trim()));
+    const commonDirectory = await realpath7(isAbsolute7(common.stdout.trim()) ? common.stdout.trim() : resolve19(repositoryRoot, common.stdout.trim()));
     return { root: repositoryRoot, commonDirectory, runtime };
   }
   async head(repository) {
@@ -12453,7 +12561,7 @@ var WriterLane = class {
     return value;
   }
   async cleanupWorktree(repository, worktree, added) {
-    const physicalWorktree = await realpath7(worktree).catch(() => resolve18(worktree));
+    const physicalWorktree = await realpath7(worktree).catch(() => resolve19(worktree));
     if (added) {
       await runIsolatedGit(repository.runtime, [
         "worktree",
@@ -14379,7 +14487,7 @@ function formatResultDetail(result, paint = chalk2, glyphs = resolveCliGlyphs())
 }
 
 // src/cli/namespace-leases.ts
-import { resolve as resolve19 } from "node:path";
+import { resolve as resolve20 } from "node:path";
 function cliNamespaceLeaseScopes(actionCommand) {
   const names = commandNames(actionCommand);
   const topLevel = names[1];
@@ -14401,7 +14509,7 @@ async function acquireCliNamespaceLeases(actionCommand) {
   const scopes = cliNamespaceLeaseScopes(actionCommand);
   const localOptions = actionCommand.opts();
   const globalOptions = actionCommand.optsWithGlobals();
-  const workspace = resolve19(localOptions.workspace ?? globalOptions.workspace ?? process.cwd());
+  const workspace = resolve20(localOptions.workspace ?? globalOptions.workspace ?? process.cwd());
   const targets = scopes.map((scope) => scope === "project" ? projectNamespacePaths(workspace).canonical : homeNamespacePaths().canonical);
   const leases = [];
   try {
@@ -14653,7 +14761,7 @@ function graphemes(value) {
 
 // src/ui/theme.ts
 import { lstat as lstat20, readdir as readdir8, readFile as readFile18 } from "node:fs/promises";
-import { basename as basename10, join as join19, resolve as resolve20 } from "node:path";
+import { basename as basename10, join as join19, resolve as resolve21 } from "node:path";
 import React, { createContext, useContext } from "react";
 function defineTheme(seed) {
   return {
@@ -14775,7 +14883,7 @@ async function reloadUserThemes(directory = userThemeDirectory()) {
   userThemeNames.clear();
   const loaded = [];
   const errors = [];
-  const resolvedDirectory = resolve20(directory);
+  const resolvedDirectory = resolve21(directory);
   let entries;
   try {
     entries = await readdir8(resolvedDirectory, { encoding: "utf8" });
@@ -17239,7 +17347,7 @@ function SkeinApp({ runner, config, extensions, initialPrompt, askMode = false,
     return () => clearInterval(timer);
   }, [busy]);
   const requestPermission = useCallback((call, category) => {
-    return new Promise((resolve25) => setPermission({ call, category, resolve: resolve25 }));
+    return new Promise((resolve26) => setPermission({ call, category, resolve: resolve26 }));
   }, []);
   const onEvent = useCallback((event) => {
     switch (event.type) {
@@ -18075,8 +18183,8 @@ function SkeinApp({ runner, config, extensions, initialPrompt, askMode = false,
   }, [append]);
   function settlePermission(grant, stop = false) {
     if (!permission) return;
-    const { call, category, resolve: resolve25 } = permission;
-    resolve25(grant);
+    const { call, category, resolve: resolve26 } = permission;
+    resolve26(grant);
     setPermission(void 0);
     if (grant === "session") {
       append({
@@ -19411,7 +19519,7 @@ async function runFirstRunOnboarding(initialConfig, options = {}) {
 }
 
 // src/runtime/extensions.ts
-import { resolve as resolve23 } from "node:path";
+import { resolve as resolve24 } from "node:path";
 
 // src/mcp/manager.ts
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
@@ -19624,7 +19732,7 @@ function isRecord2(value) {
 
 // src/mcp/validation.ts
 import { stat as stat11, realpath as realpath8 } from "node:fs/promises";
-import { isAbsolute as isAbsolute7, resolve as resolve21 } from "node:path";
+import { isAbsolute as isAbsolute8, resolve as resolve22 } from "node:path";
 var SERVER_NAME = /^[a-z][a-z0-9_-]{0,63}$/;
 var ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
 var HEADER_NAME = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
@@ -19696,9 +19804,9 @@ async function validateCwd(configured, options) {
   if (configured !== void 0 && (configured.length > 4e3 || CONTROL_CHARACTERS.test(configured))) {
     throw new Error("MCP working directory is invalid or too long");
   }
-  const defaultCwd = resolve21(options.cwd ?? process.cwd());
-  const candidate = configured ? isAbsolute7(configured) ? resolve21(configured) : resolve21(defaultCwd, configured) : defaultCwd;
-  const roots = options.workspaceRoots?.length ? options.workspaceRoots.map((root) => resolve21(root)) : [defaultCwd];
+  const defaultCwd = resolve22(options.cwd ?? process.cwd());
+  const candidate = configured ? isAbsolute8(configured) ? resolve22(configured) : resolve22(defaultCwd, configured) : defaultCwd;
+  const roots = options.workspaceRoots?.length ? options.workspaceRoots.map((root) => resolve22(root)) : [defaultCwd];
   const resolvedCandidate = await realpath8(candidate).catch(() => {
     throw new Error(`MCP working directory does not exist: ${candidate}`);
   });
@@ -20352,7 +20460,7 @@ function scopeKey(scope, context) {
 // src/skills/catalog.ts
 import { lstat as lstat21, readFile as readFile20, readdir as readdir9, realpath as realpath9 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { basename as basename12, join as join21, resolve as resolve22 } from "node:path";
+import { basename as basename12, join as join21, resolve as resolve23 } from "node:path";
 import { parse as parseYaml3 } from "yaml";
 var SkillCatalog = class {
   constructor(workspace, config) {
@@ -20421,14 +20529,14 @@ ${skill.content}
 }
 function discoveryLocations(workspace, configured) {
   const home = homedir4();
-  const workspaceRoot = resolve22(workspace);
+  const workspaceRoot = resolve23(workspace);
   return [
     { path: join21(home, ".agents", "skills"), scope: "user", trusted: true },
     { path: join21(home, ".claude", "skills"), scope: "user", trusted: true },
     { path: join21(home, ".augment", "skills"), scope: "user", trusted: true },
     { path: join21(resolveHomeNamespace(), "skills"), scope: "user", trusted: true },
     ...configured.map((path) => {
-      const resolved = resolve22(workspaceRoot, path);
+      const resolved = resolve23(workspaceRoot, path);
       return {
         path: resolved,
         scope: "configured",
@@ -20457,7 +20565,7 @@ async function readMetadata(path) {
   const { frontmatter } = splitFrontmatter(raw);
   if (!frontmatter) return void 0;
   const parsed = parseYaml3(frontmatter);
-  const name = typeof parsed?.name === "string" ? parsed.name.trim() : basename12(resolve22(path, ".."));
+  const name = typeof parsed?.name === "string" ? parsed.name.trim() : basename12(resolve23(path, ".."));
   const description = typeof parsed?.description === "string" ? parsed.description.trim() : "";
   if (!/^[a-z][a-z0-9_-]{0,63}$/.test(name) || !description || description.length > 1e3) {
     return void 0;
@@ -20478,7 +20586,7 @@ async function safeRead(path, maxBytes) {
   try {
     const info = await lstat21(path);
     if (!info.isFile() || info.isSymbolicLink() || info.size > maxBytes) return void 0;
-    const parent = resolve22(path, "..");
+    const parent = resolve23(path, "..");
     const resolvedParent = await realpath9(parent);
     const resolvedPath = await realpath9(path);
     if (!resolvedPath.startsWith(`${resolvedParent}/`)) return void 0;
@@ -20663,7 +20771,7 @@ var ExtensionRuntime = class _ExtensionRuntime {
   delegation;
   initialized = false;
   static async create(config, registry, options = {}) {
-    const runtime = new _ExtensionRuntime(config, resolve23(config.workspaceRoots[0] ?? process.cwd()), options);
+    const runtime = new _ExtensionRuntime(config, resolve24(config.workspaceRoots[0] ?? process.cwd()), options);
     try {
       await runtime.initialize(registry, options.signal);
       return runtime;
@@ -20868,15 +20976,15 @@ function upgradeCommandOverride(env = process.env) {
   return trimmed ? trimmed : void 0;
 }
 function runUpgrade(plan) {
-  return new Promise((resolve25) => {
+  return new Promise((resolve26) => {
     const child = spawn2(plan.command, plan.args, {
       stdio: "inherit",
       shell: plan.shell ?? false
     });
-    child.on("error", () => resolve25({ ok: false, exitCode: 127, display: plan.display }));
+    child.on("error", () => resolve26({ ok: false, exitCode: 127, display: plan.display }));
     child.on("close", (code) => {
       const exitCode = code ?? 1;
-      resolve25({ ok: exitCode === 0, exitCode, display: plan.display });
+      resolve26({ ok: exitCode === 0, exitCode, display: plan.display });
     });
   });
 }
@@ -21138,7 +21246,7 @@ sessionCommand.command("export <id>").description("Export a session as Markdown"
   const store = new SessionStore(workspaceOption(options.workspace));
   const session = await requireSessionSelector(store, id);
   const markdown = sessionMarkdown(session);
-  if (options.output) await writeFile3(resolve24(options.output), markdown, "utf8");
+  if (options.output) await writeFile3(resolve25(options.output), markdown, "utf8");
   else process.stdout.write(markdown);
 });
 var checkpointCommand = program.command("checkpoint").description("Inspect and restore pre-mutation snapshots");
@@ -21515,7 +21623,7 @@ async function runChat(prompts, options) {
   const stdinPrompt = !process.stdin.isTTY ? await readStdin() : "";
   const firstPrompt = [...prompts, stdinPrompt].filter(Boolean).join("\n\n").trim();
   if (shouldPrint && !firstPrompt) throw new Error("Provide a prompt argument or pipe input on stdin.");
-  const workspace = resolve24(options.workspace);
+  const workspace = resolve25(options.workspace);
   let config = await runtimeConfig(workspace, options);
   let completedOnboarding = false;
   if (!shouldPrint && needsFirstRunOnboarding(config)) {
@@ -21740,14 +21848,14 @@ async function runAgentSetup(options) {
 `);
 }
 async function runtimeConfig(workspaceInput, options) {
-  const workspace = resolve24(workspaceInput);
+  const workspace = resolve25(workspaceInput);
   const loaded = await loadConfig(workspace, options.config, {
     trustProjectConfig: options.trustProjectConfig === true
   });
   const roots = [
     workspace,
     ...loaded.workspaceRoots,
-    ...(options.addWorkspace ?? []).map((root) => resolve24(workspace, root))
+    ...(options.addWorkspace ?? []).map((root) => resolve25(workspace, root))
   ];
   const provider = options.provider ? validateProvider(options.provider) : loaded.model.provider;
   return {
@@ -21903,7 +22011,7 @@ function collect(value, previous) {
 }
 function workspaceOption(value) {
   const rootOptions = program.opts();
-  return resolve24(value ?? rootOptions.workspace ?? process.cwd());
+  return resolve25(value ?? rootOptions.workspace ?? process.cwd());
 }
 function runtimeOptions(options) {
   const root = program.opts();