@songsid/agend 2.1.4-beta.5 → 2.1.4-beta.50

package/dist/general-knowledge/skills/worker-collaboration/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: worker-collaboration
+description: Complete assigned fleet work as a worker, report the result to the assigning instance, and request missing information without taking over coordinator duties.
+roles: [worker]
+---
+
+# Worker Collaboration
+
+## Complete assigned work
+
+- Treat the assignment as the full scope unless the sender explicitly expands it.
+- Work without acknowledgment-only messages. Silence means the task is in progress.
+- Do not call `delegate_task`; delegation and fleet orchestration belong to General.
+
+## Request missing information
+
+Use `request_information` only when a concrete missing fact blocks safe progress. Ask the assigning instance one focused question and preserve the task correlation ID when the tool supports it.
+
+Do not resend after a timeout without checking delivery evidence. A timeout can mean the request was queued or delivered while the caller stopped waiting.
+
+## Report the result
+
+Call `report_result` exactly once when the assignment is complete or genuinely blocked. Send it to the assigning instance with the original correlation ID. Include:
+
+- the conclusion or delivered artifact;
+- material changes and file paths;
+- tests or checks run and their results;
+- remaining risk, blocker, or follow-up, if any.
+
+Do not put user-facing results only in terminal text; the fleet report is the delivery channel.

package/dist/instance-lifecycle.d.ts

@@ -5,6 +5,10 @@ import type { IpcClient } from "./channel/ipc-bridge.js";
 import type { EventLog } from "./event-log.js";
 import type { TmuxControlClient } from "./tmux-control.js";
 import type { FleetInstructionsParams } from "./instructions.js";
+import { type ProviderUsage } from "./usage/providers.js";
+import type { SpawnGate } from "./spawn-gate.js";
+import type { StormWindow } from "./storm-window.js";
+import type { BackendOutageTracker } from "./backend-outage.js";
 export { isFleetStartCommandLine } from "./fleet-lock.js";
 export interface BackendInstallationInfo {
     binary: string;
@@ -34,7 +38,21 @@ export interface LifecycleContext {
     readonly sessionRegistry: Map<string, string>;
     readonly eventLog: EventLog | null;
     readonly controlClient: TmuxControlClient | null;
+    readonly spawnGate?: SpawnGate;
+    readonly stormWindow?: StormWindow;
+    /** Fleet-level backend reachability memory (see backend-outage.ts). */
+    readonly backendOutage?: BackendOutageTracker;
     getInstanceDir(name: string): string;
+    /** Fleet-level (General topic) notification, throttled per message text. */
+    notifyFleetError?(text: string): void;
+    /** Hand a failed/blocked instance to the fleet's delayed automatic startup retry. */
+    scheduleStartupRetry?(name: string, attempt: number): void;
+    /**
+     * Stop THIS daemon (identity-checked) and schedule the delayed startup retry,
+     * serialized against operator stop/restart so neither can be undone by the
+     * other. Fleet-owned; the lifecycle falls back to stopIfCurrent without it.
+     */
+    handOffToStartupRetry?(name: string, daemon: unknown): Promise<void>;
     saveFleetConfig(): void;
     /** Full stop+start. freshStart forces the respawn to skip session resume. */
     restartSingleInstance(name: string, opts?: {
@@ -57,6 +75,8 @@ export interface LifecycleContext {
     isClassicInstance?(name: string): boolean;
     /** True while the fleet is stopping on purpose or an `agend update` is running. */
     isPlannedRestart(): boolean;
+    /** Suppress only incident kinds caused by the active tmux server storm. */
+    stormSuppressed?(kind: string): boolean;
     /** List claimed tasks for an instance (from task board). Returns empty array if unavailable. */
     listClaimedTasks(assignee: string): Array<{
         id: string;
@@ -66,6 +86,10 @@ export interface LifecycleContext {
     checkModelFailover(name: string, fiveHourPct: number): void;
     /** Retire (delete) any pending Cancel button for an instance. No-op if none. */
     clearCancelButton(name: string): void;
+    /** Test/integration seam for the non-LLM Codex quota second opinion. */
+    verifyCodexQuota?(): Promise<CodexQuotaVerdict>;
+    /** Test/integration seam for the non-LLM Claude quota second opinion. */
+    verifyClaudeQuota?(): Promise<ClaudeQuotaVerdict>;
     startStatuslineWatcher(name: string): void;
     stopStatuslineWatcher(name: string): void;
     reactMessageStatus(instanceName: string, chatId: string, messageId: string, emoji: string): void;
@@ -88,6 +112,8 @@ export interface LifecycleCreateArgs {
     description?: string;
     model?: string;
     backend?: string;
+    /** Backend-specific launch options, e.g. { codex: { provider: "glm" } }. */
+    backend_options?: Record<string, Record<string, unknown>>;
     branch?: string;
     detach?: boolean;
     worktree_path?: string;
@@ -111,12 +137,45 @@ export interface LifecycleReplaceArgs {
     name: string;
     reason?: string;
 }
+export type CodexQuotaVerdict = "available" | "exhausted" | "unknown";
+type CodexUsageResult = Omit<ProviderUsage, "id" | "name">;
+export type ClaudeQuotaVerdict = "available" | "exhausted" | "unknown";
+type ClaudeUsageResult = Omit<ProviderUsage, "id" | "name">;
+/**
+ * Convert the live Codex usage row into a conservative quota verdict. A
+ * successful response with at least one window below 100% proves that stale
+ * terminal text is no longer current only when no other window is exhausted.
+ * Missing credentials, API errors, and metric-less responses prove nothing.
+ */
+export declare function codexQuotaVerdictFromUsage(usage: CodexUsageResult): CodexQuotaVerdict;
+/** Run only the Codex usage provider, bounded independently of its network timeout. */
+export declare function verifyCodexQuotaStatus(fetchUsage?: () => Promise<CodexUsageResult>, timeoutMs?: number): Promise<CodexQuotaVerdict>;
+/**
+ * Convert a LIVE Claude usage API row into a conservative verdict. The
+ * provider can degrade to statusline data when the network/API is unavailable;
+ * that fallback is intentionally unknown because stale local limits cannot
+ * disprove a current API credit-balance error.
+ */
+export declare function claudeQuotaVerdictFromUsage(usage: ClaudeUsageResult): ClaudeQuotaVerdict;
+/** Run only the Claude usage provider, bounded independently of its network timeout. */
+export declare function verifyClaudeQuotaStatus(fetchUsage?: () => Promise<ClaudeUsageResult>, timeoutMs?: number): Promise<ClaudeQuotaVerdict>;
 export declare class InstanceLifecycle {
     private ctx;
     /** Active daemon processes: instanceName → Daemon */
     readonly daemons: Map<string, import("./daemon.js").Daemon>;
     /** backend → last auth-error alert time, so one expiry sends one alert. */
     private lastAuthAlertAt;
+    /**
+     * backend → cached token-free auth verification (see AUTH_VERIFY_CACHE_MS).
+     * The PROMISE is cached, not the result: a shared credential expiring makes
+     * every instance of the backend fire in the same tick, and they must join
+     * one in-flight check instead of each spawning their own.
+     */
+    private authVerifyCache;
+    /** Same-tick Codex quota alerts join one live usage probe. */
+    private codexQuotaVerifyInFlight;
+    /** Same-tick Claude quota alerts join one live usage probe. */
+    private claudeQuotaVerifyInFlight;
     /**
      * Minimum gap between MCP-revival auto-restarts of one instance. Kept here —
      * not in the daemon — because each restart replaces the daemon object, which
@@ -143,6 +202,27 @@ export declare class InstanceLifecycle {
     private notifyIncident;
     /** Backend a running instance uses (config → fleet default). */
     private backendOf;
+    /**
+     * Confirm a pane-detected auth error with the backend's token-free status
+     * probe before pausing anything: pattern matching over terminal text also
+     * fires on an agent DISCUSSING a 401. "valid" means false positive — ignore.
+     * "invalid" and "unknown" (timeout, missing binary) both pause: for a
+     * suspected expiry, pausing too much is recoverable, delivering into a dead
+     * CLI is not. Cached per backend so simultaneous alerts run one check.
+     */
+    private verifyAuthError;
+    private verifyCodexQuota;
+    private verifyClaudeQuota;
+    /** Same verification keyed by backend (used by startup pre-flight priming). */
+    verifyBackendAuth(backend: string): Promise<"valid" | "invalid" | "unknown">;
+    /**
+     * Startup pre-flight: warm the per-backend auth verification cache so the
+     * detectors that fire seconds later (login-screen scan, MCP-died gate) get an
+     * instant answer. Advisory only — a pre-flight result alone never pauses
+     * anything, because e.g. codex on a custom provider runs fine while
+     * `codex login status` reports logged out (live-verified on this fleet).
+     */
+    primeAuthVerification(backends: Iterable<string>): void;
     /**
      * One alert per backend per cooldown, naming every affected instance — a CLI's
      * credentials are shared, so N instances failing is ONE problem with ONE fix
@@ -150,6 +230,13 @@ export declare class InstanceLifecycle {
      * instances, so the fleet-level map does it here.
      */
     private notifyAuthErrorOnce;
+    /**
+     * A fleet-wide backend outage (see backend-outage.ts): record the sighting so
+     * startup stops spending `--resume` attempts on it, and notify ONCE per
+     * outage at fleet level — kiro prints the line every 10s on every instance,
+     * so per-instance incidents would be N × (one message per cooldown).
+     */
+    private noteBackendOutage;
     /**
      * System errors from a ClassicBot belong in the operator's General topic,
      * never in the end user's chat channel. Fleet-topic instances retain their
@@ -169,6 +256,18 @@ export declare class InstanceLifecycle {
     getLastPausedAt(name: string): number | null;
     pause(name: string): Promise<void>;
     wake(name: string, timeoutMs?: number): Promise<void>;
+    /**
+     * Ownership boundary for a daemon that is not yet registered: if start()
+     * rejects, nothing else will ever dispose it, so do it here before
+     * rethrowing. The abort is best-effort — the start error is the one to
+     * surface.
+     */
+    static startOrDispose(daemon: {
+        start(): Promise<void>;
+        abortStartup(): Promise<void>;
+    }, name: string, logger: Logger): Promise<void>;
+    /** Stop the registered daemon only if it is still `daemon` (a concurrent restart may have replaced it). */
+    stopIfCurrent(name: string, daemon: unknown): Promise<boolean>;
     stop(name: string): Promise<void>;
     remove(name: string): Promise<void>;
     /** Handle create_instance tool call from a daemon. */