@deeplake/hivemind 0.7.45 → 0.7.47

package/codex/skills/hivemind-goals/SKILL.md

@@ -0,0 +1,157 @@
+---
+name: hivemind-goals
+description: Create, track and update team goals + KPIs via the Deeplake virtual filesystem at memory/goal/ and memory/kpi/. Use whenever the user mentions a goal, objective, KPI, target, milestone, or asks to track progress on something measurable.
+allowed-tools: Bash
+---
+
+# Hivemind Goals
+
+Track goals and KPIs as Markdown files inside the Deeplake virtual filesystem. Each file is one row in a dedicated team-shared table — the path encodes the structural metadata, the file body holds the human-readable description.
+
+## When to use this skill
+
+Activate when the user expresses any of:
+- "I want to track X / aim for X / track my progress on Y"
+- "add a goal", "add a KPI", "what are my goals?"
+- "mark this as done", "close that goal"
+- "shipping X by Friday", "5 PRs this week", any measurable target
+
+For "list my goals" → run `ls ~/.deeplake/memory/goal/<userName>/opened/` and `ls ~/.deeplake/memory/goal/<userName>/in_progress/`. If empty, ask the user if they want to create one.
+
+## Path conventions (LEARN THESE)
+
+```
+~/.deeplake/memory/goal/<owner>/<status>/<goal_id>.md
+~/.deeplake/memory/kpi/<goal_id>/<kpi_id>.md
+```
+
+- `<owner>` — user identifier (use the userName from `hivemind whoami` or the credentials)
+- `<status>` — one of `opened`, `in_progress`, `closed`
+- `<goal_id>` — UUIDv4 you generate at create time
+- `<kpi_id>` — short slug like `k-prs` or `k-demos`
+
+**Path encoding is the source of truth.** The owner, status, goal_id, and kpi_id come from the path — NOT from the file body. Do NOT write owner/status/goal_id/kpi_id inside the file content.
+
+## File body format
+
+Goal file body — plain markdown, free form:
+```
+ship the goals-graph feature
+
+Notes: focus on KPI tracking via VFS, no separate CLI.
+Due: 2026-05-30.
+```
+
+KPI file body — markdown with a few mandatory key:value lines so the commit-driven auto-progress worker can parse and bump:
+```
+PRs merged
+
+- target: 5
+- current: 2
+- unit: count
+```
+
+The `target:`, `current:`, `unit:` lines must stay on a single line each. The first line is the human-readable name. Anything else is free notes.
+
+## Operations
+
+### 1. Create a new goal
+
+When the user expresses a new goal:
+
+1. Get the current owner with `hivemind whoami` (use the userName, e.g. `emanuele.fenocchi`).
+2. Generate a UUIDv4: `uuidgen` or `node -e 'console.log(crypto.randomUUID())'`.
+3. Write the goal file at `~/.deeplake/memory/goal/<owner>/opened/<uuid>.md` with the goal description as body.
+4. Respond to the user that the goal is created.
+
+**Do NOT auto-generate KPIs.** A goal is created with zero KPI files by default. Generate KPIs ONLY when the user explicitly asks you to ("aggiungi KPI per …", "add metrics for this goal", "track these metrics: …"). When the user asks, write each KPI as a separate file at `~/.deeplake/memory/kpi/<goal_id>/<kpi-slug>.md` with the body format documented above.
+
+### 2. List goals
+
+```bash
+ls ~/.deeplake/memory/goal/<owner>/opened/
+ls ~/.deeplake/memory/goal/<owner>/in_progress/
+```
+
+Then `cat` each `<uuid>.md` to read the body. Optionally `ls ~/.deeplake/memory/kpi/<uuid>/` and `cat` each KPI to surface progress.
+
+### 3. Edit a goal description
+
+```bash
+# Use Read + Edit (or Write) on the existing file. The VFS handles
+# version-bumping — every write produces a fresh row in the
+# hivemind_goals table.
+```
+
+### 4. Move a goal to in_progress
+
+```bash
+mv ~/.deeplake/memory/goal/<owner>/opened/<uuid>.md ~/.deeplake/memory/goal/<owner>/in_progress/<uuid>.md
+```
+
+`mv` between status folders is an atomic version-bump. The file body carries over unchanged.
+
+### 5. Close a goal
+
+Two equivalent ways:
+
+```bash
+# Explicit mv to closed (recommended — clearest intent)
+mv ~/.deeplake/memory/goal/<owner>/in_progress/<uuid>.md ~/.deeplake/memory/goal/<owner>/closed/<uuid>.md
+
+# Or: rm (the VFS interprets rm on a goal path as a soft-close)
+rm ~/.deeplake/memory/goal/<owner>/opened/<uuid>.md
+```
+
+**Important:** `rm` does NOT actually delete the goal. It is a soft-close — the VFS writes a new version with status=closed. The goal remains in the team-shared table for audit. There is no hard-delete in v1.
+
+### 6. Add a KPI manually
+
+```bash
+Write the file at ~/.deeplake/memory/kpi/<uuid>/<kpi-slug>.md with:
+  <KPI name>
+
+  - target: <N>
+  - current: 0
+  - unit: <unit>
+```
+
+### 7. Record progress on a KPI
+
+Read the KPI file, increment the `current:` line, write it back:
+
+```
+<KPI name>
+
+- target: 5
+- current: 3       ← incremented from 2
+- unit: count
+```
+
+Use the Edit tool for the most surgical change (just the line with `current:`).
+
+### 8. Reassign a goal (transfer ownership)
+
+```bash
+mv ~/.deeplake/memory/goal/<old-owner>/<status>/<uuid>.md ~/.deeplake/memory/goal/<new-owner>/<status>/<uuid>.md
+```
+
+Goal ownership lives in the path. KPI files do NOT have an owner segment — they are linked to the goal by `<uuid>`, so they need no change when a goal is reassigned.
+
+## Constraints — DO NOT do these
+
+- Do NOT put `owner`, `status`, `goal_id`, or `kpi_id` inside the file body. The path is the source of truth — duplicating in the body causes drift.
+- Do NOT use status values other than `opened`, `in_progress`, `closed`.
+- Do NOT rename the goal_id (the UUID in the filename) via `mv`. The VFS rejects goal_id renames.
+- Do NOT block on the KPI generator subprocess — always spawn it detached (`nohup … &`).
+- Do NOT use the old `hivemind tasks` CLI — that belonged to an earlier design and is being removed.
+
+## Auto-progress from `git commit`
+
+A PostToolUse hook listens for `git commit`. When it fires, it spawns the agent's native LLM in the background with the commit diff + the list of the current user's open goals. The LLM reads each goal + its KPIs, judges whether the commit advanced any KPI, and edits the relevant KPI file to bump `current:`. This is fire-and-forget; the user does not block on it.
+
+To disable globally: `HIVEMIND_AUTO_KPI_FROM_COMMITS=false`.
+
+## Team visibility
+
+Every write goes to a team-shared table on Deeplake (`hivemind_goals` or `hivemind_kpis`). Other team members see your goals in their SessionStart context and via direct `ls` / `cat` on the same paths in their own VFS. No explicit sharing step needed.

package/cursor/bundle/capture.js

@@ -54,13 +54,13 @@ var init_index_marker_store = __esm({
 
 // dist/src/utils/stdin.js
 function readStdin() {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     let data = "";
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => data += chunk);
     process.stdin.on("end", () => {
       try {
-        resolve2(JSON.parse(data));
+        resolve3(JSON.parse(data));
       } catch (err) {
         reject(new Error(`Failed to parse hook input: ${err}`));
       }
@@ -98,6 +98,23 @@ function loadConfig() {
     tableName: process.env.HIVEMIND_TABLE ?? "memory",
     sessionsTableName: process.env.HIVEMIND_SESSIONS_TABLE ?? "sessions",
     skillsTableName: process.env.HIVEMIND_SKILLS_TABLE ?? "skills",
+    // Defaults match the table name written into the SQL — keep aligned
+    // with RULES_COLUMNS / TASKS_COLUMNS / TASK_EVENTS_COLUMNS in
+    // deeplake-schema.ts and with the e2e test-org override convention
+    // (memory_test / sessions_test → goals_test, etc.) documented in
+    // CLAUDE.md.
+    rulesTableName: process.env.HIVEMIND_RULES_TABLE ?? "hivemind_rules",
+    tasksTableName: process.env.HIVEMIND_TASKS_TABLE ?? "hivemind_tasks",
+    taskEventsTableName: process.env.HIVEMIND_TASK_EVENTS_TABLE ?? "hivemind_task_events",
+    // Goals + KPIs (refined design — VFS path classifier maps
+    //   memory/goal/<user>/<status>/<uuid>.md → hivemind_goals row
+    //   memory/kpi/<uuid>/<kpi_id>.md → hivemind_kpis row
+    // See src/shell/deeplake-fs.ts for the translation logic and
+    // GOALS_COLUMNS / KPIS_COLUMNS in deeplake-schema.ts for the
+    // table shape.
+    goalsTableName: process.env.HIVEMIND_GOALS_TABLE ?? "hivemind_goals",
+    kpisTableName: process.env.HIVEMIND_KPIS_TABLE ?? "hivemind_kpis",
+    codebaseTableName: process.env.HIVEMIND_CODEBASE_TABLE ?? "codebase",
     memoryPath: process.env.HIVEMIND_MEMORY_PATH ?? join(home, ".deeplake", "memory")
   };
 }
@@ -198,6 +215,65 @@ var SKILLS_COLUMNS = Object.freeze([
   { name: "created_at", sql: "TEXT NOT NULL DEFAULT ''" },
   { name: "updated_at", sql: "TEXT NOT NULL DEFAULT ''" }
 ]);
+var RULES_COLUMNS = Object.freeze([
+  { name: "id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "rule_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "text", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "scope", sql: "TEXT NOT NULL DEFAULT 'team'" },
+  { name: "status", sql: "TEXT NOT NULL DEFAULT 'active'" },
+  { name: "assigned_by", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "version", sql: "BIGINT NOT NULL DEFAULT 1" },
+  { name: "created_at", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "agent", sql: "TEXT NOT NULL DEFAULT 'manual'" },
+  { name: "plugin_version", sql: "TEXT NOT NULL DEFAULT ''" }
+]);
+var TASKS_COLUMNS = Object.freeze([
+  { name: "id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "task_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "text", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "scope", sql: "TEXT NOT NULL DEFAULT 'me'" },
+  { name: "status", sql: "TEXT NOT NULL DEFAULT 'active'" },
+  { name: "assigned_to", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "assigned_by", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "kpis", sql: "JSONB" },
+  { name: "version", sql: "BIGINT NOT NULL DEFAULT 1" },
+  { name: "created_at", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "agent", sql: "TEXT NOT NULL DEFAULT 'manual'" },
+  { name: "plugin_version", sql: "TEXT NOT NULL DEFAULT ''" }
+]);
+var TASK_EVENTS_COLUMNS = Object.freeze([
+  { name: "id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "task_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "task_version", sql: "BIGINT NOT NULL DEFAULT 1" },
+  { name: "kpi_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "value", sql: "BIGINT NOT NULL DEFAULT 0" },
+  { name: "note", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "source", sql: "TEXT NOT NULL DEFAULT 'user'" },
+  { name: "agent", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "ts", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "plugin_version", sql: "TEXT NOT NULL DEFAULT ''" }
+]);
+var GOALS_COLUMNS = Object.freeze([
+  { name: "id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "goal_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "owner", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "status", sql: "TEXT NOT NULL DEFAULT 'opened'" },
+  { name: "content", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "version", sql: "BIGINT NOT NULL DEFAULT 1" },
+  { name: "created_at", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "agent", sql: "TEXT NOT NULL DEFAULT 'manual'" },
+  { name: "plugin_version", sql: "TEXT NOT NULL DEFAULT ''" }
+]);
+var KPIS_COLUMNS = Object.freeze([
+  { name: "id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "goal_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "kpi_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "content", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "version", sql: "BIGINT NOT NULL DEFAULT 1" },
+  { name: "created_at", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "agent", sql: "TEXT NOT NULL DEFAULT 'manual'" },
+  { name: "plugin_version", sql: "TEXT NOT NULL DEFAULT ''" }
+]);
 function validateSchema(label, cols) {
   const seen = /* @__PURE__ */ new Set();
   for (const col of cols) {
@@ -215,9 +291,38 @@ function validateSchema(label, cols) {
     }
   }
 }
+var CODEBASE_COLUMNS = Object.freeze([
+  // Identity key (matches the PK below)
+  { name: "org_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "workspace_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "repo_slug", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "user_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "worktree_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "commit_sha", sql: "TEXT NOT NULL DEFAULT ''" },
+  // Observation metadata
+  { name: "parent_sha", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "branch", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "ts", sql: "TIMESTAMP" },
+  { name: "pushed_by", sql: "TEXT NOT NULL DEFAULT ''" },
+  // Snapshot payload
+  { name: "snapshot_sha256", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "snapshot_jsonb", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "node_count", sql: "BIGINT NOT NULL DEFAULT 0" },
+  { name: "edge_count", sql: "BIGINT NOT NULL DEFAULT 0" },
+  // Generator metadata (for drift diagnostics — what hivemind version produced this?)
+  { name: "generator", sql: "TEXT NOT NULL DEFAULT 'hivemind-graph'" },
+  { name: "generator_version", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "schema_version", sql: "BIGINT NOT NULL DEFAULT 1" }
+]);
 validateSchema("MEMORY_COLUMNS", MEMORY_COLUMNS);
 validateSchema("SESSIONS_COLUMNS", SESSIONS_COLUMNS);
 validateSchema("SKILLS_COLUMNS", SKILLS_COLUMNS);
+validateSchema("RULES_COLUMNS", RULES_COLUMNS);
+validateSchema("TASKS_COLUMNS", TASKS_COLUMNS);
+validateSchema("TASK_EVENTS_COLUMNS", TASK_EVENTS_COLUMNS);
+validateSchema("GOALS_COLUMNS", GOALS_COLUMNS);
+validateSchema("KPIS_COLUMNS", KPIS_COLUMNS);
+validateSchema("CODEBASE_COLUMNS", CODEBASE_COLUMNS);
 function buildCreateTableSql(tableName, cols) {
   const safe = sqlIdent(tableName);
   const colSql = cols.map((c) => `${c.name} ${c.sql}`).join(", ");
@@ -442,7 +547,7 @@ function getQueryTimeoutMs() {
   return Number(process.env.HIVEMIND_QUERY_TIMEOUT_MS ?? 1e4);
 }
 function sleep2(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 function isTimeoutError(error) {
   const name = error instanceof Error ? error.name.toLowerCase() : "";
@@ -472,7 +577,7 @@ var Semaphore = class {
       this.active++;
       return;
     }
-    await new Promise((resolve2) => this.waiting.push(resolve2));
+    await new Promise((resolve3) => this.waiting.push(resolve3));
   }
   release() {
     this.active--;
@@ -782,6 +887,24 @@ var DeeplakeApi = class {
    * This sidesteps the Deeplake UPDATE-coalescing quirk that bit the wiki
    * worker.
    */
+  /**
+   * Create the codebase table. One row per (org, workspace, repo, user,
+   * worktree, commit) — see CODEBASE_COLUMNS for the schema. Healing
+   * + index follow the same pattern as ensureSessionsTable.
+   */
+  async ensureCodebaseTable(name) {
+    const safe = sqlIdent(name);
+    const tables = await this.listTables();
+    if (!tables.includes(safe)) {
+      log3(`table "${safe}" not found, creating`);
+      await this.createTableWithRetry(buildCreateTableSql(safe, CODEBASE_COLUMNS), safe);
+      log3(`table "${safe}" created`);
+      if (!tables.includes(safe))
+        this._tablesCache = [...tables, safe];
+    }
+    await this.healSchema(safe, CODEBASE_COLUMNS);
+    await this.ensureLookupIndex(safe, "codebase_identity", `("org_id", "workspace_id", "repo_slug", "user_id", "worktree_id", "commit_sha")`);
+  }
   async ensureSkillsTable(name) {
     const safe = sqlIdent(name);
     const tables = await this.listTables();
@@ -795,6 +918,111 @@ var DeeplakeApi = class {
     await this.healSchema(safe, SKILLS_COLUMNS);
     await this.ensureLookupIndex(safe, "project_key_name", `("project_key", "name")`);
   }
+  /**
+   * Create the rules table.
+   *
+   * One row per rule version (same write pattern as skills): edits INSERT
+   * a fresh row with version+1, reads pick latest per rule_id via
+   * `ORDER BY version DESC LIMIT 1`. Sidesteps the Deeplake
+   * UPDATE-coalescing quirk by never UPDATEing.
+   */
+  async ensureRulesTable(name) {
+    const safe = sqlIdent(name);
+    const tables = await this.listTables();
+    if (!tables.includes(safe)) {
+      log3(`table "${safe}" not found, creating`);
+      await this.createTableWithRetry(buildCreateTableSql(safe, RULES_COLUMNS), safe);
+      log3(`table "${safe}" created`);
+      if (!tables.includes(safe))
+        this._tablesCache = [...tables, safe];
+    }
+    await this.healSchema(safe, RULES_COLUMNS);
+    await this.ensureLookupIndex(safe, "rule_id_version", `("rule_id", "version")`);
+  }
+  /**
+   * Create the tasks table.
+   *
+   * Same write pattern as rules + skills. `kpis` is a nullable JSONB
+   * column with the agent's KPI metadata; KPI current values come from
+   * `task_events` (SUM(value)), not this snapshot.
+   */
+  async ensureTasksTable(name) {
+    const safe = sqlIdent(name);
+    const tables = await this.listTables();
+    if (!tables.includes(safe)) {
+      log3(`table "${safe}" not found, creating`);
+      await this.createTableWithRetry(buildCreateTableSql(safe, TASKS_COLUMNS), safe);
+      log3(`table "${safe}" created`);
+      if (!tables.includes(safe))
+        this._tablesCache = [...tables, safe];
+    }
+    await this.healSchema(safe, TASKS_COLUMNS);
+    await this.ensureLookupIndex(safe, "task_id_version", `("task_id", "version")`);
+  }
+  /**
+   * Create the task-events table.
+   *
+   * Append-only. Every INSERT is a fresh row; never UPDATE. KPI current
+   * value is `SUM(value) WHERE task_id=? AND kpi_id=?`. Index on
+   * (task_id, kpi_id) is the canonical aggregation key.
+   */
+  async ensureTaskEventsTable(name) {
+    const safe = sqlIdent(name);
+    const tables = await this.listTables();
+    if (!tables.includes(safe)) {
+      log3(`table "${safe}" not found, creating`);
+      await this.createTableWithRetry(buildCreateTableSql(safe, TASK_EVENTS_COLUMNS), safe);
+      log3(`table "${safe}" created`);
+      if (!tables.includes(safe))
+        this._tablesCache = [...tables, safe];
+    }
+    await this.healSchema(safe, TASK_EVENTS_COLUMNS);
+    await this.ensureLookupIndex(safe, "task_id_kpi_id", `("task_id", "kpi_id")`);
+  }
+  /**
+   * Create the goals table.
+   *
+   * Backed by the VFS path convention memory/goal/<owner>/<status>/<goal_id>.md.
+   * INSERT-only version-bumped: rm and mv operations translate to fresh
+   * v=N+1 rows (status flips for mv → closed; rm is the same soft-close).
+   * The (goal_id, version) index lets the VFS dispatch a cheap latest-row
+   * read on cat / Read of a single goal.
+   */
+  async ensureGoalsTable(name) {
+    const safe = sqlIdent(name);
+    const tables = await this.listTables();
+    if (!tables.includes(safe)) {
+      log3(`table "${safe}" not found, creating`);
+      await this.createTableWithRetry(buildCreateTableSql(safe, GOALS_COLUMNS), safe);
+      log3(`table "${safe}" created`);
+      if (!tables.includes(safe))
+        this._tablesCache = [...tables, safe];
+    }
+    await this.healSchema(safe, GOALS_COLUMNS);
+    await this.ensureLookupIndex(safe, "goal_id_version", `("goal_id", "version")`);
+    await this.ensureLookupIndex(safe, "owner_status", `("owner", "status")`);
+  }
+  /**
+   * Create the kpis table.
+   *
+   * Backed by memory/kpi/<goal_id>/<kpi_id>.md. KPI rows do NOT carry
+   * owner — ownership derives from the parent goal via logical join on
+   * goal_id. INSERT-only version-bumped. (goal_id, kpi_id) index is the
+   * canonical lookup the VFS uses on Read and Write.
+   */
+  async ensureKpisTable(name) {
+    const safe = sqlIdent(name);
+    const tables = await this.listTables();
+    if (!tables.includes(safe)) {
+      log3(`table "${safe}" not found, creating`);
+      await this.createTableWithRetry(buildCreateTableSql(safe, KPIS_COLUMNS), safe);
+      log3(`table "${safe}" created`);
+      if (!tables.includes(safe))
+        this._tablesCache = [...tables, safe];
+    }
+    await this.healSchema(safe, KPIS_COLUMNS);
+    await this.ensureLookupIndex(safe, "goal_id_kpi_id", `("goal_id", "kpi_id")`);
+  }
 };
 
 // dist/src/utils/session-path.js
@@ -1057,7 +1285,7 @@ var EmbedClient = class {
     }
   }
   connectOnce() {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const sock = connect(this.socketPath);
       const to = setTimeout(() => {
         sock.destroy();
@@ -1065,7 +1293,7 @@ var EmbedClient = class {
       }, this.timeoutMs);
       sock.once("connect", () => {
         clearTimeout(to);
-        resolve2(sock);
+        resolve3(sock);
       });
       sock.once("error", (e) => {
         clearTimeout(to);
@@ -1147,7 +1375,7 @@ var EmbedClient = class {
     throw new Error("daemon did not become ready within spawnWaitMs");
   }
   sendAndWait(sock, req) {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       let buf = "";
       const to = setTimeout(() => {
         sock.destroy();
@@ -1162,7 +1390,7 @@ var EmbedClient = class {
         const line = buf.slice(0, nl);
         clearTimeout(to);
         try {
-          resolve2(JSON.parse(line));
+          resolve3(JSON.parse(line));
         } catch (e) {
           reject(e);
         }
@@ -1818,9 +2046,54 @@ function spawnSkillifyWorker(opts) {
 
 // dist/src/skillify/state.js
 import { readFileSync as readFileSync9, writeFileSync as writeFileSync8, writeSync as writeSync3, mkdirSync as mkdirSync10, renameSync as renameSync6, rmdirSync, existsSync as existsSync9, lstatSync as lstatSync2, unlinkSync as unlinkSync5, openSync as openSync4, closeSync as closeSync4 } from "node:fs";
+import { join as join18 } from "node:path";
+
+// dist/src/utils/repo-identity.js
 import { execSync as execSync2 } from "node:child_process";
 import { createHash } from "node:crypto";
-import { join as join18, basename as basename2 } from "node:path";
+import { basename as basename2, resolve as resolve2 } from "node:path";
+var DEFAULT_PORTS = {
+  http: "80",
+  https: "443",
+  ssh: "22",
+  git: "9418"
+};
+function normalizeGitRemoteUrl(url) {
+  let s = url.trim();
+  const schemeMatch = s.match(/^([a-z][a-z0-9+.-]*):\/\//i);
+  const scheme = schemeMatch ? schemeMatch[1].toLowerCase() : null;
+  if (schemeMatch)
+    s = s.slice(schemeMatch[0].length);
+  if (!scheme) {
+    const scp = s.match(/^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/);
+    if (scp)
+      s = `${scp[1]}/${scp[2]}`;
+  }
+  s = s.replace(/^[^@/]+@/, "");
+  if (scheme && DEFAULT_PORTS[scheme]) {
+    s = s.replace(new RegExp(`^([^/]+):${DEFAULT_PORTS[scheme]}(/|$)`), "$1$2");
+  }
+  s = s.replace(/\.git\/?$/i, "");
+  s = s.replace(/\/+$/, "");
+  return s.toLowerCase();
+}
+function deriveProjectKey(cwd) {
+  const absCwd = resolve2(cwd);
+  const project = basename2(absCwd) || "unknown";
+  let signature = null;
+  try {
+    const raw = execSync2("git config --get remote.origin.url", {
+      cwd: absCwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    signature = raw ? normalizeGitRemoteUrl(raw) : null;
+  } catch {
+  }
+  const input = signature ?? absCwd;
+  const key = createHash("sha1").update(input).digest("hex").slice(0, 16);
+  return { key, project };
+}
 
 // dist/src/skillify/legacy-migration.js
 import { existsSync as existsSync8, renameSync as renameSync5 } from "node:fs";
@@ -1875,47 +2148,6 @@ function statePath2(projectKey) {
 function lockPath3(projectKey) {
   return join18(getStateDir(), `${projectKey}.lock`);
 }
-var DEFAULT_PORTS = {
-  http: "80",
-  https: "443",
-  ssh: "22",
-  git: "9418"
-};
-function normalizeGitRemoteUrl(url) {
-  let s = url.trim();
-  const schemeMatch = s.match(/^([a-z][a-z0-9+.-]*):\/\//i);
-  const scheme = schemeMatch ? schemeMatch[1].toLowerCase() : null;
-  if (schemeMatch)
-    s = s.slice(schemeMatch[0].length);
-  if (!scheme) {
-    const scp = s.match(/^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/);
-    if (scp)
-      s = `${scp[1]}/${scp[2]}`;
-  }
-  s = s.replace(/^[^@/]+@/, "");
-  if (scheme && DEFAULT_PORTS[scheme]) {
-    s = s.replace(new RegExp(`^([^/]+):${DEFAULT_PORTS[scheme]}(/|$)`), "$1$2");
-  }
-  s = s.replace(/\.git\/?$/i, "");
-  s = s.replace(/\/+$/, "");
-  return s.toLowerCase();
-}
-function deriveProjectKey(cwd) {
-  const project = basename2(cwd) || "unknown";
-  let signature = null;
-  try {
-    const raw = execSync2("git config --get remote.origin.url", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim();
-    signature = raw ? normalizeGitRemoteUrl(raw) : null;
-  } catch {
-  }
-  const input = signature ?? cwd;
-  const key = createHash("sha1").update(input).digest("hex").slice(0, 16);
-  return { key, project };
-}
 function readState2(projectKey) {
   migrateLegacyStateDir();
   const p = statePath2(projectKey);