talking-stick 0.4.9 → 0.4.11

package/dist/service.js

@@ -1416,10 +1416,13 @@ export class TalkingStickService {
             return null;
         }
         const lastOwnership = this.getLastOwnershipByAgent(roomId);
-        const referenceOrdinal = members.find((member) => member.agent_id === afterAgentId)?.ordinal ?? -1;
+        const ordinalRanks = ordinalRankByAgent(members);
+        const referenceRank = afterAgentId
+            ? ordinalRanks.get(afterAgentId) ?? -1
+            : -1;
         return candidates
             .slice()
-            .sort((left, right) => compareFairCandidates(left, right, lastOwnership, referenceOrdinal, members.length))[0];
+            .sort((left, right) => compareFairCandidates(left, right, lastOwnership, ordinalRanks, referenceRank, members.length))[0];
     }
     getLastOwnershipByAgent(roomId) {
         const rows = this.db
@@ -1691,7 +1694,7 @@ export class TalkingStickService {
                 : "gone";
             state =
                 this.hasExpired(room.claim_expires_at, now) &&
-                    reservedLiveness === "gone"
+                    this.isGonePersistent(reservedMember, reservedLiveness, now)
                     ? "recipient_gone"
                     : "reserved";
         }
@@ -1741,7 +1744,7 @@ export class TalkingStickService {
                 : "gone";
             state =
                 this.hasExpired(room.claim_expires_at, now) &&
-                    reservedLiveness === "gone"
+                    this.isGonePersistent(reservedMember, reservedLiveness, now)
                     ? "recipient_gone"
                     : "reserved";
         }
@@ -1899,7 +1902,7 @@ function mapNoteRow(row) {
         resolved_by_agent_id: row.resolved_by_agent_id
     };
 }
-function compareFairCandidates(left, right, lastOwnership, referenceOrdinal, memberCount) {
+function compareFairCandidates(left, right, lastOwnership, ordinalRanks, referenceRank, memberCount) {
     const leftLastOwned = lastOwnership.get(left.agent_id);
     const rightLastOwned = lastOwnership.get(right.agent_id);
     if (!leftLastOwned && rightLastOwned) {
@@ -1911,18 +1914,24 @@ function compareFairCandidates(left, right, lastOwnership, referenceOrdinal, mem
     if (leftLastOwned && rightLastOwned && leftLastOwned !== rightLastOwned) {
         return Date.parse(leftLastOwned) - Date.parse(rightLastOwned);
     }
-    const leftDistance = sequenceDistance(left.ordinal, referenceOrdinal, memberCount);
-    const rightDistance = sequenceDistance(right.ordinal, referenceOrdinal, memberCount);
+    const leftDistance = sequenceDistance(ordinalRanks.get(left.agent_id) ?? left.ordinal, referenceRank, memberCount);
+    const rightDistance = sequenceDistance(ordinalRanks.get(right.agent_id) ?? right.ordinal, referenceRank, memberCount);
     if (leftDistance !== rightDistance) {
         return leftDistance - rightDistance;
     }
     return left.ordinal - right.ordinal;
 }
-function sequenceDistance(ordinal, referenceOrdinal, memberCount) {
-    if (memberCount <= 0 || referenceOrdinal < 0) {
-        return ordinal;
+function ordinalRankByAgent(members) {
+    return new Map(members
+        .slice()
+        .sort((left, right) => left.ordinal - right.ordinal)
+        .map((member, index) => [member.agent_id, index]));
+}
+function sequenceDistance(ordinalRank, referenceRank, memberCount) {
+    if (memberCount <= 0 || referenceRank < 0) {
+        return ordinalRank;
     }
-    const distance = (ordinal - referenceOrdinal + memberCount) % memberCount;
+    const distance = (ordinalRank - referenceRank + memberCount) % memberCount;
     return distance === 0 ? memberCount : distance;
 }
 function parseTimestampMs(timestamp) {

package/dist/session-store.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { writeFileAtomic } from "./atomic-write.js";
 import { resolveDataDir } from "./config.js";
 import { ancestorPaths, resolveContextPath } from "./path-resolution.js";
 export function resolveCliSessionPath(options = {}) {
@@ -22,8 +23,7 @@ export function readCliSessions(sessionPath) {
     }
 }
 export function writeCliSessions(sessionPath, sessions) {
-    fs.mkdirSync(path.dirname(sessionPath), { recursive: true });
-    fs.writeFileSync(sessionPath, `${JSON.stringify(sessions, null, 2)}\n`);
+    writeFileAtomic(sessionPath, `${JSON.stringify(sessions, null, 2)}\n`);
 }
 export function upsertCliSession(sessionPath, session) {
     const sessions = readCliSessions(sessionPath);

package/dist/skill-install.js

@@ -4,7 +4,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { MissingHarnessError, resolveHarnessConfigDir, skipAction } from "./install.js";
 export const DEFAULT_SKILL_NAME = "talking-stick";
-const FILE_SKILL_HARNESSES = ["claude-code", "codex", "opencode"];
+const FILE_SKILL_HARNESSES = ["claude-code", "codex", "grok", "opencode"];
 export function resolveBundledSkillPath(options = {}) {
     return options.sourcePath ?? path.resolve(currentPackageDir(), "skills", DEFAULT_SKILL_NAME);
 }
@@ -15,8 +15,10 @@ export function resolveSkillTargetPath(harness, options = {}) {
             return path.join(homeDir, ".claude", "skills", options.skillName ?? DEFAULT_SKILL_NAME);
         case "codex":
             return path.join(homeDir, ".codex", "skills", options.skillName ?? DEFAULT_SKILL_NAME);
+        case "grok":
+            return path.join(resolveHarnessConfigDir("grok", options), "skills", options.skillName ?? DEFAULT_SKILL_NAME);
         case "opencode":
-            return path.join(homeDir, ".opencode", "skills", options.skillName ?? DEFAULT_SKILL_NAME);
+            return path.join(resolveHarnessConfigDir("opencode", options), "skills", options.skillName ?? DEFAULT_SKILL_NAME);
         default:
             throw new Error(`Unknown skill-install harness: ${harness}`);
     }
@@ -33,14 +35,16 @@ export function planSkillInstall(harness, options = {}) {
                 harness,
                 command: "gemini",
                 args: ["skills", "link", sourcePath, "--scope", "user", "--consent"],
-                description: `gemini skills link ${sourcePath} --scope user --consent`
+                description: `gemini skills link ${sourcePath} --scope user --consent`,
+                operation: "install"
             }
             : {
                 kind: "exec",
                 harness,
                 command: "gemini",
                 args: ["skills", "install", sourcePath, "--scope", "user", "--consent"],
-                description: `gemini skills install ${sourcePath} --scope user --consent`
+                description: `gemini skills install ${sourcePath} --scope user --consent`,
+                operation: "install"
             };
     }
     const targetPath = resolveSkillTargetPath(harness, options);
@@ -56,6 +60,8 @@ export function planSkillInstall(harness, options = {}) {
         description: shouldLink
             ? `link ${sourcePath} -> ${targetPath}`
             : `copy ${sourcePath} -> ${targetPath}`,
+        operation: "install",
+        inspect: () => inspectInstalledSkill(sourcePath, targetPath, shouldLink),
         apply: () => installSkillDirectory(sourcePath, targetPath, harnessRootPath, shouldLink, options)
     };
 }
@@ -175,6 +181,31 @@ function syncInstalledFileSkill(harness, sourcePath, sourceDigest, options) {
         };
     }
 }
+function inspectInstalledSkill(sourcePath, targetPath, link) {
+    try {
+        const stat = fs.lstatSync(targetPath);
+        if (link) {
+            if (!stat.isSymbolicLink()) {
+                return "different";
+            }
+            const currentTarget = fs.readlinkSync(targetPath);
+            const resolvedCurrentTarget = path.resolve(path.dirname(targetPath), currentTarget);
+            return sameRealPath(resolvedCurrentTarget, sourcePath)
+                ? "present"
+                : "different";
+        }
+        if (stat.isDirectory() && digestDirectory(targetPath) === digestDirectory(sourcePath)) {
+            return "present";
+        }
+        return "different";
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return "absent";
+        }
+        throw error;
+    }
+}
 function removeInstalledSkill(targetPath, harnessRootPath, options = {}) {
     const pathExists = options.pathExists ?? fs.existsSync;
     if (options.skipMissing && harnessRootPath && !pathExists(harnessRootPath)) {

package/docs/releases/0.4.10.md

@@ -0,0 +1,17 @@
+# Talking Stick 0.4.10
+
+Date: 2026-06-08
+
+## Added
+- **Grok Build harness support.** `tt install grok` now installs the native `~/.grok/skills/talking-stick` skill and a trusted global `~/.grok/hooks/talking-stick-session.json` hook. Grok-launched `tt` calls work without cmux by detecting a `grok` root process in ancestry; `CMUX_AGENT_LAUNCH_KIND=grok` remains optional fast evidence when present. The hook records `GROK_SESSION_ID` context in `${TALKING_STICK_DATA_DIR}/grok-sessions.jsonl` so identity can upgrade from pid-root identity to the real Grok session id when the record matches the workspace and harness process.
+
+## Verification
+
+```bash
+npm run typecheck
+npm test
+npm run build
+node dist/cli.js --help
+git diff --check
+npm pack --dry-run
+```

package/docs/releases/0.4.11.md

@@ -0,0 +1,28 @@
+# Talking Stick 0.4.11
+
+Date: 2026-06-09
+
+## Fixed
+- **Guardian no longer leaks when readiness times out.** `spawnGuardian`'s readiness timeout now kills the detached child and clears its listeners before rejecting. Previously the orphaned guardian survived, wrote `READY` to a stream nobody read, and held the lease indefinitely with no recorded PID for `stopGuardian` to reach. (#31)
+- **Fair-turn ordering survives member churn.** Round-robin distance is now computed from each member's rank within the current member list instead of raw join ordinals modulo member count, which inverted ordering once departures left sparse ordinals (e.g. `[0, 5, 7]`). (#32)
+- **Reserved-member liveness gets the same gone grace as owners.** Both room-inspection paths now run the reserved branch through `isGonePersistent`, so a transient process-check misread right after claim expiry can no longer deny the rightful recipient its grant. (#33)
+- **`cli-sessions.json` and harness config patches are written atomically.** Both now write to a temp sibling and `rename`, so a crash or full disk mid-write can no longer truncate the session store or a user-owned config such as `opencode.json`. (#34)
+- **`ps` lstart parsing is locale-stable.** Process inspection invokes `ps` with `LC_ALL=C`, so non-C locales no longer silently degrade identity resolution and liveness to the weakest fallback. (#35)
+- **Errors are machine-readable in JSON mode.** When `--json` is requested, plain CLI errors serialize as `{"error": "cli_error", "message": ...}` on stderr (matching `ProtocolError`'s shape) instead of bare text, keeping the non-zero exit code. (#36)
+- **Boolean flags never consume positionals.** The CLI parser has a boolean-flag registry, retiring the `--json`-eats-positional footgun and the per-command repair shims; `--after`-style integer options now reject trailing garbage like `100ms`. (#37)
+- **Non-harness `##` headings no longer bleed into harness sections.** In instruction files, an unrecognized `##` heading after harness sections ends the current section; its content is excluded from harness extraction. (#38)
+- **OpenCode skill installs follow the XDG-aware config dir.** The skill now lands next to `opencode.json` (normally `~/.config/opencode/skills/talking-stick`, honoring `XDG_CONFIG_HOME`) instead of the hardcoded `~/.opencode` tree; verified against OpenCode source, which scans both `skill/` and `skills/` under the config dir. (#39)
+- **Restarted Grok sessions mint fresh identity.** When PID identity is available but matches no recorded session, the workspace-candidate fallback no longer hands the new process the previous session's identity while the old `session_end` hook is pending. (#40)
+- **`tt install` is idempotent for skills.** Skill install actions carry `operation`/`inspect`, so a second run reports `already_present` instead of deleting and re-copying the skill directory every time. (#41)
+- **Docs drift from the MCP-to-skill migration cleaned up.** AGENTS.md/README no longer reference the removed `src/mcp-server.ts` entry point or stale install paths; `patchOpencodeConfig`'s dead install branch is gone and the legacy `tt mcp` command constant is marked as match-only. (#42)
+
+## Verification
+
+```bash
+npm run typecheck
+npm test
+npm run build
+node dist/cli.js --help
+git diff --check
+npm pack --dry-run
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talking-stick",
-  "version": "0.4.9",
+  "version": "0.4.11",
   "description": "CLI coordination tool for path-scoped agent handoffs.",
   "type": "module",
   "bin": {

package/skills/talking-stick/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: talking-stick
-description: Use when working in a repo that coordinates multiple agent harnesses with Talking Stick (`tt` / `talking-stick`), or when the user asks you to avoid parallel work, wait your turn, pass structured handoffs, or coordinate with Claude, Codex, Gemini, or OpenCode in the same workspace. Also use when a workspace contains a `.talking-stick/` marker.
+description: Use when working in a repo that coordinates multiple agent harnesses with Talking Stick (`tt` / `talking-stick`), or when the user asks you to avoid parallel work, wait your turn, pass structured handoffs, or coordinate with Claude, Codex, Gemini, Grok, or OpenCode in the same workspace. Also use when a workspace contains a `.talking-stick/` marker.
 ---
 
 This skill teaches a harness how to behave in a Talking Stick workspace.
@@ -49,7 +49,7 @@ Some workspaces may also have sibling receive processes running `tt events --fol
 
 If coordination is required and `tt` is unavailable, say so briefly and ask the user whether they want to install or enable Talking Stick first. Do not pretend coordination is active.
 
-Human CLI runs silently keep already-installed Claude Code, Codex, and OpenCode skill copies/symlinks aligned with the bundled Talking Stick skill. This is best effort and only updates existing installs; Gemini skills are registry-managed and should be refreshed with `tt install gemini` when needed.
+Human CLI runs silently keep already-installed Claude Code, Codex, Grok, and OpenCode skill copies/symlinks aligned with the bundled Talking Stick skill. This is best effort and only updates existing installs; Gemini skills are registry-managed and should be refreshed with `tt install gemini` when needed.
 
 ### 2. Join The Workspace Room Once