@phnx-labs/agents-cli 1.22.59 → 1.22.61

package/dist/lib/claude-statusline.d.ts

@@ -9,6 +9,7 @@ export declare const CLAUDE_STATUSLINE_COMMAND = "agents __claude-statusline";
 export declare function isStatusLineSelfReference(command: string): boolean;
 interface ClaudeStatusLinePayload {
     cwd?: string;
+    session_id?: string;
     workspace?: {
         current_dir?: string;
     };
@@ -29,7 +30,19 @@ interface ClaudeStatusLinePayload {
 }
 export declare function ingestClaudeStatusLineUsage(payload: ClaudeStatusLinePayload, versionHome: string): boolean;
 export declare function renderDelegate(payload: string, versionHome: string): string;
-export declare function renderClaudeStatusLine(payload: ClaudeStatusLinePayload, host?: string, delegated?: string): string;
+/**
+ * Format a reminder as a dimmed statusline part (empty string when none). The
+ * ◆ marker distinguishes it from the host/model/usage parts, and the ANSI dim
+ * keeps it quiet next to the live figures.
+ */
+export declare function formatReminderPart(short: string | undefined): string;
+export declare function renderClaudeStatusLine(payload: ClaudeStatusLinePayload, host?: string, delegated?: string, reminder?: string): string;
+/**
+ * Resolve the per-session reminder for the statusline, or '' when none is
+ * configured. A malformed reminders file is swallowed here on purpose — a broken
+ * prompt is worse than a missing reminder — while `agents reminders` surfaces it.
+ */
+export declare function resolveReminderPart(sessionId?: string): string;
 export declare function runClaudeStatusLine(): Promise<number>;
 export declare function installClaudeStatusLine(versionHome: string): {
     changed: boolean;

package/dist/lib/claude-statusline.js

@@ -5,6 +5,7 @@ import { spawnSync } from 'child_process';
 import { readClaudeHomeConfig } from './agent-spec/agents.js';
 import { atomicWriteFileSync } from './fs-atomic.js';
 import { mergeClaudeUsageCacheWindows } from './accounting/usage.js';
+import { loadReminders, pickReminderForSession } from './reminders.js';
 export const CLAUDE_STATUSLINE_COMMAND = 'agents __claude-statusline';
 const DELEGATE_FILE = path.join('.agents', 'claude-statusline-delegate');
 // The private subcommand this feature runs. It is only ever invoked internally,
@@ -103,7 +104,16 @@ export function renderDelegate(payload, versionHome) {
     });
     return result.status === 0 ? result.stdout.trim() : '';
 }
-export function renderClaudeStatusLine(payload, host = os.hostname().split('.')[0] || os.hostname(), delegated = '') {
+/**
+ * Format a reminder as a dimmed statusline part (empty string when none). The
+ * ◆ marker distinguishes it from the host/model/usage parts, and the ANSI dim
+ * keeps it quiet next to the live figures.
+ */
+export function formatReminderPart(short) {
+    const text = short?.trim();
+    return text ? `\x1b[2m◆ ${text}\x1b[22m` : '';
+}
+export function renderClaudeStatusLine(payload, host = os.hostname().split('.')[0] || os.hostname(), delegated = '', reminder = '') {
     const model = payload.model?.display_name?.trim() || payload.model?.id?.trim() || 'model pending';
     const parts = [host, model];
     if (delegated)
@@ -114,8 +124,23 @@ export function renderClaudeStatusLine(payload, host = os.hostname().split('.')[
         parts.push(`5h ${Math.round(fiveHour)}%`);
     if (Number.isFinite(sevenDay))
         parts.push(`7d ${Math.round(sevenDay)}%`);
+    if (reminder)
+        parts.push(reminder);
     return parts.join(' · ');
 }
+/**
+ * Resolve the per-session reminder for the statusline, or '' when none is
+ * configured. A malformed reminders file is swallowed here on purpose — a broken
+ * prompt is worse than a missing reminder — while `agents reminders` surfaces it.
+ */
+export function resolveReminderPart(sessionId) {
+    try {
+        return formatReminderPart(pickReminderForSession(loadReminders(), sessionId)?.short);
+    }
+    catch {
+        return '';
+    }
+}
 export async function runClaudeStatusLine() {
     const raw = await new Promise((resolve, reject) => {
         let input = '';
@@ -135,7 +160,7 @@ export async function runClaudeStatusLine() {
     const versionHome = versionHomeFromEnv(process.env);
     if (versionHome)
         ingestClaudeStatusLineUsage(payload, versionHome);
-    process.stdout.write(renderClaudeStatusLine(payload, undefined, versionHome ? renderDelegate(raw, versionHome) : ''));
+    process.stdout.write(renderClaudeStatusLine(payload, undefined, versionHome ? renderDelegate(raw, versionHome) : '', resolveReminderPart(payload.session_id)));
     return 0;
 }
 export function installClaudeStatusLine(versionHome) {

package/dist/lib/daemon/runner.js

@@ -36,7 +36,7 @@ import { ensureLockTarget } from '../fs-atomic.js';
 import { walkForFiles } from '../fs-walk.js';
 import { getBinaryPath, isVersionInstalled, resolveVersion, getVersionHomePath } from '../installations/versions.js';
 import { resolveClaudeSetupToken } from '../claude-account-token.js';
-import { getConfiguredRunStrategy, resolveRunVersion, resolveAccountVersion, rotationFailoverChain, readinessFromCandidate, formatNoHealthyAccountError, } from '../accounting/rotate.js';
+import { getConfiguredRunStrategy, resolveRunVersion, resolveAccountVersion, rotationFailoverChain, readinessFromCandidate, formatNoHealthyAccountError, formatNoVerifiedUsageError, } from '../accounting/rotate.js';
 import { isHeadedDeviceRole, selfConfiguredDeviceRole } from '../device-config.js';
 import { isSelfUpdatingAgent, ROUTINE_AGENT_IDS, isAgentHardDeprecated, hardDeprecationError } from '../agents.js';
 import { isCustomHarnessName, readProfile } from '../profiles.js';
@@ -959,12 +959,21 @@ export async function resolveRoutineLaunch(config, cwd = process.cwd(), deps = {
     let version;
     let rotation = null;
     let exhausted;
+    let noVerifiedUsage = false;
     try {
         const resolved = await (deps.resolveRunVersion ?? resolveRunVersion)(agent, strategy, cwd);
         version = resolved.version ?? undefined;
         rotation = resolved.rotation;
         exhausted = resolved.exhausted;
-        if (rotation) {
+        noVerifiedUsage = resolved.noVerifiedUsage ?? false;
+        if (noVerifiedUsage) {
+            // Entirely stale usage (PHNX-2526): a routine is unattended, so there is
+            // no picker to divert to — it fails loud below rather than launch on a
+            // stale number. Do NOT log `rotation.picked` as a pick; it is the refused
+            // stale candidate, kept only for the failover chain.
+            process.stderr.write(`[agents] routine ${config.name}: ${strategy} found no ${agent} account with fresh usage — refusing to route on stale data\n`);
+        }
+        else if (rotation) {
             const label = rotation.picked.email
                 ? `${rotation.picked.email} · ${agent}@${rotation.picked.version}`
                 : `${agent}@${rotation.picked.version}`;
@@ -996,6 +1005,12 @@ export async function resolveRoutineLaunch(config, cwd = process.cwd(), deps = {
     if (exhausted) {
         throw new Error(formatNoHealthyAccountError(agent, strategy, exhausted));
     }
+    // Entirely stale usage is also NOT a "fall back to the default pin" case — the
+    // default is exactly the account whose stale number can't be trusted. Fail the
+    // run loud (NO_VERIFIED_USAGE) rather than hammer it every tick (PHNX-2526).
+    if (noVerifiedUsage) {
+        throw new Error(formatNoVerifiedUsageError(agent, strategy, rotation?.healthy ?? []));
+    }
     if (!version) {
         version = resolveVersion(agent, cwd) ?? undefined;
     }

package/dist/lib/devices/doctor-findings.d.ts

@@ -6,7 +6,7 @@ import type { OwnerSinkStatus } from '../channels/owner-sink.js';
 import { type WindowsSshEnrollmentAudit } from './windows-ssh-enrollment.js';
 import type { SyncStatusRow, OrphanRow } from '../drift.js';
 import type { FetchStatusMarker } from '../auto-pull.js';
-import type { VersionResourceReport } from '../doctor-diff.js';
+import { type VersionResourceReport } from '../doctor-diff.js';
 import type { FleetDivergence, FleetHookRuntimeState, FleetVersionSignIn } from './fleet-divergence.js';
 export type FindingSeverity = 'critical' | 'warning';
 /** A machine-stable class for a finding — drives {@link remediationFor} and lets

package/dist/lib/devices/doctor-findings.js

@@ -44,6 +44,24 @@ import { loginHint } from '../signin-badge.js';
 import { CONFIG_ENV_ISOLATED_AGENTS } from '../installations/shims.js';
 import { padToWidth, stringWidth } from '../text/width.js';
 import { windowsSshEnrollmentProblem } from './windows-ssh-enrollment.js';
+import { DOCTOR_ALL_KINDS } from '../doctor-diff.js';
+/**
+ * Singular noun per resource kind for finding messages. A naive `kind.replace(/s$/,'')`
+ * mangles `memory` → `memor` and `mcp` → `mcp` inconsistently, so the mapping is
+ * explicit. Keyed by `DoctorKind` so a new kind fails the type check until named.
+ */
+const KIND_SINGULAR = {
+    commands: 'command',
+    skills: 'skill',
+    hooks: 'hook',
+    rules: 'rule',
+    mcp: 'mcp',
+    permissions: 'permission',
+    subagents: 'subagent',
+    plugins: 'plugin',
+    workflows: 'workflow',
+    memory: 'memory',
+};
 const AGENT_NAMES = Object.fromEntries(ALL_AGENT_IDS.map((id) => [id, AGENTS[id].name]));
 /** Agents with NO per-version credential isolation: their login is shared across
  *  every installed version, so a "log into THIS version" remediation would be a
@@ -87,8 +105,8 @@ export const ALL_FINDING_KINDS = [
     'hook-runtime-broken', // a wired hook's generated shim wrapper is missing/unusable
     'hook-runtime-visibility-unavailable', // remote CLI cannot report generated wrapper health
     'cli-missing', // a managed agent whose binary won't resolve
-    'missing-resource', // a missing command/skill/rule/mcp/permission/subagent
-    'content-drift', // a resource diverged from source
+    'missing-resource', // a missing command/skill/rule/mcp/permission/subagent/workflow/memory
+    'content-drift', // a resource (any synced kind) diverged from source
     'never-synced', // installed but never synced
     'stale', // sources changed since last sync
     'repo-behind', // a config repo behind origin
@@ -392,8 +410,8 @@ export function buildLocalFindings(input) {
         const missingPlugins = [];
         const missingOther = [];
         const drifted = [];
-        for (const kind of ['commands', 'skills', 'hooks', 'rules', 'mcp', 'permissions', 'subagents', 'plugins', 'promptcuts']) {
-            const singular = kind.replace(/s$/, '');
+        for (const kind of DOCTOR_ALL_KINDS) {
+            const singular = KIND_SINGULAR[kind];
             for (const r of report.kinds[kind] ?? []) {
                 if (r.status === 'missing') {
                     if (kind === 'hooks')

package/dist/lib/doctor-diff.d.ts

@@ -9,21 +9,37 @@
  *   - missing  — resolved source exists, not present in home
  *   - extra    — present in home, no source in any layer
  *
- * Coverage:
+ * Coverage — every kind `syncResourcesToVersion` writes is content-aware, so a
+ * byte change under an unchanged name is `diff`, never a false `ok` (PHNX-3504):
  *   commands, skills, hooks, rules — full content compare with source layer.
- *   mcp, permissions, subagents, plugins, promptcuts — presence-only.
+ *   mcp        — structural compare of the home server def vs resolved source.
+ *   subagents  — re-render source through the registry transform, byte-compare.
+ *   workflows  — layout-aware per-harness content compare (dir tree or file).
+ *   memory     — knowledge facts (~/.agents/memory/*.md), per-fact byte-compare.
+ *   plugins    — per-item content compare of the marketplace mirror.
+ *   permissions — per-rule compare in the harness's native vocabulary for the
+ *     representable harnesses (claude/opencode/cursor/droid/openclaw); the lossy
+ *     TOML/flag harnesses stay presence-only with an honest `detail`, never a
+ *     faked `ok`.
+ * A completeness test binds `DOCTOR_ALL_KINDS` to the writer set so a future
+ * synced kind cannot silently become a blind spot. `promptcuts` is NOT a kind —
+ * it is not version-scoped, so there is nothing per-home to diff.
  *
  * Intentional asymmetries (must mirror sync):
  *   - hooks ignore the project layer (`syncResourcesToVersion` skips
  *     project/.agents/hooks/ for safety).
- *   - rules/AGENTS.md on agents without native @-import support is compared
- *     against the compiled artifact, not the raw source file.
+ *   - rules/AGENTS.md is compared against the preset composition the rules writer
+ *     emits (`composeRulesFromState`), re-rendered from the current `subrules/`
+ *     fragments — so a fragment edit is caught even though `rules/AGENTS.md`
+ *     never changed. A non-@-import home compiled by `agents refresh-rules`
+ *     carries a leading `COMPILED_HEADER`, which is stripped before comparing so
+ *     a header-compiled home still reconciles (the header is not source content).
  */
 import type { AgentId } from './types.js';
 import type { DiscoveredPlugin } from './types.js';
 import { type HookWiringReport } from './hooks/install.js';
 import { type ResourceInventory } from './resource-inventory.js';
-export type DoctorKind = 'commands' | 'skills' | 'hooks' | 'rules' | 'mcp' | 'permissions' | 'subagents' | 'plugins' | 'promptcuts';
+export type DoctorKind = 'commands' | 'skills' | 'hooks' | 'rules' | 'mcp' | 'permissions' | 'subagents' | 'plugins' | 'workflows' | 'memory';
 export type DiffStatus = 'ok' | 'diff' | 'missing' | 'extra';
 export type SourceLayer = 'project' | 'user' | 'system' | 'extra';
 export interface ResourceDiff {

package/dist/lib/doctor-diff.js

@@ -9,21 +9,44 @@
  *   - missing  — resolved source exists, not present in home
  *   - extra    — present in home, no source in any layer
  *
- * Coverage:
+ * Coverage — every kind `syncResourcesToVersion` writes is content-aware, so a
+ * byte change under an unchanged name is `diff`, never a false `ok` (PHNX-3504):
  *   commands, skills, hooks, rules — full content compare with source layer.
- *   mcp, permissions, subagents, plugins, promptcuts — presence-only.
+ *   mcp        — structural compare of the home server def vs resolved source.
+ *   subagents  — re-render source through the registry transform, byte-compare.
+ *   workflows  — layout-aware per-harness content compare (dir tree or file).
+ *   memory     — knowledge facts (~/.agents/memory/*.md), per-fact byte-compare.
+ *   plugins    — per-item content compare of the marketplace mirror.
+ *   permissions — per-rule compare in the harness's native vocabulary for the
+ *     representable harnesses (claude/opencode/cursor/droid/openclaw); the lossy
+ *     TOML/flag harnesses stay presence-only with an honest `detail`, never a
+ *     faked `ok`.
+ * A completeness test binds `DOCTOR_ALL_KINDS` to the writer set so a future
+ * synced kind cannot silently become a blind spot. `promptcuts` is NOT a kind —
+ * it is not version-scoped, so there is nothing per-home to diff.
  *
  * Intentional asymmetries (must mirror sync):
  *   - hooks ignore the project layer (`syncResourcesToVersion` skips
  *     project/.agents/hooks/ for safety).
- *   - rules/AGENTS.md on agents without native @-import support is compared
- *     against the compiled artifact, not the raw source file.
+ *   - rules/AGENTS.md is compared against the preset composition the rules writer
+ *     emits (`composeRulesFromState`), re-rendered from the current `subrules/`
+ *     fragments — so a fragment edit is caught even though `rules/AGENTS.md`
+ *     never changed. A non-@-import home compiled by `agents refresh-rules`
+ *     carries a leading `COMPILED_HEADER`, which is stripped before comparing so
+ *     a header-compiled home still reconciles (the header is not source content).
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import { AGENTS, agentConfigDirName } from './agents.js';
-import { getProjectAgentsDir, getUserAgentsDir, getSystemAgentsDir, getEnabledExtraRepos, getResolvedRulesDir, getUserRulesDir, getEffectivePromptcutsPath, getActiveRulesPreset, } from './state.js';
+import { AGENTS, agentConfigDirName, getMcpConfigPathForHome } from './agents.js';
+import { getProjectAgentsDir, getUserAgentsDir, getSystemAgentsDir, getEnabledExtraRepos, getResolvedRulesDir, getUserRulesDir, getActiveRulesPreset, } from './state.js';
 import { composeRulesFromState } from './rules/compose.js';
+import { COMPILED_HEADER, supportsRulesImports } from './rules/compile.js';
+import { dirsContentMatch, filesContentMatch } from './resource-content-diff.js';
+import { subagentContentMatches } from './subagents-registry.js';
+import { getMcpServersByName, mcpServerMatches } from './mcp.js';
+import { permissionsGroupMatches, PERMISSIONS_REPRESENTABLE } from './permissions.js';
+import { workflowContentMatches, resolveWorkflowRef } from './workflows.js';
+import { listMemoryFacts, memoryTargetDir } from './memory.js';
 import { getAvailableResources, getActuallySyncedResources, getVersionHomePath, compareVersions, } from './installations/versions.js';
 import { discoverPlugins, marketplaceSpecForName } from './plugins/plugins.js';
 import { pluginInstallDir, repairableManifestFields } from './plugins/plugin-marketplace.js';
@@ -47,7 +70,8 @@ const ALL_KINDS = [
     'permissions',
     'subagents',
     'plugins',
-    'promptcuts',
+    'workflows',
+    'memory',
 ];
 function normalize(content) {
     return content.replace(/\r\n/g, '\n').trim();
@@ -121,6 +145,36 @@ function buildLayerBases(cwd, kind, opts = {}) {
         out.push({ layer: 'extra', path: path.join(e.dir, kind), alias: e.alias });
     return out;
 }
+/**
+ * Resolve directory-shaped source resources of `kind` by name across the layers
+ * (project > user > system > extra; first layer wins a name collision), keeping
+ * only entries whose directory satisfies `predicate` (e.g. holds `AGENT.md`).
+ */
+function resolveSourceDirsByName(kind, cwd, excludeProject, predicate) {
+    const out = new Map();
+    for (const base of buildLayerBases(cwd, kind, { excludeProject })) {
+        if (!fs.existsSync(base.path))
+            continue;
+        let entries;
+        try {
+            entries = fs.readdirSync(base.path, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith('.'))
+                continue;
+            if (out.has(entry.name))
+                continue;
+            const dir = path.join(base.path, entry.name);
+            if (!predicate(dir))
+                continue;
+            out.set(entry.name, { layer: base.layer, path: dir, alias: base.alias });
+        }
+    }
+    return out;
+}
 // ─── commands ─────────────────────────────────────────────────────────────────
 function diffCommands(agent, version, cwd, excludeProject = false) {
     const agentConfig = AGENTS[agent];
@@ -265,55 +319,6 @@ function diffCommands(agent, version, cwd, excludeProject = false) {
     return rows.sort((a, b) => a.name.localeCompare(b.name));
 }
 // ─── skills ───────────────────────────────────────────────────────────────────
-function dirsContentMatch(src, dst) {
-    const ignore = new Set(['.DS_Store', '.git', '.gitignore', '.venv', '__pycache__', 'node_modules']);
-    const srcEntries = (() => {
-        try {
-            return fs.readdirSync(src, { withFileTypes: true });
-        }
-        catch {
-            return null;
-        }
-    })();
-    const dstEntries = (() => {
-        try {
-            return fs.readdirSync(dst, { withFileTypes: true });
-        }
-        catch {
-            return null;
-        }
-    })();
-    if (!srcEntries || !dstEntries)
-        return false;
-    const filter = (es) => es.filter((e) => !e.isSymbolicLink() && !ignore.has(e.name)).sort((a, b) => a.name.localeCompare(b.name));
-    const srcF = filter(srcEntries);
-    const dstF = filter(dstEntries);
-    if (srcF.length !== dstF.length)
-        return false;
-    for (let i = 0; i < srcF.length; i++) {
-        if (srcF[i].name !== dstF[i].name)
-            return false;
-        const a = path.join(src, srcF[i].name);
-        const b = path.join(dst, dstF[i].name);
-        if (srcF[i].isDirectory()) {
-            if (!dstF[i].isDirectory())
-                return false;
-            if (!dirsContentMatch(a, b))
-                return false;
-        }
-        else if (srcF[i].isFile()) {
-            if (!dstF[i].isFile())
-                return false;
-            const ac = readSafe(a);
-            const bc = readSafe(b);
-            if (ac == null || bc == null)
-                return false;
-            if (normalize(ac) !== normalize(bc))
-                return false;
-        }
-    }
-    return true;
-}
 function diffSkills(agent, version, cwd, excludeProject = false) {
     // Native ~/.agents/skills consumers (Gemini, …) read central skills directly.
     // The orchestrator DELETES their version-home skills dir (syncResourcesToVersion)
@@ -523,11 +528,18 @@ function diffRules(agent, version, cwd, excludeProject = false) {
             continue;
         }
         const expected = expectedRuleContent(agent, name, version, src.path);
-        const actual = readSafe(homePath);
+        let actual = readSafe(homePath);
         if (expected == null || actual == null) {
             rows.push({ kind: 'rules', name, status: 'diff', source: src.layer, sourcePath: src.path, homePath });
             continue;
         }
+        // A non-@-import home compiled by `agents refresh-rules` carries a leading
+        // COMPILED_HEADER the raw preset composition does not. Strip it before the
+        // compare so a header-compiled home still reconciles — the header is
+        // agents-cli provenance, not source content (PHNX-3504).
+        if (name === 'AGENTS' && !supportsRulesImports(agent) && actual.startsWith(COMPILED_HEADER)) {
+            actual = actual.slice(COMPILED_HEADER.length);
+        }
         rows.push({
             kind: 'rules',
             name,
@@ -555,22 +567,175 @@ function diffRules(agent, version, cwd, excludeProject = false) {
     }
     return rows.sort((a, b) => a.name.localeCompare(b.name));
 }
-// ─── presence-only kinds ──────────────────────────────────────────────────────
-function diffPresenceOnly(kind, available, synced) {
+// ─── mcp (content-aware) ────────────────────────────────────────────────────
+function diffMcp(agent, version, cwd, available, synced) {
+    const versionHome = getVersionHomePath(agent, version);
+    const syncedSet = new Set(synced);
     const availableSet = new Set(available);
+    const homePath = getMcpConfigPathForHome(agent, versionHome);
+    // Resolve each available server's source def once (project trust off — this is
+    // a read-only diff, and the writer applies the same servers).
+    const sourceByName = new Map(getMcpServersByName(available, { cwd, enforceProjectTrust: false }).map((s) => [s.name, s]));
+    const rows = [];
+    for (const name of available) {
+        if (!syncedSet.has(name)) {
+            rows.push({ kind: 'mcp', name, status: 'missing', sourcePath: sourceByName.get(name)?.path });
+            continue;
+        }
+        const source = sourceByName.get(name);
+        const matches = source ? mcpServerMatches(agent, versionHome, name, source.config) : false;
+        rows.push({
+            kind: 'mcp',
+            name,
+            status: matches ? 'ok' : 'diff',
+            sourcePath: source?.path,
+            homePath,
+        });
+    }
+    for (const name of synced) {
+        if (!availableSet.has(name))
+            rows.push({ kind: 'mcp', name, status: 'extra', homePath });
+    }
+    return rows.sort((a, b) => a.name.localeCompare(b.name));
+}
+// ─── permissions (content-aware where the native format allows) ──────────────
+function diffPermissions(agent, version, available, synced) {
+    const versionHome = getVersionHomePath(agent, version);
     const syncedSet = new Set(synced);
+    const availableSet = new Set(available);
+    const representable = PERMISSIONS_REPRESENTABLE.has(agent);
     const rows = [];
     for (const name of available) {
+        if (!syncedSet.has(name)) {
+            rows.push({ kind: 'permissions', name, status: 'missing' });
+            continue;
+        }
+        if (representable) {
+            const matches = permissionsGroupMatches(agent, versionHome, name);
+            rows.push({ kind: 'permissions', name, status: matches ? 'ok' : 'diff' });
+        }
+        else {
+            // Lossy TOML/flag harness — the on-disk format carries no faithful
+            // per-group rule provenance, so we can only attest presence. Say so
+            // explicitly rather than fake a verified `ok` (PHNX-3504).
+            rows.push({ kind: 'permissions', name, status: 'ok', detail: 'format cannot verify content' });
+        }
+    }
+    for (const name of synced) {
+        if (!availableSet.has(name))
+            rows.push({ kind: 'permissions', name, status: 'extra' });
+    }
+    return rows.sort((a, b) => a.name.localeCompare(b.name));
+}
+// ─── subagents (content-aware) ───────────────────────────────────────────────
+function diffSubagents(agent, version, cwd, available, synced) {
+    const versionHome = getVersionHomePath(agent, version);
+    const syncedSet = new Set(synced);
+    const availableSet = new Set(available);
+    // Resolve sources across the SAME layers `available` was built from
+    // (getAvailableResources is project-inclusive), so every available name finds
+    // its source dir for the content compare rather than false-diffing.
+    const sourceByName = resolveSourceDirsByName('subagents', cwd, false, (dir) => fs.existsSync(path.join(dir, 'AGENT.md')));
+    const rows = [];
+    for (const name of available) {
+        const src = sourceByName.get(name);
+        if (!syncedSet.has(name)) {
+            rows.push({ kind: 'subagents', name, status: 'missing', source: src?.layer, sourcePath: src?.path });
+            continue;
+        }
+        const matches = src ? subagentContentMatches(agent, versionHome, name, src.path) : false;
         rows.push({
-            kind,
+            kind: 'subagents',
             name,
-            status: syncedSet.has(name) ? 'ok' : 'missing',
+            status: matches ? 'ok' : 'diff',
+            source: src?.layer,
+            sourcePath: src?.path,
         });
     }
     for (const name of synced) {
-        if (availableSet.has(name))
+        if (!availableSet.has(name))
+            rows.push({ kind: 'subagents', name, status: 'extra' });
+    }
+    return rows.sort((a, b) => a.name.localeCompare(b.name));
+}
+// ─── workflows (content-aware) ───────────────────────────────────────────────
+function diffWorkflows(agent, version, cwd, available, synced) {
+    const versionHome = getVersionHomePath(agent, version);
+    const syncedSet = new Set(synced);
+    const availableSet = new Set(available);
+    const rows = [];
+    for (const name of available) {
+        const sourcePath = resolveWorkflowRef(name, cwd);
+        if (!syncedSet.has(name)) {
+            rows.push({ kind: 'workflows', name, status: 'missing', sourcePath: sourcePath ?? undefined });
             continue;
-        rows.push({ kind, name, status: 'extra' });
+        }
+        const matches = sourcePath ? workflowContentMatches(agent, versionHome, name, sourcePath) : false;
+        rows.push({
+            kind: 'workflows',
+            name,
+            status: matches ? 'ok' : 'diff',
+            sourcePath: sourcePath ?? undefined,
+        });
+    }
+    for (const name of synced) {
+        if (!availableSet.has(name))
+            rows.push({ kind: 'workflows', name, status: 'extra' });
+    }
+    return rows.sort((a, b) => a.name.localeCompare(b.name));
+}
+// ─── memory (knowledge facts — content-aware) ────────────────────────────────
+/**
+ * Diff synced knowledge-fact memory (~/.agents/memory/*.md fanned into each
+ * capable home under `memoryTargetDir`). Distinct from the rules-preset list
+ * that overloads `AvailableResources.memory` — this reads the canonical facts
+ * (`listMemoryFacts`) and the home copies bounded by the `.agents-cli-memory.json`
+ * manifest, so an untracked native memory file the user authored is never
+ * mistaken for drift (PHNX-3504).
+ */
+function diffMemory(agent, version, cwd) {
+    if (!supports(agent, 'memory', version).ok)
+        return [];
+    const versionHome = getVersionHomePath(agent, version);
+    const targetDir = path.join(versionHome, memoryTargetDir(agent));
+    const facts = listMemoryFacts(cwd);
+    // The manifest names exactly the fact files agents-cli wrote (plus 'MEMORY').
+    const managedManifestPath = path.join(targetDir, '.agents-cli-memory.json');
+    let managed = [];
+    try {
+        const raw = JSON.parse(fs.readFileSync(managedManifestPath, 'utf-8'));
+        if (Array.isArray(raw.facts))
+            managed = raw.facts.filter((f) => typeof f === 'string');
+    }
+    catch { /* no manifest → nothing managed yet */ }
+    const managedSet = new Set(managed);
+    const rows = [];
+    const factNames = new Set(facts.map((f) => f.name));
+    for (const fact of facts) {
+        const homePath = path.join(targetDir, `${fact.name}.md`);
+        if (!fs.existsSync(homePath)) {
+            rows.push({ kind: 'memory', name: fact.name, status: 'missing', source: fact.layer, sourcePath: fact.path });
+            continue;
+        }
+        const matches = filesContentMatch(fact.path, homePath);
+        rows.push({
+            kind: 'memory',
+            name: fact.name,
+            status: matches ? 'ok' : 'diff',
+            source: fact.layer,
+            sourcePath: fact.path,
+            homePath,
+        });
+    }
+    // A managed fact still on disk but no longer in the canonical set is an orphan
+    // the next sync would prune — surface it as extra. Never flag 'MEMORY' (the
+    // index, always regenerated) or an unmanaged native file (not ours to reconcile).
+    for (const name of managedSet) {
+        if (name === 'MEMORY' || factNames.has(name))
+            continue;
+        const homePath = path.join(targetDir, `${name}.md`);
+        if (fs.existsSync(homePath))
+            rows.push({ kind: 'memory', name, status: 'extra', homePath });
     }
     return rows.sort((a, b) => a.name.localeCompare(b.name));
 }
@@ -683,12 +848,6 @@ function diffPlugins(agent, version, cwd) {
     }
     return rows.sort((a, b) => a.name.localeCompare(b.name));
 }
-function diffPromptcuts() {
-    const sourcePath = getEffectivePromptcutsPath();
-    if (!fs.existsSync(sourcePath))
-        return [];
-    return [{ kind: 'promptcuts', name: 'promptcuts.yaml', status: 'ok', sourcePath }];
-}
 export function diffVersionResources(agent, version, options = {}) {
     const rawCwd = options.cwd ?? process.cwd();
     const excludeProject = options.excludeProject ?? false;
@@ -709,7 +868,8 @@ export function diffVersionResources(agent, version, options = {}) {
         permissions: [],
         subagents: [],
         plugins: [],
-        promptcuts: [],
+        workflows: [],
+        memory: [],
     };
     if (requested.has('commands'))
         empty.commands = diffCommands(agent, version, cwd, excludeProject);
@@ -725,20 +885,26 @@ export function diffVersionResources(agent, version, options = {}) {
     if (requested.has('rules'))
         empty.rules = diffRules(agent, version, cwd, excludeProject);
     if (requested.has('mcp'))
-        empty.mcp = diffPresenceOnly('mcp', available.mcp, synced.mcp);
-    if (requested.has('permissions'))
-        empty.permissions = diffPresenceOnly('permissions', available.permissions, synced.permissions);
+        empty.mcp = diffMcp(agent, version, cwd, available.mcp, synced.mcp);
+    if (requested.has('permissions')) {
+        empty.permissions = diffPermissions(agent, version, supports(agent, 'allowlist', version).ok ? available.permissions : [], synced.permissions);
+    }
     // Subagents are version-gated (e.g. kimi >= 0.29.0). A version below the floor
     // is never written any subagent by the sync writer, so counting the source
     // ones as "missing" is phantom drift no sync can clear (PHNX-3186). Zero the
     // available set when unsupported; a stale installed copy still surfaces `extra`.
     if (requested.has('subagents')) {
-        empty.subagents = diffPresenceOnly('subagents', supports(agent, 'subagents', version).ok ? available.subagents : [], synced.subagents);
+        empty.subagents = diffSubagents(agent, version, cwd, supports(agent, 'subagents', version).ok ? available.subagents : [], synced.subagents);
     }
     if (requested.has('plugins'))
         empty.plugins = diffPlugins(agent, version, cwd);
-    if (requested.has('promptcuts'))
-        empty.promptcuts = diffPromptcuts();
+    // Workflows are version-gated too (e.g. grok >= 0.2.111); zero the available
+    // set below the floor so a source workflow is not phantom-missing drift.
+    if (requested.has('workflows')) {
+        empty.workflows = diffWorkflows(agent, version, cwd, supports(agent, 'workflows', version).ok ? available.workflows : [], synced.workflows);
+    }
+    if (requested.has('memory'))
+        empty.memory = diffMemory(agent, version, cwd);
     let ok = 0, diff = 0, missing = 0, extra = 0;
     for (const list of Object.values(empty)) {
         for (const r of list) {