@cluesmith/codev 3.2.4 → 3.3.0

package/dist/agent-farm/servers/cron-delivery.js

@@ -0,0 +1,80 @@
+/**
+ * Cron message delivery through the mailbox + gate (Spec 1313, Phase 6).
+ *
+ * Cron is today the most unguarded message writer: it wrote straight to the PTY with
+ * no idle check and logged "delivered" unconditionally. This phase makes it an
+ * ordinary mailbox sender — every cron notification is persisted and then delivered
+ * through the SAME single gated path (`deliverAgentMailSerialized`) that `handleSend`
+ * and the backstop drainer use, so a cron message can never land mid-draft or fuse
+ * with a human's half-typed line. There is no force path: a busy/menu/wrapper screen
+ * holds the message for the backstop, exactly like any other send.
+ *
+ * Two cron-specific twists on top of the shared path:
+ *  - **Supersede key = task name** (Baked Decision 6): a newer run of a task replaces
+ *    its own older *held* row instead of queueing a backlog. Supersede keys are
+ *    cron-only in this project — no non-cron send ever supplies one.
+ *  - **Honest run outcome**: the caller logs the real fate (`delivered` / `held` /
+ *    `superseded`) rather than an unconditional "delivered".
+ *
+ * This module holds the registry-free orchestration core behind the Phase-4
+ * {@link DeliveryPorts} seam, so it is unit-testable against a real mailbox DB with
+ * fake edges (no live Tower). The identity resolution that needs the live routing
+ * registry (`resolveTarget` + the architect reverse-map + the dead-session registry
+ * fallback) lives in `tower-routes.ts`'s `deliverCronMessage`, which calls this.
+ */
+import { supersede, getById, countHeldWithKey } from '../db/mailbox.js';
+import { deliverAgentMailSerialized } from './mailbox-delivery.js';
+/** The pseudo-agent identity every cron notification is sent as. */
+export const CRON_SENDER = 'af-cron';
+/**
+ * Persist a cron notification (superseding any still-held row from an earlier run of
+ * the same task) and attempt one gated delivery, returning the run's real outcome.
+ *
+ * The corruption-safety is entirely inherited from {@link deliverAgentMailSerialized}:
+ * the body is only ever written to a render-verified empty prompt, and the per-agent
+ * serializer means a concurrent send can never interleave with this write. A busy or
+ * unclassifiable screen simply leaves the row held for the backstop — there is no
+ * force path here, by construction.
+ */
+export async function deliverCronMail(ports, db, target) {
+    const { workspacePath, toAgent, supersedeKey } = target;
+    // Did an earlier run of this task leave a row still held? Read it BEFORE the
+    // supersede, with no await between, so the pair is atomic on the synchronous DB
+    // handle (see countHeldWithKey). This only informs the log word — the "no backlog"
+    // correctness comes from supersede() being atomic regardless.
+    const replacedPrior = countHeldWithKey(db, workspacePath, supersedeKey) > 0;
+    const row = supersede(db, workspacePath, supersedeKey, {
+        workspacePath,
+        toAgent,
+        terminalId: target.terminalId,
+        body: target.body,
+        formattedMessage: target.formattedMessage,
+        fromAgent: CRON_SENDER,
+        fromWorkspace: workspacePath,
+    }, ports.now());
+    // The held set changed (a new row enqueued, possibly replacing a prior held one) →
+    // refresh the indicator count (Spec 1313, Phase 7). A clean delivery below fires it
+    // again when the row leaves the set; both are cheap, idempotent refetch triggers.
+    ports.onHeldStateChange();
+    try {
+        await deliverAgentMailSerialized(ports, db, workspacePath, toAgent);
+    }
+    catch (err) {
+        // A gate/write error leaves the row HELD (markDelivered only runs on a completed
+        // write); the backstop drainer retries. Mirrors handleSend — never throws upward.
+        ports.log(`[cron] delivery attempt errored for ${toAgent} (row ${row.id.slice(0, 8)}… stays held): ${String(err)}`);
+    }
+    const stored = getById(db, row.id);
+    if (stored?.status === 'delivered') {
+        return { outcome: 'delivered', reason: null, mailboxId: row.id };
+    }
+    // Held. `reason` is set by the delivery pass when it holds; default to `busy` for
+    // the rare case where an older row for the same agent delivered first and left ours
+    // queued behind it (its Enter makes the line busy for the next pass anyway).
+    return {
+        outcome: replacedPrior ? 'superseded' : 'held',
+        reason: stored?.reason ?? 'busy',
+        mailboxId: row.id,
+    };
+}
+//# sourceMappingURL=cron-delivery.js.map

package/dist/agent-farm/servers/cron-delivery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron-delivery.js","sourceRoot":"","sources":["../../../src/agent-farm/servers/cron-delivery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAExE,OAAO,EAAE,0BAA0B,EAAsB,MAAM,uBAAuB,CAAC;AAEvF,oEAAoE;AACpE,MAAM,CAAC,MAAM,WAAW,GAAG,SAAS,CAAC;AAoCrC;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,KAAoB,EACpB,EAAqB,EACrB,MAAkB;IAElB,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,YAAY,EAAE,GAAG,MAAM,CAAC;IAExD,6EAA6E;IAC7E,gFAAgF;IAChF,mFAAmF;IACnF,8DAA8D;IAC9D,MAAM,aAAa,GAAG,gBAAgB,CAAC,EAAE,EAAE,aAAa,EAAE,YAAY,CAAC,GAAG,CAAC,CAAC;IAC5E,MAAM,GAAG,GAAG,SAAS,CACnB,EAAE,EACF,aAAa,EACb,YAAY,EACZ;QACE,aAAa;QACb,OAAO;QACP,UAAU,EAAE,MAAM,CAAC,UAAU;QAC7B,IAAI,EAAE,MAAM,CAAC,IAAI;QACjB,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;QACzC,SAAS,EAAE,WAAW;QACtB,aAAa,EAAE,aAAa;KAC7B,EACD,KAAK,CAAC,GAAG,EAAE,CACZ,CAAC;IACF,mFAAmF;IACnF,oFAAoF;IACpF,kFAAkF;IAClF,KAAK,CAAC,iBAAiB,EAAE,CAAC;IAE1B,IAAI,CAAC;QACH,MAAM,0BAA0B,CAAC,KAAK,EAAE,EAAE,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;IACtE,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,iFAAiF;QACjF,kFAAkF;QAClF,KAAK,CAAC,GAAG,CAAC,uCAAuC,OAAO,SAAS,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,kBAAkB,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACtH,CAAC;IAED,MAAM,MAAM,GAAG,OAAO,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;IACnC,IAAI,MAAM,EAAE,MAAM,KAAK,WAAW,EAAE,CAAC;QACnC,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC;IACnE,CAAC;IACD,kFAAkF;IAClF,oFAAoF;IACpF,6EAA6E;IAC7E,OAAO;QACL,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,MAAM;QAC9C,MAAM,EAAE,MAAM,EAAE,MAAM,IAAI,MAAM;QAChC,SAAS,EAAE,GAAG,CAAC,EAAE;KAClB,CAAC;AACJ,CAAC"}

package/dist/agent-farm/servers/delayed-send.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Due-time timer for the delayed `afx send --delay --interrupt` path (Spec 1307,
+ * reshaped by Spec 1313 round 3).
+ *
+ * ## What this module does NOW (and no longer does)
+ *
+ * The message *body* of every `--delay` send is persisted to the durable mailbox
+ * at REQUEST time, with a `not_before` due time, by `handleDelayedSend` in
+ * tower-routes.ts — NOT here, and NOT at fire time. The gated backstop drainer
+ * delivers that row once `not_before` passes, so a plain `--delay` keeps no timer
+ * at all and survives a Tower restart by construction.
+ *
+ * This module holds a due-time timer used by ONE caller: the delayed-`--interrupt`
+ * path. When it fires it writes only the Ctrl+C that ends the current turn — no
+ * message body, and it marks nothing `delivered`. The body then lands through the
+ * same render gate every send uses, after the ^C ends the turn.
+ *
+ * ## Why the registry exists at all
+ *
+ * A bare `setTimeout` would work until Tower shuts down, at which point the
+ * process would either hang on a pending timer or exit with a ^C half-scheduled
+ * and no record of it. The registry makes shutdown explicit.
+ *
+ * ## Shutdown drops the ^C nudge, never the message
+ *
+ * A pre-due `--delay` message is a persisted mailbox row: it survives a restart
+ * and delivers when the target's prompt is next clean. Only the in-memory ^C
+ * nudge is dropped on shutdown — recoverable (a human re-interrupts if it matters),
+ * and matching the documented "only the interrupt semantics gracefully degrade"
+ * boundary. This is the CONSCIOUS reversal of Spec 1307's original body-drop-on-
+ * restart trade (see review 1313): the render gate now supplies the protection that
+ * trade wanted — a post-restart delivery still only lands on a render-verified empty
+ * prompt, and a stale pending row is visible and cancellable in `afx inbox`.
+ */
+/**
+ * Upper bound on `--delay`, in seconds.
+ *
+ * One hour. Not a meaningful workflow limit — it exists so a typo (`--delay
+ * 1500` when 15 was meant) cannot park a message far in the future unnoticed.
+ * Under Spec 1313 round 3 a parked send IS listable and cancellable via
+ * `afx inbox` / `afx inbox dismiss` (it is a durable mailbox row), but the
+ * ceiling stays as a cheap guard against the typo case.
+ */
+export declare const MAX_DELAY_SECONDS = 3600;
+/**
+ * Validate a delay in seconds, returning null when acceptable or an error
+ * string naming the problem.
+ *
+ * `Number.isInteger` rather than a bare comparison chain: `NaN > 0` and
+ * `NaN <= 0` are both false, so a NaN slips through any single comparison
+ * written the obvious way and yields a `setTimeout` that fires immediately —
+ * silently converting a delayed send into an immediate one. Infinity is
+ * rejected for the same class of reason.
+ */
+export declare function validateDelaySeconds(value: unknown): string | null;
+/**
+ * Schedule `deliver` to run after `delaySeconds`.
+ *
+ * The callback is responsible for re-resolving the session and re-deciding how
+ * to deliver; this module guarantees only *when* it is invoked, and that it is
+ * invoked at most once.
+ */
+export declare function scheduleDelayedSend(delaySeconds: number, terminalId: string, 
+/**
+ * Invoked when the send comes due. Receives `isStillLive`, which it must
+ * re-check at the moment it actually writes (inside the submission lock): a
+ * delivery can acquire the lock only AFTER a shutdown that fired while it
+ * queued, and the generation check below only guards the moment BEFORE it
+ * enters the lock. Return value is ignored.
+ */
+deliver: (isStillLive: () => boolean) => unknown): void;
+/**
+ * Cancel every pending delayed send without delivering. Returns the count of
+ * still-timing sends dropped, so shutdown can log it rather than losing
+ * messages silently.
+ *
+ * Covers two states: sends still on their timer (cleared here) and sends whose
+ * timer has fired but whose delivery has not started — invalidated by bumping
+ * `generation`, which the delivery callback re-checks. A delivery already
+ * writing when this runs is NOT interrupted; see `generation`'s note.
+ */
+export declare function shutdownDelayedSends(): number;
+/** Number of pending delayed sends. Diagnostics and tests. */
+export declare function pendingDelayedSendCount(): number;
+//# sourceMappingURL=delayed-send.d.ts.map

package/dist/agent-farm/servers/delayed-send.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delayed-send.d.ts","sourceRoot":"","sources":["../../../src/agent-farm/servers/delayed-send.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAwCH;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,OAAO,CAAC;AAEtC;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAWlE;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM;AAClB;;;;;;GAMG;AACH,OAAO,EAAE,CAAC,WAAW,EAAE,MAAM,OAAO,KAAK,OAAO,GAC/C,IAAI,CAmCN;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAQ7C;AAED,8DAA8D;AAC9D,wBAAgB,uBAAuB,IAAI,MAAM,CAEhD"}

package/dist/agent-farm/servers/delayed-send.js

@@ -0,0 +1,165 @@
+/**
+ * Due-time timer for the delayed `afx send --delay --interrupt` path (Spec 1307,
+ * reshaped by Spec 1313 round 3).
+ *
+ * ## What this module does NOW (and no longer does)
+ *
+ * The message *body* of every `--delay` send is persisted to the durable mailbox
+ * at REQUEST time, with a `not_before` due time, by `handleDelayedSend` in
+ * tower-routes.ts — NOT here, and NOT at fire time. The gated backstop drainer
+ * delivers that row once `not_before` passes, so a plain `--delay` keeps no timer
+ * at all and survives a Tower restart by construction.
+ *
+ * This module holds a due-time timer used by ONE caller: the delayed-`--interrupt`
+ * path. When it fires it writes only the Ctrl+C that ends the current turn — no
+ * message body, and it marks nothing `delivered`. The body then lands through the
+ * same render gate every send uses, after the ^C ends the turn.
+ *
+ * ## Why the registry exists at all
+ *
+ * A bare `setTimeout` would work until Tower shuts down, at which point the
+ * process would either hang on a pending timer or exit with a ^C half-scheduled
+ * and no record of it. The registry makes shutdown explicit.
+ *
+ * ## Shutdown drops the ^C nudge, never the message
+ *
+ * A pre-due `--delay` message is a persisted mailbox row: it survives a restart
+ * and delivers when the target's prompt is next clean. Only the in-memory ^C
+ * nudge is dropped on shutdown — recoverable (a human re-interrupts if it matters),
+ * and matching the documented "only the interrupt semantics gracefully degrade"
+ * boundary. This is the CONSCIOUS reversal of Spec 1307's original body-drop-on-
+ * restart trade (see review 1313): the render gate now supplies the protection that
+ * trade wanted — a post-restart delivery still only lands on a render-verified empty
+ * prompt, and a stale pending row is visible and cancellable in `afx inbox`.
+ */
+const pending = new Set();
+/*
+ * NOTE: this module no longer serialises deliveries. It used to hold a
+ * per-terminal promise chain; Spec 1273's `submitToSession` now owns that, and
+ * every due message re-enters the mailbox delivery path, which submits under the
+ * lock. One mechanism, not two — per the architect's ruling that this project
+ * adopts the primitive rather than keeping a rival.
+ */
+/**
+ * Incremented by every shutdown. Each scheduled send captures the value current
+ * when it was scheduled and re-checks it at delivery.
+ *
+ * Clearing the pending timers is not sufficient on its own. A message whose
+ * timer has already fired is out of `pending` but its delivery may not have
+ * started yet — it can be waiting on the session's `submitToSession` lock
+ * behind an in-flight write. That queued delivery would otherwise run AFTER
+ * shutdown, which is exactly what "shutdown drops pending delayed sends"
+ * promises it will not. The generation check re-read at delivery time makes
+ * such an already-scheduled delivery a no-op.
+ *
+ * Honest bound: a delivery that has ALREADY begun its write when shutdown fires
+ * still completes — the lock does not interrupt a write in progress. "Drops on
+ * shutdown" therefore means "does not START anything new," not "aborts what is
+ * mid-flight." See the shutdown function.
+ */
+let generation = 0;
+/**
+ * Upper bound on `--delay`, in seconds.
+ *
+ * One hour. Not a meaningful workflow limit — it exists so a typo (`--delay
+ * 1500` when 15 was meant) cannot park a message far in the future unnoticed.
+ * Under Spec 1313 round 3 a parked send IS listable and cancellable via
+ * `afx inbox` / `afx inbox dismiss` (it is a durable mailbox row), but the
+ * ceiling stays as a cheap guard against the typo case.
+ */
+export const MAX_DELAY_SECONDS = 3600;
+/**
+ * Validate a delay in seconds, returning null when acceptable or an error
+ * string naming the problem.
+ *
+ * `Number.isInteger` rather than a bare comparison chain: `NaN > 0` and
+ * `NaN <= 0` are both false, so a NaN slips through any single comparison
+ * written the obvious way and yields a `setTimeout` that fires immediately —
+ * silently converting a delayed send into an immediate one. Infinity is
+ * rejected for the same class of reason.
+ */
+export function validateDelaySeconds(value) {
+    if (typeof value !== 'number' || !Number.isInteger(value)) {
+        return `delay must be a whole number of seconds, got '${String(value)}'`;
+    }
+    if (value <= 0) {
+        return `delay must be greater than zero, got ${value}`;
+    }
+    if (value > MAX_DELAY_SECONDS) {
+        return `delay must be at most ${MAX_DELAY_SECONDS} seconds (1 hour), got ${value}`;
+    }
+    return null;
+}
+/**
+ * Schedule `deliver` to run after `delaySeconds`.
+ *
+ * The callback is responsible for re-resolving the session and re-deciding how
+ * to deliver; this module guarantees only *when* it is invoked, and that it is
+ * invoked at most once.
+ */
+export function scheduleDelayedSend(delaySeconds, terminalId, 
+/**
+ * Invoked when the send comes due. Receives `isStillLive`, which it must
+ * re-check at the moment it actually writes (inside the submission lock): a
+ * delivery can acquire the lock only AFTER a shutdown that fired while it
+ * queued, and the generation check below only guards the moment BEFORE it
+ * enters the lock. Return value is ignored.
+ */
+deliver) {
+    const entry = {
+        terminalId,
+        dueAt: Date.now() + delaySeconds * 1000,
+        // Assigned below; the object must exist first so the callback can
+        // deregister itself by identity.
+        timer: undefined,
+    };
+    const scheduledGeneration = generation;
+    entry.timer = setTimeout(() => {
+        // Deregister BEFORE delivering. If delivery throws, the entry must not be
+        // left behind as a phantom pending send that shutdown would then report.
+        pending.delete(entry);
+        void (async () => {
+            // Generation re-checked at DELIVERY time, not timer time: delivery now
+            // queues behind the session's submission lock, so the wait to actually
+            // write can outlast a shutdown.
+            if (generation !== scheduledGeneration)
+                return;
+            try {
+                // Passed through to the write site, where it is re-checked while the
+                // lock is held — closing the shutdown-during-lock-wait window.
+                await deliver(() => generation === scheduledGeneration);
+            }
+            catch {
+                // The mailbox delivery path logs a write failure at its own site with
+                // terminal context; this catch is a last-resort guard so an unexpected
+                // throw cannot become an unhandled rejection that takes Tower down over
+                // one undeliverable message.
+            }
+        })();
+    }, delaySeconds * 1000);
+    pending.add(entry);
+}
+/**
+ * Cancel every pending delayed send without delivering. Returns the count of
+ * still-timing sends dropped, so shutdown can log it rather than losing
+ * messages silently.
+ *
+ * Covers two states: sends still on their timer (cleared here) and sends whose
+ * timer has fired but whose delivery has not started — invalidated by bumping
+ * `generation`, which the delivery callback re-checks. A delivery already
+ * writing when this runs is NOT interrupted; see `generation`'s note.
+ */
+export function shutdownDelayedSends() {
+    const count = pending.size;
+    for (const entry of pending) {
+        clearTimeout(entry.timer);
+    }
+    pending.clear();
+    generation++;
+    return count;
+}
+/** Number of pending delayed sends. Diagnostics and tests. */
+export function pendingDelayedSendCount() {
+    return pending.size;
+}
+//# sourceMappingURL=delayed-send.js.map

package/dist/agent-farm/servers/delayed-send.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delayed-send.js","sourceRoot":"","sources":["../../../src/agent-farm/servers/delayed-send.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAWH,MAAM,OAAO,GAAG,IAAI,GAAG,EAAsB,CAAC;AAE9C;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,IAAI,UAAU,GAAG,CAAC,CAAC;AAEnB;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI,CAAC;AAEtC;;;;;;;;;GASG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAc;IACjD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1D,OAAO,iDAAiD,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC;IAC3E,CAAC;IACD,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;QACf,OAAO,wCAAwC,KAAK,EAAE,CAAC;IACzD,CAAC;IACD,IAAI,KAAK,GAAG,iBAAiB,EAAE,CAAC;QAC9B,OAAO,yBAAyB,iBAAiB,0BAA0B,KAAK,EAAE,CAAC;IACrF,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CACjC,YAAoB,EACpB,UAAkB;AAClB;;;;;;GAMG;AACH,OAAgD;IAEhD,MAAM,KAAK,GAAuB;QAChC,UAAU;QACV,KAAK,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,YAAY,GAAG,IAAI;QACvC,kEAAkE;QAClE,iCAAiC;QACjC,KAAK,EAAE,SAAqD;KAC7D,CAAC;IAEF,MAAM,mBAAmB,GAAG,UAAU,CAAC;IAEvC,KAAK,CAAC,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE;QAC5B,0EAA0E;QAC1E,yEAAyE;QACzE,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAEtB,KAAK,CAAC,KAAK,IAAI,EAAE;YACf,uEAAuE;YACvE,uEAAuE;YACvE,gCAAgC;YAChC,IAAI,UAAU,KAAK,mBAAmB;gBAAE,OAAO;YAC/C,IAAI,CAAC;gBACH,qEAAqE;gBACrE,+DAA+D;gBAC/D,MAAM,OAAO,CAAC,GAAG,EAAE,CAAC,UAAU,KAAK,mBAAmB,CAAC,CAAC;YAC1D,CAAC;YAAC,MAAM,CAAC;gBACP,sEAAsE;gBACtE,uEAAuE;gBACvE,wEAAwE;gBACxE,6BAA6B;YAC/B,CAAC;QACH,CAAC,CAAC,EAAE,CAAC;IACP,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC,CAAC;IAExB,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACrB,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,oBAAoB;IAClC,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAC3B,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC5B,CAAC;IACD,OAAO,CAAC,KAAK,EAAE,CAAC;IAChB,UAAU,EAAE,CAAC;IACb,OAAO,KAAK,CAAC;AACf,CAAC;AAED,8DAA8D;AAC9D,MAAM,UAAU,uBAAuB;IACrC,OAAO,OAAO,CAAC,IAAI,CAAC;AACtB,CAAC"}

package/dist/agent-farm/servers/gate-profiles.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Render-gate classifier profiles (Spec 1313, Phase 2).
+ *
+ * A profile tells {@link classifyScreen} how to find and bound a given app's
+ * composer. Profiles are per-app *data* by design (spike constraint 9): a TUI
+ * layout change is a profile drift the smoke suite catches, never a silent
+ * misdelivery — an unmatched marker classifies NOT clean.
+ *
+ * Measured apps have a profile: claude, codex (spike g2), and agy (Spec 1313
+ * Phase 3 measurement — its own marker `> ` and a color-keyed placeholder rule,
+ * because agy renders its idle hint in palette-8 gray, not SGR-dim). Everything
+ * else — gemini, opencode, an unknown binary, or a launch we can't identify —
+ * resolves to `null`, and the caller holds the message with reason `no-profile`.
+ * This is the strict app-identity table the spike mandates (constraint 10): we
+ * deliberately do NOT reuse `resolveHarness`, whose claude fallback would make an
+ * agy terminal masquerade as claude and receive claude's (wrong) profile — a
+ * correctness bug, since agy's screens classify by an entirely different rule.
+ */
+import type { GateProfile } from './render-gate.js';
+/** claude composer profile (marker ❯, dim placeholder — measured, spike g2). */
+export declare const CLAUDE_PROFILE: GateProfile;
+/** codex composer profile (marker ›, dim placeholder — measured, spike g2). */
+export declare const CODEX_PROFILE: GateProfile;
+/**
+ * agy composer profile (Spec 1313 Phase 3 — net-new measurement). agy breaks the
+ * dim-placeholder assumption: its idle mode-hint (`Accept-edits mode: …`) renders
+ * at NORMAL intensity but in **palette-8 (gray)**, while user-typed text is
+ * default-fg — so the placeholder signal is a foreground COLOR, not SGR-dim
+ * (`placeholderFgPalette: 8`). Consequences, all measured: idle → clean (the
+ * gray hint is ignored), draft → busy (default-fg text counted), and the
+ * per-folder trust dialog → busy (its selected `> Yes, I trust this folder`
+ * option is palette-12, counted) — so a blind Enter never confirms filesystem
+ * trust. Region bounds reuse the shared rule-line/status patterns (agy brackets
+ * its composer with `─────` rules, like claude).
+ */
+export declare const AGY_PROFILE: GateProfile;
+/**
+ * The identity signals a caller extracts from a live session. A `PtySession`
+ * satisfies this structurally via its `command` / `launchArgs` getters (the
+ * Spec 1313 identity seam); tests pass a plain object.
+ *
+ * `label` is intentionally not used for matching: for a builder it is the
+ * builder id (e.g. `spir-1313`), for an architect the architect name — neither
+ * names the agent. The authoritative signal is the launch `command`.
+ */
+export interface AppIdentity {
+    command: string;
+    args?: string[];
+    label?: string;
+}
+/**
+ * Map a session's identity to its classifier profile, or `null` when the app is
+ * unknown/unmeasured (→ caller holds with `no-profile`).
+ *
+ * Resolution is strict: the launch `command`'s basename must match a measured
+ * agent. agy is matched directly (its binary is `agy`/`antigravity`), because the
+ * shared {@link detectHarnessFromCommand} does not recognize it and we will not
+ * extend that resolver — its claude fallback is exactly the misidentification the
+ * gate must avoid (constraint 10). claude/codex resolve via that helper. Wrapped
+ * launches — a builder run through `.builder-start.sh` whose `command` is the
+ * shell, not the agent — resolve to `null` here; the delivery wiring (Phase 4)
+ * supplies the resolved agent command for those (it already reads the launch
+ * script to identify the harness, as `afx reset` does). Fail-safe by
+ * construction: an unresolved identity is held and surfaced, never guessed.
+ */
+export declare function resolveProfile(identity: AppIdentity): GateProfile | null;
+//# sourceMappingURL=gate-profiles.d.ts.map

package/dist/agent-farm/servers/gate-profiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate-profiles.d.ts","sourceRoot":"","sources":["../../../src/agent-farm/servers/gate-profiles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AA+BpD,gFAAgF;AAChF,eAAO,MAAM,cAAc,EAAE,WAI5B,CAAC;AAEF,+EAA+E;AAC/E,eAAO,MAAM,aAAa,EAAE,WAI3B,CAAC;AASF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,EAAE,WAKzB,CAAC;AAQF;;;;;;;;GAQG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,WAAW,GAAG,WAAW,GAAG,IAAI,CAMxE"}

package/dist/agent-farm/servers/gate-profiles.js

@@ -0,0 +1,113 @@
+/**
+ * Render-gate classifier profiles (Spec 1313, Phase 2).
+ *
+ * A profile tells {@link classifyScreen} how to find and bound a given app's
+ * composer. Profiles are per-app *data* by design (spike constraint 9): a TUI
+ * layout change is a profile drift the smoke suite catches, never a silent
+ * misdelivery — an unmatched marker classifies NOT clean.
+ *
+ * Measured apps have a profile: claude, codex (spike g2), and agy (Spec 1313
+ * Phase 3 measurement — its own marker `> ` and a color-keyed placeholder rule,
+ * because agy renders its idle hint in palette-8 gray, not SGR-dim). Everything
+ * else — gemini, opencode, an unknown binary, or a launch we can't identify —
+ * resolves to `null`, and the caller holds the message with reason `no-profile`.
+ * This is the strict app-identity table the spike mandates (constraint 10): we
+ * deliberately do NOT reuse `resolveHarness`, whose claude fallback would make an
+ * agy terminal masquerade as claude and receive claude's (wrong) profile — a
+ * correctness bug, since agy's screens classify by an entirely different rule.
+ */
+import { basename } from 'node:path';
+import { detectHarnessFromCommand } from '../utils/harness.js';
+/**
+ * Marker family shared by the measured TUIs: both render a `❯`/`›` prompt glyph
+ * at the start of the composer input row. Kept in one place but referenced
+ * per-profile so a future app whose marker diverges gets its own pattern without
+ * disturbing the others.
+ */
+const COMPOSER_MARKER = /^[❯›]/;
+/**
+ * Lines that END the composer region — the rule line claude draws beneath its
+ * input (`─────`) and the status line codex draws (model / reasoning / cwd, e.g.
+ * `  gpt-5.6-sol   high: …   ~/repo`). Scanning stops at the first such line so
+ * status chrome below the composer is never miscounted as user text. Both
+ * patterns are carried by both profiles (harmless: a claude screen has no
+ * `gpt|high:|~/` status line, a codex screen has no long rule line under input),
+ * exactly as the validated spike classifier applied them.
+ *
+ * Load-bearing since the Spec 1313 render-gate hardening: when NONE of these matches
+ * below the marker, the gate now HOLDS (`no-region-end`) rather than scanning to the
+ * screen bottom — so this list is the sole lower-bound signal, and it is FAIL-SAFE but
+ * DRIFT-FRAGILE. The rule pattern requires the line to *start* with `─/━/╌/┄`; a claude
+ * reversion to a rounded box (`╰────╯`, note `╰`/`└` are ignorable glyphs but NOT in
+ * this class) or an indented rule would stop matching and hold every send to that app.
+ * That is the safe direction (never a false-clean), and a sustained hold now escalates
+ * to liveness telemetry (mailbox-delivery `recordStreak`), but broaden this list ONLY
+ * from a real capture — a too-loose pattern that matches draft content is a false-clean.
+ */
+const REGION_END_PATTERNS = [/^[─━╌┄]{5,}/, /^\s{2,}(gpt|high:|~\/)/];
+/** claude composer profile (marker ❯, dim placeholder — measured, spike g2). */
+export const CLAUDE_PROFILE = {
+    app: 'claude',
+    markerPattern: COMPOSER_MARKER,
+    regionEndPatterns: REGION_END_PATTERNS,
+};
+/** codex composer profile (marker ›, dim placeholder — measured, spike g2). */
+export const CODEX_PROFILE = {
+    app: 'codex',
+    markerPattern: COMPOSER_MARKER,
+    regionEndPatterns: REGION_END_PATTERNS,
+};
+/**
+ * agy (Antigravity CLI 1.1.8) composer marker: a `> ` prompt glyph at the input
+ * row start — a different glyph from claude/codex's `❯`/`›`, so its own pattern.
+ * (Measured, Spec 1313 Phase 3; the marker cell renders palette-12 bright-blue.)
+ */
+const AGY_MARKER = /^> /;
+/**
+ * agy composer profile (Spec 1313 Phase 3 — net-new measurement). agy breaks the
+ * dim-placeholder assumption: its idle mode-hint (`Accept-edits mode: …`) renders
+ * at NORMAL intensity but in **palette-8 (gray)**, while user-typed text is
+ * default-fg — so the placeholder signal is a foreground COLOR, not SGR-dim
+ * (`placeholderFgPalette: 8`). Consequences, all measured: idle → clean (the
+ * gray hint is ignored), draft → busy (default-fg text counted), and the
+ * per-folder trust dialog → busy (its selected `> Yes, I trust this folder`
+ * option is palette-12, counted) — so a blind Enter never confirms filesystem
+ * trust. Region bounds reuse the shared rule-line/status patterns (agy brackets
+ * its composer with `─────` rules, like claude).
+ */
+export const AGY_PROFILE = {
+    app: 'agy',
+    markerPattern: AGY_MARKER,
+    regionEndPatterns: REGION_END_PATTERNS,
+    placeholderFgPalette: 8,
+};
+/** Registry keyed by the harness name `detectHarnessFromCommand` returns. */
+const PROFILES_BY_HARNESS = {
+    claude: CLAUDE_PROFILE,
+    codex: CODEX_PROFILE,
+};
+/**
+ * Map a session's identity to its classifier profile, or `null` when the app is
+ * unknown/unmeasured (→ caller holds with `no-profile`).
+ *
+ * Resolution is strict: the launch `command`'s basename must match a measured
+ * agent. agy is matched directly (its binary is `agy`/`antigravity`), because the
+ * shared {@link detectHarnessFromCommand} does not recognize it and we will not
+ * extend that resolver — its claude fallback is exactly the misidentification the
+ * gate must avoid (constraint 10). claude/codex resolve via that helper. Wrapped
+ * launches — a builder run through `.builder-start.sh` whose `command` is the
+ * shell, not the agent — resolve to `null` here; the delivery wiring (Phase 4)
+ * supplies the resolved agent command for those (it already reads the launch
+ * script to identify the harness, as `afx reset` does). Fail-safe by
+ * construction: an unresolved identity is held and surfaced, never guessed.
+ */
+export function resolveProfile(identity) {
+    const base = basename(identity.command).toLowerCase();
+    if (base.includes('agy') || base.includes('antigravity'))
+        return AGY_PROFILE;
+    const harness = detectHarnessFromCommand(identity.command);
+    if (harness && harness in PROFILES_BY_HARNESS)
+        return PROFILES_BY_HARNESS[harness];
+    return null;
+}
+//# sourceMappingURL=gate-profiles.js.map

package/dist/agent-farm/servers/gate-profiles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate-profiles.js","sourceRoot":"","sources":["../../../src/agent-farm/servers/gate-profiles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrC,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAG/D;;;;;GAKG;AACH,MAAM,eAAe,GAAG,OAAO,CAAC;AAEhC;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,mBAAmB,GAAG,CAAC,aAAa,EAAE,wBAAwB,CAAC,CAAC;AAEtE,gFAAgF;AAChF,MAAM,CAAC,MAAM,cAAc,GAAgB;IACzC,GAAG,EAAE,QAAQ;IACb,aAAa,EAAE,eAAe;IAC9B,iBAAiB,EAAE,mBAAmB;CACvC,CAAC;AAEF,+EAA+E;AAC/E,MAAM,CAAC,MAAM,aAAa,GAAgB;IACxC,GAAG,EAAE,OAAO;IACZ,aAAa,EAAE,eAAe;IAC9B,iBAAiB,EAAE,mBAAmB;CACvC,CAAC;AAEF;;;;GAIG;AACH,MAAM,UAAU,GAAG,KAAK,CAAC;AAEzB;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,WAAW,GAAgB;IACtC,GAAG,EAAE,KAAK;IACV,aAAa,EAAE,UAAU;IACzB,iBAAiB,EAAE,mBAAmB;IACtC,oBAAoB,EAAE,CAAC;CACxB,CAAC;AAEF,6EAA6E;AAC7E,MAAM,mBAAmB,GAAgC;IACvD,MAAM,EAAE,cAAc;IACtB,KAAK,EAAE,aAAa;CACrB,CAAC;AAiBF;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,cAAc,CAAC,QAAqB;IAClD,MAAM,IAAI,GAAG,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,WAAW,EAAE,CAAC;IACtD,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC;QAAE,OAAO,WAAW,CAAC;IAC7E,MAAM,OAAO,GAAG,wBAAwB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC3D,IAAI,OAAO,IAAI,OAAO,IAAI,mBAAmB;QAAE,OAAO,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACnF,OAAO,IAAI,CAAC;AACd,CAAC"}