@phnx-labs/agents-cli 1.22.112 → 1.22.114

package/dist/lib/redact.js

@@ -47,12 +47,103 @@ const SECRET_PATTERNS = [
     [/(https?:\/\/)[^/\s:@]+:[^@\s/]+@/gi, '$1[REDACTED]@'],
     [/\b([A-Z0-9_]*(?:TOKEN|KEY|SECRET|PASSWORD)[A-Z0-9_]*)=("[^"]*"|'[^']*'|\S+)/gi, '$1=[REDACTED]'],
 ];
-const TERMINAL_ESCAPE_REGEX = /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x9d[^\x07\x9c]*(?:\x07|\x9c)|\x1b\[[0-?]*[ -/]*[@-~]|\x9b[0-?]*[ -/]*[@-~]|\x1b[@-_]|[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g;
-/** Remove terminal control sequences from untrusted text before storage or display. */
+const ESC = 0x1b;
+const BEL = 0x07;
+const CSI_8BIT = 0x9b;
+const OSC_8BIT = 0x9d;
+const ST_8BIT = 0x9c;
+/** C0 controls (minus \t \n \r), DEL, and the C1 range. */
+function isControlByte(c) {
+    return (c <= 0x08) || c === 0x0b || c === 0x0c || (c >= 0x0e && c <= 0x1f) || (c >= 0x7f && c <= 0x9f);
+}
+/** End (exclusive) of a CSI parameter/intermediate/final run starting at `i`, or `i` when unterminated. */
+function csiEnd(text, i) {
+    let j = i;
+    while (j < text.length && text.charCodeAt(j) >= 0x30 && text.charCodeAt(j) <= 0x3f)
+        j++;
+    while (j < text.length && text.charCodeAt(j) >= 0x20 && text.charCodeAt(j) <= 0x2f)
+        j++;
+    if (j < text.length && text.charCodeAt(j) >= 0x40 && text.charCodeAt(j) <= 0x7e)
+        return j + 1;
+    return i;
+}
+/**
+ * Remove terminal control sequences from untrusted text before storage or display.
+ *
+ * A single forward scan, not a regex: an OSC lookup for its terminator (BEL or
+ * ESC-\) is the classic polynomial-backtracking shape, and untrusted text can be
+ * built to trigger it. Each character is visited a bounded number of times here.
+ */
 export function sanitizeForTerminal(text) {
     if (!text)
         return text;
-    return text.replace(TERMINAL_ESCAPE_REGEX, '');
+    let out = '';
+    let i = 0;
+    const n = text.length;
+    // Once an 8-bit OSC scan reaches the end without a terminator, no later one can find one either.
+    let noOsc8Terminator = false;
+    while (i < n) {
+        const c = text.charCodeAt(i);
+        if (c === ESC && i + 1 < n) {
+            const next = text.charCodeAt(i + 1);
+            if (next === 0x5d) {
+                // OSC: runs to BEL or ESC-\. Any other ESC aborts the sequence, so the
+                // scan never re-covers ground a later OSC start could claim.
+                let j = i + 2;
+                while (j < n && text.charCodeAt(j) !== BEL && text.charCodeAt(j) !== ESC)
+                    j++;
+                if (j < n && text.charCodeAt(j) === BEL) {
+                    i = j + 1;
+                    continue;
+                }
+                if (j + 1 < n && text.charCodeAt(j) === ESC && text.charCodeAt(j + 1) === 0x5c) {
+                    i = j + 2;
+                    continue;
+                }
+                i += 2;
+                continue;
+            }
+            if (next === 0x5b) {
+                const end = csiEnd(text, i + 2);
+                if (end > i + 2) {
+                    i = end;
+                    continue;
+                }
+                i += 2;
+                continue;
+            }
+            if (next >= 0x40 && next <= 0x5f) {
+                i += 2;
+                continue;
+            }
+            i += 1;
+            continue;
+        }
+        if (c === OSC_8BIT && !noOsc8Terminator) {
+            let j = i + 1;
+            while (j < n && text.charCodeAt(j) !== BEL && text.charCodeAt(j) !== ST_8BIT)
+                j++;
+            if (j < n) {
+                i = j + 1;
+                continue;
+            }
+            noOsc8Terminator = true;
+            i += 1;
+            continue;
+        }
+        if (c === CSI_8BIT) {
+            const end = csiEnd(text, i + 1);
+            i = end > i + 1 ? end : i + 1;
+            continue;
+        }
+        if (isControlByte(c)) {
+            i += 1;
+            continue;
+        }
+        out += text[i];
+        i += 1;
+    }
+    return out;
 }
 /** Env vars whose NAME marks their VALUE as a credential worth masking literally. */
 const SECRET_ENV_NAME = /(?:TOKEN|KEY|SECRET|PASSWORD)/i;

package/dist/lib/refresh-coordinator.d.ts

@@ -1,5 +1,5 @@
 export declare function setRefreshLockRootForTest(root: string | null): string | null;
-export interface RefreshLeaseOptions<T> {
+interface RefreshLeaseOptions<T> {
     scope: string;
     key: string;
     /**
@@ -22,3 +22,4 @@ export interface RefreshLeaseOptions<T> {
  * async provider request is in flight.
  */
 export declare function withRefreshLease<T>(options: RefreshLeaseOptions<T>): Promise<T>;
+export {};

package/dist/lib/refresh.d.ts

@@ -10,7 +10,7 @@
  * `agents repo refresh` alias.)
  */
 import type { AgentId } from './types.js';
-export interface RefreshOptions {
+interface RefreshOptions {
     /** Limit operations to a single agent (claude/codex/etc). Default: all installed. */
     agentFilter?: AgentId;
     /** Auto-sync everything and skip interactive prompts. */
@@ -37,7 +37,7 @@ export interface RefreshOptions {
  * visible only on the interactive path — `agents sync --yes` and the
  * `--device all` fan-out reported a clean sync (RUSH-2700).
  */
-export interface RefreshResult {
+interface RefreshResult {
     /** User-facing sentences, one per refused resource, prefixed with the agent. */
     declined: string[];
     /**
@@ -51,3 +51,4 @@ export interface RefreshResult {
     }>;
 }
 export declare function refresh(options?: RefreshOptions): Promise<RefreshResult>;
+export {};

package/dist/lib/remote-agents-json.d.ts

@@ -1,4 +1,4 @@
-export interface RemoteAgentsJsonOptions<T> {
+interface RemoteAgentsJsonOptions<T> {
     args: string[];
     noFanoutEnv: string;
     hosts?: string[];
@@ -46,7 +46,7 @@ export interface RemoteAgentsJsonParseResult<T> {
     items: T[];
     valid: boolean;
 }
-export interface RemoteAgentsJsonResult<T> {
+interface RemoteAgentsJsonResult<T> {
     items: T[];
     deviceCount: number;
     /** Devices that were dialed but answered with an error / no CLI / a timeout. */
@@ -96,3 +96,4 @@ export declare function captureBoundedStdout(child: CapturableChild, { timeoutMs
 }>;
 /** Query explicit hosts, or every registered online peer when hosts is omitted. */
 export declare function gatherRemoteAgentsJson<T>(options: RemoteAgentsJsonOptions<T>, deps?: GatherRemoteAgentsJsonDeps): Promise<RemoteAgentsJsonResult<T>>;
+export {};

package/dist/lib/reserved-stores.d.ts

@@ -2,8 +2,6 @@ import type { SecretsBackend } from './secrets-types.js';
 import { type AgentId } from './types.js';
 /** Legacy readable alias for `__claude__`. Not migrated in this track. */
 export declare const AUTH_STORE_ALIAS = "auth";
-/** The one reserved bundle name most callers actually need. */
-export declare const AUTH_BUNDLE_NAME = "auth";
 /**
  * The reserved `auth` bundle holds per-account Claude setup-tokens for
  * unattended usage/probe and MUST be file-backed (headless, fleet-shareable —

package/dist/lib/reserved-stores.js

@@ -20,8 +20,6 @@ import { bundleExistsSync, bundleBackendSync, isSecretsClientError } from './sec
 import { AGENT_IDS } from './types.js';
 /** Legacy readable alias for `__claude__`. Not migrated in this track. */
 export const AUTH_STORE_ALIAS = 'auth';
-/** The one reserved bundle name most callers actually need. */
-export const AUTH_BUNDLE_NAME = AUTH_STORE_ALIAS;
 /**
  * The reserved `auth` bundle holds per-account Claude setup-tokens for
  * unattended usage/probe and MUST be file-backed (headless, fleet-shareable —
@@ -31,7 +29,7 @@ export const AUTH_BUNDLE_NAME = AUTH_STORE_ALIAS;
  * loud instead of silently being ignored by usage/probe (SEC-GAP-3).
  */
 export const AUTH_BUNDLE_BACKEND = 'file';
-export const RESERVED_BUNDLE_NAMES = new Set([AUTH_BUNDLE_NAME]);
+export const RESERVED_BUNDLE_NAMES = new Set([AUTH_STORE_ALIAS]);
 export function isReservedBundleName(name) {
     return RESERVED_BUNDLE_NAMES.has(name.trim().toLowerCase());
 }
@@ -108,13 +106,13 @@ function storableCredentialRefusal(kind, harness) {
 export function inspectReservedAuthBundle() {
     let exists;
     try {
-        exists = bundleExistsSync(AUTH_BUNDLE_NAME);
+        exists = bundleExistsSync(AUTH_STORE_ALIAS);
     }
     catch {
         return { exists: false, backend: null, ok: true };
     }
     if (!exists)
         return { exists: false, backend: null, ok: true };
-    const backend = bundleBackendSync(AUTH_BUNDLE_NAME);
+    const backend = bundleBackendSync(AUTH_STORE_ALIAS);
     return { exists: true, backend, ok: backend === AUTH_BUNDLE_BACKEND };
 }

package/dist/lib/resource-content-diff.d.ts

@@ -15,8 +15,6 @@
  * between two independently-written trees is not reported as content drift. This
  * mirrors the byte compare `diffCommands` / `diffRules` already apply per file.
  */
-/** OS metadata / local tooling that is never synced into a version home. */
-export declare const RESOURCE_CONTENT_IGNORE: Set<string>;
 /** CRLF → LF and trim, so line-ending / trailing-newline skew is not drift. */
 export declare function normalizeResourceContent(content: string): string;
 /**

package/dist/lib/resource-content-diff.js

@@ -18,7 +18,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 /** OS metadata / local tooling that is never synced into a version home. */
-export const RESOURCE_CONTENT_IGNORE = new Set([
+const RESOURCE_CONTENT_IGNORE = new Set([
     '.DS_Store',
     '.git',
     '.gitignore',

package/dist/lib/resource-patterns.d.ts

@@ -11,7 +11,7 @@
  *
  * Evaluation rule: union all inclusions, then subtract all exclusions.
  */
-export interface ParsedPattern {
+interface ParsedPattern {
     negate: boolean;
     source: string;
     name: string;
@@ -39,3 +39,4 @@ export declare function expandPatterns(patterns: string[], available: Map<string
  * @param includeProject  Whether to append "project:*". False for hooks (security).
  */
 export declare function defaultPatterns(extraAliases?: string[], includeProject?: boolean): string[];
+export {};

package/dist/lib/resource-profiles.d.ts

@@ -7,20 +7,14 @@
  */
 import type { ResourceProfilePreset } from './types.js';
 export type ProfiledResourceKind = 'commands' | 'skills' | 'hooks' | 'subagents' | 'plugins' | 'workflows' | 'permissions' | 'mcp' | 'memory' | 'secrets';
-export type PatternedProfileKind = Exclude<ProfiledResourceKind, 'memory' | 'secrets'>;
-export interface ActiveResourceProfile {
+interface ActiveResourceProfile {
     name: string;
     preset: ResourceProfilePreset;
 }
-export declare function validateResourceProfileName(name: string): void;
-export declare function listResourceProfileNames(): string[];
-export declare function getResourceProfilePreset(name: string): ResourceProfilePreset | null;
-export declare function getActiveResourceProfileName(): string | null;
 export declare function getActiveResourceProfile(): ActiveResourceProfile | null;
 export declare function upsertResourceProfilePreset(name: string, preset: ResourceProfilePreset): void;
 export declare function setActiveResourceProfile(name: string | null): void;
-export declare function patternedProfileKinds(): PatternedProfileKind[];
 export declare function activeRulesPreset(): string | null;
 export declare function filterNamesForActiveResourceProfile(kind: ProfiledResourceKind, names: string[], sourceMap?: Map<string, string>): string[];
 export declare function isNameActiveInResourceProfile(kind: ProfiledResourceKind, name: string, source?: string): boolean;
-export declare function assertNameActiveInResourceProfile(kind: ProfiledResourceKind, name: string): void;
+export {};

package/dist/lib/resource-profiles.js

@@ -8,29 +8,16 @@
 import { readMeta, updateMeta } from './state.js';
 import { brandProfileName } from './brand.js';
 const PROFILE_NAME_PATTERN = /^[a-z0-9][a-z0-9-_]{0,48}$/i;
-const PATTERNED_KINDS = [
-    'commands',
-    'skills',
-    'hooks',
-    'subagents',
-    'plugins',
-    'workflows',
-    'permissions',
-    'mcp',
-];
-export function validateResourceProfileName(name) {
+function validateResourceProfileName(name) {
     if (!PROFILE_NAME_PATTERN.test(name)) {
         throw new Error(`Invalid profile name '${name}'. Use letters, digits, dash, underscore (max 48 chars).`);
     }
 }
-export function listResourceProfileNames() {
-    return Object.keys(readMeta().profiles?.presets ?? {}).sort((a, b) => a.localeCompare(b));
-}
-export function getResourceProfilePreset(name) {
+function getResourceProfilePreset(name) {
     validateResourceProfileName(name);
     return readMeta().profiles?.presets?.[name] ?? null;
 }
-export function getActiveResourceProfileName() {
+function getActiveResourceProfileName() {
     // A white-label brand pins its own profile; when running under a brand
     // (AGENTS_BRAND set) that preset wins over the global `profiles.active`, so
     // every resource filter that keys off the active profile becomes brand-scoped.
@@ -75,9 +62,6 @@ export function setActiveResourceProfile(name) {
         },
     }));
 }
-export function patternedProfileKinds() {
-    return [...PATTERNED_KINDS];
-}
 function plainPatternMatches(pattern, name) {
     if (pattern === '*')
         return true;
@@ -146,11 +130,3 @@ export function isNameActiveInResourceProfile(kind, name, source) {
     const sourceMap = source ? new Map([[name, source]]) : undefined;
     return filterNamesForActiveResourceProfile(kind, [name], sourceMap).includes(name);
 }
-export function assertNameActiveInResourceProfile(kind, name) {
-    const active = getActiveResourceProfile();
-    if (!active)
-        return;
-    if (isNameActiveInResourceProfile(kind, name))
-        return;
-    throw new Error(`${kind === 'secrets' ? 'Secrets bundle' : 'Resource'} '${name}' is not active in profile '${active.name}'.`);
-}

package/dist/lib/resources/workflows.d.ts

@@ -6,7 +6,7 @@
  * Resolution order (docs/07-entrypoints): project > user > plugin > extra > system.
  */
 import type { AgentId, ResolvedItem, ResourceHandler } from './types.js';
-export interface WorkflowItem {
+interface WorkflowItem {
     name: string;
     description: string;
     model?: string;

package/dist/lib/resources.d.ts

@@ -43,12 +43,6 @@ export interface ResolvedResource {
      */
     readonly aliases: string[] | undefined;
 }
-/**
- * The declared frontmatter `aliases:` of a single resource, or `[]` for a kind
- * that doesn't support aliases. Only `skills` (SKILL.md) and `commands` carry
- * them today. `resourcePath` is the skill directory or the command file.
- */
-export declare function resourceAliases(kind: ResourceKind, resourcePath: string): string[];
 /**
  * True when `rawName` (a filename with its extension already stripped) names a
  * directory doc rather than a resource of `kind`. Exported so every enumerator
@@ -84,13 +78,13 @@ export interface SkillResourceEntry extends ResourceEntry {
     ruleCount?: number;
 }
 /** An MCP server resource entry. */
-export interface McpResourceEntry {
+interface McpResourceEntry {
     name: string;
     scope: 'user' | 'project';
     version?: string;
 }
 /** All resources installed for a specific agent. */
-export interface AgentResources {
+interface AgentResources {
     agentId: AgentId;
     commands: ResourceEntry[];
     skills: SkillResourceEntry[];
@@ -101,7 +95,7 @@ export interface AgentResources {
     workflows: ResourceEntry[];
 }
 /** Options for resource discovery. */
-export interface GetAgentResourcesOptions {
+interface GetAgentResourcesOptions {
     cwd?: string;
     scope?: 'user' | 'project' | 'all';
     /** For MCP scanning - whether the CLI is installed */
@@ -114,3 +108,4 @@ export interface GetAgentResourcesOptions {
  * This is the source of truth - not the tracking data in agents.yaml.
  */
 export declare function getAgentResources(agentId: AgentId, options?: GetAgentResourcesOptions): AgentResources;
+export {};

package/dist/lib/resources.js

@@ -21,7 +21,7 @@ import { resolveSnapshotSha } from './git.js';
  * that doesn't support aliases. Only `skills` (SKILL.md) and `commands` carry
  * them today. `resourcePath` is the skill directory or the command file.
  */
-export function resourceAliases(kind, resourcePath) {
+function resourceAliases(kind, resourcePath) {
     if (kind === 'skills')
         return parseSkillMetadata(resourcePath)?.aliases ?? [];
     if (kind === 'commands')

package/dist/lib/routine-context.d.ts

@@ -100,10 +100,6 @@ export interface ResolvedExecutionContext {
     /** Present when `ready` is false. */
     readiness?: RoutineReadiness;
 }
-/** Expand a leading `~`/`$HOME` against the target home; pass other values through. */
-export declare function expandTargetHome(home: string, p: string): string;
-/** Rewrite an absolute path under the target home to its portable `~/…` form; pass others through. */
-export declare function toTargetPortable(home: string, abs: string): string;
 /**
  * True for a bare relative path (not absolute, not home-anchored) ON THE TARGET.
  *
@@ -121,7 +117,7 @@ export declare function isBareRelative(home: string, p: string): boolean;
  */
 export declare function resolveRoutineExecutionContext(input: ExecutionContextInput): ResolvedExecutionContext;
 /** Injected harness/target probes for {@link evaluateRoutineReadiness}. */
-export interface HarnessReadinessProbes {
+interface HarnessReadinessProbes {
     /** Is the resolved agent+version installed on the target? */
     agentInstalled?(): boolean;
     /** Is the absolute execution dir a trusted Codex workspace? (Codex agent only.) */
@@ -150,3 +146,4 @@ export declare function evaluateRoutineReadiness(context: ResolvedExecutionConte
     agent?: string;
     version?: string;
 }): RoutineReadinessResult;
+export {};

package/dist/lib/routine-context.js

@@ -50,7 +50,7 @@ function targetPath(home) {
     return /^[A-Za-z]:[\\/]/.test(home) || home.includes('\\') ? path.win32 : path.posix;
 }
 /** Expand a leading `~`/`$HOME` against the target home; pass other values through. */
-export function expandTargetHome(home, p) {
+function expandTargetHome(home, p) {
     if (p === '~' || p === '$HOME')
         return home;
     const tp = targetPath(home);
@@ -61,7 +61,7 @@ export function expandTargetHome(home, p) {
     return p;
 }
 /** Rewrite an absolute path under the target home to its portable `~/…` form; pass others through. */
-export function toTargetPortable(home, abs) {
+function toTargetPortable(home, abs) {
     const tp = targetPath(home);
     const rel = tp.relative(home, abs);
     if (rel === '')

package/dist/lib/routine-notify-owner.d.ts

@@ -4,14 +4,14 @@
  * The desktop lifecycle notifications (routine-notify.ts) never leave the
  * machine, so a failed scheduled routine on a headless fleet box was invisible
  * until someone happened to look. The per-routine prompt pattern (a prompt that
- * ends by shelling `agents notify`) does not close the gap either: when the
+ * ends by shelling `agents send --to owner`) does not close the gap either: when the
  * routine's OWN agent fails to spawn (`auth_failed`) that prompt never runs, so
  * the one failure most worth surfacing is the one that goes unheard.
  *
  * So the DAEMON delivers on failure, from the SAME owner channel stack `agents
- * notify` uses (humans.yaml owner channels, or the legacy `notify.owner`),
+ * send --to owner` uses (humans.yaml owner channels, or the legacy `notify.owner`),
  * calling the channel providers IN-PROCESS — no shelling out to `ssh mac-mini
- * agents notify`. When the primary owner channel cannot deliver from this box it
+ * agents send --to owner`. When the primary owner channel cannot deliver from this box it
  * walks the remaining configured owner channels as fallbacks (OpenClaw, a second
  * channel, …). Telegram is never used.
  *
@@ -45,13 +45,13 @@ export declare function routineFinishOwnerText(meta: Pick<RunMeta, 'jobName' | '
  */
 export declare function routineStartFailedOwnerText(config: Pick<JobConfig, 'name' | 'agent' | 'workflow' | 'command'>, error: string, host: string): string;
 /** One resolved owner destination to attempt, in plan order. */
-export interface OwnerDest {
+interface OwnerDest {
     channel: string;
     to: string;
 }
 /**
  * Ordered owner delivery plan for a failure ping: the primary owner destination
- * (the same one `agents notify` resolves) first, then every other configured
+ * (the same one `agents send --to owner` resolves) first, then every other configured
  * owner channel as a fallback. Deduped by (channel, to). Telegram channels and
  * intrusive channels (a voice call is too much for a routine failure) are
  * excluded entirely — so an owner whose ONLY channel is Telegram gets an empty
@@ -63,12 +63,12 @@ export interface OwnerDest {
  */
 export declare function ownerFailureDeliveryPlan(meta: Meta): OwnerDest[];
 /** Outcome of one delivery attempt, for logging/telemetry. */
-export interface OwnerDeliveryAttempt {
+interface OwnerDeliveryAttempt {
     channel: string;
     ok: boolean;
     error?: string;
 }
-export interface OwnerDeliveryResult {
+interface OwnerDeliveryResult {
     /** True once any channel in the plan accepted the message. */
     delivered: boolean;
     /** The channel that delivered, when `delivered`. */
@@ -100,3 +100,4 @@ export declare function notifyOwnerRoutineFinish(meta: RunMeta): Promise<OwnerDe
  * distinct failure the owner should hear about. Best-effort.
  */
 export declare function notifyOwnerRoutineStartFailed(config: JobConfig, error: string): Promise<OwnerDeliveryResult>;
+export {};

package/dist/lib/routine-notify-owner.js

@@ -4,14 +4,14 @@
  * The desktop lifecycle notifications (routine-notify.ts) never leave the
  * machine, so a failed scheduled routine on a headless fleet box was invisible
  * until someone happened to look. The per-routine prompt pattern (a prompt that
- * ends by shelling `agents notify`) does not close the gap either: when the
+ * ends by shelling `agents send --to owner`) does not close the gap either: when the
  * routine's OWN agent fails to spawn (`auth_failed`) that prompt never runs, so
  * the one failure most worth surfacing is the one that goes unheard.
  *
  * So the DAEMON delivers on failure, from the SAME owner channel stack `agents
- * notify` uses (humans.yaml owner channels, or the legacy `notify.owner`),
+ * send --to owner` uses (humans.yaml owner channels, or the legacy `notify.owner`),
  * calling the channel providers IN-PROCESS — no shelling out to `ssh mac-mini
- * agents notify`. When the primary owner channel cannot deliver from this box it
+ * agents send --to owner`. When the primary owner channel cannot deliver from this box it
  * walks the remaining configured owner channels as fallbacks (OpenClaw, a second
  * channel, …). Telegram is never used.
  *
@@ -92,7 +92,7 @@ function isTelegramChannel(channelId, meta, humansTransport) {
 }
 /**
  * Ordered owner delivery plan for a failure ping: the primary owner destination
- * (the same one `agents notify` resolves) first, then every other configured
+ * (the same one `agents send --to owner` resolves) first, then every other configured
  * owner channel as a fallback. Deduped by (channel, to). Telegram channels and
  * intrusive channels (a voice call is too much for a routine failure) are
  * excluded entirely — so an owner whose ONLY channel is Telegram gets an empty
@@ -123,7 +123,7 @@ export function ownerFailureDeliveryPlan(meta) {
         seen.add(key);
         plan.push({ channel: c, to: t });
     };
-    // Primary = the destination `agents notify` would resolve (humans policy →
+    // Primary = the destination `agents send --to owner` would resolve (humans policy →
     // first addressable → legacy notify.owner). Same filters as the fallbacks.
     const primary = readOwnerDest(meta);
     if (primary)

package/dist/lib/routine-process-cleanup.d.ts

@@ -1,5 +1,5 @@
 import type { RunMeta } from './scheduling/routines.js';
-export interface RoutineProcessCleanupOptions {
+interface RoutineProcessCleanupOptions {
     runsDir?: string;
     alive?: (pid: number) => boolean;
     owns?: (meta: RunMeta) => Promise<boolean> | boolean;
@@ -7,3 +7,4 @@ export interface RoutineProcessCleanupOptions {
 }
 /** Reap process groups whose durable run record is already terminal. */
 export declare function reapTerminalRoutineProcesses(opts?: RoutineProcessCleanupOptions): Promise<number[]>;
+export {};

package/dist/lib/routine-readiness.d.ts

@@ -34,8 +34,6 @@ export declare function fireTimeAuthReadiness(agent: string, version: string): R
 export declare function evaluateActivationReadiness(config: JobConfig, deps?: {
     probeAgent?: (agent: string) => boolean;
 }): RoutineReadinessResult;
-/** One-line human summary of a blocked readiness result, with its repair. */
-export declare function formatReadinessBlocker(result: RoutineReadinessResult): string;
 interface RemoteProjectDefinition {
     name: string;
     root?: string;

package/dist/lib/routine-readiness.js

@@ -93,13 +93,6 @@ export function evaluateActivationReadiness(config, deps = {}) {
             : undefined,
     }, { agent: config.agent, version: pinnedLocally });
 }
-/** One-line human summary of a blocked readiness result, with its repair. */
-export function formatReadinessBlocker(result) {
-    if (result.ready || !result.readiness)
-        return 'ready';
-    const { code, message, repair } = result.readiness;
-    return `${code}: ${message}${repair ? `\n  repair: ${repair}` : ''}`;
-}
 /** Parse the target HOME sentinel and the project catalog returned by one SSH call. */
 export function parseRemoteProjectSnapshot(stdout) {
     const lines = stdout.split(/\r?\n/);

package/dist/lib/routines-project.d.ts

@@ -12,21 +12,19 @@
  * `list` shows them as disabled. `syncProjectRoutines` refreshes materialised
  * copies from their source YAML (also invoked on daemon SIGHUP).
  */
-import { type JobConfig, type JobSource } from './scheduling/routines.js';
+import { type JobConfig } from './scheduling/routines.js';
 /** Expand `~/…` and resolve to an absolute path. */
 export declare function expandProjectPath(p: string): string;
 /** Store paths home-relative when under $HOME so they travel across machines. */
 export declare function displayProjectPath(abs: string): string;
 /** Resolve the project root (parent of `.agents/`) from a cwd, or null. */
 export declare function resolveProjectRoot(cwd?: string): string | null;
-/** Git provenance for a project root (best-effort; never throws). */
-export declare function readProjectGitSource(projectRoot: string): Pick<JobSource, 'repo' | 'branch' | 'commit'>;
 /** List project routine YAML files (name + absolute path). */
 export declare function listProjectRoutineFiles(projectRoot: string): Array<{
     name: string;
     path: string;
 }>;
-export interface SyncProjectResult {
+interface SyncProjectResult {
     projectRoot: string;
     synced: string[];
     skipped: Array<{
@@ -105,3 +103,4 @@ export declare function materialiseProjectRoutine(projectRoot: string, name: str
 } | {
     error: string;
 };
+export {};

package/dist/lib/routines-project.js

@@ -49,7 +49,7 @@ export function resolveProjectRoot(cwd = process.cwd()) {
     return path.dirname(agentsDir);
 }
 /** Git provenance for a project root (best-effort; never throws). */
-export function readProjectGitSource(projectRoot) {
+function readProjectGitSource(projectRoot) {
     const abs = expandProjectPath(projectRoot);
     const out = {};
     try {

package/dist/lib/rules/compile.d.ts

@@ -16,18 +16,8 @@ import { type RulesLayer } from './compose.js';
  */
 export declare const COMPILED_HEADER: string;
 export declare const COMPILED_HEADER_PROJECT: string;
-/** Sidecar manifest recording source file hashes for staleness detection. */
-export interface CompileManifest {
-    compiledAt: string;
-    sources: {
-        path: string;
-        sha256: string;
-        mtime?: number;
-        size?: number;
-    }[];
-}
 /** Result of resolving @-imports in a rules file. */
-export interface ResolveResult {
+interface ResolveResult {
     /** Fully-inlined content. */
     content: string;
     /** Absolute paths of every file read during resolution (including the root). */
@@ -55,26 +45,13 @@ export declare function supportsRulesImports(agentId: AgentId): boolean;
  * nothing to compile.
  */
 export declare function isRulesStale(agentId: AgentId, version: string): boolean;
-/**
- * Resolve the source `rules/AGENTS.md` (with all @-imports expanded) and
- * write the result into the version home, alongside a sidecar manifest that
- * records source file hashes for staleness detection.
- *
- * Agents that natively resolve @-imports are skipped (no-op) — their sync
- * uses the standard copyFileSync path in `syncResourcesToVersion`.
- */
-export declare function compileRulesForAgent(agentId: AgentId, version: string): {
-    compiled: boolean;
-    compiledPath: string;
-    sources: number;
-};
 /**
  * Recompile rules if stale. Safe to call on every agent invocation — the
  * staleness check is fast (sha256 of 8-10 small files, ~10-20ms). Returns
  * true if a recompile happened, false otherwise.
  */
 export declare function ensureRulesFresh(agentId: AgentId, version: string): boolean;
-export interface ProjectCompileResult {
+interface ProjectCompileResult {
     /** True when cwd/AGENTS.md was newly written or rewritten. */
     compiled: boolean;
     /** Absolute path to cwd/AGENTS.md. Empty when no project rules dir was present. */
@@ -110,3 +87,4 @@ export declare function compileRulesForProject(cwd: string, opts?: {
     preset?: string;
     layers?: RulesLayer[];
 }): ProjectCompileResult;
+export {};