@phnx-labs/agents-cli 1.22.100 → 1.22.102

package/dist/lib/session/active.js

@@ -174,6 +174,13 @@ export function backfillActiveRowsFromMeta(sessions, metaById) {
             s.durationMs = m.durationMs;
         if (s.subAgentCount == null && m.subAgentCount != null)
             s.subAgentCount = m.subAgentCount;
+        // A pane kept open for days has a start time but no activity signal of its
+        // own; the index's last transcript write is what "idle 14d" is read from.
+        if (s.lastActivityMs == null && m.lastActivity) {
+            const ts = Date.parse(m.lastActivity);
+            if (!Number.isNaN(ts))
+                s.lastActivityMs = ts;
+        }
     }
 }
 function loadBackfillMetaFor(sessions) {

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

@@ -56,6 +56,13 @@ export interface StructuredQuestion {
 export interface DetectedPr {
     url: string;
     number?: number;
+    /** `gh pr view` status, attached by the feed watch when it has fetched it. */
+    state?: string;
+    isDraft?: boolean;
+    reviewDecision?: string;
+    mergeable?: string;
+    /** The check rollup folded to one verdict. */
+    checks?: 'passing' | 'failing' | 'pending';
 }
 export interface DetectedWorktree {
     /** Absolute worktree path (the session cwd). */

package/dist/lib/sync-status.d.ts

@@ -115,6 +115,12 @@ export interface ResidualDrift {
 export declare function verifyVersionConverged(agent: AgentId, version: string, cwd?: string): ResidualDrift | null;
 /** One-line-per-resource description of residual drift, for the sync exit line. */
 export declare function formatResidualDrift(residual: ResidualDrift[]): string[];
+/**
+ * The rows behind a "N drifted" count, one line each, for the human renderers.
+ * A count alone cannot be acted on; the name says which skill or hook to look
+ * at, and `detail` says what differs when the differ knows.
+ */
+export declare function formatDriftRows(v: AgentVersionStatus): string[];
 export interface SyncStatusOptions {
     cwd?: string;
     /** Restrict to specific agent ids; undefined = every supported agent. */

package/dist/lib/sync-status.js

@@ -54,6 +54,17 @@ export function formatResidualDrift(residual) {
     }
     return lines;
 }
+/**
+ * The rows behind a "N drifted" count, one line each, for the human renderers.
+ * A count alone cannot be acted on; the name says which skill or hook to look
+ * at, and `detail` says what differs when the differ knows.
+ */
+export function formatDriftRows(v) {
+    return v.resources
+        .filter((r) => r.status === 'drifted' || r.status === 'missing')
+        .sort((a, b) => a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name))
+        .map((r) => `${r.status.padEnd(7)} ${r.kind}/${r.name}${r.detail ? ` (${r.detail})` : ''}`);
+}
 const STATUS_MAP = {
     ok: 'synced',
     diff: 'drifted',

package/dist/lib/system-run-sync.d.ts

@@ -0,0 +1,11 @@
+import type { AgentId } from './types.js';
+export interface SystemRunSyncResult {
+    /** Names rewritten per kind; empty when the sentinel matched (skip-fast). */
+    skills: string[];
+    subagents: string[];
+}
+/**
+ * Refresh the system layer's skills and subagents into the version home when
+ * their source directories changed since the last run for (agent, version).
+ */
+export declare function applySystemResourcesAtRun(agent: AgentId, version: string, versionHome: string): SystemRunSyncResult;

package/dist/lib/system-run-sync.js

@@ -0,0 +1,114 @@
+/**
+ * System-layer skills and subagents refresh at `agents run` launch time.
+ *
+ * `agents sync <harness>@all system` rewrites every version home, but nothing
+ * runs it when the `.system` mirror moves: the shim's `--launch` path compiles
+ * project rules and mirrors project resources only, and the SessionStart
+ * autosync fires the umbrella at most once per 4 h. Rules already close that
+ * gap per run (`rules/run-sync.ts`); skills and subagents did not, so a merged
+ * system-layer skill change left 31 of 33 installed copies on the old text
+ * (PHNX-4056). This is the same shape as the rules run-sync: a small per-
+ * (agent, version) sentinel of source fingerprints, stat-tier comparison, and
+ * a write through the registered writers only when a source file changed.
+ *
+ * Scope: the system layer's `skills/` and `subagents/` directories. The
+ * writers resolve each name through the normal precedence (a user-layer
+ * shadow still wins), and the active resource profile filters both kinds the
+ * same way `syncResourcesToVersion` does. Never blocks a launch: any failure
+ * is swallowed and leaves the sentinel stale, so the next run retries.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { getCacheDir, getSystemSkillsDir, getSystemSubagentsDir } from './state.js';
+import { getWriter } from './staleness/registry.js';
+import { fingerprintDir, isDirStale } from './staleness/fingerprint.js';
+import { filterNamesForActiveResourceProfile } from './resource-profiles.js';
+/** ~/.agents/.cache/system-run-sync/ — regenerable; a lost sentinel costs one extra write. */
+function sentinelPath(agent, version) {
+    const key = `${agent}@${version}`.replace(/[^a-zA-Z0-9@._-]/g, '_');
+    return path.join(getCacheDir(), 'system-run-sync', `${key}.json`);
+}
+function loadSentinel(agent, version) {
+    try {
+        return JSON.parse(fs.readFileSync(sentinelPath(agent, version), 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+function saveSentinel(agent, version, sentinel) {
+    const p = sentinelPath(agent, version);
+    try {
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, JSON.stringify(sentinel));
+    }
+    catch {
+        // Best-effort — a failed write just means the next run redoes the copy.
+    }
+}
+/** Subdirectories of `dir` that carry `marker` (SKILL.md / AGENT.md). */
+function namesWithMarker(dir, marker) {
+    const out = new Map();
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const e of entries) {
+        if (!e.isDirectory() || e.name.startsWith('.'))
+            continue;
+        const src = path.join(dir, e.name, marker);
+        if (fs.existsSync(src))
+            out.set(e.name, src);
+    }
+    return out;
+}
+/**
+ * Refresh the system layer's skills and subagents into the version home when
+ * their source directories changed since the last run for (agent, version).
+ */
+export function applySystemResourcesAtRun(agent, version, versionHome) {
+    const result = { skills: [], subagents: [] };
+    const stored = loadSentinel(agent, version);
+    const next = { ...stored };
+    const kinds = [
+        { kind: 'skills', dir: getSystemSkillsDir(), marker: 'SKILL.md' },
+        { kind: 'subagents', dir: getSystemSubagentsDir(), marker: 'AGENT.md' },
+    ];
+    for (const { kind, dir, marker } of kinds) {
+        if (!fs.existsSync(dir))
+            continue;
+        const prev = stored[kind];
+        if (prev && prev.dir === dir && !isDirStale(prev.dir, prev.files, dir))
+            continue;
+        const writer = getWriter(kind, agent);
+        if (!writer)
+            continue;
+        const sources = namesWithMarker(dir, marker);
+        // The active resource profile is the per-client scoping seam (a brand pins
+        // one); it filters every kind here exactly as `syncResourcesToVersion` does.
+        const names = filterNamesForActiveResourceProfile(kind, Array.from(sources.keys()), sources);
+        if (names.length === 0) {
+            next[kind] = { dir, files: fingerprintDir(dir) };
+            continue;
+        }
+        let written;
+        try {
+            written = writer.write({ version, versionHome, selection: names, cwd: '' });
+        }
+        catch {
+            continue; // leave the sentinel stale so the next run retries
+        }
+        result[kind] = written.synced;
+        // A per-name failure (an AGENT.md that does not parse) also leaves the
+        // sentinel stale: the next run retries instead of never seeing it again.
+        if (written.errors?.length)
+            continue;
+        next[kind] = { dir, files: fingerprintDir(dir) };
+    }
+    if (JSON.stringify(next) !== JSON.stringify(stored))
+        saveSentinel(agent, version, next);
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.22.100",
+  "version": "1.22.102",
   "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",