talking-stick 0.4.10 → 0.4.12

package/README.md

@@ -167,7 +167,7 @@ For harnesses that only notice completed subprocesses, run `tt events --wait --a
 - Codex: copied or linked into `~/.codex/skills/talking-stick`
 - Gemini: installed with `gemini skills install ... --scope user` or linked with `gemini skills link ... --scope user`
 - Grok Build: copied or linked into `~/.grok/skills/talking-stick`, plus a trusted global session hook at `~/.grok/hooks/talking-stick-session.json`
-- OpenCode: copied or linked into `~/.opencode/skills/talking-stick`
+- OpenCode: copied or linked into the resolved OpenCode config directory, normally `~/.config/opencode/skills/talking-stick` and honoring `XDG_CONFIG_HOME`
 
 By default, `tt install` links the bundled skill into each harness so local updates are picked up immediately. Pass `--copy` if you want a standalone snapshot instead.
 

package/dist/atomic-write.js

@@ -0,0 +1,21 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+export function writeFileAtomic(filePath, data) {
+    const directory = path.dirname(filePath);
+    fs.mkdirSync(directory, { recursive: true });
+    const tempPath = path.join(directory, `.${path.basename(filePath)}.${process.pid}.${Date.now()}.${crypto.randomUUID()}.tmp`);
+    try {
+        fs.writeFileSync(tempPath, data);
+        fs.renameSync(tempPath, filePath);
+    }
+    catch (error) {
+        try {
+            fs.rmSync(tempPath, { force: true });
+        }
+        catch {
+            // Best effort cleanup for failed writes.
+        }
+        throw error;
+    }
+}

package/dist/cli/guardian.js

@@ -103,8 +103,46 @@ export async function spawnGuardian(input) {
         const inspector = createSystemProcessInspector();
         let stdout = "";
         let stderr = "";
+        let settled = false;
+        const cleanup = () => {
+            clearTimeout(timeout);
+            child.stdout?.removeAllListeners();
+            child.stderr?.removeAllListeners();
+            child.removeAllListeners("exit");
+            child.removeAllListeners("error");
+            child.stdout?.destroy();
+            child.stderr?.destroy();
+        };
+        const killChild = () => {
+            try {
+                child.kill("SIGTERM");
+            }
+            catch {
+                // Best effort cleanup for a child that failed readiness.
+            }
+        };
+        const rejectOnce = (error, kill = false) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (kill) {
+                killChild();
+            }
+            cleanup();
+            reject(error);
+        };
+        const resolveOnce = (value) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            child.unref();
+            resolve(value);
+        };
         const timeout = setTimeout(() => {
-            reject(new Error("Guardian did not signal readiness in time."));
+            rejectOnce(new Error("Guardian did not signal readiness in time."), true);
         }, GUARD_READY_TIMEOUT_MS);
         child.stdout?.setEncoding("utf8");
         child.stderr?.setEncoding("utf8");
@@ -113,15 +151,11 @@ export async function spawnGuardian(input) {
             if (!stdout.includes(GUARD_READY)) {
                 return;
             }
-            clearTimeout(timeout);
-            child.stdout?.destroy();
-            child.stderr?.destroy();
-            child.unref();
             if (!child.pid) {
-                reject(new Error("Guardian started without a PID."));
+                rejectOnce(new Error("Guardian started without a PID."), true);
                 return;
             }
-            resolve({
+            resolveOnce({
                 pid: child.pid,
                 process_started_at: inspector.inspect(child.pid)?.startTime ?? null
             });
@@ -130,8 +164,10 @@ export async function spawnGuardian(input) {
             stderr += chunk;
         });
         child.on("exit", (code) => {
-            clearTimeout(timeout);
-            reject(new Error(`Guardian exited before readiness (code ${code ?? "unknown"}): ${stderr.trim()}`));
+            rejectOnce(new Error(`Guardian exited before readiness (code ${code ?? "unknown"}): ${stderr.trim()}`));
+        });
+        child.on("error", (error) => {
+            rejectOnce(error instanceof Error ? error : new Error(String(error)));
         });
     });
 }

package/dist/cli/install-commands.js

@@ -6,11 +6,8 @@ import { FileAuditLog, defaultAuditLogPath } from "../install-audit.js";
 import { removeStaleMcpRegistrations } from "../install-migration.js";
 import { detectInstallSource, isPackageManager, planSelfUpdate, resolveCurrentBinaryPath } from "../self-update.js";
 import { readPackageVersion, runStaleMcpCleanup } from "../update-migration.js";
-import { getStringOption, hasOption, normalizeBooleanFlag } from "./parser.js";
+import { getStringOption, hasOption } from "./parser.js";
 export async function runInstallCommand(parsed) {
-    normalizeBooleanFlag(parsed, "print");
-    normalizeBooleanFlag(parsed, "copy");
-    normalizeBooleanFlag(parsed, "link");
     const harnesses = selectHarnesses(parsed);
     const dryRun = hasOption(parsed, "print");
     const installOptions = {
@@ -32,7 +29,6 @@ export async function runInstallCommand(parsed) {
     printInstructionHint(results);
 }
 export async function runUninstallCommand(parsed) {
-    normalizeBooleanFlag(parsed, "print");
     const harnesses = selectHarnesses(parsed);
     const dryRun = hasOption(parsed, "print");
     const installOptions = { skipMissing: true };
@@ -48,9 +44,6 @@ export async function runUninstallCommand(parsed) {
     reportCleanupResults(await runCleanup(harnesses, "uninstall", installOptions), "uninstall");
 }
 export async function runInstallSkillCommand(parsed) {
-    normalizeBooleanFlag(parsed, "print");
-    normalizeBooleanFlag(parsed, "copy");
-    normalizeBooleanFlag(parsed, "link");
     const harnesses = selectHarnesses(parsed);
     const dryRun = hasOption(parsed, "print");
     const link = resolveSkillInstallLinkMode(parsed);
@@ -66,7 +59,6 @@ export async function runInstallSkillCommand(parsed) {
     reportInstallResults(results, "install");
 }
 export async function runUninstallSkillCommand(parsed) {
-    normalizeBooleanFlag(parsed, "print");
     const harnesses = selectHarnesses(parsed);
     const dryRun = hasOption(parsed, "print");
     const installOptions = { skipMissing: true };
@@ -81,7 +73,6 @@ export async function runUninstallSkillCommand(parsed) {
     reportInstallResults(results, "uninstall");
 }
 export async function runSelfUpdateCommand(parsed, cliEntryUrl) {
-    normalizeBooleanFlag(parsed, "print");
     const dryRun = hasOption(parsed, "print");
     const managerOverride = getStringOption(parsed, "manager");
     let source;
@@ -121,7 +112,6 @@ export async function runSelfUpdateCommand(parsed, cliEntryUrl) {
     process.stdout.write("Done. Restart any long-running harness sessions to pick up the new tt.\n");
 }
 export async function runMcpMigrationCommand(parsed) {
-    normalizeBooleanFlag(parsed, "quiet");
     const reason = parseAuditReason(getStringOption(parsed, "reason") ?? "manual");
     const quiet = hasOption(parsed, "quiet");
     const cleanup = await runStaleMcpCleanup({
@@ -248,15 +238,19 @@ function reportInstallResults(results, mode) {
         throw new Error(`${mode} completed with failures.`);
     }
 }
-function printInstructionHint(results) {
-    if (!results.some((result) => result.ok && !result.skipped)) {
+export function printInstructionHint(results) {
+    const changed = new Set(["added", "updated", "ok"]);
+    if (!results.some((result) => result.ok && changed.has(result.status))) {
         return;
     }
     process.stdout.write("Customize collaboration instructions with: tt instructions edit\n");
 }
-function reportCleanupResults(results, mode) {
+export function reportCleanupResults(results, mode) {
     let anyFailed = false;
     for (const result of results) {
+        if (result.action === "absent" || result.action === "skipped") {
+            continue;
+        }
         process.stdout.write(`[${result.harness}] mcp-cleanup ${result.action}: ${result.message}\n`);
         if (result.action === "failed")
             anyFailed = true;

package/dist/cli/instructions-commands.js

@@ -24,8 +24,6 @@ export async function handleInstructionsCommand(parsed) {
     }
 }
 function handleInstructionsShowCommand(parsed) {
-    repairBooleanFlag(parsed, "json", 0);
-    repairBooleanFlag(parsed, "text", 0);
     const contextPath = resolveContextPathArg(parsed);
     const scope = parseInstructionScope(getStringOption(parsed, "scope"));
     const identity = deriveCliIdentity(parsed);
@@ -45,10 +43,6 @@ function handleInstructionsShowCommand(parsed) {
     });
 }
 async function handleInstructionsEditCommand(parsed) {
-    repairBooleanFlag(parsed, "json", 0);
-    repairBooleanFlag(parsed, "text", 0);
-    repairBooleanFlag(parsed, "user", 0);
-    repairBooleanFlag(parsed, "project", 0);
     const contextPath = resolveContextPathArg(parsed);
     const scope = resolveEditableScope(parsed, false);
     const result = await editInstructions({
@@ -66,10 +60,6 @@ async function handleInstructionsEditCommand(parsed) {
     });
 }
 function handleInstructionsResetCommand(parsed) {
-    repairBooleanFlag(parsed, "json", 0);
-    repairBooleanFlag(parsed, "text", 0);
-    repairBooleanFlag(parsed, "user", 0);
-    repairBooleanFlag(parsed, "project", 0);
     const contextPath = resolveContextPathArg(parsed);
     const scope = resolveEditableScope(parsed, true);
     const result = resetInstructions({
@@ -104,10 +94,3 @@ function resolveContextPathArg(parsed) {
     }
     return pathOption ?? parsed.positionals[0] ?? process.cwd();
 }
-function repairBooleanFlag(parsed, key, insertAt) {
-    const value = parsed.options.get(key);
-    if (typeof value === "string") {
-        parsed.positionals.splice(insertAt, 0, value);
-        parsed.options.set(key, true);
-    }
-}

package/dist/cli/msg-commands.js

@@ -29,8 +29,6 @@ async function handleMsgSendCommand(runtime, parsed) {
     const identity = deriveCliIdentity(parsed);
     const session = resolveSessionForNotes(runtime, parsed, identity);
     const usesRoomFlag = hasOption(parsed, "room");
-    repairBooleanFlag(parsed, "room", 0);
-    repairBooleanFlag(parsed, "interrupt", usesRoomFlag ? 0 : 1);
     const recipientSelector = usesRoomFlag ? "room" : parsed.positionals[0];
     if (!recipientSelector) {
         throw new Error("Usage: tt msg send <recipient|room> <body...> [--interrupt] [--stdin].");
@@ -69,13 +67,6 @@ async function handleMsgRecvCommand(runtime, parsed) {
         force_tail_cursor: false
     });
 }
-function repairBooleanFlag(parsed, key, insertAt) {
-    const value = parsed.options.get(key);
-    if (typeof value === "string") {
-        parsed.positionals.splice(insertAt, 0, value);
-        parsed.options.set(key, true);
-    }
-}
 function shortEventId(eventId) {
     return eventId.slice(0, 8);
 }

package/dist/cli/parser.js

@@ -1,3 +1,26 @@
+const BOOLEAN_FLAGS = new Set([
+    "all",
+    "copy",
+    "events",
+    "explain",
+    "follow",
+    "force",
+    "force-new",
+    "help",
+    "interrupt",
+    "json",
+    "link",
+    "operator-requested",
+    "park",
+    "print",
+    "project",
+    "quiet",
+    "room",
+    "stdin",
+    "text",
+    "user",
+    "wait"
+]);
 export function parseCommand(argv) {
     const [name = "", ...rest] = argv;
     const options = new Map();
@@ -9,6 +32,10 @@ export function parseCommand(argv) {
             continue;
         }
         const key = token.slice(2);
+        if (BOOLEAN_FLAGS.has(key)) {
+            options.set(key, true);
+            continue;
+        }
         const next = rest[index + 1];
         if (!next || next.startsWith("--")) {
             options.set(key, true);
@@ -33,18 +60,14 @@ export function requireStringOption(parsed, key) {
     }
     return value;
 }
-export function normalizeBooleanFlag(parsed, key) {
-    const value = parsed.options.get(key);
-    if (typeof value === "string") {
-        parsed.positionals.unshift(value);
-        parsed.options.set(key, true);
-    }
-}
 export function parseOptionalInteger(parsed, key) {
     const value = getStringOption(parsed, key);
     if (!value) {
         return undefined;
     }
+    if (!/^\d+$/.test(value)) {
+        throw new Error(`--${key} must be an integer.`);
+    }
     const parsedValue = Number.parseInt(value, 10);
     if (!Number.isInteger(parsedValue)) {
         throw new Error(`--${key} must be an integer.`);

package/dist/cli/room-commands.js

@@ -1,7 +1,7 @@
 import { deriveCliIdentity, resolveCliIdentity } from "./identity.js";
 import { removeCliSession, removeCliSessionsForRoom, resolveCliSessionPath } from "../index.js";
 import { stopGuardian } from "./guardian.js";
-import { getStringOption, hasOption, normalizeBooleanFlag, parseOptionalInteger } from "./parser.js";
+import { getStringOption, hasOption, parseOptionalInteger } from "./parser.js";
 import { formatRelativeTime, printResult } from "./output.js";
 import { parseEventTypeFilter, runEventStream } from "./event-stream.js";
 import { resolveSessionForReads, upsertSessionFromJoin } from "./session.js";
@@ -129,8 +129,6 @@ export function handleStateCommand(runtime, parsed) {
     });
 }
 export async function handleEventsCommand(runtime, parsed) {
-    normalizeBooleanFlag(parsed, "wait");
-    normalizeBooleanFlag(parsed, "follow");
     const identity = deriveCliIdentity(parsed);
     const session = resolveSessionForReads(runtime, parsed, identity);
     if (hasOption(parsed, "wait") || hasOption(parsed, "follow")) {

package/dist/cli/turn-commands.js

@@ -2,13 +2,11 @@ import { clearCliSessionLease, createSystemProcessInspector, findCliSessionByRoo
 import { checkGuardianLiveness, spawnGuardian, stopGuardian } from "./guardian.js";
 import { resolveHandoff } from "./handoff.js";
 import { deriveCliIdentity, resolveTakeoverReason, shouldUseOperatorOverride } from "./identity.js";
-import { getStringOption, hasOption, normalizeBooleanFlag, parseRequiredInteger, parseWaitTimeout } from "./parser.js";
+import { getStringOption, hasOption, parseRequiredInteger, parseWaitTimeout } from "./parser.js";
 import { resolveTargetFilter } from "./event-stream.js";
 import { formatWaitResult, printResult } from "./output.js";
 import { requireLeaseSession, upsertSessionFromJoin } from "./session.js";
 export async function handleWaitCommand(runtime, parsed, isTry, cliEntryUrl) {
-    normalizeBooleanFlag(parsed, "park");
-    normalizeBooleanFlag(parsed, "events");
     const park = hasOption(parsed, "park");
     const includeEvents = hasOption(parsed, "events");
     const afterEventSeq = includeEvents

package/dist/cli.js

@@ -4,7 +4,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { isProtocolError } from "./index.js";
 import { parseCommand } from "./cli/parser.js";
-import { printHelp } from "./cli/output.js";
+import { printHelp, shouldUseJson } from "./cli/output.js";
 import { getCommand } from "./cli/registry.js";
 import { createRuntime } from "./cli/runtime.js";
 import { runStartupMaintenance } from "./cli/startup-maintenance.js";
@@ -49,12 +49,24 @@ function isDirectExecution() {
 }
 if (isDirectExecution()) {
     await runCli().catch((error) => {
-        const message = isProtocolError(error)
-            ? JSON.stringify(error.toJSON(), null, 2)
-            : error instanceof Error
+        const parsed = parseCommand(process.argv.slice(2));
+        if (shouldUseJson(parsed)) {
+            const payload = isProtocolError(error)
+                ? error.toJSON()
+                : {
+                    error: "cli_error",
+                    message: error instanceof Error ? error.message : String(error)
+                };
+            process.stderr.write(`${JSON.stringify(payload, null, 2)}\n`);
+        }
+        else {
+            const message = isProtocolError(error)
                 ? error.message
-                : String(error);
-        process.stderr.write(`${message}\n`);
+                : error instanceof Error
+                    ? error.message
+                    : String(error);
+            process.stderr.write(`${message}\n`);
+        }
         process.exit(1);
     });
 }

package/dist/grok-session-store.js

@@ -70,6 +70,9 @@ export function findGrokSessionRecord(input) {
             return record;
         }
     }
+    if (input.grokPid != null && input.grokProcessStartedAt != null) {
+        return null;
+    }
     const uniqueSessionIds = new Set(workspaceCandidates.map((record) => record.grok_session_id));
     if (uniqueSessionIds.size === 1) {
         return workspaceCandidates[0] ?? null;

package/dist/install.js

@@ -2,8 +2,10 @@ import { spawn } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { writeFileAtomic } from "./atomic-write.js";
 export const SUPPORTED_HARNESSES = ["claude-code", "codex", "gemini", "grok", "opencode"];
 export const DEFAULT_SERVER_NAME = "talking-stick";
+// Legacy MCP command retained only to identify stale config entries for removal.
 export const DEFAULT_SERVER_COMMAND = ["tt", "mcp"];
 export const GROK_SESSION_HOOK_FILE = "talking-stick-session.json";
 export const DEFAULT_GROK_SESSION_HOOK_COMMAND = ": talking-stick-grok-session-hook; if command -v tt >/dev/null 2>&1; then tt grok-session-hook >/dev/null 2>/dev/null || true; fi";
@@ -68,7 +70,7 @@ function defaultReadFile(filePath) {
     }
 }
 function defaultWriteFile(filePath, data) {
-    fs.writeFileSync(filePath, data);
+    writeFileAtomic(filePath, data);
 }
 function defaultEnsureDir(dirPath) {
     fs.mkdirSync(dirPath, { recursive: true });
@@ -196,7 +198,7 @@ export function planUninstall(harness, options = {}) {
                 operation: "uninstall",
                 serverName: resolved.serverName,
                 inspect: () => inspectOpencodeConfig(filePath, resolved),
-                apply: () => patchOpencodeConfig(filePath, resolved, "uninstall")
+                apply: () => patchOpencodeConfig(filePath, resolved)
             };
         }
         default:
@@ -223,6 +225,7 @@ export function planGrokSessionHookInstall(options = {}) {
         harness: "grok",
         filePath,
         description: `write Grok session hook ${filePath}`,
+        operation: "install",
         inspect: () => inspectGrokSessionHook(filePath, resolved),
         apply: () => writeGrokSessionHook(filePath, resolved)
     };
@@ -281,29 +284,20 @@ function removeGrokSessionHook(filePath, resolved) {
         throw error;
     }
 }
-function patchOpencodeConfig(filePath, resolved, mode) {
+function patchOpencodeConfig(filePath, resolved) {
     const existing = resolved.hooks.readFile(filePath);
     if (resolved.skipMissing) {
         const configDir = path.dirname(filePath);
         if (!resolved.hooks.pathExists(configDir)) {
             throw new MissingHarnessError(`opencode config directory not found: ${configDir}`);
         }
-        if (mode === "uninstall" && existing === null) {
+        if (existing === null) {
             throw new MissingHarnessError(`opencode config not found: ${filePath}`);
         }
     }
     const config = existing ? parseJsonOrThrow(existing, filePath) : {};
     const mcp = isPlainObject(config.mcp) ? { ...config.mcp } : {};
-    if (mode === "install") {
-        mcp[resolved.serverName] = {
-            type: "local",
-            command: [...resolved.serverCommand],
-            enabled: true
-        };
-    }
-    else {
-        delete mcp[resolved.serverName];
-    }
+    delete mcp[resolved.serverName];
     config.mcp = mcp;
     resolved.hooks.ensureDir(path.dirname(filePath));
     resolved.hooks.writeFile(filePath, JSON.stringify(config, null, 2) + "\n");
@@ -576,6 +570,8 @@ export async function runAction(action, options = {}) {
     }
 }
 async function inspectExecAction(action, resolved) {
+    if (action.inspect)
+        return action.inspect();
     if (!action.operation || !action.serverName)
         return "unknown";
     if (action.harness === "gemini") {
@@ -606,6 +602,25 @@ function successStatusForOperation(operation, beforeState) {
 }
 function formatMcpActionMessage(action, status, fallback) {
     if (!action.serverName || !action.operation) {
+        if (action.kind === "file-patch") {
+            switch (status) {
+                case "added":
+                    return `Installed ${action.filePath}.`;
+                case "updated":
+                    return `Updated ${action.filePath}.`;
+                case "already_present":
+                    return `${action.filePath} is already installed.`;
+                case "removed":
+                    return `Removed ${action.filePath}.`;
+                case "already_absent":
+                    return `${action.filePath} is already absent.`;
+                default:
+                    break;
+            }
+        }
+        if (action.kind === "exec" && status === "already_present") {
+            return "skill is already installed.";
+        }
         return fallback ?? "ok";
     }
     const target = `MCP server '${action.serverName}'`;

package/dist/instructions.js

@@ -12,7 +12,7 @@ On freshly invoked multi-agent tasks, give peers a short window to join before d
 
 Use phase names in handoffs when they clarify the work: draft, adversarial review, convergence, implementation, implementation review, test review, and release. These phases are vocabulary, not protocol state.
 
-Typical fits are advisory. Claude is usually strong at prose, first-pass synthesis, tool-running, implementation review, and test review. Codex is usually strong at adversarial review, convergence, implementation, edge cases, and release mechanics after operator approval. Gemini and OpenCode start with conservative local guidance until project dogfood says otherwise.
+Claude and Codex are peers of comparable capability; neither outranks the other. Split work evenly between them rather than routing by stereotype, and have all models plan, implement, and evaluate together: any harness can draft, review, converge, implement, or release. Gemini and OpenCode start with conservative local guidance until project dogfood says otherwise.
 
 For multi-agent design work, prefer independent read-only drafts first, then adversarial review and convergence. Do not impose a draft file structure on the workspace by default. If scratch draft files are useful, delete superseded pre-convergence drafts after the converged plan exists unless the operator asks to keep them.
 
@@ -20,11 +20,11 @@ Default to normal release handoffs. Use named assignment only when a specific me
 
 ## Claude
 
-Lean into drafting, synthesis, tool-running, implementation review, and test review. Watch for scope creep and messy first-pass artifacts. When implementation belongs elsewhere, make the next phase explicit in the handoff.
+Take a full, even share of planning, implementation, and evaluation. Watch for scope creep and messy first-pass artifacts. Make the next phase explicit in the handoff.
 
 ## Codex
 
-Lean into adversarial review, convergence, precise implementation, edge-case sweeps, and release mechanics after operator approval. Watch for over-indexing on mechanics when the operator still needs to decide direction.
+Take a full, even share of planning, implementation, and evaluation. Watch for over-indexing on mechanics when the operator still needs to decide direction. Make the next phase explicit in the handoff.
 
 ## Gemini
 
@@ -151,6 +151,10 @@ export function extractHarnessInstructions(markdown, harness) {
             sections.get(current)?.push(line);
             continue;
         }
+        if (sawSection && isMarkdownH2Header(line)) {
+            current = null;
+            continue;
+        }
         if (!sawSection) {
             shared.push(line);
             continue;
@@ -202,6 +206,9 @@ function ensureInstructionFile(filePath) {
     fs.writeFileSync(filePath, DEFAULT_INSTRUCTIONS_MARKDOWN);
     return true;
 }
+function isMarkdownH2Header(line) {
+    return /^##\s+.+?\s*$/.test(line);
+}
 function parseHarnessHeader(line) {
     const match = line.match(/^##\s+(.+?)\s*$/);
     if (!match) {

package/dist/process-utils.js

@@ -56,7 +56,11 @@ function inspectSystemProcess(pid, options) {
     try {
         const output = (options.execFile ?? defaultExecFile)("ps", ["-o", "ppid=", "-o", "lstart=", "-o", "command=", "-p", String(pid)], {
             encoding: "utf8",
-            stdio: ["ignore", "pipe", "ignore"]
+            stdio: ["ignore", "pipe", "ignore"],
+            env: {
+                ...process.env,
+                LC_ALL: "C"
+            }
         }).trimEnd();
         if (!output.trim()) {
             return null;

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

@@ -18,7 +18,7 @@ export function resolveSkillTargetPath(harness, options = {}) {
         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}`);
     }
@@ -29,20 +29,25 @@ export function planSkillInstall(harness, options = {}) {
     const shouldLink = options.link ?? true;
     ensureSkillSourceExists(sourcePath);
     if (harness === "gemini") {
+        const geminiTargetPath = path.join(resolveHarnessConfigDir("gemini", options), "skills", skillName);
         return shouldLink
             ? {
                 kind: "exec",
                 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",
+                inspect: () => inspectInstalledSkill(sourcePath, geminiTargetPath, true)
             }
             : {
                 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",
+                inspect: () => inspectInstalledSkill(sourcePath, geminiTargetPath, false)
             };
     }
     const targetPath = resolveSkillTargetPath(harness, options);
@@ -58,6 +63,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)
     };
 }
@@ -177,6 +184,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.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/docs/releases/0.4.12.md

@@ -0,0 +1,17 @@
+# Talking Stick 0.4.12
+
+Date: 2026-06-09
+
+## Fixed
+- **No-op `tt install` runs are quiet.** Legacy MCP cleanup lines are only printed when an entry was actually removed, preserved, or failed — `absent`/`skipped` no-ops stay silent. The Grok session hook and Gemini skill installs now inspect their targets and report `already_present` instead of rewriting (`ok: Updated ...`) or re-linking (`added: ok`) on every run, and the `tt instructions edit` hint only prints when an install actually changed something.
+
+## 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.10",
+  "version": "0.4.12",
   "description": "CLI coordination tool for path-scoped agent handoffs.",
   "type": "module",
   "bin": {