talking-stick 0.4.8 → 0.4.10

package/README.md

@@ -2,7 +2,7 @@
 
 A CLI coordination tool 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.4.1. Multi-process-safe (SQLite WAL), liveness-aware, no daemon. Supports Claude Code, Codex CLI, Gemini CLI, and OpenCode out of the box. Two agents in the same room can also chat out-of-band — without passing the stick — via `tt msg send/recv`.
+**Version:** 0.4.1. Multi-process-safe (SQLite WAL), liveness-aware, no daemon. Supports Claude Code, Codex CLI, Gemini CLI, Grok Build, and OpenCode out of the box. Two agents in the same room can also chat out-of-band — without passing the stick — via `tt msg send/recv`.
 
 ## Quickstart
 
@@ -105,7 +105,7 @@ tt msg send/recv   — out-of-band chat into the room event log
 tt instructions    — editable collaboration prompt loaded by the skill
 ```
 
-A workspace maps to a room — usually the `git` root or nearest project marker — so two agents `cd`'d anywhere under the same repo join the same room automatically.
+A workspace maps to a room — usually the `git` root or nearest project marker — so two agents `cd`'d anywhere under the same repo join the same room automatically. Marker files directly in your home directory are ignored for descendant paths, so scratch directories under `$HOME` do not collapse into one broad home-scoped room unless you explicitly join home itself.
 
 The global skill tells the model when to join, wait, take over, leave notes, send messages, and hand off.
 
@@ -166,13 +166,14 @@ For harnesses that only notice completed subprocesses, run `tt events --wait --a
 - Claude Code: copied or linked into `~/.claude/skills/talking-stick`
 - 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`
 
 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.
 
-Stale MCP cleanup is strict for OpenCode JSON entries: it removes only the canonical `mcp.talking-stick` value with `["tt", "mcp"]` and leaves hand-edited entries alone. Claude Code, Codex, and Gemini cleanup uses their own `mcp remove` commands when the old server name exists. Every cleanup run appends JSONL audit entries to `${TALKING_STICK_DATA_DIR}/update-migrations.log`.
+Stale MCP cleanup is strict for OpenCode JSON entries: it removes only the canonical `mcp.talking-stick` value with `["tt", "mcp"]` and leaves hand-edited entries alone. Claude Code, Codex, and Gemini cleanup uses their own `mcp remove` commands when the old server name exists. Grok Build has no Talking Stick MCP registration path; install is native skill plus hook only. Every cleanup run appends JSONL audit entries to `${TALKING_STICK_DATA_DIR}/update-migrations.log`.
 
-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 gemini` after updating when needed.
+Human CLI invocations also perform a silent best-effort sync for already-installed file-based skills in Claude Code, Codex, Grok Build, 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 gemini` after updating when needed.
 
 ## Human CLI
 
@@ -189,7 +190,7 @@ tt state [path]                                           # full room state
 tt events [path] [--after N] [--limit N] [--wait|--follow] [--event TYPE[,TYPE]] [--target self|any|agent]  # room event log; --wait/--follow long-polls
 tt msg send <recipient|room> <body...> [--interrupt] [--stdin] [--path DIR]  # send an OOB message
 tt msg recv [--wait|--follow] [--from agent] [--after N] [--target self|any|agent] [--path DIR]  # receive OOB messages
-tt instructions show [path] [--harness claude|codex|gemini|opencode|all] [--scope effective|bundled|user|project]  # show collaboration prompt
+tt instructions show [path] [--harness claude|codex|gemini|grok|opencode|all] [--scope effective|bundled|user|project]  # show collaboration prompt
 tt instructions edit [path] [--user|--project]             # edit user or project prompt
 tt instructions reset [path] (--user|--project)            # delete a user or project prompt
 tt release [path] --status TEXT --next-action TEXT        # normal handoff
@@ -216,7 +217,8 @@ By default, `tt` behaves like a human CLI and resolves to `human:<username>` onl
 
 Harness-aware CLI identity is resolved before the human fallback:
 
-- Known harness environment markers such as `CLAUDECODE=1`, `CODEX_THREAD_ID`, `GEMINI_CLI=1`, or `OPENCODE=1` make `tt` derive a harness-style identity automatically.
+- Known harness environment markers such as `CLAUDECODE=1`, `CODEX_THREAD_ID`, `GEMINI_CLI=1`, `CMUX_AGENT_LAUNCH_KIND=grok`, or `OPENCODE=1` make `tt` derive a harness-style identity automatically. The cmux Grok marker is optional; Grok Build also works without cmux by walking process ancestry for a `grok` root process.
+- Grok Build's installed hook records hook-only `GROK_SESSION_ID` context into `${TALKING_STICK_DATA_DIR}/grok-sessions.jsonl`, letting later Grok-launched `tt` calls upgrade from process identity to the real Grok session id. `GROK_SESSION_ID` by itself is not treated as a normal shell marker, and the hook is not required for basic Grok detection.
 - Set `TT_HARNESS_AGENT_ID=<agent-id>` if the harness wants to export the exact agent id directly.
 - Set `TT_HARNESS_EXPORT=1` only when you need ancestry-based harness detection without a known harness environment marker.
 

package/dist/cli/event-stream.js

@@ -20,7 +20,11 @@ export async function runEventStream(runtime, parsed, identity, roomId, options)
         event_type: options.event_type,
         target_agent_id: targetAgentId,
         from_agent_id: fromAgentId,
-        max_wait_ms: follow || wait ? parseWaitTimeout(parsed) : 0
+        max_wait_ms: follow || wait ? parseWaitTimeout(parsed) : 0,
+        // Carry the caller's identity so a sustained self-receiver registers and
+        // refreshes presence (issue #29 Defect 1) — a `tt events --follow` /
+        // `--wait` watcher stays visible even if it never ran `tt join`.
+        process_metadata: identity.process_metadata
     };
     if (!follow) {
         const result = await runtime.commands.waitForEvents(waitInput);
@@ -38,7 +42,8 @@ export function resolveOptionalAgentSelector(runtime, identity, roomId, raw) {
 export function resolveAgentSelector(runtime, identity, roomId, raw) {
     const members = runtime.commands.getRoomState({
         room_id: roomId,
-        agent_id: identity.agent_id
+        agent_id: identity.agent_id,
+        process_metadata: identity.process_metadata
     }).members;
     const exact = members.find((member) => member.agent_id === raw);
     if (exact) {

package/dist/cli/grok-session-hook.js

@@ -0,0 +1,69 @@
+import { createSystemProcessInspector } from "../process-utils.js";
+import { appendGrokSessionRecord } from "../grok-session-store.js";
+import { findHarnessRootInAncestry } from "../identity.js";
+export async function runGrokSessionHookCommand(options = {}) {
+    try {
+        const env = options.env ?? process.env;
+        const input = parseHookInput(options.stdin ?? await readStdin());
+        const sessionId = firstNonEmptyString(env.GROK_SESSION_ID, input.sessionId);
+        const workspaceRoot = firstNonEmptyString(env.GROK_WORKSPACE_ROOT, env.CLAUDE_PROJECT_DIR, input.workspaceRoot);
+        if (!sessionId || !workspaceRoot) {
+            return;
+        }
+        const event = firstNonEmptyString(env.GROK_HOOK_EVENT, input.hookEventName) ?? "unknown";
+        const inspector = options.inspector ?? createSystemProcessInspector();
+        const parentPid = options.parentPid ?? process.ppid;
+        const parentInspection = inspector.inspect(parentPid);
+        const grokRoot = findHarnessRootInAncestry("grok", parentPid, parentInspection, inspector, 20);
+        const record = {
+            source: "grok_hook",
+            grok_session_id: sessionId,
+            workspace_root: workspaceRoot,
+            cwd: firstNonEmptyString(input.cwd),
+            event,
+            observed_at: firstNonEmptyString(input.timestamp) ??
+                (options.now ?? new Date()).toISOString(),
+            grok_pid: grokRoot?.pid ?? null,
+            grok_process_started_at: grokRoot?.startTime ?? null
+        };
+        appendGrokSessionRecord(record, { logPath: options.logPath });
+    }
+    catch {
+        // Grok hooks must fail open. Identity can fall back to pid-root detection
+        // when the hook cannot record a session row.
+    }
+}
+function parseHookInput(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return {};
+    try {
+        const parsed = JSON.parse(trimmed);
+        return isObjectRecord(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        let raw = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => {
+            raw += chunk;
+        });
+        process.stdin.on("error", reject);
+        process.stdin.on("end", () => resolve(raw));
+    });
+}
+function firstNonEmptyString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value.trim();
+        }
+    }
+    return null;
+}
+function isObjectRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/cli/guardian.js

@@ -14,11 +14,12 @@ export async function runGuardCommand(parsed) {
         displayName: requireStringOption(parsed, "agent").replace(/^human:/, ""),
         sessionKind: "human_guardian"
     });
+    const harnessMetadata = parseHarnessMetadataOptions(parsed);
     const identity = {
         ...baseIdentity,
         process_metadata: {
             ...baseIdentity.process_metadata,
-            ...parseHarnessMetadataOptions(parsed)
+            ...harnessMetadata
         }
     };
     const runtime = createRuntime();
@@ -32,8 +33,28 @@ export async function runGuardCommand(parsed) {
             expected_turn_id: parseRequiredInteger(parsed, "turn-id")
         };
         const intervalMs = joined.policy.heartbeatIntervalMs;
+        const harnessRef = {
+            pid: harnessMetadata.harness_pid,
+            process_started_at: harnessMetadata.harness_process_started_at
+        };
+        const inspector = createSystemProcessInspector();
         process.stdout.write(`${GUARD_READY}\n`);
         const timer = setInterval(() => {
+            // Tier-1 stale-guardian purge: if our own harness process is provably
+            // gone, surrender the turn instead of renewing the lease forever. This is
+            // the definitive case (no timeout): an orphaned guardian must not pin the
+            // stick once the harness it represents has exited. `unknown`/`alive` both
+            // fall through to the normal heartbeat; we only act on a definite `gone`.
+            if (checkGuardianLiveness(harnessRef, inspector) === "gone") {
+                try {
+                    runtime.commands.relinquishOwnership(identity, heartbeatInput);
+                }
+                catch {
+                    // Best effort: a takeover or graceful release may have already moved
+                    // the turn on. Either way the harness is gone, so we exit.
+                }
+                process.exit(0);
+            }
             try {
                 runtime.commands.heartbeat(identity, heartbeatInput);
             }

package/dist/cli/install-commands.js

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { SUPPORTED_HARNESSES, detectHarness, parseHarnessList, planUninstall, runAction } from "../install.js";
+import { SUPPORTED_HARNESSES, detectHarness, parseHarnessList, planGrokSessionHookInstall, planGrokSessionHookUninstall, planUninstall, runAction } from "../install.js";
 import { planSkillInstall, planSkillUninstall } from "../skill-install.js";
 import { resolveDataDir } from "../config.js";
 import { FileAuditLog, defaultAuditLogPath } from "../install-audit.js";
@@ -145,7 +145,7 @@ function resolveSkillInstallLinkMode(parsed) {
     return true;
 }
 function planInstallActions(harnesses, installOptions) {
-    return harnesses.map((harness) => planSkillInstall(harness, installOptions));
+    return harnesses.flatMap((harness) => planInstallActionsForHarness(harness, installOptions));
 }
 function planUninstallActions(harnesses, installOptions) {
     return harnesses.flatMap((harness) => [
@@ -153,6 +153,14 @@ function planUninstallActions(harnesses, installOptions) {
             ...installOptions,
             skipMissing: false
         }),
+        ...(harness === "grok"
+            ? [
+                planGrokSessionHookUninstall({
+                    ...installOptions,
+                    skipMissing: false
+                })
+            ]
+            : []),
         planUninstall(harness, installOptions)
     ]);
 }
@@ -160,14 +168,31 @@ function planCleanupActions(harnesses, installOptions) {
     return harnesses.map((harness) => planUninstall(harness, installOptions));
 }
 async function runSkillInstall(harness, installOptions) {
-    const skillAction = planSkillInstall(harness, installOptions);
-    const skillResult = await runAction(skillAction, installOptions);
-    return [skillResult];
+    const actions = planInstallActionsForHarness(harness, installOptions);
+    return Promise.all(actions.map((action) => runAction(action, installOptions)));
 }
 async function runSkillUninstall(harness, installOptions) {
-    const skillAction = planSkillUninstall(harness, installOptions);
-    const skillResult = await runAction(skillAction, installOptions);
-    return [skillResult];
+    const actions = [
+        planSkillUninstall(harness, {
+            ...installOptions,
+            skipMissing: false
+        }),
+        ...(harness === "grok"
+            ? [
+                planGrokSessionHookUninstall({
+                    ...installOptions,
+                    skipMissing: false
+                })
+            ]
+            : [])
+    ];
+    return Promise.all(actions.map((action) => runAction(action, installOptions)));
+}
+function planInstallActionsForHarness(harness, installOptions) {
+    return [
+        planSkillInstall(harness, installOptions),
+        ...(harness === "grok" ? [planGrokSessionHookInstall(installOptions)] : [])
+    ];
 }
 async function runCleanup(harnesses, reason, installOptions) {
     const dataDir = resolveDataDir();

package/dist/cli/output.js

@@ -164,7 +164,7 @@ Commands:
   tt events [path] [--after N] [--limit N] [--wait|--follow] [--event TYPE[,TYPE]] [--target self|any|agent]
   tt msg send <recipient|room> <body...> [--interrupt] [--stdin] [--path DIR]
   tt msg recv [--wait|--follow] [--from agent] [--after N] [--target self|any|agent] [--path DIR]
-  tt instructions show [path] [--harness claude|codex|gemini|opencode|all] [--scope effective|bundled|user|project]
+  tt instructions show [path] [--harness claude|codex|gemini|grok|opencode|all] [--scope effective|bundled|user|project]
   tt instructions edit [path] [--user|--project]
   tt instructions reset [path] (--user|--project)
   tt release [path] (--status TEXT --next-action TEXT | --stdin)

package/dist/cli/registry.js

@@ -1,4 +1,5 @@
 import { runGuardCommand } from "./guardian.js";
+import { runGrokSessionHookCommand } from "./grok-session-hook.js";
 import { runInstallCommand, runMcpMigrationCommand, runSelfUpdateCommand, runUninstallCommand } from "./install-commands.js";
 import { handleInstructionsCommand } from "./instructions-commands.js";
 import { handleMsgCommand } from "./msg-commands.js";
@@ -15,6 +16,15 @@ export const COMMAND_REGISTRY = [
         description: "Run an internal lease heartbeat guardian.",
         handler: ({ parsed }) => runGuardCommand(parsed)
     },
+    {
+        name: "grok-session-hook",
+        needsRuntime: false,
+        startupMaintenance: false,
+        internal: true,
+        usage: "tt grok-session-hook",
+        description: "Record Grok hook session context for identity resolution.",
+        handler: () => runGrokSessionHookCommand()
+    },
     {
         name: "install",
         needsRuntime: false,

package/dist/cli/room-commands.js

@@ -95,7 +95,8 @@ export function handleStateCommand(runtime, parsed) {
     const session = resolveSessionForReads(runtime, parsed, identity);
     const state = runtime.commands.getRoomState({
         room_id: session.room_id,
-        agent_id: identity.agent_id
+        agent_id: identity.agent_id,
+        process_metadata: identity.process_metadata
     });
     printResult(parsed, { room: state.room, members: state.members }, () => {
         const lines = [
@@ -144,7 +145,8 @@ export async function handleEventsCommand(runtime, parsed) {
         room_id: session.room_id,
         agent_id: identity.agent_id,
         after_event_seq: parseOptionalInteger(parsed, "after"),
-        limit: parseOptionalInteger(parsed, "limit")
+        limit: parseOptionalInteger(parsed, "limit"),
+        process_metadata: identity.process_metadata
     });
     printResult(parsed, events, () => {
         if (events.length === 0) {

package/dist/cli/turn-commands.js

@@ -245,7 +245,8 @@ function resolveAssignmentTarget(runtime, identity, session, selector) {
     }
     const state = runtime.commands.getRoomState({
         room_id: session.room_id,
-        agent_id: identity.agent_id
+        agent_id: identity.agent_id,
+        process_metadata: identity.process_metadata
     });
     const normalizedSelector = selector.toLowerCase();
     const candidates = state.members.filter((member) => {
@@ -265,7 +266,8 @@ function resolveAssignmentTarget(runtime, identity, session, selector) {
     const events = runtime.commands.getRoomEvents({
         room_id: session.room_id,
         agent_id: identity.agent_id,
-        limit: 500
+        limit: 500,
+        process_metadata: identity.process_metadata
     });
     return pickFairAssignmentCandidate(candidates, events).agent_id;
 }

package/dist/commands.js

@@ -41,7 +41,8 @@ export class TalkingStickCommands {
             auto_claim: input.auto_claim,
             include_events: input.include_events,
             after_event_seq: input.after_event_seq,
-            target_agent_id: input.target_agent_id
+            target_agent_id: input.target_agent_id,
+            process_metadata: identity.process_metadata
         });
     }
     heartbeat(identity, input) {
@@ -52,6 +53,14 @@ export class TalkingStickCommands {
             expected_turn_id: input.expected_turn_id
         });
     }
+    relinquishOwnership(identity, input) {
+        return this.service.relinquishOwnership({
+            agent_id: identity.agent_id,
+            room_id: input.room_id,
+            lease_id: input.lease_id,
+            expected_turn_id: input.expected_turn_id
+        });
+    }
     releaseStick(identity, input) {
         return this.service.releaseStick({
             agent_id: identity.agent_id,
@@ -92,7 +101,8 @@ export class TalkingStickCommands {
             room_id: input.room_id,
             body: input.body,
             to_agent_id: input.to_agent_id,
-            delivery_hint: input.delivery_hint
+            delivery_hint: input.delivery_hint,
+            process_metadata: identity.process_metadata
         });
     }
     waitForEvents(input) {
@@ -106,7 +116,8 @@ export class TalkingStickCommands {
             agent_id: identity.agent_id,
             room_id: input.room_id,
             body: input.body,
-            turn_id: input.turn_id
+            turn_id: input.turn_id,
+            process_metadata: identity.process_metadata
         });
     }
     listNotes(identity, input) {
@@ -115,7 +126,8 @@ export class TalkingStickCommands {
             agent_id: identity?.agent_id,
             after_note_id: input.after_note_id,
             include_resolved: input.include_resolved,
-            limit: input.limit
+            limit: input.limit,
+            process_metadata: identity?.process_metadata
         });
     }
 }

package/dist/config.js

@@ -2,6 +2,7 @@ import os from "node:os";
 import path from "node:path";
 export const defaultPolicy = {
     ownerLeaseTtlMs: 45 * 60 * 1000,
+    ownerActivityTtlMs: 45 * 60 * 1000,
     heartbeatIntervalMs: 5 * 60 * 1000,
     claimTtlMs: 20 * 60 * 1000,
     waitForTurnMaxWaitMs: 110 * 1000,

package/dist/grok-session-store.js

@@ -0,0 +1,140 @@
+import fs from "node:fs";
+import path from "node:path";
+import { resolveDataDir } from "./config.js";
+export const DEFAULT_GROK_SESSION_RECORD_MAX_AGE_MS = 4 * 60 * 60 * 1000;
+export function resolveGrokSessionLogPath(options = {}) {
+    return path.join(resolveDataDir(options), "grok-sessions.jsonl");
+}
+export function appendGrokSessionRecord(record, options = {}) {
+    const logPath = options.logPath ?? resolveGrokSessionLogPath(options.dataDirOptions ?? {});
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    fs.appendFileSync(logPath, `${JSON.stringify(record)}\n`, "utf8");
+}
+export function readGrokSessionRecords(logPath) {
+    let raw;
+    try {
+        raw = fs.readFileSync(logPath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+    const records = [];
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            const record = parseGrokSessionRecord(parsed);
+            if (record)
+                records.push(record);
+        }
+        catch {
+            // Hook logs are append-only and best-effort; one bad line should not
+            // break identity resolution for the whole session.
+        }
+    }
+    return records;
+}
+export function findGrokSessionRecord(input) {
+    const workspaceRoot = normalizeWorkspaceRoot(input.workspaceRoot);
+    if (!workspaceRoot)
+        return null;
+    const logPath = input.logPath ?? resolveGrokSessionLogPath();
+    const nowMs = input.now?.getTime() ?? Date.now();
+    const maxAgeMs = input.maxAgeMs ?? DEFAULT_GROK_SESSION_RECORD_MAX_AGE_MS;
+    const records = readGrokSessionRecords(logPath);
+    const endedSessionIds = new Set();
+    const workspaceCandidates = [];
+    for (const record of records.slice().reverse()) {
+        if (normalizeWorkspaceRoot(record.workspace_root) !== workspaceRoot) {
+            continue;
+        }
+        if (isStaleRecord(record, nowMs, maxAgeMs)) {
+            continue;
+        }
+        if (isGrokSessionEndEvent(record.event)) {
+            endedSessionIds.add(record.grok_session_id);
+            continue;
+        }
+        if (endedSessionIds.has(record.grok_session_id)) {
+            continue;
+        }
+        workspaceCandidates.push(record);
+        if (input.grokPid != null &&
+            input.grokProcessStartedAt != null &&
+            record.grok_pid === input.grokPid &&
+            record.grok_process_started_at === input.grokProcessStartedAt) {
+            return record;
+        }
+    }
+    const uniqueSessionIds = new Set(workspaceCandidates.map((record) => record.grok_session_id));
+    if (uniqueSessionIds.size === 1) {
+        return workspaceCandidates[0] ?? null;
+    }
+    return null;
+}
+export function isGrokSessionEndEvent(event) {
+    return normalizeEventName(event) === "sessionend";
+}
+function parseGrokSessionRecord(value) {
+    if (!isObjectRecord(value))
+        return null;
+    if (value.source !== "grok_hook")
+        return null;
+    const grokSessionId = nonEmptyString(value.grok_session_id);
+    const workspaceRoot = nonEmptyString(value.workspace_root);
+    const event = nonEmptyString(value.event);
+    const observedAt = nonEmptyString(value.observed_at);
+    if (!grokSessionId || !workspaceRoot || !event || !observedAt) {
+        return null;
+    }
+    return {
+        source: "grok_hook",
+        grok_session_id: grokSessionId,
+        workspace_root: workspaceRoot,
+        cwd: nullableString(value.cwd),
+        event,
+        observed_at: observedAt,
+        grok_pid: nullableInteger(value.grok_pid),
+        grok_process_started_at: nullableString(value.grok_process_started_at)
+    };
+}
+function isStaleRecord(record, nowMs, maxAgeMs) {
+    const observedAtMs = Date.parse(record.observed_at);
+    if (Number.isNaN(observedAtMs))
+        return true;
+    return nowMs - observedAtMs > maxAgeMs;
+}
+function normalizeWorkspaceRoot(value) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        return null;
+    try {
+        return fs.realpathSync.native(trimmed);
+    }
+    catch {
+        return path.resolve(trimmed);
+    }
+}
+function normalizeEventName(event) {
+    return event.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0
+        ? value
+        : null;
+}
+function nullableString(value) {
+    return typeof value === "string" && value.trim().length > 0
+        ? value
+        : null;
+}
+function nullableInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) ? value : null;
+}
+function isObjectRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}