@brainervirus/workit-core 2.1.0 → 2.1.2

package/src/core/task-store.ts

@@ -105,6 +105,73 @@ const metadataLockSchema = z
     externalAction: z.literal(true).optional(),
   })
   .strict();
+/** One task's listing facts, kept in `.workit/index.json` so per-turn host
+ * hooks can find a session's task without parsing every full record. */
+export type TaskIndexEntry = {
+  id: Id;
+  revision: Revision;
+  status: TaskRecord["status"];
+  createdAt: Utc;
+  updatedAt: Utc;
+  objective: string;
+  source: { host: string; kind: Provenance["kind"] };
+  progress: { summary: string; nextAction: string | null };
+  /** Host sessions bound to the task: the intent session (workerId null) and worker sessions. */
+  sessions: { host: string; handle: string; workerId: Id | null }[];
+  /** Stat signature of the task file the entry was derived from. */
+  file: string;
+};
+const INDEX_VERSION = 1;
+const hostSession = (value: unknown): { host: string; handle: string } | null =>
+  isObject(value) &&
+  value.kind === "host" &&
+  typeof value.host === "string" &&
+  typeof value.handle === "string"
+    ? { host: value.host, handle: value.handle }
+    : null;
+const indexEntry = (task: TaskRecord, file: string): TaskIndexEntry => {
+  const sessions: TaskIndexEntry["sessions"] = [];
+  const intent = hostSession(task.intent.provenance.session);
+  if (intent) sessions.push({ ...intent, workerId: null });
+  for (const worker of task.workers) {
+    const session = hostSession(worker.data.session);
+    if (session) sessions.push({ ...session, workerId: worker.id });
+  }
+  return {
+    id: task.id,
+    revision: task.revision,
+    status: task.status,
+    createdAt: task.createdAt,
+    updatedAt: task.updatedAt,
+    objective: task.intent.data.objective,
+    source: { host: task.intent.provenance.host, kind: task.intent.provenance.kind },
+    progress: { summary: task.progress.summary, nextAction: task.progress.nextAction },
+    sessions,
+    file,
+  };
+};
+/** Cheap change detector. Atomic replacement can reuse inodes and file
+ * timestamps are often only jiffy-granular, so a signature alone may repeat
+ * across rapid rewrites; see `racySignature`. */
+export const fileSignature = (file: string): string | null => {
+  try {
+    const stat = fs.statSync(file, { bigint: true });
+    return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
+  } catch {
+    return null;
+  }
+};
+const RACY_WINDOW_NS = 2_000_000_000n;
+/** Like Git's racy-index rule: a file changed within the timestamp-granularity
+ * window may be rewritten again without changing its signature, so callers
+ * must re-read it instead of trusting a cached signature. */
+export const racySignature = (signature: string): boolean => {
+  // ctime catches content written with a back-dated mtime (cp -p, touch -d).
+  const [mtime = 0n, ctime = 0n] = signature.split(":").slice(3, 5).map(BigInt);
+  const changed = mtime > ctime ? mtime : ctime;
+  return BigInt(Date.now()) * 1_000_000n - changed < RACY_WINDOW_NS;
+};
+
 export type RecoveryCandidate = {
   target: "task" | "workspace";
   path: string;
@@ -258,6 +325,58 @@ export class TaskStore {
     return success(null, null, tasks);
   }
 
+  /**
+   * List tasks from `.workit/index.json` without parsing full records. Each
+   * entry is checked against its task file's stat signature; missing, stale,
+   * or corrupt entries are rebuilt from the full (validated) record and the
+   * index is rewritten best-effort. Errors match `listTasks()`.
+   */
+  listTaskIndex(): Result<TaskIndexEntry[]> {
+    if (!fs.existsSync(this.tasksDir)) return success(null, null, []);
+    let names: string[];
+    try {
+      names = fs.readdirSync(this.tasksDir).filter((name) => name.endsWith(".json"));
+    } catch (error) {
+      return failure("storage_error", `unable to list tasks: ${String(error)}`, {
+        path: this.tasksDir,
+      });
+    }
+    const workspace = this.readWorkspace();
+    if (!workspace.ok) return workspace as Result<never>;
+    if (!workspace.data)
+      return failure("recovery_required", "task workspace binding is invalid", {
+        path: this.workspacePath,
+      });
+    const stored = this.readIndex(workspace.data.id);
+    const entries: TaskIndexEntry[] = [];
+    let changed = Object.keys(stored).length !== names.length;
+    for (const name of names.sort()) {
+      const file = path.join(this.tasksDir, name);
+      const signature = fileSignature(file);
+      if (signature === null) {
+        changed = true;
+        continue;
+      }
+      const cached = stored[name.slice(0, -5)];
+      if (cached && cached.file === signature && !racySignature(signature)) {
+        entries.push(cached);
+        continue;
+      }
+      const item = this.readRecord<TaskRecord>(file, taskRecordSchema);
+      if (!item.exists) continue;
+      if (!item.result.ok) return item.result as Result<never>;
+      if (!validId(name.slice(0, -5)) || item.result.data.id !== name.slice(0, -5))
+        return failure("recovery_required", "task filename and record ID differ", { path: name });
+      if (item.result.data.workspaceId !== workspace.data.id)
+        return failure("recovery_required", "task workspace binding is invalid", { path: name });
+      const entry = indexEntry(item.result.data, signature);
+      if (!cached || canonicalJson(cached) !== canonicalJson(entry)) changed = true;
+      entries.push(entry);
+    }
+    if (changed) this.writeIndex(workspace.data.id, entries);
+    return success(null, null, entries);
+  }
+
   readWorkspace(): Result<WorkspaceRecord | null> {
     const item = this.readRecord<WorkspaceRecord>(this.workspacePath, workspaceRecordSchema);
     if (!item.exists) return success(null, null, null);
@@ -1108,6 +1227,7 @@ export class TaskStore {
       fs.renameSync(temporary, file);
       temporary = undefined;
       this.fsyncDirectory(path.dirname(file));
+      if (path.dirname(file) === this.tasksDir) this.indexTaskWrite(file, value as TaskRecord);
       return success(null, null, value);
     } catch (error) {
       return failure("storage_error", `snapshot replacement failed: ${String(error)}`, {
@@ -1121,6 +1241,68 @@ export class TaskStore {
     }
   }
 
+  private readIndex(workspaceId: Id): Record<string, TaskIndexEntry> {
+    try {
+      const value = JSON.parse(fs.readFileSync(this.indexPath, "utf8")) as unknown;
+      if (
+        !isObject(value) ||
+        value.version !== INDEX_VERSION ||
+        value.workspaceId !== workspaceId ||
+        !isObject(value.tasks)
+      )
+        return {};
+      const tasks: Record<string, TaskIndexEntry> = {};
+      for (const [id, entry] of Object.entries(value.tasks))
+        if (
+          isObject(entry) &&
+          entry.id === id &&
+          typeof entry.file === "string" &&
+          typeof entry.status === "string" &&
+          typeof entry.updatedAt === "string" &&
+          Array.isArray(entry.sessions) &&
+          isObject(entry.progress) &&
+          isObject(entry.source)
+        )
+          tasks[id] = entry as TaskIndexEntry;
+      return tasks;
+    } catch {
+      return {};
+    }
+  }
+
+  /** The index is a disposable cache: write it atomically, never fail the caller. */
+  private writeIndex(workspaceId: Id, entries: TaskIndexEntry[]) {
+    const temporary = `${this.indexPath}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+      fs.writeFileSync(
+        temporary,
+        JSON.stringify({
+          version: INDEX_VERSION,
+          workspaceId,
+          tasks: Object.fromEntries(entries.map((entry) => [entry.id, entry])),
+        }),
+        { mode: 0o600, flag: "wx" },
+      );
+      fs.renameSync(temporary, this.indexPath);
+    } catch {
+      try {
+        fs.unlinkSync(temporary);
+      } catch {}
+    }
+  }
+
+  private indexTaskWrite(file: string, task: TaskRecord) {
+    try {
+      const signature = fileSignature(file);
+      if (signature === null) return;
+      const tasks = this.readIndex(task.workspaceId);
+      tasks[task.id] = indexEntry(task, signature);
+      this.writeIndex(task.workspaceId, Object.values(tasks));
+    } catch {
+      // A stale index entry is repaired by the next listTaskIndex().
+    }
+  }
+
   private saveRecovery(file: string, bytes: string | Buffer) {
     const target = path.basename(file) === "workspace.json" ? "workspace" : "task";
     const id = target === "task" ? path.basename(file, ".json") : "workspace";
@@ -1298,6 +1480,9 @@ export class TaskStore {
   private get workspacePath() {
     return path.join(this.workitDir, "workspace.json");
   }
+  private get indexPath() {
+    return path.join(this.workitDir, "index.json");
+  }
   private get lockPath() {
     return path.join(this.workitDir, "metadata.lock");
   }

package/src/core/templates.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { configDir } from "./config";
 import { assetRoot } from "./package-root";
@@ -20,28 +20,3 @@ export const readTemplate = (
     content: readFileSync(path.join(repoRoot, "templates", `${name}.md`), "utf8"),
   };
 };
-
-export const writeTemplate = (
-  name: TemplateName,
-  content: string,
-  confirmed: boolean,
-): { ok: true; path: string } | { ok: false; error: string } => {
-  if (!confirmed) return { ok: false, error: "confirmed: true required" };
-  const file = templatePath(name);
-  mkdirSync(path.dirname(file), { recursive: true });
-  writeFileSync(file, content, "utf8");
-  return { ok: true, path: file };
-};
-
-export const listTemplates = (): {
-  name: TemplateName;
-  source: "config" | "repo" | "missing";
-  path: string;
-}[] =>
-  (["issue-update", "greeting", "headers"] as TemplateName[]).map((name) => {
-    const cfg = templatePath(name);
-    const repoFile = path.join(repoRoot, "templates", `${name}.md`);
-    if (existsSync(cfg)) return { name, source: "config", path: cfg };
-    if (existsSync(repoFile)) return { name, source: "repo", path: repoFile };
-    return { name, source: "missing", path: cfg };
-  });

package/src/core/vcs-config.ts

@@ -303,10 +303,6 @@ export function vcsCliIdentity(cwd?: string): Record<string, any> {
 }
 
 /** Legacy command name, now verifies native CLI auth rather than a separate token. */
-export async function vcsVerifyToken(): Promise<Record<string, any>> {
-  return vcsCliIdentity();
-}
-
 /** Port of scripts/vcs/merged-style.sh — recent merged MR/PR bodies for style reference. */
 export function mergedPrStyle(limit = 6, cwd?: string): Record<string, any> {
   const cfg = vcsConfig("load", cwd);

package/src/core/workspaces.ts

@@ -448,8 +448,7 @@ export const resolveWorkspaceFromEntries = <T extends { name: string; glob: stri
   // macOS/Windows tmpdir symlinks (/var -> /private/var): git's
   // --show-toplevel returns the realpath while config globs are usually
   // written with the logical path, so a workspace would silently stop
-  // matching on macOS. Match both forms on each side — same class as the
-  // docs-migration escape-guard realpath comparison; on Linux both forms
+  // matching on macOS. Match both forms on each side; on Linux both forms
   // are identical so behavior is unchanged.
   const targets = [cwd, realpathOf(cwd)].map((p) => p.replaceAll("\\", "/"));
   const matches: T[] = [];

package/src/core.ts

@@ -60,7 +60,13 @@ export type {
   Result as ContractResult,
 } from "./core/task-contract";
 export { TaskStore, runtimeVersion } from "./core/task-store";
-export type { MetadataLock, ProcessEvidence, RecoveryInput } from "./core/task-store";
+export type {
+  MetadataLock,
+  ProcessEvidence,
+  RecoveryInput,
+  TaskIndexEntry,
+} from "./core/task-store";
+export { sessionCompactContext, unfinishedTaskOffer } from "./core/session-context";
 export { compactTaskContext, reconcileResume } from "./core/task-context";
 export type {
   CompactTaskContext,

package/src/core/config-guard.ts

@@ -1,27 +0,0 @@
-import { initStatus } from "./init";
-
-export const ALL_ITEM_IDS = ["youtrack_json", "youtrack_token", "vcs_json"];
-export const CONFIG_GAP_MARKER = "workflow config missing";
-
-export function describeConfigGaps(scope?: string[]): { missing: string[]; ok: boolean } {
-  const all = scope ?? ALL_ITEM_IDS;
-  try {
-    const status: unknown = initStatus();
-    if (!status || typeof status !== "object" || (status as Record<string, unknown>).error)
-      return { missing: all, ok: false };
-    const items = (status as Record<string, unknown>).items;
-    if (!Array.isArray(items) || items.length === 0) return { missing: all, ok: false };
-    const known = all;
-    const missing = items
-      .filter((item) => item && (item as Record<string, unknown>).ok === false)
-      .map((item) => String((item as Record<string, unknown>).id))
-      .filter((id) => known.includes(id));
-    return { missing, ok: missing.length === 0 };
-  } catch {
-    return { missing: all, ok: false };
-  }
-}
-
-export function configGuardError(missing: string[]): string {
-  return `${CONFIG_GAP_MARKER}: ${missing.join(", ")}. Run \`npx workit init\` or \`/wk-init\` to configure.`;
-}

package/src/core/doc-render.ts

@@ -1,14 +0,0 @@
-export const MAX_LINES = 150;
-export const MAX_BYTES = 8192;
-export const MAX_MERMAID = 3;
-
-const MERMAID_FENCE = /^```mermaid\s*$/gm;
-
-export const shouldRenderDoc = (text: string): boolean => {
-  const lines = text.split(/\r?\n/);
-  if (lines[lines.length - 1] === "") lines.pop();
-  if (lines.length > MAX_LINES) return false;
-  if (Buffer.byteLength(text, "utf8") > MAX_BYTES) return false;
-  const mermaidCount = text.match(MERMAID_FENCE)?.length ?? 0;
-  return mermaidCount <= MAX_MERMAID;
-};

package/src/core/docs-layout.ts

@@ -1,279 +0,0 @@
-import { existsSync, lstatSync, mkdirSync, realpathSync, statSync } from "node:fs";
-import path from "node:path";
-
-// One canonical document path contract (DC-01, DC-02, DC-04, DC-14): workspace
-// root, slug, and spec/plan pair resolution all funnel through here so every
-// document/flow/SDD consumer on both hosts enforces the same containment rules.
-
-export type CanonicalLayout = {
-  /** Canonical (realpath) workspace root. */
-  workspace: string;
-  /** Validated slug. */
-  slug: string;
-  /** Canonical path of docs/. */
-  docs: string;
-  /** Canonical path of docs/<slug>/. */
-  dir: string;
-  /** Canonical path of docs/<slug>/spec.md. */
-  spec: string;
-  /** Canonical path of docs/<slug>/plan.md. */
-  plan: string;
-  /** Canonical path of docs/<slug>/sdd/. */
-  sdd: string;
-};
-
-export type LayoutResult = { ok: true; layout: CanonicalLayout } | { ok: false; error: string };
-
-export type LegacyProbe = {
-  /** `.superpowers/sdd` exists. */
-  legacy_sdd: boolean;
-  /** `docs/superpowers/` exists. */
-  superpowers_dir: boolean;
-};
-
-export type PrepareResult =
-  | { ok: true; layout: CanonicalLayout; created: string[]; legacy: LegacyProbe }
-  | { ok: false; error: string };
-
-const SLUG_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-
-/** Reserved legacy root (DC-05): never resolve or prepare a slug under it. */
-const LEGACY_SLUG = "superpowers";
-
-const posix = (p: string) => p.split(path.sep).join("/");
-
-// Realpath the nearest existing ancestor of `candidate` and reject the result
-// when it escapes `base` (base must already be canonical). The returned path is
-// canonical where it exists and joined for the non-existent tail.
-const canonicalize = (base: string, candidate: string): string => {
-  const abs = path.resolve(base, candidate);
-  let ancestor = abs;
-  while (!existsSync(ancestor)) ancestor = path.dirname(ancestor);
-  let real: string;
-  try {
-    real = realpathSync(ancestor);
-  } catch (error) {
-    // macOS realpath fails with EACCES on a mode-000 file while Linux succeeds;
-    // an existing non-symlink file cannot escape the workspace, so resolve the
-    // nearest existing directory instead (symlinks keep the strict path).
-    if (
-      (error as NodeJS.ErrnoException).code === "EACCES" &&
-      !lstatSync(ancestor).isSymbolicLink()
-    ) {
-      real = path.join(realpathSync(path.dirname(ancestor)), path.basename(ancestor));
-    } else {
-      throw error;
-    }
-  }
-  if (real !== base && !real.startsWith(base + path.sep)) {
-    throw new Error(`path must stay inside repository root: ${candidate}`);
-  }
-  return path.join(real, path.relative(ancestor, abs));
-};
-
-const buildLayout = (workspace: string, slug: string): CanonicalLayout => {
-  const docs = canonicalize(workspace, "docs");
-  const dir = canonicalize(workspace, path.join(docs, slug));
-  return {
-    workspace,
-    slug,
-    docs,
-    dir,
-    spec: path.join(dir, "spec.md"),
-    plan: path.join(dir, "plan.md"),
-    sdd: path.join(dir, "sdd"),
-  };
-};
-
-/** Read-only legacy detection (DC-04): never mutates legacy state. */
-export const probeLegacyDocs = (workspace: string): LegacyProbe => ({
-  legacy_sdd: existsSync(path.join(workspace, ".superpowers", "sdd")),
-  superpowers_dir: existsSync(path.join(workspace, "docs", LEGACY_SLUG)),
-});
-
-/**
- * The one canonical workspace/slug/pair resolver. Given a slug or any spec/plan
- * pair path, returns canonical paths for the pair. Rejects absolute paths,
- * traversal, symlink escapes, cross-slug pairs, wrong basenames, and arbitrary
- * or legacy locations (DC-01, DC-02). Creates nothing.
- */
-export const resolveCanonicalLayout = (input: {
-  workspace_root: string;
-  slug?: string;
-  spec_path?: string;
-  plan_path?: string;
-}): LayoutResult => {
-  const { workspace_root, slug, spec_path, plan_path } = input;
-  if (!workspace_root) return { ok: false, error: "workspace_root required" };
-  let workspace: string;
-  try {
-    workspace = realpathSync(path.resolve(workspace_root));
-  } catch {
-    return { ok: false, error: `workspace root not found: ${workspace_root}` };
-  }
-
-  let derived: string | null = null;
-  for (const [candidate, kind] of [
-    [spec_path, "spec"],
-    [plan_path, "plan"],
-  ] as const) {
-    if (!candidate) continue;
-    if (path.isAbsolute(candidate)) {
-      return { ok: false, error: `absolute path not allowed: ${candidate}` };
-    }
-    // Exact-spelling contract (DC-01): the caller path must be written as the
-    // canonical `docs/<slug>/spec.md` / `docs/<slug>/plan.md` — no `./`,
-    // no `..` segments, no repeated or trailing separators. The strict regex
-    // below rejects those spellings before any bytes are read or resolved.
-    const spelling = posix(candidate);
-    const match = spelling.match(/^docs\/([^/]+)\/(spec|plan)\.md$/);
-    if (!match) {
-      return {
-        ok: false,
-        error: `path must be docs/<slug>/(spec|plan).md inside workspace_root: ${candidate}`,
-      };
-    }
-    const pathSlug = match[1];
-    if (pathSlug === LEGACY_SLUG) {
-      return { ok: false, error: `legacy path not allowed: ${candidate}` };
-    }
-    if (!SLUG_RE.test(pathSlug)) {
-      return { ok: false, error: `invalid slug derived from path: ${JSON.stringify(pathSlug)}` };
-    }
-    if (match[2] !== kind) {
-      return {
-        ok: false,
-        error: `wrong basename for ${kind}: expected ${kind}.md, got ${path.basename(candidate)}`,
-      };
-    }
-    if (derived && derived !== pathSlug) {
-      return {
-        ok: false,
-        error: "cross-slug pair: spec_path and plan_path must share the same docs/<slug>/",
-      };
-    }
-    derived = pathSlug;
-    // Symlink/canonical containment (DC-02): after the exact-spelling match,
-    // resolve the canonical path so a symlinked docs/<slug> or doc file that
-    // escapes the workspace or resolves to a different slug is still rejected.
-    let abs: string;
-    try {
-      abs = canonicalize(workspace, candidate);
-    } catch (error) {
-      return { ok: false, error: error instanceof Error ? error.message : String(error) };
-    }
-    if (posix(path.relative(workspace, abs)) !== spelling) {
-      return {
-        ok: false,
-        error: `path must resolve to ${JSON.stringify(spelling)}: ${candidate}`,
-      };
-    }
-  }
-
-  let resolvedSlug = slug;
-  if (resolvedSlug !== undefined) {
-    if (!SLUG_RE.test(resolvedSlug)) {
-      return { ok: false, error: `invalid slug: ${JSON.stringify(resolvedSlug)}` };
-    }
-    if (resolvedSlug === LEGACY_SLUG) {
-      return { ok: false, error: `reserved slug: ${LEGACY_SLUG}` };
-    }
-    if (derived && derived !== resolvedSlug) {
-      return {
-        ok: false,
-        error: `slug ${JSON.stringify(resolvedSlug)} does not match docs path ${JSON.stringify(derived)}`,
-      };
-    }
-  } else if (derived) {
-    resolvedSlug = derived;
-  } else {
-    return { ok: false, error: "slug or spec_path/plan_path required" };
-  }
-
-  try {
-    return { ok: true, layout: buildLayout(workspace, resolvedSlug) };
-  } catch (error) {
-    return { ok: false, error: error instanceof Error ? error.message : String(error) };
-  }
-};
-
-/**
- * Prepare the canonical layout (DC-04): create only missing `docs/` and
- * `docs/<slug>/`, return canonical (realpath) paths, and probe legacy state
- * read-only. Never creates sdd/, spec.md, or plan.md.
- */
-export const prepareDocsLayout = (input: {
-  workspace_root: string;
-  slug?: string;
-  spec_path?: string;
-  plan_path?: string;
-}): PrepareResult => {
-  const resolved = resolveCanonicalLayout(input);
-  if (!resolved.ok) return { ok: false, error: resolved.error };
-  const { layout } = resolved;
-  const created: string[] = [];
-  const ensure = (dir: string) => {
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-      const rel = posix(path.relative(layout.workspace, dir));
-      created.push(rel || ".");
-    } else if (!statSync(dir).isDirectory()) {
-      throw new Error(
-        `path exists but is not a directory: ${posix(path.relative(layout.workspace, dir))}`,
-      );
-    }
-  };
-  try {
-    ensure(layout.docs);
-    ensure(layout.dir);
-    // Re-canonicalize after creation so a symlinked docs/<slug> that escapes
-    // the workspace is rejected, not silently accepted (DC-02).
-    const docs = canonicalize(layout.workspace, "docs");
-    const dir = canonicalize(layout.workspace, path.join(docs, layout.slug));
-    return {
-      ok: true,
-      layout: { ...layout, docs, dir },
-      created,
-      legacy: probeLegacyDocs(layout.workspace),
-    };
-  } catch (error) {
-    return { ok: false, error: error instanceof Error ? error.message : String(error) };
-  }
-};
-
-/**
- * Containment check for paths that must live inside the workspace docs tree
- * (sdd dirs, progress files, plan links). Rejects absolute paths, escapes, and
- * the reserved legacy root `docs/superpowers/`.
- */
-export const resolveDocsPath = (input: {
-  workspace_root: string;
-  path: string;
-}): { ok: true; path: string; relative: string; base: string } | { ok: false; error: string } => {
-  if (path.isAbsolute(input.path)) {
-    return { ok: false, error: `absolute path not allowed: ${input.path}` };
-  }
-  let workspace: string;
-  try {
-    workspace = realpathSync(path.resolve(input.workspace_root));
-  } catch {
-    return { ok: false, error: `workspace root not found: ${input.workspace_root}` };
-  }
-  try {
-    const abs = canonicalize(workspace, input.path);
-    const relative = posix(path.relative(workspace, abs));
-    if (
-      !relative.startsWith("docs/") ||
-      relative === `docs/${LEGACY_SLUG}` ||
-      relative.startsWith(`docs/${LEGACY_SLUG}/`)
-    ) {
-      return {
-        ok: false,
-        error: `path must live under docs/ and not under docs/${LEGACY_SLUG}/: ${input.path}`,
-      };
-    }
-    return { ok: true, path: abs, relative, base: workspace };
-  } catch (error) {
-    return { ok: false, error: error instanceof Error ? error.message : String(error) };
-  }
-};