team 0.0.1 → 0.1.1

package/dist/watch/checks/extra.js

@@ -0,0 +1,18 @@
+import { WATCH_LABEL } from "../../status/compare.js";
+// An agent herdr lists in a pane no seat of the file answers for: started outside the team, and
+// nobody's. The watch's own workspace is the watch itself, and never extra.
+export const extra = {
+    name: 'extra',
+    run(team, ctx) {
+        const labels = new Map(team.live.workspaces.map((workspace) => [workspace.id, workspace.label]));
+        const reports = [];
+        for (const agent of team.live.agents) {
+            if (team.known.has(agent.pane) || labels.get(agent.workspace) === WATCH_LABEL)
+                continue;
+            const report = ctx.once(`extra:${agent.pane}`, `${agent.name ?? `an unnamed ${agent.agent ?? 'agent'}`} (${agent.pane}) is running and is not in the file`);
+            if (report)
+                reports.push(report);
+        }
+        return reports;
+    },
+};

package/dist/watch/checks/idle.d.ts

@@ -0,0 +1,2 @@
+import { type SeatCheck } from '../check.ts';
+export declare const idle: SeatCheck;

package/dist/watch/checks/idle.js

@@ -0,0 +1,32 @@
+import { minutes } from "../check.js";
+// A seat that has stopped: quiet, with no running turn, no prompt and no unsent text. The
+// duration counts from the last moment it was seen working. A seat never seen working was already
+// idle when the watch started: it is reported that way, with no duration from another source.
+// The leads and parked seats are reported on, but their idle time is not the team's: skipped.
+export const idle = {
+    name: 'idle',
+    run(seat, ctx) {
+        const told = ctx.memory('idle', () => ({}));
+        if (!seat.running)
+            return [];
+        if (!seat.quiet || seat.working || seat.prompt) {
+            delete told[seat.name];
+            return [];
+        }
+        if (seat.lead || seat.parked)
+            return [];
+        const worked = seat.history.lastWorking;
+        const since = ctx.now - (worked ?? seat.history.idleSince ?? ctx.now);
+        const at = told[seat.name];
+        if (since < ctx.watch.idleFirst * 1000 || (at !== undefined && ctx.now - at < ctx.watch.idleRepeat * 1000))
+            return [];
+        told[seat.name] = ctx.now;
+        return [{
+                key: `idle:${seat.name}`,
+                text: worked === undefined
+                    ? `${seat.name} has been idle since the watch started`
+                    : `${seat.name} has been idle for ${minutes(since)} minutes`,
+                to: 'operator',
+            }];
+    },
+};

package/dist/watch/checks/load.d.ts

@@ -0,0 +1,2 @@
+import { type TeamCheck } from '../check.ts';
+export declare const load: TeamCheck;

package/dist/watch/checks/load.js

@@ -0,0 +1,11 @@
+import { reported } from "../check.js";
+// Load per core above the file's maximum. A figure that wasn't read is never reported.
+export const load = {
+    name: 'load',
+    run(team, ctx) {
+        const value = team.machine.loadPerCore;
+        if (value === null || value <= team.limits.loadMax)
+            return [];
+        return reported(ctx.once('load', `the load is ${value.toFixed(1)} per core, above ${team.limits.loadMax}`, 'owner'));
+    },
+};

package/dist/watch/checks/memory.d.ts

@@ -0,0 +1,2 @@
+import { type TeamCheck } from '../check.ts';
+export declare const memory: TeamCheck;

package/dist/watch/checks/memory.js

@@ -0,0 +1,11 @@
+import { reported } from "../check.js";
+// Free memory below the file's minimum, in percent. A figure that wasn't read is never reported.
+export const memory = {
+    name: 'memory',
+    run(team, ctx) {
+        const value = team.machine.memoryFree;
+        if (value === null || value >= team.limits.memoryMin)
+            return [];
+        return reported(ctx.once('memory', `free memory is ${Math.round(value)}%, below ${team.limits.memoryMin}%`, 'owner'));
+    },
+};

package/dist/watch/checks/missing.d.ts

@@ -0,0 +1,2 @@
+import { type SeatCheck } from '../check.ts';
+export declare const missing: SeatCheck;

package/dist/watch/checks/missing.js

@@ -0,0 +1,12 @@
+import { reported } from "../check.js";
+// A seat the file holds that no agent answers for. A stopped seat is not started: absent from
+// herdr is its normal state, and draws nothing. And when the session itself doesn't answer, every
+// seat is absent for the same reason — the watch reports none of them.
+export const missing = {
+    name: 'missing',
+    run(seat, ctx) {
+        if (seat.running || seat.stopped || !seat.herdr)
+            return [];
+        return reported(ctx.once(`missing:${seat.name}`, `${seat.name} is in the file and is not running`));
+    },
+};

package/dist/watch/checks/model-drift.d.ts

@@ -0,0 +1,2 @@
+import { type SeatCheck } from '../check.ts';
+export declare const modelDrift: SeatCheck;

package/dist/watch/checks/model-drift.js

@@ -0,0 +1,14 @@
+import { reported } from "../check.js";
+// A seat that runs a model other than the one the file declares: what it signs with is not what
+// the owner approved. A temporary seat has no file model, and a screen the profile cannot read is
+// unread, never a mismatch.
+export const modelDrift = {
+    name: 'model-drift',
+    run(seat, ctx) {
+        const file = seat.seat;
+        const running = seat.model;
+        if (!file || !running || (running.model === file.model && running.version === file.version))
+            return [];
+        return reported(ctx.once(`model:${seat.name}`, `${seat.name} runs ${running.model} ${running.version}; the file says ${file.model} ${file.version}: it signs with the wrong model`));
+    },
+};

package/dist/watch/checks/swap-free.d.ts

@@ -0,0 +1,2 @@
+import { type TeamCheck } from '../check.ts';
+export declare const swapFree: TeamCheck;

package/dist/watch/checks/swap-free.js

@@ -0,0 +1,12 @@
+import { gb } from "../machine.js";
+import { reported } from "../check.js";
+// Free swap below the file's minimum. A machine with no swap reads none, and reports nothing.
+export const swapFree = {
+    name: 'swap-free',
+    run(team, ctx) {
+        const value = team.machine.swapFree;
+        if (value === null || value >= team.limits.swapFreeMin)
+            return [];
+        return reported(ctx.once('swap-free', `free swap is ${gb(value)}, below ${gb(team.limits.swapFreeMin)}`, 'owner'));
+    },
+};

package/dist/watch/checks/swap-growth.d.ts

@@ -0,0 +1,2 @@
+import { type TeamCheck } from '../check.ts';
+export declare const swapGrowth: TeamCheck;

package/dist/watch/checks/swap-growth.js

@@ -0,0 +1,18 @@
+import { gb, recordSwap } from "../machine.js";
+import { minutes, reported } from "../check.js";
+// Swap that grew inside the window, even while free swap is high: the growth is the pressure.
+// The samples are this check's own memory, shared with nothing. A figure that wasn't read is
+// never reported.
+export const swapGrowth = {
+    name: 'swap-growth',
+    run(team, ctx) {
+        const used = team.machine.swapUsed;
+        if (used === null)
+            return [];
+        const samples = ctx.memory('swap-growth', () => []);
+        const growth = recordSwap(samples, used, ctx.now, team.limits.swapGrowthWindow);
+        if (growth <= team.limits.swapGrowthMax)
+            return [];
+        return reported(ctx.once('swap-growth', `swap grew by ${gb(growth)} in ${minutes(team.limits.swapGrowthWindow * 1000)} minutes, above ${gb(team.limits.swapGrowthMax)}`, 'owner'));
+    },
+};

package/dist/watch/checks/team-idle.d.ts

@@ -0,0 +1,2 @@
+import type { TeamCheck } from '../check.ts';
+export declare const teamIdle: TeamCheck;

package/dist/watch/checks/team-idle.js

@@ -0,0 +1,18 @@
+// Every worker idle at once, reported once per idle stretch, after `team_idle`. A worker that
+// works again re-arms it. The leads and parked seats never count as the team's workers.
+export const teamIdle = {
+    name: 'team-idle',
+    run(team, ctx) {
+        const memory = ctx.memory('team-idle', () => ({ since: null, told: false }));
+        if (!team.workers.length || !team.workers.every((worker) => worker.idle)) {
+            memory.since = null;
+            memory.told = false;
+            return [];
+        }
+        memory.since ??= ctx.now;
+        if (memory.told || ctx.now - memory.since < ctx.watch.teamIdle * 1000)
+            return [];
+        memory.told = true;
+        return [{ key: 'team-idle', text: 'every agent is idle', to: 'operator' }];
+    },
+};

package/dist/watch/checks/unsent.d.ts

@@ -0,0 +1,2 @@
+import { type SeatCheck } from '../check.ts';
+export declare const unsent: SeatCheck;

package/dist/watch/checks/unsent.js

@@ -0,0 +1,18 @@
+import { reported } from "../check.js";
+// Text held in the composer that was never sent: a seat herdr calls idle, holding a sentence. It
+// is reported once the text has stood there for `unsent_after`, and its clock clears the moment
+// the seat is anything else — running, at a prompt, or holding nothing.
+export const unsent = {
+    name: 'unsent',
+    run(seat, ctx) {
+        const since = ctx.memory('unsent', () => ({}));
+        if (!seat.running || !seat.quiet || seat.working || seat.prompt || seat.screen.kind !== 'unsent') {
+            delete since[seat.name];
+            return [];
+        }
+        since[seat.name] ??= ctx.now;
+        if (ctx.now - since[seat.name] < ctx.watch.unsentAfter * 1000)
+            return [];
+        return reported(ctx.once(`unsent:${seat.name}`, `${seat.name} holds text in its input box that was never sent`));
+    },
+};

package/dist/watch/close.d.ts

@@ -0,0 +1,19 @@
+import type { EndView } from './end.ts';
+export type CloseDecision = {
+    close: boolean;
+    /** Set when this pass saw commits of the branch's own. The next pass can then prove a merge. */
+    ownCommits?: boolean;
+    report?: string;
+};
+export declare function judgeTemporary(input: {
+    worked: boolean;
+    free: boolean;
+    ownBefore: boolean;
+    end: EndView;
+}): CloseDecision;
+export declare function judgeWorktree(input: {
+    policy: 'on-merge' | 'manual';
+    occupied: boolean;
+    ownBefore: boolean;
+    end: EndView;
+}): CloseDecision;

package/dist/watch/close.js

@@ -0,0 +1,40 @@
+export function judgeTemporary(input) {
+    if (input.end.kind === 'result') {
+        if (!input.end.exists || !input.worked || !input.free)
+            return { close: false };
+        return { close: true };
+    }
+    if (input.end.ownNow > 0)
+        return openBranch(input.end.detail);
+    if (input.end.verdict === 'unproven')
+        return { close: false, report: input.end.detail };
+    if (!input.ownBefore || !input.worked || !input.free)
+        return { close: false };
+    if (input.end.verdict === 'merged')
+        return { close: true };
+    return { close: false };
+}
+export function judgeWorktree(input) {
+    if (input.policy !== 'on-merge')
+        return { close: false };
+    if (input.end.kind !== 'merged')
+        return { close: false };
+    if (input.end.ownNow > 0)
+        return openBranch(input.end.detail);
+    if (input.end.verdict === 'unproven')
+        return { close: false, report: input.end.detail };
+    if (!input.ownBefore || input.occupied)
+        return { close: false };
+    if (input.end.verdict === 'merged')
+        return { close: true };
+    return { close: false };
+}
+// A squash leaves commits on the branch while its tree matches the base. That is reported once,
+// the same way a failed fetch is, and nothing is closed.
+function openBranch(detail) {
+    return {
+        close: false,
+        ownCommits: true,
+        ...(detail.includes('not provable') ? { report: detail } : {}),
+    };
+}

package/dist/watch/dialect.d.ts

@@ -0,0 +1,5 @@
+export declare class DialectError extends Error {
+    constructor(message: string);
+}
+/** Compile one pattern. `ignoreCase` is the stage's flag, never an inline `(?i)`. */
+export declare function compilePattern(source: string, ignoreCase?: boolean): RegExp;