npm - talking-stick - Versions diffs - 0.1.0-alpha.2 → 0.1.0-alpha.3 - Mend

talking-stick 0.1.0-alpha.2 → 0.1.0-alpha.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/README.md +14 -6
package/dist/cli.js +231 -23
package/dist/commands.js +2 -1
package/dist/config.js +2 -1
package/dist/db.js +7 -0
package/dist/index.js +1 -1
package/dist/self-update.js +74 -0
package/dist/service.js +144 -21
package/dist/skill-install.js +106 -0
package/docs/cli-refactor-plan.md +178 -0
package/docs/releases/0.1.0-alpha.3.md +102 -0
package/docs/talking-stick-plan.md +18 -15
package/package.json +1 -1
package/skills/talking-stick/SKILL.md +19 -6

package/README.md CHANGED Viewed

@@ -2,7 +2,7 @@
 An MCP coordination server that lets multiple AI coding agents share a single workspace without stepping on each other. One agent holds the stick at a time; handoffs carry structured context so the next agent doesn't have to re-derive it.
-**Version:** 0.1.0-alpha.2. Multi-process-safe (SQLite WAL), liveness-aware, no daemon. Supports Claude Code, Codex CLI, Gemini CLI, and OpenCode out of the box.
+**Version:** 0.1.0-alpha.3. Multi-process-safe (SQLite WAL), liveness-aware, no daemon. Supports Claude Code, Codex CLI, Gemini CLI, and OpenCode out of the box.
 ## Quickstart
@@ -27,7 +27,7 @@ That's it. The next time two agents `cd` into the same repo, they see each other
 | Method | Command | Notes |
 |---|---|---|
-| **From npm** | `npm i -g talking-stick` | Published as `0.1.0-alpha.2`. Requires Node ≥ 22. |
+| **From npm** | `npm i -g talking-stick` | Published as `0.1.0-alpha.3`. Requires Node ≥ 22. |
 | **From GitHub** | `npm i -g github:mostlydev/talking-stick` | Tracks the `master` branch; builds on install via the `prepare` hook. |
 | **From source** | `git clone … && npm install && npm link` | For contributors. |
@@ -67,7 +67,7 @@ list_rooms         — which rooms exist under a path
 join_path          — join the room for this workspace
 wait_for_turn      — block until the stick is available, with takeover signals
 heartbeat          — prove liveness while holding the stick
-release_stick      — normal handoff to the next member, with structured Handoff
+release_stick      — normal handoff to the next fair waiter, with structured Handoff
 pass_stick         — explicit handoff to a named agent
 takeover_stick     — deliberate claim when the prior holder is gone/stuck
 get_room_state     — authoritative state projection
@@ -117,6 +117,8 @@ Talking Stick also ships with a portable `talking-stick` skill:
 By default, `tt install-skill` links the bundled skill into each harness so local updates are picked up immediately. Pass `--copy` if you want a standalone snapshot instead.
+Human CLI invocations also perform a silent best-effort sync for already-installed file-based skills in Claude Code, Codex, and OpenCode. If the installed skill is a copy, it is refreshed from the bundled skill; if it is a stale symlink, it is relinked. Missing harness config directories and missing skill installs are skipped. Gemini skills are managed by Gemini's own registry, so use `tt install-skill gemini` after updating when needed.
 ## Human CLI
 The same `tt` binary also works as a human CLI, useful for watching or participating in a room from your terminal:
@@ -130,8 +132,10 @@ tt try [path]                                             # non-blocking claim a
 tt state [path]                                           # full room state
 tt events [path] [--after N] [--limit N]                  # room event log
 tt release [path] --status TEXT --next-action TEXT        # normal handoff
-tt pass [target] [path] --status TEXT --next-action TEXT  # explicit handoff
-tt takeover [path] --reason TEXT                          # deliberate takeover
+tt pass [path] --status TEXT --next-action TEXT           # pass/end your turn
+tt assign <target|next> [path] --status TEXT --next-action TEXT  # explicit handoff
+tt take [path] [--reason TEXT]                            # human-friendly take/override
+tt takeover [path] [--reason TEXT]                        # alias for take
 tt notes add <body> [--turn N] [--path DIR] [--stdin]     # leave an async note
 tt notes list [--all] [--after ID] [--limit N] [--path DIR] # read notes
 tt mcp                                                    # run the MCP stdio server
@@ -139,9 +143,12 @@ tt install <harness...> | --all [--print]                 # register MCP server
 tt uninstall <harness...> | --all [--print]               # remove MCP server
 tt install-skill <harness...> | --all [--print] [--copy] [--link]  # install global talking-stick skill
 tt uninstall-skill <harness...> | --all [--print]         # remove global talking-stick skill
+tt self-update [--print] [--manager npm|pnpm|yarn|bun]    # update to the latest published tt
 ```
-Human CLI commands use a stable identity like `human:<username>`. When `tt wait` or `tt takeover` wins the turn, a small background guardian keeps the lease alive on your behalf until you release or pass it.
+`tt self-update` detects how `tt` was installed (npm / pnpm / yarn / bun, including npm-via-Homebrew/mise/asdf/nvm) and runs the right global-update command. Pass `--print` to see the inferred command without running it; pass `--manager` to override detection. Running `tt self-update` from a development checkout (where `tt` resolves outside `node_modules/talking-stick`) refuses and tells you to `git pull && npm install && npm run build` instead.
+Human CLI commands use a stable identity like `human:<username>`. When `tt wait`, `tt take`, or `tt takeover` wins the turn, a small background guardian keeps the lease alive on your behalf until you release, pass, or assign it. Human CLI `take` intentionally works without a required reason so an operator can step into a stuck room quickly; harness-aware CLI takeovers still require `--reason` unless the command includes `--operator-requested`.
 ### CLI identity
@@ -160,6 +167,7 @@ Use `tt whoami --explain` to see which identity path the CLI chose.
 - **Workspace-root room resolution.** An agent at any depth under `/repo/` joins the `/repo/` room automatically. Nested rooms require explicit `force_new`.
 - **Structured handoffs.** `release_stick` and `pass_stick` carry a typed `Handoff` with required `status` / `next_action` and optional `artifacts[]` pointing at specific files and line ranges.
+- **Fair handoff selection.** Normal release prefers a recent waiter that is new or has gone longest without holding the stick; if the best-known candidate is between wait polls, a short grace window prevents immediate recycling to a less-fair claimant.
 - **Fencing tokens.** `lease_id` + `turn_id` make stale writes impossible — an agent who lost their turn cannot commit anything under the room's name.
 - **Liveness-aware recovery.** Dead or crashed holders are detected with OS-level process checks; claim-timeout takeover skips the prior owner when another active member is waiting.
 - **Multi-process safe.** Shared SQLite with WAL mode, `BEGIN IMMEDIATE` writes, 250 ms polling for `wait_for_turn`. No daemon required.

package/dist/cli.js CHANGED Viewed

@@ -5,12 +5,15 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { clearCliSessionLease, createSystemProcessInspector, deriveHarnessCliIdentity, deriveHumanCliIdentity, findCliSessionByRoom, findCliSessionForContextPath, isProtocolError, resolveCliSessionPath, runStdioServer, TalkingStickCommands, TalkingStickService, terminateKnownProcess, upsertCliSession, upsertJoinedCliSession } from "./index.js";
 import { SUPPORTED_HARNESSES, detectHarness, parseHarnessList, planInstall, planUninstall, runAction } from "./install.js";
-import { planSkillInstall, planSkillUninstall } from "./skill-install.js";
+import { planSkillInstall, planSkillUninstall, syncInstalledSkills } from "./skill-install.js";
 import { resolveContextPath } from "./path-resolution.js";
+import { detectInstallSource, isPackageManager, planSelfUpdate, resolveCurrentBinaryPath } from "./self-update.js";
 const GUARD_READY = "READY";
+const GUARD_READY_TIMEOUT_MS = 10_000;
 const STALE_GUARD_ERRORS = new Set(["stale_lease", "turn_mismatch", "room_not_found"]);
 export async function runCli(argv = process.argv.slice(2)) {
     const parsed = parseCommand(argv);
+    maybeSyncInstalledSkills(parsed);
     if (!parsed.name || parsed.name === "help" || parsed.name === "--help") {
         printHelp();
         return;
@@ -39,6 +42,10 @@ export async function runCli(argv = process.argv.slice(2)) {
         await runUninstallSkillCommand(parsed);
         return;
     }
+    if (parsed.name === "self-update") {
+        await runSelfUpdateCommand(parsed);
+        return;
+    }
     if (parsed.name === "whoami") {
         handleWhoAmICommand(parsed);
         return;
@@ -64,6 +71,9 @@ export async function runCli(argv = process.argv.slice(2)) {
             case "try":
                 await handleWaitCommand(runtime, parsed, true);
                 return;
+            case "take":
+                await handleTakeCommand(runtime, parsed);
+                return;
             case "takeover":
                 await handleTakeoverCommand(runtime, parsed);
                 return;
@@ -73,6 +83,9 @@ export async function runCli(argv = process.argv.slice(2)) {
             case "pass":
                 await handlePassCommand(runtime, parsed);
                 return;
+            case "assign":
+                await handleAssignCommand(runtime, parsed);
+                return;
             case "notes":
                 await handleNotesCommand(runtime, parsed);
                 return;
@@ -269,21 +282,52 @@ async function handleWaitCommand(runtime, parsed, isTry) {
     printResult(parsed, waitResult, () => formatWaitResult(waitResult));
 }
 async function handleTakeoverCommand(runtime, parsed) {
+    await handleTakeCommand(runtime, parsed);
+}
+async function handleTakeCommand(runtime, parsed) {
     const contextPath = parsed.positionals[0] ?? process.cwd();
     const identity = deriveCliIdentity(parsed);
+    const reason = resolveTakeoverReason(parsed);
+    const operatorOverride = shouldUseOperatorOverride(parsed);
     const joined = runtime.commands.joinPath(identity, { context_path: contextPath });
     upsertSessionFromJoin(identity, joined);
     const availability = await runtime.commands.waitForTurn(identity, {
         room_id: joined.room_id,
         max_wait_ms: 0
     });
-    if (availability.status !== "takeover_available") {
+    if (availability.status === "your_turn") {
+        const guardianPid = await spawnGuardian({
+            agentId: identity.agent_id,
+            canonicalPath: joined.canonical_path,
+            roomId: joined.room_id,
+            leaseId: availability.lease_id,
+            turnId: availability.turn_id
+        });
+        upsertCliSession(resolveCliSessionPath(), {
+            agent_id: identity.agent_id,
+            room_id: joined.room_id,
+            canonical_path: joined.canonical_path,
+            workspace_root: joined.workspace_root,
+            lease_id: availability.lease_id,
+            turn_id: availability.turn_id,
+            guardian_pid: guardianPid.pid,
+            guardian_process_started_at: guardianPid.process_started_at,
+            updated_at: new Date().toISOString()
+        });
+        printResult(parsed, { ...availability, guardian_pid: guardianPid.pid }, () => `Took the stick. Guardian ${guardianPid.pid} is holding the lease.`);
+        return;
+    }
+    if (availability.status === "closed") {
+        throw new Error("Takeover is not available: room is closed.");
+    }
+    if (availability.status !== "takeover_available" && !operatorOverride) {
         throw new Error(`Takeover is not available: ${formatWaitResult(availability)}`);
     }
     const result = runtime.commands.takeoverStick(identity, {
         room_id: joined.room_id,
         expected_turn_id: availability.turn_id,
-        reason: requireStringOption(parsed, "reason")
+        reason,
+        operator_override: operatorOverride
     });
     const guardianPid = await spawnGuardian({
         agentId: identity.agent_id,
@@ -303,7 +347,7 @@ async function handleTakeoverCommand(runtime, parsed) {
         guardian_process_started_at: guardianPid.process_started_at,
         updated_at: new Date().toISOString()
     });
-    printResult(parsed, { ...result, guardian_pid: guardianPid.pid }, () => `Takeover succeeded. Guardian ${guardianPid.pid} is holding the lease.`);
+    printResult(parsed, { ...result, guardian_pid: guardianPid.pid }, () => `Took the stick. Guardian ${guardianPid.pid} is holding the lease.`);
 }
 async function handleReleaseCommand(runtime, parsed) {
     const identity = deriveCliIdentity(parsed);
@@ -324,26 +368,37 @@ async function handleReleaseCommand(runtime, parsed) {
     });
 }
 async function handlePassCommand(runtime, parsed) {
+    if (parsed.positionals[0]?.includes(":")) {
+        await handleAssignCommand(runtime, parsed);
+        return;
+    }
     const identity = deriveCliIdentity(parsed);
-    const contextPath = parsed.positionals[1] ?? process.cwd();
+    const contextPath = parsed.positionals[0] ?? process.cwd();
     const session = requireLeaseSession(identity, contextPath);
     const handoff = await resolveHandoff(parsed);
-    const target = parsed.positionals[0];
-    if (!target) {
-        const result = runtime.commands.releaseStick(identity, {
-            room_id: session.room_id,
-            lease_id: session.lease_id,
-            expected_turn_id: session.turn_id,
-            handoff
-        });
-        clearCliSessionLease(resolveCliSessionPath(), identity.agent_id, session.room_id);
-        stopGuardian(session.guardian_pid, session.guardian_process_started_at ?? null);
-        printResult(parsed, result, () => {
-            const reserved = result.reserved_for ? ` to ${result.reserved_for}` : "";
-            return `Passed${reserved}.`;
-        });
-        return;
+    const result = runtime.commands.releaseStick(identity, {
+        room_id: session.room_id,
+        lease_id: session.lease_id,
+        expected_turn_id: session.turn_id,
+        handoff
+    });
+    clearCliSessionLease(resolveCliSessionPath(), identity.agent_id, session.room_id);
+    stopGuardian(session.guardian_pid, session.guardian_process_started_at ?? null);
+    printResult(parsed, result, () => {
+        const reserved = result.reserved_for ? ` Next: ${result.reserved_for}.` : "";
+        return `Passed turn.${reserved}`;
+    });
+}
+async function handleAssignCommand(runtime, parsed) {
+    const targetSelector = parsed.positionals[0];
+    if (!targetSelector) {
+        throw new Error("Usage: tt assign <target|next> [path] (--status TEXT --next-action TEXT | --stdin)");
     }
+    const identity = deriveCliIdentity(parsed);
+    const contextPath = parsed.positionals[1] ?? process.cwd();
+    const session = requireLeaseSession(identity, contextPath);
+    const handoff = await resolveHandoff(parsed);
+    const target = resolveAssignmentTarget(runtime, identity, session, targetSelector);
     const result = runtime.commands.passStick(identity, {
         room_id: session.room_id,
         lease_id: session.lease_id,
@@ -585,6 +640,61 @@ function requireLeaseSession(identity, contextPath) {
     }
     return session;
 }
+function resolveAssignmentTarget(runtime, identity, session, selector) {
+    if (selector.includes(":")) {
+        return selector;
+    }
+    const state = runtime.commands.getRoomState({
+        room_id: session.room_id,
+        agent_id: identity.agent_id
+    });
+    const normalizedSelector = selector.toLowerCase();
+    const candidates = state.members.filter((member) => {
+        if (member.agent_id === identity.agent_id || member.status !== "active") {
+            return false;
+        }
+        if (normalizedSelector === "next") {
+            return true;
+        }
+        return (member.agent_id.toLowerCase() === normalizedSelector ||
+            member.agent_id.toLowerCase().startsWith(`${normalizedSelector}:`) ||
+            member.display_name?.toLowerCase() === normalizedSelector);
+    });
+    if (candidates.length === 0) {
+        throw new Error(`No active room member matched assignment target: ${selector}`);
+    }
+    const events = runtime.commands.getRoomEvents({
+        room_id: session.room_id,
+        agent_id: identity.agent_id,
+        limit: 500
+    });
+    return pickFairAssignmentCandidate(candidates, events).agent_id;
+}
+function pickFairAssignmentCandidate(candidates, events) {
+    const lastOwnership = new Map();
+    for (const event of events) {
+        if ((event.event_type === "claim" || event.event_type === "takeover") &&
+            event.to_agent_id) {
+            lastOwnership.set(event.to_agent_id, event.created_at);
+        }
+    }
+    return candidates
+        .slice()
+        .sort((left, right) => {
+        const leftLastOwned = lastOwnership.get(left.agent_id);
+        const rightLastOwned = lastOwnership.get(right.agent_id);
+        if (!leftLastOwned && rightLastOwned) {
+            return -1;
+        }
+        if (leftLastOwned && !rightLastOwned) {
+            return 1;
+        }
+        if (leftLastOwned && rightLastOwned && leftLastOwned !== rightLastOwned) {
+            return Date.parse(leftLastOwned) - Date.parse(rightLastOwned);
+        }
+        return left.ordinal - right.ordinal;
+    })[0];
+}
 function upsertSessionFromJoin(identity, joined) {
     upsertJoinedCliSession(resolveCliSessionPath(), {
         agent_id: identity.agent_id,
@@ -629,6 +739,58 @@ function requireStringOption(parsed, key) {
     }
     return value;
 }
+function resolveTakeoverReason(parsed, env = process.env) {
+    const explicitReason = getStringOption(parsed, "reason");
+    if (explicitReason) {
+        return explicitReason;
+    }
+    if (hasOption(parsed, "operator-requested")) {
+        return "operator requested takeover";
+    }
+    if (isKnownHarnessCliEnv(env)) {
+        throw new Error("Missing required option --reason. Harness CLI takeovers must explain why, unless --operator-requested is set.");
+    }
+    return "operator takeover";
+}
+function shouldUseOperatorOverride(parsed, env = process.env) {
+    return (!isKnownHarnessCliEnv(env) ||
+        hasOption(parsed, "operator-requested") ||
+        hasOption(parsed, "force"));
+}
+function isKnownHarnessCliEnv(env = process.env) {
+    if (env.TT_HARNESS_AGENT_ID?.trim()) {
+        return true;
+    }
+    return deriveHarnessCliIdentity({ env }) !== null;
+}
+function maybeSyncInstalledSkills(parsed, env = process.env) {
+    if (!shouldAutoSyncInstalledSkills(parsed, env)) {
+        return;
+    }
+    try {
+        syncInstalledSkills({ skipMissing: true });
+    }
+    catch {
+        // Skill sync is a best-effort human CLI convenience. It must not make an
+        // unrelated tt command fail.
+    }
+}
+export function shouldAutoSyncInstalledSkills(parsed, env = process.env) {
+    if (env.TALKING_STICK_DISABLE_SKILL_SYNC?.trim()) {
+        return false;
+    }
+    if (isKnownHarnessCliEnv(env)) {
+        return false;
+    }
+    return !new Set([
+        "mcp",
+        "guard",
+        "install-skill",
+        "uninstall-skill",
+        "install",
+        "uninstall"
+    ]).has(parsed.name);
+}
 function parseOptionalInteger(parsed, key) {
     const value = getStringOption(parsed, key);
     if (!value) {
@@ -748,7 +910,7 @@ async function spawnGuardian(input) {
         let stderr = "";
         const timeout = setTimeout(() => {
             reject(new Error("Guardian did not signal readiness in time."));
-        }, 3_000);
+        }, GUARD_READY_TIMEOUT_MS);
         child.stdout?.setEncoding("utf8");
         child.stderr?.setEncoding("utf8");
         child.stdout?.on("data", (chunk) => {
@@ -1037,6 +1199,49 @@ function printActionPlan(action) {
     }
     process.stdout.write(`[${action.harness}] ${action.description}\n`);
 }
+async function runSelfUpdateCommand(parsed) {
+    normalizeBooleanFlag(parsed, "print");
+    const dryRun = hasOption(parsed, "print");
+    const managerOverride = getStringOption(parsed, "manager");
+    let source;
+    if (managerOverride) {
+        if (!isPackageManager(managerOverride)) {
+            throw new Error(`--manager must be one of npm | pnpm | yarn | bun (got ${managerOverride}).`);
+        }
+        source = managerOverride;
+    }
+    else {
+        const binaryPath = resolveCurrentBinaryPath(import.meta.url);
+        source = detectInstallSource({ binaryPath });
+    }
+    const plan = planSelfUpdate(source);
+    if (!plan) {
+        if (source === "dev") {
+            throw new Error("tt is running from a development checkout. Use `git pull && npm install && npm run build` instead of `tt self-update`, or pass `--manager npm|pnpm|yarn|bun` if this is wrong.");
+        }
+        throw new Error(`Could not determine how tt was installed. Pass --manager npm|pnpm|yarn|bun to override.`);
+    }
+    if (dryRun) {
+        process.stdout.write(`${plan.description}\n`);
+        return;
+    }
+    process.stdout.write(`Updating via: ${plan.description}\n`);
+    await runInheritIo(plan.command, plan.args);
+    process.stdout.write("Done. Restart your harness MCP subprocess to pick up the new dist.\n");
+}
+function runInheritIo(command, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { stdio: "inherit", shell: false });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`${command} exited with code ${code}.`));
+        });
+    });
+}
 function reportInstallResults(results, mode) {
     let anyFailed = false;
     for (const result of results) {
@@ -1063,8 +1268,10 @@ Commands:
   tt state [path]
   tt events [path] [--after N] [--limit N]
   tt release [path] (--status TEXT --next-action TEXT | --stdin)
-  tt pass [target] [path] (--status TEXT --next-action TEXT | --stdin)
-  tt takeover [path] --reason TEXT
+  tt pass [path] (--status TEXT --next-action TEXT | --stdin)
+  tt assign <target|next> [path] (--status TEXT --next-action TEXT | --stdin)
+  tt take [path] [--reason TEXT] [--operator-requested]
+  tt takeover [path] [--reason TEXT] [--operator-requested]
   tt notes add <body> [--turn N] [--path DIR] [--stdin]
   tt notes list [--all] [--after NOTE_ID] [--limit N] [--path DIR]
   tt mcp
@@ -1072,6 +1279,7 @@ Commands:
   tt uninstall <harness...> | --all [--print]
   tt install-skill <harness...> | --all [--print] [--copy] [--link]
   tt uninstall-skill <harness...> | --all [--print]
+  tt self-update [--print] [--manager npm|pnpm|yarn|bun]
 Harnesses: ${SUPPORTED_HARNESSES.join(", ")}

package/dist/commands.js CHANGED Viewed

@@ -57,7 +57,8 @@ export class TalkingStickCommands {
             agent_id: identity.agent_id,
             room_id: input.room_id,
             expected_turn_id: input.expected_turn_id,
-            reason: input.reason
+            reason: input.reason,
+            operator_override: input.operator_override
         });
     }
     getRoomState(input) {

package/dist/config.js CHANGED Viewed

@@ -6,7 +6,8 @@ export const defaultPolicy = {
     claimTtlMs: 20 * 60 * 1000,
     waitForTurnMaxWaitMs: 30 * 1000,
     waitForTurnPollMs: 250,
-    presenceTtlMs: 4 * 60 * 60 * 1000
+    presenceTtlMs: 4 * 60 * 60 * 1000,
+    waiterGraceMs: 10 * 1000
 };
 export function resolveDataDir(options = {}) {
     const env = options.env ?? process.env;

package/dist/db.js CHANGED Viewed

@@ -89,6 +89,13 @@ const migrations = [
       CREATE INDEX notes_by_room_created
         ON notes (room_id, created_at, note_id);
     `
+    },
+    {
+        id: 4,
+        name: "room_member_wait_presence",
+        up: `
+      ALTER TABLE room_members ADD COLUMN last_wait_at TEXT;
+    `
     }
 ];
 export function resolveDatabasePath(options = {}) {

package/dist/index.js CHANGED Viewed

@@ -6,7 +6,7 @@ export { deriveHarnessCliIdentity, deriveHumanCliIdentity, deriveMcpHarnessIdent
 export { ancestorPaths, canonicalizeContextPath, resolveContextPath, resolveWorkspaceRoot } from "./path-resolution.js";
 export { createMcpServer, runStdioServer } from "./mcp-server.js";
 export { SUPPORTED_HARNESSES, MissingHarnessError, detectHarness, parseHarnessList, planInstall, planUninstall, resolveHarnessConfigDir, resolveOpencodeConfigDir, resolveOpencodeConfigPath, runAction, skipAction } from "./install.js";
-export { DEFAULT_SKILL_NAME, planSkillInstall, planSkillUninstall, resolveBundledSkillPath, resolveSkillTargetPath } from "./skill-install.js";
+export { DEFAULT_SKILL_NAME, planSkillInstall, planSkillUninstall, resolveBundledSkillPath, resolveSkillTargetPath, syncInstalledSkills } from "./skill-install.js";
 export { createSystemProcessInspector, terminateKnownProcess } from "./process-utils.js";
 export { clearCliSessionLease, findCliSessionByRoom, findCliSessionForContextPath, readCliSessions, resolveCliSessionPath, upsertCliSession, upsertJoinedCliSession, writeCliSessions } from "./session-store.js";
 export { TalkingStickService, createDefaultProcessLivenessChecker } from "./service.js";

package/dist/self-update.js ADDED Viewed

@@ -0,0 +1,74 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+export function detectInstallSource(input) {
+    const p = normalize(input.binaryPath);
+    // pnpm global layout: ~/.local/share/pnpm/... or pnpm-prefixed segments.
+    if (/(^|\/)\.local\/share\/pnpm\//.test(p))
+        return "pnpm";
+    if (/(^|\/)pnpm\/global\//.test(p))
+        return "pnpm";
+    // Yarn classic global layout: ~/.config/yarn/global/... or /yarn/global/.
+    if (/(^|\/)yarn\/global\//.test(p))
+        return "yarn";
+    // Bun global layout: ~/.bun/install/global/...
+    if (/(^|\/)\.bun\/install\//.test(p))
+        return "bun";
+    // npm-managed layouts (also covers Homebrew node, nvm, mise, asdf, volta — any
+    // tool that puts the package under a standard `node_modules/talking-stick`
+    // segment). Has to come AFTER the pnpm/yarn/bun checks because they also have
+    // node_modules segments.
+    if (/\/node_modules\/talking-stick\//.test(p))
+        return "npm";
+    // Anything else (a checked-out source tree, an unknown layout) is treated as
+    // a development install. Self-update there would be wrong; we tell the user
+    // to git pull instead.
+    return "dev";
+}
+export function planSelfUpdate(source) {
+    switch (source) {
+        case "npm":
+            return {
+                command: "npm",
+                args: ["install", "-g", "talking-stick@latest"],
+                description: "npm install -g talking-stick@latest"
+            };
+        case "pnpm":
+            return {
+                command: "pnpm",
+                args: ["install", "-g", "talking-stick@latest"],
+                description: "pnpm install -g talking-stick@latest"
+            };
+        case "yarn":
+            return {
+                command: "yarn",
+                args: ["global", "add", "talking-stick@latest"],
+                description: "yarn global add talking-stick@latest"
+            };
+        case "bun":
+            return {
+                command: "bun",
+                args: ["add", "-g", "talking-stick@latest"],
+                description: "bun add -g talking-stick@latest"
+            };
+        case "dev":
+        case "unknown":
+            return null;
+    }
+}
+export function resolveCurrentBinaryPath(metaUrl) {
+    const target = fileURLToPath(metaUrl);
+    try {
+        return fs.realpathSync(target);
+    }
+    catch {
+        return path.resolve(target);
+    }
+}
+export function isPackageManager(value) {
+    return value === "npm" || value === "pnpm" || value === "yarn" || value === "bun";
+}
+function normalize(value) {
+    // Treat backslashes as forward slashes for cross-platform regex matching.
+    return value.replace(/\\/g, "/");
+}