@phnx-labs/agents-cli 1.20.54 → 1.20.56

package/dist/lib/tmux/session.d.ts

@@ -123,9 +123,10 @@ export declare function paneExitStatus(pane: string, socket?: string): Promise<P
  * Bind a per-session hook. Used by the spawn-wrap path to install a `pane-died`
  * hook that detaches the attach client the instant the wrapped agent exits (the
  * global `remain-on-exit on` otherwise leaves the client staring at a dead pane).
- * Best-effort — a failed hook just means the user Ctrl-b d's out manually.
+ * Best-effort — returns false when tmux rejects the hook so callers do not
+ * stamp a schema marker and daemon reconciliation can retry later.
  */
-export declare function setSessionHook(name: string, hook: string, command: string, socket?: string): Promise<void>;
+export declare function setSessionHook(name: string, hook: string, command: string, socket?: string): Promise<boolean>;
 /**
  * Schema version of the `pane-died` hook installed on managed `agents run`
  * sessions. Bump whenever the hook's SHAPE changes so the daemon reconcile
@@ -135,15 +136,30 @@ export declare function setSessionHook(name: string, hook: string, command: stri
  *        user exiting a split they opened) tore down the whole client.
  *   v2 — `#{hook_pane}`-guarded: only the AGENT pane dying detaches; a user
  *        split's death runs `kill-pane`, closing just that split.
+ *   v3 — the else-branch pins its target via
+ *        `run-shell "tmux -S <socket> kill-pane -t #{hook_pane}"`. Untargeted
+ *        kill-pane resolves "current pane" inside the hook context, which goes
+ *        nondeterministic on a loaded detached server (CI flake #965: the dead
+ *        split survived as a husk); run-shell format-expands its command at
+ *        fire time, so the event pane is always the target.
+ *   v4 — `run-shell -C "kill-pane -t #{hook_pane}"` executes the targeted command
+ *        in the tmux server instead of launching a second tmux client against
+ *        the same socket from inside the hook. That self-client could race the
+ *        server under load and leave the dead split behind.
  */
-export declare const AGENT_HOOK_SCHEMA = 2;
+export declare const AGENT_HOOK_SCHEMA = 4;
 /**
  * The guarded `pane-died` hook. Detach the client ONLY when the agent pane dies
  * (so the blocking attach in runInTmux returns and the exit status can be read);
- * a user split's death falls through to `kill-pane`, which — because the hook
- * runs in the dead pane's context — closes that split in place. Single source of
- * truth: both the spawn-wrap (exec.ts) and the daemon reconcile build the hook
- * here, so the two can never drift.
+ * a user split's death runs the else-branch, closing just that split. The
+ * else-branch goes through `run-shell -C` with an explicit `-t #{hook_pane}`
+ * target: tmux format-expands the command at fire time and executes it inside
+ * the server command queue, so the event pane is always the one killed without
+ * launching a second tmux client against the same socket. A bare `kill-pane`
+ * relied on the hook context supplying a "current pane", while an external
+ * self-client could race the server under load. Single source of truth: both
+ * the spawn-wrap (exec.ts) and the daemon reconcile build the hook here, so the
+ * two can never drift.
  */
 export declare function agentPaneDiedHook(sessionName: string, agentPane: string): string;
 /** Stamp a session's hook-schema marker to the current version. */

package/dist/lib/tmux/session.js

@@ -262,12 +262,18 @@ export async function paneExitStatus(pane, socket) {
  * Bind a per-session hook. Used by the spawn-wrap path to install a `pane-died`
  * hook that detaches the attach client the instant the wrapped agent exits (the
  * global `remain-on-exit on` otherwise leaves the client staring at a dead pane).
- * Best-effort — a failed hook just means the user Ctrl-b d's out manually.
+ * Best-effort — returns false when tmux rejects the hook so callers do not
+ * stamp a schema marker and daemon reconciliation can retry later.
  */
 export async function setSessionHook(name, hook, command, socket) {
     assertValidSessionName(name);
     const sock = socket ?? getDefaultSocketPath();
-    await runTmux({ socket: sock, args: ['set-hook', '-t', name, hook, command], throwOnError: false }).catch(() => { });
+    const result = await runTmux({
+        socket: sock,
+        args: ['set-hook', '-t', name, hook, command],
+        throwOnError: false,
+    }).catch(() => null);
+    return result?.code === 0;
 }
 /**
  * Schema version of the `pane-died` hook installed on managed `agents run`
@@ -278,20 +284,35 @@ export async function setSessionHook(name, hook, command, socket) {
  *        user exiting a split they opened) tore down the whole client.
  *   v2 — `#{hook_pane}`-guarded: only the AGENT pane dying detaches; a user
  *        split's death runs `kill-pane`, closing just that split.
+ *   v3 — the else-branch pins its target via
+ *        `run-shell "tmux -S <socket> kill-pane -t #{hook_pane}"`. Untargeted
+ *        kill-pane resolves "current pane" inside the hook context, which goes
+ *        nondeterministic on a loaded detached server (CI flake #965: the dead
+ *        split survived as a husk); run-shell format-expands its command at
+ *        fire time, so the event pane is always the target.
+ *   v4 — `run-shell -C "kill-pane -t #{hook_pane}"` executes the targeted command
+ *        in the tmux server instead of launching a second tmux client against
+ *        the same socket from inside the hook. That self-client could race the
+ *        server under load and leave the dead split behind.
  */
-export const AGENT_HOOK_SCHEMA = 2;
+export const AGENT_HOOK_SCHEMA = 4;
 /** Per-session tmux user-option that records which AGENT_HOOK_SCHEMA a session's hook is at. */
 const HOOK_SCHEMA_OPTION = '@ag_hook_schema';
 /**
  * The guarded `pane-died` hook. Detach the client ONLY when the agent pane dies
  * (so the blocking attach in runInTmux returns and the exit status can be read);
- * a user split's death falls through to `kill-pane`, which — because the hook
- * runs in the dead pane's context — closes that split in place. Single source of
- * truth: both the spawn-wrap (exec.ts) and the daemon reconcile build the hook
- * here, so the two can never drift.
+ * a user split's death runs the else-branch, closing just that split. The
+ * else-branch goes through `run-shell -C` with an explicit `-t #{hook_pane}`
+ * target: tmux format-expands the command at fire time and executes it inside
+ * the server command queue, so the event pane is always the one killed without
+ * launching a second tmux client against the same socket. A bare `kill-pane`
+ * relied on the hook context supplying a "current pane", while an external
+ * self-client could race the server under load. Single source of truth: both
+ * the spawn-wrap (exec.ts) and the daemon reconcile build the hook here, so the
+ * two can never drift.
  */
 export function agentPaneDiedHook(sessionName, agentPane) {
-    return `if -F '#{==:#{hook_pane},${agentPane}}' 'detach-client -s =${sessionName}' 'kill-pane'`;
+    return `if -F '#{==:#{hook_pane},${agentPane}}' 'detach-client -s =${sessionName}' 'run-shell -C "kill-pane -t #{hook_pane}"'`;
 }
 /** Stamp a session's hook-schema marker to the current version. */
 export async function markSessionHookSchema(name, socket) {
@@ -355,7 +376,9 @@ export async function reconcileSessionHooks(socket) {
         const agentPane = s.meta?.pane ?? await lowestPaneId(s.name, sock);
         if (!agentPane)
             continue;
-        await setSessionHook(s.name, 'pane-died', agentPaneDiedHook(s.name, agentPane), sock);
+        const installed = await setSessionHook(s.name, 'pane-died', agentPaneDiedHook(s.name, agentPane), sock);
+        if (!installed)
+            continue;
         await markSessionHookSchema(s.name, sock);
         reconciled++;
     }

package/dist/lib/triggers/webhook.js

@@ -12,7 +12,7 @@
  * The optional http listener (`startWebhookServer`) is a thin adapter over it.
  */
 import * as http from 'http';
-import { listJobs } from '../routines.js';
+import { listJobs, jobRunsOnThisDevice } from '../routines.js';
 import { executeJobDetached } from '../runner.js';
 /** Read `repository.full_name` (`owner/name`) from a webhook payload, if present. */
 export function webhookRepo(payload) {
@@ -85,7 +85,7 @@ export function jobMatchesWebhook(job, webhook) {
  * time-based jobs are unaffected by webhook delivery.
  */
 export function matchJobsToWebhook(jobs, webhook) {
-    return jobs.filter((job) => job.enabled !== false && jobMatchesWebhook(job, webhook));
+    return jobs.filter((job) => job.enabled !== false && jobRunsOnThisDevice(job) && jobMatchesWebhook(job, webhook));
 }
 /**
  * Match an incoming webhook against the persisted routines and fire each match

package/dist/lib/types.d.ts

@@ -439,6 +439,12 @@ export interface SkillEntry {
     tags?: string[];
     /** Registry-specific trust signal (e.g. 'builtin', 'trusted', 'community'). */
     trustLevel?: string;
+    /**
+     * Lowercase hex sha256 of the skill's SKILL.md, as recorded by
+     * `agents publish`. When present, install verifies the cloned SKILL.md
+     * against it and aborts on mismatch.
+     */
+    sha256?: string;
 }
 /** Paginated response from a skill registry search endpoint. */
 export interface SkillRegistryResponse {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.20.54",
+  "version": "1.20.56",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",