charness 0.0.0-stage → 3.0.0

package/dist/requests/wakeUpRules.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultRequestBackstopMs = exports.postRetryDelaysMs = exports.progressFollowUpDelayMs = exports.maxWakeUpsPerRequest = exports.maxSilentTurns = void 0;
+exports.getPostRetryUpdate = getPostRetryUpdate;
+exports.getRequestBackstopMs = getRequestBackstopMs;
+exports.checkIsWakingStopped = checkIsWakingStopped;
+exports.decideTurnEnd = decideTurnEnd;
+exports.decideUnwatchedRequest = decideUnwatchedRequest;
+exports.checkIsTurnInputConsumed = checkIsTurnInputConsumed;
+exports.getWatchedTurnState = getWatchedTurnState;
+exports.checkIsWatchedTurnStale = checkIsWatchedTurnStale;
+const minutesOverride_1 = require("../utils/minutesOverride");
+/**
+ * @description The wake-up rules of the request/answer core (S4), as pure
+ * decisions over an open request and what the session looks like right now:
+ *
+ *   turn ends, request still open
+ *     └─ the turn sent NO answer      → silent-turn counter +1
+ *          counter < 2                → wake the same session at once
+ *          counter = 2                → alert a person, stop waking
+ *     └─ the turn sent a progress     → counter = 0, wake again after 15 min
+ *   cap: 10 wake-ups per request      → alert, stop waking (loop guard)
+ *   backstop: nothing seen working on it for 90 min (a dead process, tracking
+ *             lost across a restart or a watch that never saw its turn end)
+ *                                     → resume / wake the session
+ *
+ * A wake-up never interrupts a live turn and never starts while the session is
+ * blocked on something that is not a turn end (a pending native question, a
+ * compaction, an armed API-error retry or usage-limit wait). After the alert or
+ * the cap nothing wakes the request again until it closes or is superseded.
+ */
+/** Silent turns in a row that make the rules give up. */
+exports.maxSilentTurns = 2;
+/** Wake-ups one request may receive before the loop guard gives up. */
+exports.maxWakeUpsPerRequest = 10;
+/** After a progress answer, how long before the agent is reminded again. */
+exports.progressFollowUpDelayMs = 15 * 60 * 1000;
+/**
+ * After a request's prompt could not be posted (no session, a forward that
+ * failed), when to try again (R28): soon, then less soon — these retries are not
+ * wake-ups of a silent agent, so they do not count against the wake-up cap.
+ */
+exports.postRetryDelaysMs = [60 * 1000, 5 * 60 * 1000, 15 * 60 * 1000];
+/**
+ * @description The next post retry after a failed post (R28), or `null` once the
+ * retries are spent — the normal backstop / alert rules take the request then.
+ */
+function getPostRetryUpdate(request, nowMs) {
+    const retryCount = request.postRetryCount ?? 0;
+    const delayMs = exports.postRetryDelaysMs[retryCount];
+    return delayMs === undefined ? null : { postRetryCount: retryCount + 1, nextPostRetryAt: nowMs + delayMs };
+}
+/** Default backstop: open with nothing seen working on it for this long. */
+exports.defaultRequestBackstopMs = 90 * 60 * 1000;
+/**
+ * @description The backstop window, honouring the `REQUEST_BACKSTOP_MINUTES`
+ * override (a live test shortens it to finish a killed-process scenario in
+ * minutes). A missing, non-numeric or non-positive value keeps the default.
+ */
+function getRequestBackstopMs(overrideMinutes) {
+    return (0, minutesOverride_1.getMinutesOverrideMs)(overrideMinutes, exports.defaultRequestBackstopMs);
+}
+/**
+ * @description Whether anything may still wake the request: the rules' own
+ * give-up (`isWakeStopped`, for good) and a limit stop (`isLimitStopped`, until a
+ * limit wait ends with a resume) both say no.
+ */
+function checkIsWakingStopped(request) {
+    return request.isWakeStopped || request.isLimitStopped === true;
+}
+/** The update that stops every further wake-up of a request. */
+const stopWakingUpdate = { isWakeStopped: true, nextWakeAt: undefined };
+/**
+ * @description Wake the request now unless it already used up its wake-ups, in
+ * which case the loop guard alerts instead. `update` adds to the wake's own
+ * bookkeeping.
+ */
+function getWakeOrCapDecision(request, reason, update) {
+    if (request.wakeCount >= exports.maxWakeUpsPerRequest) {
+        return { kind: 'alert', reason: 'wakeCap', update: { ...update, ...stopWakingUpdate } };
+    }
+    return {
+        kind: 'wake',
+        reason,
+        update: { ...update, wakeCount: request.wakeCount + 1, nextWakeAt: undefined },
+    };
+}
+/**
+ * @description The decision at the end of a turn the request's message started.
+ * `progressCountAtTurnStart` is the request's progress-answer count when the
+ * turn began, so an increase means this turn sent a progress note (a `question`
+ * or `final` would have closed the request — there is nothing to decide then).
+ */
+function decideTurnEnd(request, progressCountAtTurnStart, nowMs) {
+    if (checkIsWakingStopped(request))
+        return { kind: 'none' };
+    if (request.progressAnswerCount > progressCountAtTurnStart) {
+        return {
+            kind: 'followUpLater',
+            update: { silentTurnCount: 0, nextWakeAt: nowMs + exports.progressFollowUpDelayMs, lastTurnActivityAt: nowMs },
+        };
+    }
+    const silentTurnCount = request.silentTurnCount + 1;
+    if (silentTurnCount >= exports.maxSilentTurns) {
+        return { kind: 'alert', reason: 'silentTurns', update: { silentTurnCount, ...stopWakingUpdate } };
+    }
+    return getWakeOrCapDecision(request, 'silentTurn', { silentTurnCount, lastTurnActivityAt: nowMs });
+}
+/**
+ * @description The periodic decision for an open request whose turn is NOT being
+ * watched: a due progress follow-up, or the backstop. Never while the session is
+ * working or blocked — and a live turn counts as activity, which pushes the
+ * backstop back (the caller records it).
+ */
+function decideUnwatchedRequest(request, probe, nowMs, backstopMs) {
+    if (checkIsWakingStopped(request) || probe.isBusy || probe.isTurnEndBlocked)
+        return { kind: 'none' };
+    if (request.nextPostRetryAt !== undefined) {
+        // R28: outside the wake-up cap — the agent never saw the request, it is not looping.
+        return nowMs >= request.nextPostRetryAt
+            ? { kind: 'wake', reason: 'postRetry', update: { nextPostRetryAt: undefined, lastTurnActivityAt: nowMs } }
+            : { kind: 'none' };
+    }
+    if (request.nextWakeAt !== undefined) {
+        return nowMs >= request.nextWakeAt ? getWakeOrCapDecision(request, 'progressFollowUp', {}) : { kind: 'none' };
+    }
+    const lastSeenAt = request.lastTurnActivityAt ?? request.createdAt;
+    return nowMs - lastSeenAt >= backstopMs
+        ? getWakeOrCapDecision(request, 'backstop', { lastTurnActivityAt: nowMs })
+        : { kind: 'none' };
+}
+/**
+ * @description Has the backend taken in what was forwarded for this turn? Its own
+ * signal when it has one (nothing written is still unread), else busy or output
+ * seen since the forward.
+ */
+function checkIsTurnInputConsumed(turn, probe) {
+    return probe.hasUnconsumedInput === null ? turn.hasSeenBusy || turn.hasSeenOutput : !probe.hasUnconsumedInput;
+}
+/**
+ * @description Has the turn the request's message started ended? The backend
+ * must first have TAKEN IN the message — otherwise an idle reported for the
+ * earlier turn would read as this turn's end: a backend that tracks it says so
+ * (`hasUnconsumedInput`), one that does not must have been seen busy or
+ * producing output since the forward (the busy-onset race).
+ */
+function getWatchedTurnState(turn, probe) {
+    if (!probe.isActive)
+        return probe.isTurnEndBlocked ? 'running' : 'sessionGone';
+    if (!checkIsTurnInputConsumed(turn, probe) || probe.isBusy || probe.isTurnEndBlocked)
+        return 'running';
+    return 'ended';
+}
+/**
+ * @description Has a watched turn that is still `running` lost its tracking? It
+ * is idle, nothing holds it open, and nothing was seen working on the request
+ * for the whole backstop window — so what keeps it `running` is a consumption
+ * signal that never settled (an input counter left behind, a turn start never
+ * seen). Dropping the watch hands the request to the backstop: a watch that
+ * stayed forever would silence every wake-up and alert of the request.
+ */
+function checkIsWatchedTurnStale(request, probe, nowMs, backstopMs) {
+    if (probe.isBusy || probe.isTurnEndBlocked)
+        return false;
+    return nowMs - (request.lastTurnActivityAt ?? request.createdAt) >= backstopMs;
+}
+//# sourceMappingURL=wakeUpRules.js.map

package/dist/requests/wakeUpRules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wakeUpRules.js","sourceRoot":"","sources":["../../src/requests/wakeUpRules.ts"],"names":[],"mappings":"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"}

package/dist/resumeContext.d.ts

@@ -0,0 +1,87 @@
+import type { RecentTurn } from './types';
+/**
+ * @description How many recent conversational turns the resume context block
+ * shows. Tunable: raising it shows more history, lowering it shows less. Kept
+ * small so resuming a long session does not re-flood the topic — this turn
+ * count is the only flood bound (each turn is rendered in full; the bot's
+ * message-splitting handles turns longer than the Telegram cap).
+ */
+export declare const resumeContextTurnLimit = 3;
+/**
+ * @description Render the last conversational turns as role-labeled blocks, each
+ * in FULL (no per-turn truncation — the bot's message-splitting handles over-cap
+ * blocks). Shared by {@link formatResumeContext} (the `/sessions` resume block)
+ * and {@link formatReattachRecap} (the silent-reattach recap) so the turn body
+ * looks identical in both. `turns` must be chronological (oldest→newest).
+ *
+ * Pure (only reads i18n) — the stored user prompts carry the forwarded
+ * "[Telegram thread context]" glue, which is service noise when shown back, so
+ * it is stripped from user turns only (assistant text is never touched).
+ */
+export declare function renderTurns(turns: RecentTurn[]): string[];
+/**
+ * @description Render the short resume context block from the last conversational
+ * turns of a resumed session. `turns` must already be chronological
+ * (oldest→newest) and capped to {@link resumeContextTurnLimit} by the caller
+ * (the adapter's `getRecentTurns`).
+ *
+ * Output is a localized header (with the turn count) followed by the
+ * role-labeled turn blocks from {@link renderTurns}, each rendered in FULL — the
+ * user expects the complete last messages, and the bot's message-splitting path
+ * (`getOutputFlushPlan` → `splitMessage`) chunks a block over the Telegram cap.
+ * Returns `null` when there are no turns (brand-new / pruned-history session)
+ * so the caller emits nothing extra.
+ *
+ * Pure (only reads i18n, no I/O) so it is unit-testable without a live backend.
+ */
+export declare function formatResumeContext(turns: RecentTurn[]): string | null;
+/**
+ * @description Anti-spam gate for the silent-reattach recap. Decides whether
+ * {@link formatReattachRecap}'s output should actually be posted, given the boot
+ * mode. Two trigger paths:
+ *
+ * - **Known missed output** (`missedCount > 0`) → ALWAYS post: the agent produced
+ *   messages the user never saw, regardless of whether the gap was a hot reload
+ *   or a cold start. Recovering them is the whole point.
+ * - **Fallback** (watermark unknown but there ARE turns) → post ONLY on a COLD
+ *   start. On a hot reload (sub-second blink) nothing was actually missed, so
+ *   re-showing the last turns is pure noise — and a watermark-less session (first
+ *   run after ship, pruned transcript) would otherwise re-spam every active topic
+ *   on every hot rebuild (the exact regression the old recent-turns block was
+ *   disabled to avoid).
+ *
+ * Pure (no I/O) so it is unit-testable. A clean reload with a known watermark and
+ * no missed output (`missedCount === 0`, known) is always silent.
+ */
+export declare function checkShouldPostReattachRecap(args: {
+    missedCount: number;
+    isWatermarkKnown: boolean;
+    hasTurns: boolean;
+    isColdStart: boolean;
+}): boolean;
+/**
+ * @description Format the post-restart recap shown on a SILENT reattach (the bot
+ * re-adopted a session that kept working while the bot was down), so output
+ * produced during the downtime is recovered instead of lost. Mirrors
+ * {@link formatResumeContext}'s turn body (via {@link renderTurns}) under a
+ * scale-conveying header:
+ *
+ * - `isWatermarkKnown && missedCount > 0` → the count header
+ *   ("⚠️ Missed N message(s) …"); the body stays the last few turns regardless
+ *   of N (the count conveys scale, the hard turn cap is the flood bound).
+ * - otherwise (watermark unknown / untrusted) → the no-number fallback header.
+ *
+ * A best-effort trailing "still working …" line is appended only when `isActive`.
+ * Returns `null` when there are no turns to show (the caller posts nothing).
+ *
+ * Pure (only reads i18n, no I/O) so it is unit-testable. The caller
+ * (`reattachExistingSessions`) owns the anti-spam gate — it invokes this only
+ * when `missedCount > 0` OR (watermark unknown AND there are turns).
+ */
+export declare function formatReattachRecap(args: {
+    missedCount: number;
+    turns: RecentTurn[];
+    isActive: boolean;
+    isWatermarkKnown: boolean;
+}): string | null;
+//# sourceMappingURL=resumeContext.d.ts.map

package/dist/resumeContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resumeContext.d.ts","sourceRoot":"","sources":["../src/resumeContext.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAExC;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,MAAM,EAAE,CAQzD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,MAAM,GAAG,IAAI,CAKtE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE;IACjD,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;CACtB,GAAG,OAAO,CAIV;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,gBAAgB,EAAE,OAAO,CAAC;CAC3B,GAAG,MAAM,GAAG,IAAI,CAYhB"}

package/dist/resumeContext.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resumeContextTurnLimit = void 0;
+exports.renderTurns = renderTurns;
+exports.formatResumeContext = formatResumeContext;
+exports.checkShouldPostReattachRecap = checkShouldPostReattachRecap;
+exports.formatReattachRecap = formatReattachRecap;
+const i18n_1 = require("./i18n");
+const threadContextPreamble_1 = require("./threadContextPreamble");
+/**
+ * @description How many recent conversational turns the resume context block
+ * shows. Tunable: raising it shows more history, lowering it shows less. Kept
+ * small so resuming a long session does not re-flood the topic — this turn
+ * count is the only flood bound (each turn is rendered in full; the bot's
+ * message-splitting handles turns longer than the Telegram cap).
+ */
+exports.resumeContextTurnLimit = 3;
+/**
+ * @description Render the last conversational turns as role-labeled blocks, each
+ * in FULL (no per-turn truncation — the bot's message-splitting handles over-cap
+ * blocks). Shared by {@link formatResumeContext} (the `/sessions` resume block)
+ * and {@link formatReattachRecap} (the silent-reattach recap) so the turn body
+ * looks identical in both. `turns` must be chronological (oldest→newest).
+ *
+ * Pure (only reads i18n) — the stored user prompts carry the forwarded
+ * "[Telegram thread context]" glue, which is service noise when shown back, so
+ * it is stripped from user turns only (assistant text is never touched).
+ */
+function renderTurns(turns) {
+    const userLabel = (0, i18n_1.t)('resume.context_user_label');
+    const assistantLabel = (0, i18n_1.t)('resume.context_assistant_label');
+    return turns.map((turn) => {
+        const label = turn.role === 'user' ? userLabel : assistantLabel;
+        const visibleText = turn.role === 'user' ? (0, threadContextPreamble_1.stripThreadContextPreamble)(turn.text) : turn.text;
+        return `${label} ${visibleText}`;
+    });
+}
+/**
+ * @description Render the short resume context block from the last conversational
+ * turns of a resumed session. `turns` must already be chronological
+ * (oldest→newest) and capped to {@link resumeContextTurnLimit} by the caller
+ * (the adapter's `getRecentTurns`).
+ *
+ * Output is a localized header (with the turn count) followed by the
+ * role-labeled turn blocks from {@link renderTurns}, each rendered in FULL — the
+ * user expects the complete last messages, and the bot's message-splitting path
+ * (`getOutputFlushPlan` → `splitMessage`) chunks a block over the Telegram cap.
+ * Returns `null` when there are no turns (brand-new / pruned-history session)
+ * so the caller emits nothing extra.
+ *
+ * Pure (only reads i18n, no I/O) so it is unit-testable without a live backend.
+ */
+function formatResumeContext(turns) {
+    if (turns.length === 0)
+        return null;
+    const header = (0, i18n_1.t)('resume.context_header', { count: turns.length });
+    return [header, ...renderTurns(turns)].join('\n\n');
+}
+/**
+ * @description Anti-spam gate for the silent-reattach recap. Decides whether
+ * {@link formatReattachRecap}'s output should actually be posted, given the boot
+ * mode. Two trigger paths:
+ *
+ * - **Known missed output** (`missedCount > 0`) → ALWAYS post: the agent produced
+ *   messages the user never saw, regardless of whether the gap was a hot reload
+ *   or a cold start. Recovering them is the whole point.
+ * - **Fallback** (watermark unknown but there ARE turns) → post ONLY on a COLD
+ *   start. On a hot reload (sub-second blink) nothing was actually missed, so
+ *   re-showing the last turns is pure noise — and a watermark-less session (first
+ *   run after ship, pruned transcript) would otherwise re-spam every active topic
+ *   on every hot rebuild (the exact regression the old recent-turns block was
+ *   disabled to avoid).
+ *
+ * Pure (no I/O) so it is unit-testable. A clean reload with a known watermark and
+ * no missed output (`missedCount === 0`, known) is always silent.
+ */
+function checkShouldPostReattachRecap(args) {
+    const { missedCount, isWatermarkKnown, hasTurns, isColdStart } = args;
+    if (missedCount > 0)
+        return true;
+    return isColdStart && !isWatermarkKnown && hasTurns;
+}
+/**
+ * @description Format the post-restart recap shown on a SILENT reattach (the bot
+ * re-adopted a session that kept working while the bot was down), so output
+ * produced during the downtime is recovered instead of lost. Mirrors
+ * {@link formatResumeContext}'s turn body (via {@link renderTurns}) under a
+ * scale-conveying header:
+ *
+ * - `isWatermarkKnown && missedCount > 0` → the count header
+ *   ("⚠️ Missed N message(s) …"); the body stays the last few turns regardless
+ *   of N (the count conveys scale, the hard turn cap is the flood bound).
+ * - otherwise (watermark unknown / untrusted) → the no-number fallback header.
+ *
+ * A best-effort trailing "still working …" line is appended only when `isActive`.
+ * Returns `null` when there are no turns to show (the caller posts nothing).
+ *
+ * Pure (only reads i18n, no I/O) so it is unit-testable. The caller
+ * (`reattachExistingSessions`) owns the anti-spam gate — it invokes this only
+ * when `missedCount > 0` OR (watermark unknown AND there are turns).
+ */
+function formatReattachRecap(args) {
+    const { missedCount, turns, isActive, isWatermarkKnown } = args;
+    if (turns.length === 0)
+        return null;
+    const header = isWatermarkKnown && missedCount > 0
+        ? (0, i18n_1.t)('recap.missedCountHeader', { count: missedCount })
+        : (0, i18n_1.t)('recap.restartedFallbackHeader');
+    const lines = [header, ...renderTurns(turns)];
+    if (isActive)
+        lines.push((0, i18n_1.t)('recap.stillWorkingLine'));
+    return lines.join('\n\n');
+}
+//# sourceMappingURL=resumeContext.js.map

package/dist/resumeContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resumeContext.js","sourceRoot":"","sources":["../src/resumeContext.ts"],"names":[],"mappings":";;;AAwBA,kCAQC;AAiBD,kDAKC;AAoBD,oEASC;AAqBD,kDAiBC;AAzHD,iCAA2B;AAC3B,mEAAqE;AAGrE;;;;;;GAMG;AACU,QAAA,sBAAsB,GAAG,CAAC,CAAC;AAExC;;;;;;;;;;GAUG;AACH,SAAgB,WAAW,CAAC,KAAmB;IAC7C,MAAM,SAAS,GAAG,IAAA,QAAC,EAAC,2BAA2B,CAAC,CAAC;IACjD,MAAM,cAAc,GAAG,IAAA,QAAC,EAAC,gCAAgC,CAAC,CAAC;IAC3D,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;QACxB,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,cAAc,CAAC;QAChE,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,IAAA,kDAA0B,EAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;QAC7F,OAAO,GAAG,KAAK,IAAI,WAAW,EAAE,CAAC;IACnC,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,mBAAmB,CAAC,KAAmB;IACrD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAEpC,MAAM,MAAM,GAAG,IAAA,QAAC,EAAC,uBAAuB,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;IACnE,OAAO,CAAC,MAAM,EAAE,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AACtD,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,4BAA4B,CAAC,IAK5C;IACC,MAAM,EAAE,WAAW,EAAE,gBAAgB,EAAE,QAAQ,EAAE,WAAW,EAAE,GAAG,IAAI,CAAC;IACtE,IAAI,WAAW,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IACjC,OAAO,WAAW,IAAI,CAAC,gBAAgB,IAAI,QAAQ,CAAC;AACtD,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,mBAAmB,CAAC,IAKnC;IACC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,QAAQ,EAAE,gBAAgB,EAAE,GAAG,IAAI,CAAC;IAChE,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAEpC,MAAM,MAAM,GACV,gBAAgB,IAAI,WAAW,GAAG,CAAC;QACjC,CAAC,CAAC,IAAA,QAAC,EAAC,yBAAyB,EAAE,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC;QACtD,CAAC,CAAC,IAAA,QAAC,EAAC,+BAA+B,CAAC,CAAC;IAEzC,MAAM,KAAK,GAAG,CAAC,MAAM,EAAE,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;IAC9C,IAAI,QAAQ;QAAE,KAAK,CAAC,IAAI,CAAC,IAAA,QAAC,EAAC,wBAAwB,CAAC,CAAC,CAAC;IACtD,OAAO,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAC5B,CAAC"}

package/dist/scheduler/checkRun.d.ts

@@ -0,0 +1,95 @@
+/**
+ * @description The `'check'` delivery kind: a watchdog the agent creates with
+ * `schedule_create` + `checkCommand`. At fire time the BOT runs the command in the
+ * topic's bound folder; exit 0 is a pass and stays silent. The first failure after
+ * a pass pins an alert and wakes the agent with the job's prompt plus the failure
+ * and the output tail; further failures stay silent until a run passes again,
+ * which posts one unpinned "passes again" line.
+ *
+ * WHY the bot runs it: a watcher the agent builds itself (a background loop,
+ * `nohup`, a `sleep` loop, a tmux pane) dies with the session, a bot restart or a
+ * crash, and then fails silently. A schedule is persisted, re-armed at boot and
+ * catches up a run missed while the bot was down.
+ *
+ * The command runs as the bot's own user, the same user the agent's shell tools
+ * run as, so it grants the agent nothing it could not already do.
+ */
+/** Timeout applied when `schedule_create` leaves `checkTimeoutSeconds` out. */
+export declare const defaultCheckTimeoutSec = 60;
+/** Upper bound of `checkTimeoutSeconds`: a check is a probe, not a job. */
+export declare const maxCheckTimeoutSec = 600;
+/** Longest `checkCommand` accepted. */
+export declare const maxCheckCommandLength = 1000;
+/** Output kept from a run (its TAIL — the end of a log is where the failure is). */
+export declare const checkOutputMaxChars = 3000;
+/**
+ * Output tail shown in the topic alert. Shorter than {@link checkOutputMaxChars}
+ * so the alert stays under Telegram's 4096-character message cap with the
+ * command and the job name around it; the agent gets the full kept tail.
+ */
+export declare const checkAlertOutputMaxChars = 1500;
+/**
+ * @name CheckRunResult
+ * @description One finished check run. `exitCode` is null when the process was
+ * killed by a signal or never started (`startError`).
+ */
+export interface CheckRunResult {
+    exitCode: number | null;
+    signal: NodeJS.Signals | null;
+    isTimedOut: boolean;
+    /** Why the shell could not be started (e.g. the folder is gone). */
+    startError?: string;
+    /** Combined stdout + stderr, the last {@link checkOutputMaxChars} characters. */
+    output: string;
+}
+/** @description A run passes only when it exited 0 within its timeout. */
+export declare function checkIsCheckPassing(result: CheckRunResult): boolean;
+/**
+ * What a finished run should produce: nothing (`quiet`), the alert that wakes
+ * the agent (`alert`), or the one "passes again" line (`recovered`).
+ */
+export type CheckAlertDecision = 'quiet' | 'alert' | 'recovered';
+/**
+ * @description Alert on the passing → failing edge only, and announce the
+ * failing → passing edge once. A check that keeps failing stays quiet: it already
+ * raised its alert and woke the agent, and repeating that on every run would bury
+ * the topic in pins.
+ */
+export declare function getCheckAlertDecision(input: {
+    isPassing: boolean;
+    wasFailing: boolean;
+}): CheckAlertDecision;
+/** @description Short technical description of a failed run: `exit 3`, `timeout 60s`, `SIGKILL`. */
+export declare function describeCheckFailure(result: CheckRunResult, timeoutSec: number): string;
+/** @description The last `maxChars` characters of `text`, marked when something was cut. */
+export declare function getOutputTail(text: string, maxChars: number): string;
+/** @description The command as the topic alert shows it, cut to a readable length. */
+export declare function getCheckAlertCommand(command: string): string;
+/**
+ * @description The prompt the agent is woken with: what failed and how, the
+ * output tail, then the job's own prompt (what to do about it). English, like the
+ * `[Scheduled run]` marker — it is read by the agent, never shown in the topic.
+ */
+export declare function buildCheckFailurePrompt(input: {
+    name: string;
+    command: string;
+    failure: string;
+    output: string;
+    prompt: string;
+}): string;
+/** @description The bot's environment minus the variables a check must not see. */
+export declare function buildCheckEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+/**
+ * @description Run `command` through `/bin/sh -c` in `cwd` and collect its output
+ * tail. The shell leads its own process group, so a run that outlives
+ * `timeoutMs` is stopped together with everything it started: SIGTERM to the
+ * group, SIGKILL after a grace period. Never rejects — a shell that cannot start
+ * resolves with `startError`.
+ */
+export declare function runCheckCommand(input: {
+    command: string;
+    cwd: string;
+    timeoutMs: number;
+    env: NodeJS.ProcessEnv;
+}): Promise<CheckRunResult>;
+//# sourceMappingURL=checkRun.d.ts.map

package/dist/scheduler/checkRun.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkRun.d.ts","sourceRoot":"","sources":["../../src/scheduler/checkRun.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AAEH,+EAA+E;AAC/E,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC,2EAA2E;AAC3E,eAAO,MAAM,kBAAkB,MAAM,CAAC;AAEtC,uCAAuC;AACvC,eAAO,MAAM,qBAAqB,OAAO,CAAC;AAE1C,oFAAoF;AACpF,eAAO,MAAM,mBAAmB,OAAO,CAAC;AAExC;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAW7C;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC;IAC9B,UAAU,EAAE,OAAO,CAAC;IACpB,oEAAoE;IACpE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iFAAiF;IACjF,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,0EAA0E;AAC1E,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAEnE;AAED;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,OAAO,GAAG,WAAW,CAAC;AAEjE;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAE,GAAG,kBAAkB,CAG5G;AAED,oGAAoG;AACpG,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAKvF;AAED,4FAA4F;AAC5F,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGpE;AAED,sFAAsF;AACtF,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAI5D;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,MAAM,CAeT;AAED,mFAAmF;AACnF,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,CAIvE;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;CACxB,GAAG,OAAO,CAAC,cAAc,CAAC,CAoD1B"}

package/dist/scheduler/checkRun.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAlertOutputMaxChars = exports.checkOutputMaxChars = exports.maxCheckCommandLength = exports.maxCheckTimeoutSec = exports.defaultCheckTimeoutSec = void 0;
+exports.checkIsCheckPassing = checkIsCheckPassing;
+exports.getCheckAlertDecision = getCheckAlertDecision;
+exports.describeCheckFailure = describeCheckFailure;
+exports.getOutputTail = getOutputTail;
+exports.getCheckAlertCommand = getCheckAlertCommand;
+exports.buildCheckFailurePrompt = buildCheckFailurePrompt;
+exports.buildCheckEnv = buildCheckEnv;
+exports.runCheckCommand = runCheckCommand;
+const node_child_process_1 = require("node:child_process");
+/**
+ * @description The `'check'` delivery kind: a watchdog the agent creates with
+ * `schedule_create` + `checkCommand`. At fire time the BOT runs the command in the
+ * topic's bound folder; exit 0 is a pass and stays silent. The first failure after
+ * a pass pins an alert and wakes the agent with the job's prompt plus the failure
+ * and the output tail; further failures stay silent until a run passes again,
+ * which posts one unpinned "passes again" line.
+ *
+ * WHY the bot runs it: a watcher the agent builds itself (a background loop,
+ * `nohup`, a `sleep` loop, a tmux pane) dies with the session, a bot restart or a
+ * crash, and then fails silently. A schedule is persisted, re-armed at boot and
+ * catches up a run missed while the bot was down.
+ *
+ * The command runs as the bot's own user, the same user the agent's shell tools
+ * run as, so it grants the agent nothing it could not already do.
+ */
+/** Timeout applied when `schedule_create` leaves `checkTimeoutSeconds` out. */
+exports.defaultCheckTimeoutSec = 60;
+/** Upper bound of `checkTimeoutSeconds`: a check is a probe, not a job. */
+exports.maxCheckTimeoutSec = 600;
+/** Longest `checkCommand` accepted. */
+exports.maxCheckCommandLength = 1000;
+/** Output kept from a run (its TAIL — the end of a log is where the failure is). */
+exports.checkOutputMaxChars = 3000;
+/**
+ * Output tail shown in the topic alert. Shorter than {@link checkOutputMaxChars}
+ * so the alert stays under Telegram's 4096-character message cap with the
+ * command and the job name around it; the agent gets the full kept tail.
+ */
+exports.checkAlertOutputMaxChars = 1500;
+/** Command text shown in the topic alert. */
+const checkAlertCommandMaxChars = 300;
+/** Pause between SIGTERM and SIGKILL for a check that outlived its timeout. */
+const checkKillGraceMs = 5000;
+/** Environment variables a check never sees: its output is posted into the topic. */
+const checkHiddenEnvNames = ['TELEGRAM_BOT_TOKEN'];
+/** @description A run passes only when it exited 0 within its timeout. */
+function checkIsCheckPassing(result) {
+    return result.exitCode === 0 && !result.isTimedOut && result.startError === undefined;
+}
+/**
+ * @description Alert on the passing → failing edge only, and announce the
+ * failing → passing edge once. A check that keeps failing stays quiet: it already
+ * raised its alert and woke the agent, and repeating that on every run would bury
+ * the topic in pins.
+ */
+function getCheckAlertDecision(input) {
+    if (input.isPassing)
+        return input.wasFailing ? 'recovered' : 'quiet';
+    return input.wasFailing ? 'quiet' : 'alert';
+}
+/** @description Short technical description of a failed run: `exit 3`, `timeout 60s`, `SIGKILL`. */
+function describeCheckFailure(result, timeoutSec) {
+    if (result.startError !== undefined)
+        return `error: ${result.startError}`;
+    if (result.isTimedOut)
+        return `timeout ${timeoutSec}s`;
+    if (result.exitCode !== null)
+        return `exit ${result.exitCode}`;
+    return result.signal ?? 'killed';
+}
+/** @description The last `maxChars` characters of `text`, marked when something was cut. */
+function getOutputTail(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    return `…${text.slice(text.length - maxChars + 1)}`;
+}
+/** @description The command as the topic alert shows it, cut to a readable length. */
+function getCheckAlertCommand(command) {
+    return command.length <= checkAlertCommandMaxChars
+        ? command
+        : `${command.slice(0, checkAlertCommandMaxChars - 1)}…`;
+}
+/**
+ * @description The prompt the agent is woken with: what failed and how, the
+ * output tail, then the job's own prompt (what to do about it). English, like the
+ * `[Scheduled run]` marker — it is read by the agent, never shown in the topic.
+ */
+function buildCheckFailurePrompt(input) {
+    const output = input.output.trim() || '(no output)';
+    return [
+        `[Scheduled check "${input.name}" failed]`,
+        `Command (run by the bot in this folder): ${input.command}`,
+        `Result: ${input.failure}`,
+        'Output (tail):',
+        '```',
+        output,
+        '```',
+        '',
+        'The bot stays silent while the check keeps failing and tells the topic when it passes again.',
+        '',
+        input.prompt,
+    ].join('\n');
+}
+/** @description The bot's environment minus the variables a check must not see. */
+function buildCheckEnv(env) {
+    const checkEnv = { ...env };
+    for (const name of checkHiddenEnvNames)
+        delete checkEnv[name];
+    return checkEnv;
+}
+/**
+ * @description Run `command` through `/bin/sh -c` in `cwd` and collect its output
+ * tail. The shell leads its own process group, so a run that outlives
+ * `timeoutMs` is stopped together with everything it started: SIGTERM to the
+ * group, SIGKILL after a grace period. Never rejects — a shell that cannot start
+ * resolves with `startError`.
+ */
+function runCheckCommand(input) {
+    return new Promise((resolve) => {
+        let output = '';
+        let isTimedOut = false;
+        let killTimer = null;
+        let isSettled = false;
+        const child = (0, node_child_process_1.spawn)('/bin/sh', ['-c', input.command], {
+            cwd: input.cwd,
+            env: input.env,
+            detached: true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const appendOutput = (chunk) => {
+            output = getOutputTail(output + chunk.toString('utf-8'), exports.checkOutputMaxChars);
+        };
+        child.stdout?.on('data', appendOutput);
+        child.stderr?.on('data', appendOutput);
+        const signalGroup = (signal) => {
+            if (child.pid === undefined)
+                return;
+            try {
+                process.kill(-child.pid, signal);
+            }
+            catch {
+                // The group already exited.
+            }
+        };
+        const timeoutTimer = setTimeout(() => {
+            isTimedOut = true;
+            signalGroup('SIGTERM');
+            killTimer = setTimeout(() => signalGroup('SIGKILL'), checkKillGraceMs);
+            killTimer.unref?.();
+        }, input.timeoutMs);
+        timeoutTimer.unref?.();
+        const settle = (result) => {
+            if (isSettled)
+                return;
+            isSettled = true;
+            clearTimeout(timeoutTimer);
+            if (killTimer)
+                clearTimeout(killTimer);
+            resolve(result);
+        };
+        child.on('error', (error) => {
+            settle({ exitCode: null, signal: null, isTimedOut: false, startError: error.message, output });
+        });
+        child.on('close', (exitCode, signal) => {
+            settle({ exitCode, signal, isTimedOut, output });
+        });
+    });
+}
+//# sourceMappingURL=checkRun.js.map