@phnx-labs/agents-cli 1.20.90 → 1.20.91

package/dist/lib/perf/types.d.ts

@@ -0,0 +1,45 @@
+/** Shared perf sample shape (spool NDJSON + SQLite rows). */
+export type PerfKind = 'hook.fire' | 'perf.timing' | 'command.end' | string;
+export interface PerfSample {
+    tsMs?: number;
+    kind: PerfKind;
+    label: string;
+    durationMs: number;
+    /** Full session id — same string as sessions.id when known. */
+    sessionId?: string;
+    /** First 8 chars of sessionId (sessions.short_id shape). */
+    sessionShort?: string;
+    agent?: string;
+    agentVersion?: string;
+    /** Fleet registry name (sessions.machine), preferred over raw hostname. */
+    machine?: string;
+    hostname?: string;
+    actor?: string;
+    cwd?: string;
+    cache?: string;
+    exitCode?: number;
+    status?: string;
+    metaJson?: string;
+}
+export interface PerfAggregateRow {
+    kind: string;
+    label: string;
+    n: number;
+    p50Ms: number;
+    p99Ms: number;
+    meanMs: number;
+    maxMs: number;
+    minMs: number;
+    cacheHitPct?: number;
+    cacheStalePct?: number;
+    cacheMissPct?: number;
+    errorCount?: number;
+}
+export interface AggregateOptions {
+    days?: number;
+    kinds?: string[];
+    label?: string;
+    machine?: string;
+    agent?: string;
+    minN?: number;
+}

package/dist/lib/perf/types.js

@@ -0,0 +1,2 @@
+/** Shared perf sample shape (spool NDJSON + SQLite rows). */
+export {};

package/dist/lib/routines-project.js

@@ -269,6 +269,12 @@ export function syncProjectRoutines(projectRoot) {
             if (job.devices === undefined && existing.devices && existing.devices.length > 0) {
                 job.devices = existing.devices;
             }
+            // Carry the original creation stamp across. A sync rebuilds the config
+            // from the PROJECT yaml, which never carries `createdAt`, so without this
+            // every `agents routines sync` would re-stamp it to now — walking the
+            // overdue floor forward and hiding real missed fires for project routines.
+            if (existing.createdAt)
+                job.createdAt = existing.createdAt;
         }
         // Placement that leaves the firing machine must pin devices to avoid
         // every fleet daemon dispatching once.

package/dist/lib/routines.d.ts

@@ -122,6 +122,28 @@ export interface JobConfig {
      * overdue; everywhere else it is inert and `run` refuses with a pointer.
      */
     devices?: string[];
+    /**
+     * Whether a fire this device missed (daemon down, laptop asleep, wedged event
+     * loop) is run late. Defaults to true: croner only schedules forward from
+     * "now", so without catch-up a missed fire is simply lost and the routine
+     * silently does not run.
+     *
+     * Set `catchup: false` for a routine whose value is tied to its clock — a
+     * 9am standup brief is worthless at 3pm. An opted-out routine still records
+     * the miss (a `missed` run), it just is not re-run.
+     */
+    catchup?: boolean;
+    /**
+     * When this routine came into existence, ISO 8601. Stamped once by
+     * {@link writeJob}, like `actor`.
+     *
+     * Overdue detection needs it: `detectOverdueJobs` walks back a week for the
+     * most recent expected fire, so without a floor a brand-new routine is
+     * "overdue" for occurrences that happened before it was written. Harmless
+     * when catch-up was a manual command; with auto-catchup it would run every
+     * newly created routine once, immediately.
+     */
+    createdAt?: string;
     /**
      * Environment variables injected into the spawned run, on top of the sandbox
      * overlay's own. Merged by `buildSpawnEnv`, so it applies to both the
@@ -217,7 +239,14 @@ export interface RunMeta {
     pid: number | null;
     /** Process birth time (epoch ms) recorded at spawn for pid-reuse detection. */
     spawnedAt?: number;
-    status: 'running' | 'completed' | 'failed' | 'timeout';
+    /**
+     * `missed` is not an execution outcome — it is the record that a scheduled
+     * fire never happened (the daemon was down, asleep, or wedged when it came
+     * due). Without it a miss leaves no trace at all and the listing keeps
+     * showing the previous run's status as if it were current. Written by
+     * `claimMissedFire` (catchup.ts), never by the runner.
+     */
+    status: 'running' | 'completed' | 'failed' | 'timeout' | 'missed';
     startedAt: string;
     completedAt: string | null;
     exitCode: number | null;

package/dist/lib/routines.js

@@ -274,6 +274,12 @@ export function writeJob(config) {
     // only a brand-new routine (no actor yet) gets the current resolver.
     if (!config.actor)
         config.actor = resolveActor().id;
+    // Stamped once, on first write, and preserved by every later edit (an edit
+    // re-writes a config loaded from disk, which already carries it). This is the
+    // floor overdue detection uses so a routine is never judged against fires
+    // that predate it.
+    if (!config.createdAt)
+        config.createdAt = new Date().toISOString();
     const jobsDir = getRoutinesDir();
     const ymlPath = safeJoin(jobsDir, config.name + '.yml');
     const yamlPath = safeJoin(jobsDir, config.name + '.yaml');
@@ -294,6 +300,8 @@ export function writeJob(config) {
         delete output.enabled;
     if (output.runOnce === false || output.runOnce === undefined)
         delete output.runOnce;
+    if (output.catchup === true || output.catchup === undefined)
+        delete output.catchup;
     const devArr = output.devices;
     if (!devArr || devArr.length === 0)
         delete output.devices;
@@ -515,6 +523,9 @@ export function validateJob(config) {
             }
         }
     }
+    if (config.catchup !== undefined && typeof config.catchup !== 'boolean') {
+        errors.push('catchup must be a boolean (false to skip running a missed fire late)');
+    }
     // Off-box placement without a devices pin fires on every fleet daemon and
     // each dispatches once (RUSH-1980). Enforce the pin at validation so hand
     // edits and devices --clear cannot re-open the hole.

package/dist/lib/secrets/list-filter.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Filters for `agents secrets list`.
+ *
+ * The listing had no filtering at all: `--host`/`--device` pick a machine and
+ * `--json` picks a format, but nothing selected over the bundles themselves. On
+ * a fleet with fifty-odd bundles the answerable questions — which ones read with
+ * no Touch ID at all, which hold a raw literal, which have already expired, what
+ * has not been touched in three months — meant piping the table through grep, or
+ * were simply unanswerable.
+ *
+ * Everything here is pure: parsing produces a `SecretsListFilter`, and
+ * `bundleMatchesFilter` is a predicate over a bundle plus the ambient facts it
+ * cannot derive itself (which bundles the broker currently holds, and the
+ * current time). That keeps the whole surface unit-testable without a keychain.
+ *
+ * Shape follows the `agents sessions` house style: comma-separated lists, an
+ * unknown value is a loud error naming the valid set (never a silent ignore),
+ * and every axis narrows independently so they AND-compose.
+ */
+import { type SecretsBundle, type SecretsPolicy, type SecretsBackend, type SecretType } from './bundles.js';
+/** Ref kinds a var's value can have, from `describeBundle`. */
+export declare const REF_KINDS: readonly ["literal", "keychain", "env", "file", "exec"];
+export type RefKind = typeof REF_KINDS[number];
+/** Default window for `--expiring` with no argument — matches the EXPIRING column. */
+export declare const DEFAULT_EXPIRING_DAYS = 30;
+/** A parsed, validated filter. Every field is optional; absent ⇒ that axis does
+ * not narrow. All present axes must match (AND). */
+export interface SecretsListFilter {
+    /** Case-insensitive substring over bundle name and description. */
+    query?: string;
+    policy?: SecretsPolicy[];
+    backend?: SecretsBackend[];
+    type?: SecretType[];
+    kind?: RefKind[];
+    /** true ⇒ only bundles the broker holds; false ⇒ only those it does not. */
+    held?: boolean;
+    /** Only bundles with at least one var whose `expires` is already past. */
+    expired?: boolean;
+    /** Only bundles with at least one var expiring within this many days. */
+    expiringDays?: number;
+    /** Only bundles whose `last_used` is older than this epoch-ms (or never used). */
+    unusedBefore?: number;
+}
+/** The raw option bag commander hands us. */
+export interface SecretsListFilterOpts {
+    policy?: string;
+    backend?: string;
+    type?: string;
+    kind?: string;
+    held?: boolean;
+    notHeld?: boolean;
+    expired?: boolean;
+    expiring?: string | boolean;
+    unused?: string;
+}
+/**
+ * Validate one comma-separated enum list. An unknown value throws and names the
+ * whole valid set — a silent ignore would let `--policy hodl` quietly return
+ * every bundle, which reads as "nothing matches that" and is worse than an error.
+ * Values are lowercased, matching `parsePolicyOpt`'s handling of policy names.
+ */
+export declare function parseEnumList<T extends string>(raw: string, flag: string, valid: readonly T[]): T[];
+/** Build a validated filter from commander's option bag. Throws on bad input. */
+export declare function parseListFilters(opts: SecretsListFilterOpts, query?: string): SecretsListFilter;
+/** True when any axis is set — used to decide whether the empty state should
+ * explain itself rather than claim there are no bundles at all. */
+export declare function filterIsActive(f: SecretsListFilter): boolean;
+/** Expiry tallies for one bundle: how many vars are already past, and how many
+ * fall due within `withinDays`. */
+export declare function bundleExpiry(b: SecretsBundle, now: number, withinDays?: number): {
+    expired: number;
+    soon: number;
+};
+/** Ambient facts a bundle can't answer about itself. */
+export interface FilterContext {
+    /** Bundle name → hold expiry epoch-ms, from the broker. Empty off macOS. */
+    held: Map<string, number>;
+    now: number;
+}
+/** Does this bundle satisfy every set axis? Pure. */
+export declare function bundleMatchesFilter(b: SecretsBundle, f: SecretsListFilter, ctx: FilterContext): boolean;
+/** Sort fields for `--sort`. `name` is the default and matches `listBundles()`. */
+export declare const SORT_FIELDS: readonly ["name", "used", "created", "updated", "expiry"];
+export type SortField = typeof SORT_FIELDS[number];
+export declare function parseSortField(raw: string | undefined): SortField;
+/** Sort a copy. Time fields are most-recent-first (the useful direction for
+ * "what did I touch lately"); `expiry` is soonest-first; ties fall back to name
+ * so the order is stable. */
+export declare function sortBundles(bundles: SecretsBundle[], field: SortField): SecretsBundle[];
+/** Human summary of the active filters, for the empty state. `sessions` only
+ * echoes --project/--all on a miss, which leaves you guessing which flag emptied
+ * the list; naming every active axis is the difference between "nothing matched"
+ * and knowing what to relax. */
+export declare function describeFilter(f: SecretsListFilter): string;

package/dist/lib/secrets/list-filter.js

@@ -0,0 +1,245 @@
+/**
+ * Filters for `agents secrets list`.
+ *
+ * The listing had no filtering at all: `--host`/`--device` pick a machine and
+ * `--json` picks a format, but nothing selected over the bundles themselves. On
+ * a fleet with fifty-odd bundles the answerable questions — which ones read with
+ * no Touch ID at all, which hold a raw literal, which have already expired, what
+ * has not been touched in three months — meant piping the table through grep, or
+ * were simply unanswerable.
+ *
+ * Everything here is pure: parsing produces a `SecretsListFilter`, and
+ * `bundleMatchesFilter` is a predicate over a bundle plus the ambient facts it
+ * cannot derive itself (which bundles the broker currently holds, and the
+ * current time). That keeps the whole surface unit-testable without a keychain.
+ *
+ * Shape follows the `agents sessions` house style: comma-separated lists, an
+ * unknown value is a loud error naming the valid set (never a silent ignore),
+ * and every axis narrows independently so they AND-compose.
+ */
+import { parseCommaSeparatedList } from '../../commands/utils.js';
+// From the leaf module, NOT discover.js — the latter imports `../sqlite.js`, so
+// reaching through it for one parser would pull node:sqlite into every `agents
+// secrets` invocation and print Node's SQLite ExperimentalWarning on stderr.
+import { parseTimeFilter } from '../session/relative-time.js';
+import { describeBundle, bundlePolicy, SECRET_TYPES, } from './bundles.js';
+/** Ref kinds a var's value can have, from `describeBundle`. */
+export const REF_KINDS = ['literal', 'keychain', 'env', 'file', 'exec'];
+const POLICIES = ['always', 'hold', 'never'];
+const BACKENDS = ['keychain', 'file', 'vault'];
+/** Default window for `--expiring` with no argument — matches the EXPIRING column. */
+export const DEFAULT_EXPIRING_DAYS = 30;
+/**
+ * Validate one comma-separated enum list. An unknown value throws and names the
+ * whole valid set — a silent ignore would let `--policy hodl` quietly return
+ * every bundle, which reads as "nothing matches that" and is worse than an error.
+ * Values are lowercased, matching `parsePolicyOpt`'s handling of policy names.
+ */
+export function parseEnumList(raw, flag, valid) {
+    const parts = parseCommaSeparatedList(raw).map((s) => s.toLowerCase());
+    if (parts.length === 0) {
+        throw new Error(`${flag} requires at least one value. Valid values: ${valid.join(', ')}`);
+    }
+    for (const p of parts) {
+        if (!valid.includes(p)) {
+            throw new Error(`Invalid value "${p}" for ${flag}. Valid values: ${valid.join(', ')}`);
+        }
+    }
+    // De-dup so `--policy hold,hold` behaves like `--policy hold`.
+    return [...new Set(parts)];
+}
+/** Parse `--expiring` — a bare flag means the default window, a value means N days. */
+function parseExpiringDays(raw) {
+    if (raw === undefined || raw === false)
+        return undefined;
+    if (raw === true || raw === '')
+        return DEFAULT_EXPIRING_DAYS;
+    const n = Number(raw);
+    // 0 is rejected rather than accepted as a no-op: the window is `0 <= d < N`,
+    // so `--expiring 0` can never match anything, not even a key expiring today.
+    // A flag that silently returns nothing is worse than one that says why.
+    if (!Number.isFinite(n) || !Number.isInteger(n) || n < 1) {
+        throw new Error(`Invalid --expiring '${raw}'. Use a whole number of days >= 1, e.g. --expiring 7. ` +
+            'For keys that have already lapsed, use --expired.');
+    }
+    return n;
+}
+/** Build a validated filter from commander's option bag. Throws on bad input. */
+export function parseListFilters(opts, query) {
+    if (opts.held && opts.notHeld) {
+        throw new Error('--held and --not-held are mutually exclusive');
+    }
+    const filter = {};
+    const trimmedQuery = query?.trim();
+    if (trimmedQuery)
+        filter.query = trimmedQuery.toLowerCase();
+    if (opts.policy)
+        filter.policy = parseEnumList(opts.policy, '--policy', POLICIES);
+    if (opts.backend)
+        filter.backend = parseEnumList(opts.backend, '--backend', BACKENDS);
+    if (opts.type)
+        filter.type = parseEnumList(opts.type, '--type', SECRET_TYPES);
+    if (opts.kind)
+        filter.kind = parseEnumList(opts.kind, '--kind', REF_KINDS);
+    if (opts.held)
+        filter.held = true;
+    if (opts.notHeld)
+        filter.held = false;
+    if (opts.expired)
+        filter.expired = true;
+    const expiringDays = parseExpiringDays(opts.expiring);
+    if (expiringDays !== undefined)
+        filter.expiringDays = expiringDays;
+    if (opts.unused) {
+        // parseTimeFilter turns '90d' into "the epoch-ms 90 days ago"; a bundle is
+        // unused when its last_used predates that instant.
+        const cutoff = parseTimeFilter(opts.unused);
+        if (!cutoff) {
+            throw new Error(`Invalid --unused '${opts.unused}'. Use e.g. 30d, 4w, 3mo, or an ISO date.`);
+        }
+        filter.unusedBefore = cutoff;
+    }
+    return filter;
+}
+/** True when any axis is set — used to decide whether the empty state should
+ * explain itself rather than claim there are no bundles at all. */
+export function filterIsActive(f) {
+    return Object.keys(f).length > 0;
+}
+/** Whole days from now until end-of-day UTC of an ISO date. Negative once past.
+ * Mirrors the `daysUntil` used by the human render so the filter and the column
+ * can never disagree about whether something has expired. */
+function daysUntil(iso, now) {
+    const target = new Date(`${iso}T23:59:59Z`).getTime();
+    return Math.floor((target - now) / (24 * 60 * 60 * 1000));
+}
+/** Expiry tallies for one bundle: how many vars are already past, and how many
+ * fall due within `withinDays`. */
+export function bundleExpiry(b, now, withinDays = DEFAULT_EXPIRING_DAYS) {
+    let expired = 0;
+    let soon = 0;
+    for (const m of Object.values(b.meta ?? {})) {
+        if (!m.expires)
+            continue;
+        const d = daysUntil(m.expires, now);
+        if (d < 0)
+            expired++;
+        else if (d < withinDays)
+            soon++;
+    }
+    return { expired, soon };
+}
+/** Does this bundle satisfy every set axis? Pure. */
+export function bundleMatchesFilter(b, f, ctx) {
+    if (f.query) {
+        const haystack = `${b.name} ${b.description ?? ''}`.toLowerCase();
+        if (!haystack.includes(f.query))
+            return false;
+    }
+    if (f.policy && !f.policy.includes(bundlePolicy(b)))
+        return false;
+    if (f.backend && !f.backend.includes(b.backend ?? 'keychain'))
+        return false;
+    if (f.held !== undefined) {
+        // A lapsed entry is not held — same liveness rule the POLICY column uses.
+        const exp = ctx.held.get(b.name);
+        const isHeld = exp !== undefined && exp > ctx.now;
+        if (isHeld !== f.held)
+            return false;
+    }
+    if (f.type) {
+        const types = Object.values(b.meta ?? {}).map((m) => m.type).filter(Boolean);
+        if (!types.some((t) => f.type.includes(t)))
+            return false;
+    }
+    if (f.kind) {
+        const kinds = describeBundle(b).map((e) => e.kind);
+        if (!kinds.some((k) => f.kind.includes(k)))
+            return false;
+    }
+    if (f.expired || f.expiringDays !== undefined) {
+        const { expired, soon } = bundleExpiry(b, ctx.now, f.expiringDays ?? DEFAULT_EXPIRING_DAYS);
+        if (f.expired && expired === 0)
+            return false;
+        if (f.expiringDays !== undefined && soon === 0)
+            return false;
+    }
+    if (f.unusedBefore !== undefined) {
+        // Never used counts as unused — it is the strongest form of the answer.
+        if (b.last_used && new Date(b.last_used).getTime() >= f.unusedBefore)
+            return false;
+    }
+    return true;
+}
+/** Sort fields for `--sort`. `name` is the default and matches `listBundles()`. */
+export const SORT_FIELDS = ['name', 'used', 'created', 'updated', 'expiry'];
+export function parseSortField(raw) {
+    if (!raw)
+        return 'name';
+    const v = raw.toLowerCase();
+    if (!SORT_FIELDS.includes(v)) {
+        throw new Error(`Invalid --sort '${raw}'. Valid values: ${SORT_FIELDS.join(', ')}`);
+    }
+    return v;
+}
+/** Epoch-ms of a bundle's soonest expiry, or Infinity when nothing expires — so
+ * `--sort expiry` puts the most urgent first and never-expiring bundles last. */
+function soonestExpiry(b) {
+    let soonest = Infinity;
+    for (const m of Object.values(b.meta ?? {})) {
+        if (!m.expires)
+            continue;
+        const t = new Date(`${m.expires}T23:59:59Z`).getTime();
+        if (t < soonest)
+            soonest = t;
+    }
+    return soonest;
+}
+/** Sort a copy. Time fields are most-recent-first (the useful direction for
+ * "what did I touch lately"); `expiry` is soonest-first; ties fall back to name
+ * so the order is stable. */
+export function sortBundles(bundles, field) {
+    const stamp = (iso) => (iso ? new Date(iso).getTime() : 0);
+    const byName = (a, z) => a.name.localeCompare(z.name);
+    const out = [...bundles];
+    if (field === 'name')
+        return out.sort(byName);
+    out.sort((a, z) => {
+        if (field === 'expiry') {
+            const d = soonestExpiry(a) - soonestExpiry(z);
+            return d !== 0 ? d : byName(a, z);
+        }
+        const key = field === 'used' ? 'last_used' : field === 'created' ? 'created_at' : 'updated_at';
+        const d = stamp(z[key]) - stamp(a[key]);
+        return d !== 0 ? d : byName(a, z);
+    });
+    return out;
+}
+/** Human summary of the active filters, for the empty state. `sessions` only
+ * echoes --project/--all on a miss, which leaves you guessing which flag emptied
+ * the list; naming every active axis is the difference between "nothing matched"
+ * and knowing what to relax. */
+export function describeFilter(f) {
+    const parts = [];
+    if (f.query)
+        parts.push(`matching "${f.query}"`);
+    if (f.policy)
+        parts.push(`policy ${f.policy.join('/')}`);
+    if (f.backend)
+        parts.push(`backend ${f.backend.join('/')}`);
+    if (f.type)
+        parts.push(`type ${f.type.join('/')}`);
+    if (f.kind)
+        parts.push(`kind ${f.kind.join('/')}`);
+    if (f.held === true)
+        parts.push('currently held');
+    if (f.held === false)
+        parts.push('not currently held');
+    if (f.expired)
+        parts.push('with an expired key');
+    if (f.expiringDays !== undefined)
+        parts.push(`expiring within ${f.expiringDays}d`);
+    if (f.unusedBefore !== undefined)
+        parts.push('unused since the given cutoff');
+    return parts.join(', ');
+}

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

@@ -13,6 +13,13 @@ export interface FileChange {
     path: string;
     op: FileOp;
 }
+/**
+ * Path-shaped noise that must never surface as a session "change": shell
+ * redirect tokens (`2>&1`), unexpanded env-var prefixes (`$WT/...`), dependency
+ * dirs (`node_modules`), and agents-cli's internal `.system` marker. Filtered at
+ * the source so every consumer (summary, picker, digest counts) agrees.
+ */
+export declare function isNoisePath(p: string): boolean;
 /** Extract file paths deleted by a shell command (rm / git rm / unlink). Conservative. */
 export declare function extractDeletedPaths(command: string): string[];
 /**

package/dist/lib/session/digest.js

@@ -12,6 +12,29 @@
 const READ_TOOLS = new Set(['Read', 'read_file', 'view_file', 'cat_file', 'get_file']);
 const WRITE_TOOLS = new Set(['Write', 'write_file', 'create_file']);
 const EDIT_TOOLS = new Set(['Edit', 'edit_file', 'replace', 'patch', 'MultiEdit', 'apply_patch']);
+/**
+ * Path-shaped noise that must never surface as a session "change": shell
+ * redirect tokens (`2>&1`), unexpanded env-var prefixes (`$WT/...`), dependency
+ * dirs (`node_modules`), and agents-cli's internal `.system` marker. Filtered at
+ * the source so every consumer (summary, picker, digest counts) agrees.
+ */
+export function isNoisePath(p) {
+    if (!p)
+        return true;
+    if (/^\d+>[&/]?/.test(p))
+        return true; // 2>&1, 1>&2, 2>/dev/null
+    if (p.includes('>&'))
+        return true;
+    if (p.startsWith('$') || p.startsWith('"$') || p.startsWith("'$"))
+        return true; // unexpanded $VAR
+    if (/(^|\/)node_modules(\/|$)/.test(p))
+        return true;
+    if (/(^|\/)\.system$/.test(p))
+        return true;
+    if (p.includes('/.agents/.history/'))
+        return true; // agents-cli internal archives
+    return false;
+}
 /** Extract file paths deleted by a shell command (rm / git rm / unlink). Conservative. */
 export function extractDeletedPaths(command) {
     const out = [];
@@ -25,7 +48,10 @@ export function extractDeletedPaths(command) {
                 continue; // flags (-r, -f, --force)
             if (/[*?{}]/.test(tok))
                 continue; // globs — too imprecise to attribute
-            out.push(tok.replace(/^['"]|['"]$/g, '')); // unquote
+            const p = tok.replace(/^['"]|['"]$/g, ''); // unquote
+            if (isNoisePath(p))
+                continue;
+            out.push(p);
         }
     }
     return out;
@@ -57,6 +83,8 @@ export function classifyFileChanges(events) {
             continue;
         if (p.includes('.claude/plans/') && p.endsWith('.md'))
             continue;
+        if (isNoisePath(p))
+            continue;
         if (READ_TOOLS.has(tool)) {
             readBefore.add(p);
         }

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

@@ -674,5 +674,4 @@ export declare function readGrokMeta(filePath: string, currentVersion?: string):
     meta: SessionMeta;
     content: string;
 } | null;
-/** Parse a time filter string (relative like '7d' or ISO timestamp) into epoch milliseconds. */
-export declare function parseTimeFilter(input: string): number;
+export { parseTimeFilter } from './relative-time.js';

package/dist/lib/session/discover.js

@@ -16,6 +16,7 @@ import { promisify } from 'util';
 import Database from '../sqlite.js';
 import { getAgentsDir, getUserAgentsDir, getHistoryDir, getRunsDir } from '../state.js';
 import { shortCodexHome } from '../codex-home.js';
+import { parseTimeFilter } from './relative-time.js';
 const execFileAsync = promisify(execFile);
 import { AGENTS, agentConfigDirName, getCliVersion } from '../agents.js';
 import { walkForFilesWithStat } from '../fs-walk.js';
@@ -4117,27 +4118,9 @@ export function readGrokMeta(filePath, currentVersion) {
     };
     return { meta, content: topic || '' };
 }
-/** Parse a time filter string (relative like '7d' or ISO timestamp) into epoch milliseconds. */
-export function parseTimeFilter(input) {
-    // Units: m=minute, h=hour, d=day, w=week, mo=month(30d), y=year(365d). `mo`
-    // must precede the single-letter alternatives so "1mo" isn't read as "1m"+"o".
-    const relativeMatch = input.match(/^(\d+)(mo|[mhdwy])$/i);
-    if (relativeMatch) {
-        const value = parseInt(relativeMatch[1], 10);
-        const unit = relativeMatch[2].toLowerCase();
-        if (unit === 'm')
-            return Date.now() - value * 60_000;
-        if (unit === 'h')
-            return Date.now() - value * 3_600_000;
-        if (unit === 'd')
-            return Date.now() - value * 86_400_000;
-        if (unit === 'w')
-            return Date.now() - value * 7 * 86_400_000;
-        if (unit === 'mo')
-            return Date.now() - value * 30 * 86_400_000;
-        if (unit === 'y')
-            return Date.now() - value * 365 * 86_400_000;
-    }
-    const ts = new Date(input).getTime();
-    return Number.isNaN(ts) ? 0 : ts;
-}
+// parseTimeFilter moved to ./relative-time.js — a leaf module — so a caller that
+// only needs the duration parser does not pull this file's `../sqlite.js` import
+// (and Node's SQLite ExperimentalWarning on stderr) into its module graph.
+// Re-exported so every existing importer keeps working unchanged. Imported too,
+// because a bare re-export does not bind the name for this file's own callers.
+export { parseTimeFilter } from './relative-time.js';