@zeph-to/cli 1.13.2 → 1.15.0

package/dist/agent-rules-fetch.d.ts

@@ -0,0 +1,33 @@
+import { type DetectionManifest } from './agent-state.js';
+export declare const RULES_CACHE_FILE: string;
+export declare const RULES_REFRESH_INTERVAL_MS: number;
+/**
+ * Structural validation of an untrusted manifest. Engine-version gate
+ * included: a manifest authored for a future engine is rejected whole —
+ * partial interpretation of unknown semantics is worse than falling
+ * back to bundled rules.
+ */
+export declare const validateManifest: (value: unknown) => DetectionManifest | null;
+export type ManifestSource = 'remote' | 'cache' | 'bundled';
+export declare const getActiveManifest: () => DetectionManifest;
+export declare const getActiveManifestSource: () => ManifestSource;
+/** Test hook. */
+export declare const resetActiveManifest: () => void;
+/**
+ * Startup path (synchronous): promote the disk cache if it validates,
+ * else stay on bundled. Never throws — detection must work offline.
+ */
+export declare const loadManifestFromCache: () => ManifestSource;
+export declare const rulesUrl: () => string;
+export interface RefreshResult {
+    source: ManifestSource;
+    /** 'updated' | 'not-modified' | 'invalid' | 'error' — for verbose logs. */
+    outcome: string;
+    version?: string;
+}
+/**
+ * One refresh attempt: conditional GET, validate, persist, activate.
+ * All failure modes degrade to the current active manifest.
+ */
+export declare const refreshManifest: (fetchImpl?: typeof fetch) => Promise<RefreshResult>;
+//# sourceMappingURL=agent-rules-fetch.d.ts.map

package/dist/agent-rules-fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-rules-fetch.d.ts","sourceRoot":"","sources":["../src/agent-rules-fetch.ts"],"names":[],"mappings":"AAeA,OAAO,EAEH,KAAK,iBAAiB,EACzB,MAAM,kBAAkB,CAAC;AAG1B,eAAO,MAAM,gBAAgB,QAAuC,CAAC;AACrE,eAAO,MAAM,yBAAyB,QAAqB,CAAC;AA6C5D;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,OAAO,KAAG,iBAAiB,GAAG,IAWrE,CAAC;AAIF,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,CAAC;AAK5D,eAAO,MAAM,iBAAiB,QAAO,iBAAmC,CAAC;AACzE,eAAO,MAAM,uBAAuB,QAAO,cAA8B,CAAC;AAS1E,iBAAiB;AACjB,eAAO,MAAM,mBAAmB,QAAO,IAEtC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,qBAAqB,QAAO,cAWxC,CAAC;AAWF,eAAO,MAAM,QAAQ,QAAO,MAK3B,CAAC;AAEF,MAAM,WAAW,aAAa;IAC1B,MAAM,EAAE,cAAc,CAAC;IACvB,2EAA2E;IAC3E,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,GAAU,YAAW,OAAO,KAAa,KAAG,OAAO,CAAC,aAAa,CAsC5F,CAAC"}

package/dist/agent-rules-fetch.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refreshManifest = exports.rulesUrl = exports.loadManifestFromCache = exports.resetActiveManifest = exports.getActiveManifestSource = exports.getActiveManifest = exports.validateManifest = exports.RULES_REFRESH_INTERVAL_MS = exports.RULES_CACHE_FILE = void 0;
+/**
+ * OTA delivery for agent detection rules (SPEC-AGENT-AWARENESS §S7).
+ *
+ * Agent UIs change on their release cadence, not ours: when Claude
+ * Code reshapes its status line, detection must be fixable by shipping
+ * DATA, not a new daemon. The listener therefore resolves its manifest
+ * as: valid remote fetch → valid disk cache → bundled defaults. Every
+ * tier fails closed to the next — a dead endpoint, corrupt cache, or
+ * hostile payload can never leave the listener without rules, and
+ * `disabledRuleIds` in a fetched manifest acts as a same-day
+ * kill-switch for a misfiring rule (no release, no restart).
+ */
+const fs_1 = require("fs");
+const path_1 = require("path");
+const config_js_1 = require("./config.js");
+const agent_state_js_1 = require("./agent-state.js");
+const agent_rules_default_js_1 = require("./agent-rules.default.js");
+exports.RULES_CACHE_FILE = (0, path_1.join)(config_js_1.CONFIG_DIR, 'agent-rules.json');
+exports.RULES_REFRESH_INTERVAL_MS = 6 * 60 * 60 * 1000;
+// Fallback only — the manifest path normally derives from the resolved
+// API base so the stage prefix (prod /v1, dev /d1) follows the user's
+// config instead of being hardcoded here.
+const DEFAULT_API_BASE = 'https://api.zeph.to/v1';
+// Matches the server-side serving cap; anything bigger is not a manifest.
+const MAX_MANIFEST_BYTES = 256 * 1024;
+const FETCH_TIMEOUT_MS = 10_000;
+const VALID_STATES = new Set(['working', 'blocked', 'idle', 'unknown']);
+const isStringArray = (v) => Array.isArray(v) && v.every((s) => typeof s === 'string');
+const isCondition = (v) => {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    const c = v;
+    if (c.contains !== undefined && !isStringArray(c.contains))
+        return false;
+    if (c.regex !== undefined && !isStringArray(c.regex))
+        return false;
+    return true;
+};
+const isRule = (v) => {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    const r = v;
+    if (typeof r.id !== 'string' || r.id.length === 0)
+        return false;
+    if (typeof r.state !== 'string' || !VALID_STATES.has(r.state))
+        return false;
+    if (typeof r.priority !== 'number' || !Number.isFinite(r.priority))
+        return false;
+    if (r.region !== undefined && r.region !== 'tail' && r.region !== 'whole')
+        return false;
+    if (r.tailLines !== undefined && (typeof r.tailLines !== 'number' || r.tailLines < 1 || r.tailLines > 200))
+        return false;
+    if (r.contains !== undefined && !isStringArray(r.contains))
+        return false;
+    if (r.regex !== undefined && !isStringArray(r.regex))
+        return false;
+    if (r.any !== undefined && (!Array.isArray(r.any) || !r.any.every(isCondition)))
+        return false;
+    if (r.not !== undefined && (!Array.isArray(r.not) || !r.not.every(isCondition)))
+        return false;
+    if (r.skipStateUpdate !== undefined && typeof r.skipStateUpdate !== 'boolean')
+        return false;
+    return true;
+};
+/**
+ * Structural validation of an untrusted manifest. Engine-version gate
+ * included: a manifest authored for a future engine is rejected whole —
+ * partial interpretation of unknown semantics is worse than falling
+ * back to bundled rules.
+ */
+const validateManifest = (value) => {
+    if (typeof value !== 'object' || value === null)
+        return null;
+    const m = value;
+    if (m.engineVersion !== agent_state_js_1.ENGINE_VERSION)
+        return null;
+    if (typeof m.version !== 'string' || m.version.length === 0)
+        return null;
+    if (m.disabledRuleIds !== undefined && !isStringArray(m.disabledRuleIds))
+        return null;
+    if (typeof m.agents !== 'object' || m.agents === null)
+        return null;
+    for (const rules of Object.values(m.agents)) {
+        if (!Array.isArray(rules) || !rules.every(isRule))
+            return null;
+    }
+    return value;
+};
+exports.validateManifest = validateManifest;
+let activeManifest = agent_rules_default_js_1.DEFAULT_MANIFEST;
+let activeSource = 'bundled';
+const getActiveManifest = () => activeManifest;
+exports.getActiveManifest = getActiveManifest;
+const getActiveManifestSource = () => activeSource;
+exports.getActiveManifestSource = getActiveManifestSource;
+const activateManifest = (manifest, source) => {
+    activeManifest = manifest;
+    activeSource = source;
+    // Old manifest's compiled patterns must not pin memory forever.
+    (0, agent_state_js_1.clearRegexCache)();
+};
+/** Test hook. */
+const resetActiveManifest = () => {
+    activateManifest(agent_rules_default_js_1.DEFAULT_MANIFEST, 'bundled');
+};
+exports.resetActiveManifest = resetActiveManifest;
+/**
+ * Startup path (synchronous): promote the disk cache if it validates,
+ * else stay on bundled. Never throws — detection must work offline.
+ */
+const loadManifestFromCache = () => {
+    try {
+        const cache = JSON.parse((0, fs_1.readFileSync)(exports.RULES_CACHE_FILE, 'utf-8'));
+        const manifest = (0, exports.validateManifest)(cache.manifest);
+        if (manifest) {
+            activateManifest(manifest, 'cache');
+        }
+    }
+    catch {
+        // Missing/corrupt cache — bundled rules carry the session.
+    }
+    return activeSource;
+};
+exports.loadManifestFromCache = loadManifestFromCache;
+const readCachedEtag = () => {
+    try {
+        const cache = JSON.parse((0, fs_1.readFileSync)(exports.RULES_CACHE_FILE, 'utf-8'));
+        return typeof cache.etag === 'string' ? cache.etag : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+const rulesUrl = () => {
+    const override = (0, config_js_1.resolvedEnv)('ZEPH_AGENT_RULES_URL');
+    if (override)
+        return override;
+    const base = (0, config_js_1.resolvedEnv)('ZEPH_BASE_URL') ?? (0, config_js_1.loadConfig)().baseUrl ?? DEFAULT_API_BASE;
+    return `${base.replace(/\/$/, '')}/agent-detection/manifest`;
+};
+exports.rulesUrl = rulesUrl;
+/**
+ * One refresh attempt: conditional GET, validate, persist, activate.
+ * All failure modes degrade to the current active manifest.
+ */
+const refreshManifest = async (fetchImpl = fetch) => {
+    try {
+        const etag = readCachedEtag();
+        const res = await fetchImpl((0, exports.rulesUrl)(), {
+            headers: etag ? { 'If-None-Match': etag } : {},
+            signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+        });
+        if (res.status === 304) {
+            return { source: activeSource, outcome: 'not-modified', version: activeManifest.version };
+        }
+        if (!res.ok) {
+            return { source: activeSource, outcome: 'error' };
+        }
+        const body = await res.text();
+        if (Buffer.byteLength(body, 'utf-8') > MAX_MANIFEST_BYTES) {
+            return { source: activeSource, outcome: 'invalid' };
+        }
+        const manifest = (0, exports.validateManifest)(JSON.parse(body));
+        if (!manifest) {
+            return { source: activeSource, outcome: 'invalid' };
+        }
+        const cache = {
+            etag: res.headers.get('etag') ?? undefined,
+            fetchedAt: new Date().toISOString(),
+            manifest,
+        };
+        try {
+            (0, fs_1.mkdirSync)(config_js_1.CONFIG_DIR, { recursive: true });
+            (0, fs_1.writeFileSync)(exports.RULES_CACHE_FILE, JSON.stringify(cache, null, 2) + '\n');
+        }
+        catch {
+            // Cache write failure is non-fatal: the manifest still
+            // activates for this process lifetime.
+        }
+        activateManifest(manifest, 'remote');
+        return { source: 'remote', outcome: 'updated', version: manifest.version };
+    }
+    catch {
+        return { source: activeSource, outcome: 'error' };
+    }
+};
+exports.refreshManifest = refreshManifest;

package/dist/agent-rules.default.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Bundled default detection rules — the fallback when no OTA manifest
+ * has been fetched (or the fetched one fails validation, §S7).
+ *
+ * Rule content is authored HERE, from observation of each agent's UI.
+ * Do not import or transcribe rules from third-party projects: the
+ * bundled set is original work under this repo's license.
+ *
+ * Claude Code observations behind these rules (UI as of mid-2026):
+ * - While running, the status line shows an "esc to interrupt" hint
+ *   next to the spinner/progress text.
+ * - Blocking dialogs (permission requests, plan approval, question
+ *   forms) render a numbered/arrow-key option list with "esc" as the
+ *   cancel affordance and Enter as the confirm affordance.
+ * - At rest, the input box renders a `❯` prompt and the footer offers
+ *   "? for shortcuts".
+ * - The transcript viewer (ctrl+o) overlays the pane; the agent may
+ *   still be working underneath, so it must not change the state.
+ *
+ * codex/gemini start with no rules: they report `unknown` until a
+ * vetted rule set ships via OTA. Honest ignorance beats guessed state.
+ */
+import { type DetectionManifest } from './agent-state.js';
+export declare const DEFAULT_MANIFEST: DetectionManifest;
+//# sourceMappingURL=agent-rules.default.d.ts.map

package/dist/agent-rules.default.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-rules.default.d.ts","sourceRoot":"","sources":["../src/agent-rules.default.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,EAAkB,KAAK,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE1E,eAAO,MAAM,gBAAgB,EAAE,iBA8D9B,CAAC"}

package/dist/agent-rules.default.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MANIFEST = void 0;
+/**
+ * Bundled default detection rules — the fallback when no OTA manifest
+ * has been fetched (or the fetched one fails validation, §S7).
+ *
+ * Rule content is authored HERE, from observation of each agent's UI.
+ * Do not import or transcribe rules from third-party projects: the
+ * bundled set is original work under this repo's license.
+ *
+ * Claude Code observations behind these rules (UI as of mid-2026):
+ * - While running, the status line shows an "esc to interrupt" hint
+ *   next to the spinner/progress text.
+ * - Blocking dialogs (permission requests, plan approval, question
+ *   forms) render a numbered/arrow-key option list with "esc" as the
+ *   cancel affordance and Enter as the confirm affordance.
+ * - At rest, the input box renders a `❯` prompt and the footer offers
+ *   "? for shortcuts".
+ * - The transcript viewer (ctrl+o) overlays the pane; the agent may
+ *   still be working underneath, so it must not change the state.
+ *
+ * codex/gemini start with no rules: they report `unknown` until a
+ * vetted rule set ships via OTA. Honest ignorance beats guessed state.
+ */
+const agent_state_js_1 = require("./agent-state.js");
+exports.DEFAULT_MANIFEST = {
+    engineVersion: agent_state_js_1.ENGINE_VERSION,
+    version: '2026.07.04.1',
+    agents: {
+        claude: [
+            {
+                // Transcript / verbose-output overlay: freeze state.
+                id: 'claude-transcript-overlay',
+                state: 'unknown',
+                priority: 1000,
+                skipStateUpdate: true,
+                any: [
+                    { contains: ['showing detailed transcript'] },
+                    { contains: ['ctrl+o to toggle'] },
+                ],
+            },
+            {
+                // Blocking dialog: an option list waiting on the user.
+                // "esc" alone is ambiguous (working shows "esc to
+                // interrupt"), so require a selection affordance too.
+                id: 'claude-blocked-dialog',
+                state: 'blocked',
+                priority: 900,
+                contains: ['esc'],
+                any: [
+                    { contains: ['do you want'] },
+                    { contains: ['enter to select'] },
+                    { contains: ['enter to confirm'] },
+                    { contains: ['to navigate'] },
+                ],
+                not: [{ contains: ['esc to interrupt'] }],
+            },
+            {
+                id: 'claude-working-interrupt-hint',
+                state: 'working',
+                priority: 800,
+                contains: ['esc to interrupt'],
+            },
+            {
+                // Idle prompt: `❯` at line start in the tail, with no
+                // dialog affordances around it.
+                id: 'claude-idle-prompt',
+                state: 'idle',
+                priority: 600,
+                regex: ['^\\s*❯'],
+                not: [
+                    { contains: ['do you want'] },
+                    { contains: ['enter to select'] },
+                ],
+            },
+            {
+                // Fallback idle signal when the prompt glyph is themed
+                // away: the shortcuts footer only renders at rest.
+                id: 'claude-idle-shortcuts-footer',
+                state: 'idle',
+                priority: 500,
+                contains: ['? for shortcuts'],
+            },
+        ],
+        codex: [],
+        gemini: [],
+    },
+};

package/dist/agent-state.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Agent state detection engine — classifies a tmux pane's visible text
+ * into `working | blocked | idle | unknown` using declarative rules.
+ *
+ * Design constraints (see zeph/docs/SPEC-AGENT-AWARENESS.md §S1):
+ * - Rules are DATA, not code: they ship bundled but are replaceable
+ *   over the air (§S7), so agent UI changes never require a daemon
+ *   release. Everything here must therefore survive hostile or
+ *   malformed manifests: pattern-length caps, input-size caps, and
+ *   per-rule isolation of regex compile failures.
+ * - Pure functions only. The listener owns timing, tmux, and I/O;
+ *   this module owns classification and flap suppression so both are
+ *   unit-testable without a terminal.
+ * - `done` is deliberately NOT a wire state: "finished but unseen" is
+ *   per-user view state, derived client-side. The daemon reports only
+ *   what it can observe.
+ */
+import type { AgentKind } from './remote-agents.js';
+export type AgentState = 'working' | 'blocked' | 'idle' | 'unknown';
+export interface RuleCondition {
+    /** All strings must appear (case-insensitive). */
+    contains?: string[];
+    /** All patterns must match. */
+    regex?: string[];
+}
+export interface DetectionRule {
+    id: string;
+    state: AgentState;
+    /** Higher wins; first match ends evaluation. */
+    priority: number;
+    /** 'tail' = last N non-empty lines (default), 'whole' = full capture. */
+    region?: 'tail' | 'whole';
+    /** Lines for region 'tail'. Default 10. */
+    tailLines?: number;
+    contains?: string[];
+    regex?: string[];
+    /** At least one condition group must match (OR). */
+    any?: RuleCondition[];
+    /** No condition group may match (exclusion). */
+    not?: RuleCondition[];
+    /**
+     * On match, keep the previous state instead of this rule's state.
+     * For overlay screens (transcript viewer, menus) that would
+     * otherwise pollute the state while the agent is still working.
+     */
+    skipStateUpdate?: boolean;
+}
+export interface DetectionManifest {
+    engineVersion: number;
+    /** Date.revision, e.g. "2026.07.04.1" — for OTA freshness compare. */
+    version: string;
+    /** Kill-switch: rule ids to ignore without shipping a new manifest shape. */
+    disabledRuleIds?: string[];
+    agents: Partial<Record<AgentKind, DetectionRule[]>>;
+}
+export declare const ENGINE_VERSION = 1;
+export interface EvaluationResult {
+    state: AgentState;
+    /** Rule that decided the state — for verbose logs and rule debugging. */
+    ruleId?: string;
+}
+/** Test hook: manifest swaps call this so stale patterns don't pin memory. */
+export declare const clearRegexCache: () => void;
+/**
+ * Classify one pane capture. `prev` feeds skipStateUpdate rules — an
+ * overlay match returns the previous confirmed state unchanged.
+ */
+export declare const evaluateState: (paneText: string, agentKind: AgentKind, manifest: DetectionManifest, prev?: AgentState) => EvaluationResult;
+/**
+ * Safe one-pattern probe for output-match watches (§S5 v2). Same caps
+ * as rule evaluation — user-authored watch patterns are exactly as
+ * untrusted as OTA rules. Returns the matched line for the push body.
+ */
+export declare const findPatternMatch: (pattern: string, paneText: string) => {
+    line: string;
+} | null;
+export interface StateTracker {
+    /** Last CONFIRMED state — what gets reported to the server. */
+    confirmed: AgentState;
+    confirmedAt: number;
+    ruleId?: string;
+    /** Pending different observation awaiting its second sighting. */
+    candidate?: AgentState;
+    candidateRuleId?: string;
+    /** Hash of the pane text behind the last evaluation (skip re-eval). */
+    contentHash?: string;
+}
+/**
+ * Consecutive-confirmation debounce: a NEW state must be observed on
+ * two consecutive cycles (~10 s at the 5 s report interval) before it
+ * replaces the confirmed one. Menus flashed open, mid-render frames,
+ * and scroll artifacts all last one cycle and die as candidates.
+ *
+ * The very first observation confirms immediately — a fresh tracker
+ * has no baseline to protect, and the server treats a session's first
+ * reported state as baseline, not as a transition (§S2).
+ */
+export declare const advanceState: (tracker: StateTracker | undefined, observed: EvaluationResult, now: number) => StateTracker;
+//# sourceMappingURL=agent-state.d.ts.map

package/dist/agent-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-state.d.ts","sourceRoot":"","sources":["../src/agent-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAAC;AAEpE,MAAM,WAAW,aAAa;IAC1B,kDAAkD;IAClD,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,+BAA+B;IAC/B,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,aAAa;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,UAAU,CAAC;IAClB,gDAAgD;IAChD,QAAQ,EAAE,MAAM,CAAC;IACjB,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1B,2CAA2C;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,oDAAoD;IACpD,GAAG,CAAC,EAAE,aAAa,EAAE,CAAC;IACtB,gDAAgD;IAChD,GAAG,CAAC,EAAE,aAAa,EAAE,CAAC;IACtB;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,iBAAiB;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,sEAAsE;IACtE,OAAO,EAAE,MAAM,CAAC;IAChB,6EAA6E;IAC7E,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC;CACvD;AAED,eAAO,MAAM,cAAc,IAAI,CAAC;AAUhC,MAAM,WAAW,gBAAgB;IAC7B,KAAK,EAAE,UAAU,CAAC;IAClB,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAqBD,8EAA8E;AAC9E,eAAO,MAAM,eAAe,QAAO,IAElC,CAAC;AA8BF;;;GAGG;AACH,eAAO,MAAM,aAAa,GACtB,UAAU,MAAM,EAChB,WAAW,SAAS,EACpB,UAAU,iBAAiB,EAC3B,OAAM,UAAsB,KAC7B,gBAuBF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,SAAS,MAAM,EAAE,UAAU,MAAM,KAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAavF,CAAC;AAIF,MAAM,WAAW,YAAY;IACzB,+DAA+D;IAC/D,SAAS,EAAE,UAAU,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kEAAkE;IAClE,SAAS,CAAC,EAAE,UAAU,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,uEAAuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,GACrB,SAAS,YAAY,GAAG,SAAS,EACjC,UAAU,gBAAgB,EAC1B,KAAK,MAAM,KACZ,YAaF,CAAC"}

package/dist/agent-state.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.advanceState = exports.findPatternMatch = exports.evaluateState = exports.clearRegexCache = exports.ENGINE_VERSION = void 0;
+exports.ENGINE_VERSION = 1;
+// OTA manifests are semi-trusted: schema-validated but authored by
+// humans and fetched over the network. Caps bound the worst case of a
+// pathological regex (ReDoS) — a 200-char pattern over ≤8 KiB input
+// keeps even catastrophic backtracking in the low milliseconds.
+const MAX_PATTERN_LENGTH = 200;
+const MAX_INPUT_BYTES = 8 * 1024;
+const DEFAULT_TAIL_LINES = 10;
+// Compiled-regex cache. Rules are static between manifest swaps, so
+// compiling once per (pattern) is enough; a failed compile is cached as
+// null so a bad OTA pattern logs once, not every 5-second cycle.
+const regexCache = new Map();
+const compilePattern = (pattern) => {
+    if (regexCache.has(pattern))
+        return regexCache.get(pattern) ?? null;
+    let compiled = null;
+    if (pattern.length <= MAX_PATTERN_LENGTH) {
+        try {
+            compiled = new RegExp(pattern, 'im');
+        }
+        catch {
+            compiled = null;
+        }
+    }
+    regexCache.set(pattern, compiled);
+    return compiled;
+};
+/** Test hook: manifest swaps call this so stale patterns don't pin memory. */
+const clearRegexCache = () => {
+    regexCache.clear();
+};
+exports.clearRegexCache = clearRegexCache;
+const conditionMatches = (cond, text, lowerText) => {
+    for (const needle of cond.contains ?? []) {
+        if (!lowerText.includes(needle.toLowerCase()))
+            return false;
+    }
+    for (const pattern of cond.regex ?? []) {
+        const compiled = compilePattern(pattern);
+        // A pattern that failed to compile can never be satisfied —
+        // fail the condition rather than silently passing it, so a
+        // broken OTA rule becomes inert instead of over-matching.
+        if (!compiled || !compiled.test(text))
+            return false;
+    }
+    return true;
+};
+const ruleMatches = (rule, text, lowerText) => {
+    if (!conditionMatches({ contains: rule.contains, regex: rule.regex }, text, lowerText))
+        return false;
+    if (rule.any && rule.any.length > 0) {
+        if (!rule.any.some((c) => conditionMatches(c, text, lowerText)))
+            return false;
+    }
+    for (const excluded of rule.not ?? []) {
+        if (conditionMatches(excluded, text, lowerText))
+            return false;
+    }
+    return true;
+};
+const tailOf = (lines, count) => lines.filter((l) => l.trim().length > 0).slice(-count).join('\n');
+/**
+ * Classify one pane capture. `prev` feeds skipStateUpdate rules — an
+ * overlay match returns the previous confirmed state unchanged.
+ */
+const evaluateState = (paneText, agentKind, manifest, prev = 'unknown') => {
+    // Truncate from the FRONT: the bottom of the pane is where every
+    // agent renders its live status, so the tail is the signal.
+    let text = paneText;
+    if (Buffer.byteLength(text, 'utf-8') > MAX_INPUT_BYTES) {
+        text = text.slice(-MAX_INPUT_BYTES);
+    }
+    const lines = text.split('\n');
+    const disabled = new Set(manifest.disabledRuleIds ?? []);
+    const rules = (manifest.agents[agentKind] ?? [])
+        .filter((r) => !disabled.has(r.id))
+        .sort((a, b) => b.priority - a.priority);
+    for (const rule of rules) {
+        const scope = rule.region === 'whole'
+            ? text
+            : tailOf(lines, rule.tailLines ?? DEFAULT_TAIL_LINES);
+        if (ruleMatches(rule, scope, scope.toLowerCase())) {
+            if (rule.skipStateUpdate)
+                return { state: prev, ruleId: rule.id };
+            return { state: rule.state, ruleId: rule.id };
+        }
+    }
+    return { state: 'unknown' };
+};
+exports.evaluateState = evaluateState;
+/**
+ * Safe one-pattern probe for output-match watches (§S5 v2). Same caps
+ * as rule evaluation — user-authored watch patterns are exactly as
+ * untrusted as OTA rules. Returns the matched line for the push body.
+ */
+const findPatternMatch = (pattern, paneText) => {
+    let text = paneText;
+    if (Buffer.byteLength(text, 'utf-8') > MAX_INPUT_BYTES) {
+        text = text.slice(-MAX_INPUT_BYTES);
+    }
+    const compiled = compilePattern(pattern);
+    if (!compiled)
+        return null;
+    const match = compiled.exec(text);
+    if (!match)
+        return null;
+    const start = text.lastIndexOf('\n', match.index) + 1;
+    const endIdx = text.indexOf('\n', match.index);
+    const line = text.slice(start, endIdx === -1 ? undefined : endIdx).trim();
+    return { line };
+};
+exports.findPatternMatch = findPatternMatch;
+/**
+ * Consecutive-confirmation debounce: a NEW state must be observed on
+ * two consecutive cycles (~10 s at the 5 s report interval) before it
+ * replaces the confirmed one. Menus flashed open, mid-render frames,
+ * and scroll artifacts all last one cycle and die as candidates.
+ *
+ * The very first observation confirms immediately — a fresh tracker
+ * has no baseline to protect, and the server treats a session's first
+ * reported state as baseline, not as a transition (§S2).
+ */
+const advanceState = (tracker, observed, now) => {
+    if (!tracker) {
+        return { confirmed: observed.state, confirmedAt: now, ruleId: observed.ruleId };
+    }
+    if (observed.state === tracker.confirmed) {
+        // Re-confirmation clears any pending candidate.
+        return { ...tracker, candidate: undefined, candidateRuleId: undefined, ruleId: observed.ruleId ?? tracker.ruleId };
+    }
+    if (observed.state === tracker.candidate) {
+        // Second consecutive sighting — promote.
+        return { confirmed: observed.state, confirmedAt: now, ruleId: observed.ruleId };
+    }
+    return { ...tracker, candidate: observed.state, candidateRuleId: observed.ruleId };
+};
+exports.advanceState = advanceState;