charness 0.0.0-stage → 3.0.0

package/dist/requests/types.d.ts

@@ -0,0 +1,181 @@
+/**
+ * @description Shapes of the request ledger (core plan S2). A REQUEST is one unit
+ * of work the agent owes an answer to — an operator message, a scheduled run, a
+ * tracker event. At most one request per REQUEST GROUP (conversation + requester,
+ * `requestGroup.ts`) is OPEN; a closed one moves to the append-only history.
+ */
+/**
+ * @name RequestOriginKind
+ * @description What raised a request, for the agent-facing header and the logs.
+ *  - `message`      — a person wrote in the conversation.
+ *  - `scheduledRun` — a scheduled prompt fired.
+ *  - `trackerEvent` — a tracker connector picked an issue up (e.g. an assignment).
+ */
+export type RequestOriginKind = 'message' | 'scheduledRun' | 'trackerEvent';
+/**
+ * @name RequestOrigin
+ * @description Where a request came from. `attributes` are connector-owned facts
+ * the platform's answer sink needs to deliver back (a tracker's issue key and
+ * trigger id, the requester to hand back to); the core stores them verbatim and
+ * never interprets them.
+ */
+export interface RequestOrigin {
+    kind: RequestOriginKind;
+    attributes: Record<string, string>;
+}
+/**
+ * @name RequestCloseReason
+ * @description Why a request left the open set.
+ *  - `final`      — the agent answered with the result.
+ *  - `question`   — the agent asked the requester; their reply is a new request.
+ *  - `superseded` — a newer request of the same group (same conversation, same
+ *    requester) arrived; the answer to that one covers what this one asked
+ *    (or, when this one was answered first, only what the newer one adds).
+ *  - `cancelled`  — the work was stopped without an answer (interrupt, quit,
+ *    leaving the folder, a view switch that turns requests off).
+ */
+export type RequestCloseReason = 'final' | 'question' | 'superseded' | 'cancelled';
+/**
+ * @name RequestPromptOutcome
+ * @description What became of a request's prompt (Jira prompt context C4).
+ *  - `takenIn` — the agent took it in: `isPromptTakenIn` was set, or the request
+ *    was closed by its own `question` / `final` answer.
+ *  - `dropped` — the request closed otherwise (superseded, cancelled) before that.
+ */
+export type RequestPromptOutcome = 'takenIn' | 'dropped';
+/**
+ * @name OpenRequestState
+ * @description An open request as persisted in `state.json` `openRequests`
+ * (keyed by its serialized request group, `requestGroup.ts`). The wake-up fields are
+ * owned by the wake-up engine (S4) and persisted here so a restart keeps them.
+ */
+export interface OpenRequestState {
+    id: string;
+    origin: RequestOrigin;
+    /** Epoch ms the request was created. */
+    createdAt: number;
+    /** `progress` answers delivered so far (a `question` / `final` closes it). */
+    progressAnswerCount: number;
+    /** Consecutive turns that ended without any answer. */
+    silentTurnCount: number;
+    /** Wake-ups delivered for this request (the loop-guard cap counts these). */
+    wakeCount: number;
+    /** Epoch ms of the next scheduled wake-up, when one is armed. */
+    nextWakeAt?: number;
+    /** Epoch ms the agent was last seen working on it (the backstop counts from here). */
+    lastTurnActivityAt?: number;
+    /** Set once the wake-up rules gave up (alert or cap): nothing wakes it again. */
+    isWakeStopped: boolean;
+    /**
+     * The request's own prompt, kept so a request whose prompt never reached the
+     * agent — its post failed, a restart came first, a usage-limit wait held it —
+     * gets the prompt again on its next wake-up instead of a bare reminder (Jira
+     * plan R21). Absent when the request was opened without one, or it was over
+     * `requestPromptMaxLength`.
+     */
+    prompt?: string;
+    /** Set once a turn that carried `prompt` was seen taken in by the session. */
+    isPromptTakenIn?: boolean;
+    /** Post retries scheduled so far after the prompt's post failed (R28); absent = none. */
+    postRetryCount?: number;
+    /** Epoch ms of the next post retry, while one is due (R28). */
+    nextPostRetryAt?: number;
+    /**
+     * Set while a usage-limit wait will not end by itself (auto-resume off, the
+     * operator skipped or disabled the resume, the bot gave up its attempts):
+     * nothing wakes the request, as with `isWakeStopped`, but this one is LIFTED
+     * when a limit wait later ends with a resume. Absent = not stopped.
+     */
+    isLimitStopped?: boolean;
+    /**
+     * Which limit wait the bot already answered this request about (see
+     * `getUsageLimitWaitIdentity`), so each request hears about each wait once.
+     */
+    limitWaitAnsweredFor?: string;
+    /**
+     * The platform's handle on the alert posted when the wake-up rules gave up
+     * (Telegram: the pinned message id), so the alert is released when the
+     * request closes. Opaque to the core.
+     */
+    alertRef?: string;
+    /**
+     * The still-open requests of the same group this one replaced when it was
+     * created — the one open at the time and, through it, the ones that one had
+     * replaced (oldest first, bounded by `supersededRequestIdsMaxLength`). The
+     * header names them so the agent gives ONE answer covering them all. Absent
+     * when nothing was replaced.
+     */
+    supersededRequestIds?: string[];
+}
+/**
+ * @name OpenRequestUpdate
+ * @description The fields of an open request the answer handling and the
+ * wake-up engine may change.
+ */
+export type OpenRequestUpdate = Partial<Pick<OpenRequestState, 'progressAnswerCount' | 'silentTurnCount' | 'wakeCount' | 'nextWakeAt' | 'lastTurnActivityAt' | 'isWakeStopped' | 'isLimitStopped' | 'limitWaitAnsweredFor' | 'alertRef' | 'isPromptTakenIn' | 'postRetryCount' | 'nextPostRetryAt'>>;
+/**
+ * @name ClosedRequestRecord
+ * @description One line of the request history (`DATA_DIR/requests.jsonl`): the
+ * request as it was when it closed, plus its conversation and why it closed.
+ */
+export interface ClosedRequestRecord extends OpenRequestState {
+    /** The conversation's serialized `SessionKey`. */
+    conversationKey: string;
+    /** Epoch ms the request closed. */
+    closedAt: number;
+    closeReason: RequestCloseReason;
+    /** For `superseded`: the id of the request that replaced it (an answer to it covers this one). */
+    supersededBy?: string;
+}
+/**
+ * @name RequestLookup
+ * @description A request found by id, open or closed. A closed request is still
+ * known so an answer to it can be delivered without changing any request.
+ */
+export type RequestLookup = {
+    isOpen: true;
+    conversationKey: string;
+    request: OpenRequestState;
+} | {
+    isOpen: false;
+    conversationKey: string;
+    request: ClosedRequestRecord;
+};
+/**
+ * @name RequestAnswerKind
+ * @description What an `answer_request` call is.
+ *  - `progress` — an interim note; the request stays open.
+ *  - `question` — the agent needs the requester; closes the request (their reply
+ *    is a new request).
+ *  - `final`    — the result; closes the request.
+ */
+export type RequestAnswerKind = 'progress' | 'question' | 'final';
+/**
+ * @name RequestWakeUpReason
+ * @description Why the agent is reminded of an open request.
+ *  - `silentTurn` — its turn ended without any answer.
+ *  - `progressFollowUp` — it sent a progress note and the follow-up delay passed.
+ *  - `backstop` — nothing was seen working on it for the backstop window (a dead
+ *    process, or tracking lost across a restart).
+ *  - `postRetry` — the request's prompt could not be posted; tried again soon
+ *    (Jira plan R28).
+ */
+export type RequestWakeUpReason = 'silentTurn' | 'progressFollowUp' | 'backstop' | 'postRetry';
+/**
+ * @name RequestAlertReason
+ * @description Why the wake-up rules gave up and a person is told.
+ *  - `silentTurns` — the agent ended turns without answering twice in a row.
+ *  - `wakeCap` — the request used up its wake-ups (the loop guard).
+ *  - `wakeFailed` — the session could not be reached to deliver a reminder.
+ */
+export type RequestAlertReason = 'silentTurns' | 'wakeCap' | 'wakeFailed';
+/**
+ * @name UnreleasedRequestAlert
+ * @description The alert of a closed request that still has to be released: its
+ * conversation (serialized key) and the platform's alert handle.
+ */
+export interface UnreleasedRequestAlert {
+    conversationKey: string;
+    alertRef: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/requests/types.d.ts.map

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

package/dist/requests/types.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * @description Shapes of the request ledger (core plan S2). A REQUEST is one unit
+ * of work the agent owes an answer to — an operator message, a scheduled run, a
+ * tracker event. At most one request per REQUEST GROUP (conversation + requester,
+ * `requestGroup.ts`) is OPEN; a closed one moves to the append-only history.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/requests/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/requests/types.ts"],"names":[],"mappings":";AAAA;;;;;GAKG"}

package/dist/requests/wakeUpEngine.d.ts

@@ -0,0 +1,160 @@
+import { type SessionKey } from '../sessionKey';
+import type { RequestLedger } from './requestLedger';
+import type { OpenRequestState, RequestAlertReason, RequestAnswerKind } from './types';
+import { type WakeUpMessage } from './requestHeader';
+import { type SessionTurnProbe } from './wakeUpRules';
+/**
+ * @description The wake-up engine of the request/answer core (S4): it watches
+ * the turn each request (or reminder) started until that turn ends — one watch
+ * per REQUEST, so two requesters' open requests in one conversation are each
+ * followed to their own turn end (`requestGroup.ts`) — and runs a
+ * slower sweep over the open requests nobody is watching (the 15-minute
+ * follow-up after a progress note, and the backstop). Every decision is made by
+ * `wakeUpRules.ts`; this module only observes, persists and acts. The same sweep
+ * follows the agent's text after a final answer in a view that hides the stream
+ * (`answerTail.ts`), and reminds the agent once when that text is worth it.
+ *
+ * No adapter emits a turn-end event, so turns are POLLED through the injected
+ * `probeTurn` (the precedent is the deferred-compaction poll). The watch state is
+ * in memory: after a restart the persisted request times drive the sweep, and the
+ * backstop covers a turn whose tracking was lost.
+ *
+ * A wake-up is a reminder forwarded into the SAME session — never a request.
+ * The answer tails are in memory as well: a restart forgets them.
+ */
+/** How often a watched turn is polled for its end. */
+export declare const watchedTurnPollMs = 10000;
+/** How often the unwatched open requests are swept (follow-ups, backstop). */
+export declare const unwatchedSweepMs = 60000;
+/** A live turn's activity is persisted at most this often (it pushes the backstop back). */
+export declare const turnActivityPersistStepMs = 60000;
+/**
+ * @name RequestWakeUpEngineDeps
+ * @description `prepareWakeUpSession` makes sure the conversation has a live
+ * session for `message` (resuming a dead one) and resolves `false` when it could
+ * not; `forwardWakeUp` then writes the message into it. They are two steps because
+ * a resume takes seconds, and the request may be answered, cancelled or
+ * superseded meanwhile — the engine re-checks in between. `deliverAlert` tells a
+ * person and resolves the platform's alert handle, `null` when nothing needs
+ * releasing later (the ledger stores and releases it). `now` is injectable for tests.
+ */
+export interface RequestWakeUpEngineDeps {
+    ledger: Pick<RequestLedger, 'getOpenRequestById' | 'listOpenRequestsOf' | 'listOpenRequests' | 'updateOpenRequest' | 'closeRequest' | 'recordAlert'>;
+    probeTurn: (key: SessionKey) => SessionTurnProbe;
+    prepareWakeUpSession: (key: SessionKey, message: WakeUpMessage) => Promise<boolean>;
+    /** Forward the wake-up's message (the request's prompt again, or a reminder) into the session. */
+    forwardWakeUp: (key: SessionKey, request: OpenRequestState, message: WakeUpMessage) => Promise<void>;
+    deliverAlert: (key: SessionKey, request: OpenRequestState, reason: RequestAlertReason) => Promise<string | null>;
+    backstopMs: number;
+    /** Whether the conversation's view hides the agent's stream: only then is a final answer's tail followed. Absent: never. */
+    checkIsAnswerTailWatched?: (key: SessionKey) => boolean;
+    /** Bring the session up (resume only) and forward the answer-tail reminder; `false` when it could not be reached. */
+    remindAnswerTail?: (key: SessionKey, text: string) => Promise<boolean>;
+    now?: () => number;
+}
+export declare class RequestWakeUpEngine {
+    private readonly deps;
+    private readonly now;
+    /** The watched turns by REQUEST id (a conversation may hold one per requester). */
+    private readonly watched;
+    /** Last persisted live-turn activity per request id, for the persist step. */
+    private readonly activityPersistedAt;
+    /** The tail after the latest final answer, by serialized conversation key. */
+    private readonly answerTails;
+    /** The request whose tail was last reminded and how often, by serialized conversation key (the reminder cap). */
+    private readonly answerTailReminders;
+    private pollTimer;
+    private sweepTimer;
+    private isPolling;
+    private isSweeping;
+    constructor(deps: RequestWakeUpEngineDeps);
+    /**
+     * @description Start the poll and sweep timers (unref'd: they never keep the
+     * process alive). A rejected tick is logged: unhandled, it would end the whole
+     * process (Node's default for an unhandled rejection).
+     */
+    start(): void;
+    /** @description Stop both timers (shutdown). The persisted request times survive. */
+    stop(): void;
+    /** The open request `requestId` when it belongs to `key`'s conversation, else `undefined`. */
+    private getOpenRequestOf;
+    /** The watched turns of `key`'s conversation. */
+    private getWatchedTurnsOf;
+    /**
+     * @description A request's message (or a reminder for it) was just forwarded to
+     * the conversation's session: watch the turn it starts. A watch already there
+     * for the SAME request is replaced — its newest message is the one that counts;
+     * another requester's request in the conversation keeps its own watch. A post
+     * retry still pending is moot from now on (R28): the session has the request.
+     */
+    trackForwardedTurn(key: SessionKey, requestId: string, options?: {
+        isRequestPrompt: boolean;
+    }): Promise<void>;
+    /**
+     * @description The request's prompt could not be posted to the session (no
+     * session came up, the forward failed): try again soon (R28). Once the retries
+     * are spent nothing is scheduled — the backstop and its alert take over. Never
+     * rejects: its caller is a post that already failed.
+     */
+    notePostFailed(key: SessionKey, requestId: string): Promise<void>;
+    /** @description The agent produced output in this conversation (a turn is under way). */
+    noteAgentOutput(key: SessionKey): void;
+    /**
+     * @description An answer to `requestId` was delivered. Any answer ends the
+     * tail of the one before: the agent spoke to the requester. A final answer
+     * starts a fresh tail where the view hides the stream, unless its request
+     * already had all its reminders.
+     */
+    noteAnswerDelivered(key: SessionKey, requestId: string, kind: RequestAnswerKind): void;
+    /** @description The agent wrote text of its own in this conversation (not a sub-agent's, not a block the bot made). */
+    noteAnswerTailOutput(key: SessionKey): void;
+    /** Drop every watch of `key`'s conversation, its answer tail included. */
+    private unwatchConversation;
+    /**
+     * @description The person took over (interrupted, quit, restarted, switched or
+     * resumed the session, left the folder): every open request of the
+     * conversation closes silently and nothing wakes them.
+     */
+    cancelConversation(key: SessionKey): Promise<void>;
+    /**
+     * @description The bot itself forwarded a "continue" nudge into the session (an
+     * API-error retry fired, or a usage-limit wait ended): watch the turn it starts
+     * as a fresh one, so the idle the error left behind is never read as its end.
+     * `isCountersReset` (the end of a limit wait) starts every open request's
+     * wake-up bookkeeping from zero — the wait was not the agent's silence — and
+     * lifts a limit stop: the work continues, so does the waking. A request the
+     * rules already gave up on stays given up. The one session turn the nudge
+     * starts is watched for every open request of the conversation.
+     */
+    trackContinuationTurn(key: SessionKey, options: {
+        isCountersReset: boolean;
+        isRequestPrompt?: boolean;
+    }): Promise<void>;
+    /**
+     * @description A usage-limit wait will not end by itself (auto-resume is off,
+     * the operator skipped or disabled this resume, or the bot gave up after its
+     * last attempt): nothing wakes the open request, the backstop included — a
+     * reminder would only spend an attempt against the same limit — until a limit
+     * wait ends with a resume or the operator's next message supersedes it. Never
+     * rejects: its callers are command handlers and the error path, and a failed
+     * write is logged instead.
+     */
+    stopWakingForLimitWait(key: SessionKey): Promise<void>;
+    /** @description One poll over the watched turns; exported for tests (the timer calls it). */
+    pollWatchedTurns(): Promise<void>;
+    private pollWatchedTurn;
+    /** @description One sweep over the open requests nobody watches; exported for tests. */
+    sweepUnwatchedRequests(): Promise<void>;
+    private sweepOpenRequest;
+    private sweepAnswerTail;
+    /** Persist that the agent is working on it, at most once per step unless forced. */
+    private recordTurnActivity;
+    private applyDecision;
+    /**
+     * Resume the session if needed, re-check the request, forward the reminder. A
+     * step that threw did not reach the session: same as one that could not.
+     */
+    private deliverWakeUpSafely;
+    private raiseAlert;
+}
+//# sourceMappingURL=wakeUpEngine.d.ts.map

package/dist/requests/wakeUpEngine.d.ts.map

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