@ours.network/fleet 0.19.0-nightly.13 → 0.19.0-nightly.15

package/dist/rooms-tasks/markdown.d.ts

@@ -0,0 +1,49 @@
+import type { RoomOrchestrationState, TaskState } from './types.js';
+export declare const MARKDOWN_MAX_CODE_POINTS = 3500;
+export declare const MARKDOWN_MAX_BYTES = 12000;
+export interface StatusPresentation {
+    icon: string;
+    word: string;
+}
+export type MarkdownField = {
+    label: string;
+    value: unknown;
+    kind?: 'prose' | 'code' | 'markdown';
+    multiline?: boolean;
+};
+export type MarkdownSection = {
+    heading?: string;
+    items?: unknown[];
+    markdownItems?: string[];
+    prose?: unknown;
+};
+export declare function withinMarkdownBounds(value: string): boolean;
+/** Escaped single-line prose suitable for a field or list item. */
+export declare function markdownProse(value: unknown): string;
+/** Escaped heading text. Newlines and heading/list syntax cannot escape the heading. */
+export declare function markdownHeading(value: unknown): string;
+/** Escaped multiline prose. Intended line breaks remain line breaks. */
+export declare function markdownMultiline(value: unknown): string;
+/** CommonMark code span with a delimiter longer than every run in the value. */
+export declare function markdownCode(value: unknown): string;
+export declare function taskStatus(value: TaskState | string): string;
+export declare function roomStatus(value: RoomOrchestrationState | string): string;
+export declare function renderMarkdownResult(input: {
+    icon: string;
+    title: string;
+    fields?: MarkdownField[];
+    sections?: MarkdownSection[];
+}): string;
+export declare function renderMarkdownList(input: {
+    icon: string;
+    title: string;
+    empty: string;
+    records: string[];
+}): string;
+export type FailureKind = 'usage' | 'not_found' | 'conflict' | 'state' | 'pending' | 'unexpected';
+export declare function renderMarkdownFailure(input: {
+    kind: FailureKind;
+    subject: string;
+    detail?: unknown;
+    action: string;
+}): string;

package/dist/rooms-tasks/markdown.js

@@ -0,0 +1,206 @@
+import { Buffer } from 'node:buffer';
+export const MARKDOWN_MAX_CODE_POINTS = 3_500;
+export const MARKDOWN_MAX_BYTES = 12_000;
+const FIELD_MAX_CODE_POINTS = 900;
+const FIELD_MAX_BYTES = 3_000;
+const ID_MAX_CODE_POINTS = 160;
+const ID_MAX_BYTES = 640;
+const TRUNCATED = '_… output truncated._';
+const SPOOFING_CONTROLS = /[\u200b-\u200f\u202a-\u202e\u2060-\u206f\ufeff]/g;
+const SINGLE_LINE_CONTROLS = /[\u0000-\u001f\u007f-\u009f]/g;
+const MULTILINE_CONTROLS = /[\u0000-\u0009\u000b-\u001f\u007f-\u009f]/g;
+const PROSE_PUNCTUATION = /([\\`*_[\]<>])/g;
+const HEADING_PUNCTUATION = /([\\`*_[\]<>#])/g;
+const TASK_STATUS = {
+    backlog: { icon: '⏸️', word: 'Backlog' },
+    provisioning: { icon: '⏳', word: 'Provisioning' },
+    active: { icon: '🟢', word: 'Active' },
+    review: { icon: '🟡', word: 'Review' },
+    done: { icon: '✅', word: 'Done' },
+    cancelled: { icon: '🚫', word: 'Cancelled' },
+    failed: { icon: '❌', word: 'Failed' },
+};
+const ROOM_STATUS = {
+    provisioning: { icon: '⏳', word: 'Provisioning' },
+    active: { icon: '🟢', word: 'Active' },
+    closing: { icon: '⏳', word: 'Closing' },
+    closed: { icon: '🔒', word: 'Closed' },
+};
+const codePoints = (value) => Array.from(value).length;
+const bytes = (value) => Buffer.byteLength(value, 'utf8');
+export function withinMarkdownBounds(value) {
+    return codePoints(value) <= MARKDOWN_MAX_CODE_POINTS && bytes(value) <= MARKDOWN_MAX_BYTES;
+}
+function normalize(value, multiline) {
+    let text = String(value ?? '').replace(/\r\n?/g, '\n').replace(SPOOFING_CONTROLS, '�');
+    if (multiline)
+        text = text.replace(MULTILINE_CONTROLS, '�');
+    else
+        text = text.replace(SINGLE_LINE_CONTROLS, ' ').replace(/\n+/g, ' ');
+    return text;
+}
+function boundPlain(value, maxPoints, maxBytes) {
+    if (codePoints(value) <= maxPoints && bytes(value) <= maxBytes)
+        return value;
+    const suffix = '…';
+    let out = '';
+    for (const point of value) {
+        const next = out + point + suffix;
+        if (codePoints(next) > maxPoints || bytes(next) > maxBytes)
+            break;
+        out += point;
+    }
+    return out.replace(/\s+$/u, '') + suffix;
+}
+/** Escaped single-line prose suitable for a field or list item. */
+export function markdownProse(value) {
+    return boundPlain(normalize(value, false).trim(), FIELD_MAX_CODE_POINTS, FIELD_MAX_BYTES)
+        .replace(PROSE_PUNCTUATION, '\\$1');
+}
+/** Escaped heading text. Newlines and heading/list syntax cannot escape the heading. */
+export function markdownHeading(value) {
+    return boundPlain(normalize(value, false).trim(), 160, 640)
+        .replace(HEADING_PUNCTUATION, '\\$1');
+}
+/** Escaped multiline prose. Intended line breaks remain line breaks. */
+export function markdownMultiline(value) {
+    const bounded = boundPlain(normalize(value, true).trim(), FIELD_MAX_CODE_POINTS, FIELD_MAX_BYTES);
+    return bounded.split('\n').map(line => {
+        const escaped = line.replace(PROSE_PUNCTUATION, '\\$1');
+        // A multiline value is commonly nested inside a block quote. Escape every
+        // still-active line-leading block marker so user text cannot create nested
+        // headings, lists, quotes, thematic breaks, or tilde fences.
+        return escaped
+            .replace(/^([ \t]*)(#{1,6}|[-+>])(?=[ \t]|$)/u, '$1\\$2')
+            .replace(/^([ \t]*)(\d{1,9})([.)])(?=[ \t]|$)/u, '$1$2\\$3')
+            .replace(/^([ \t]*)(-{3,})(?=[ \t]*$)/u, '$1\\$2')
+            .replace(/^([ \t]*)(~{3,})/u, '$1\\$2');
+    }).join('\n');
+}
+/** CommonMark code span with a delimiter longer than every run in the value. */
+export function markdownCode(value) {
+    const normalized = normalize(value, false);
+    const text = boundPlain(normalized || '—', ID_MAX_CODE_POINTS, ID_MAX_BYTES);
+    const longest = Math.max(0, ...[...text.matchAll(/`+/g)].map(match => match[0].length));
+    const fence = '`'.repeat(longest + 1);
+    const pad = /^`|`$/.test(text) || (/^ | $/.test(text) && !/^ +$/.test(text));
+    return `${fence}${pad ? ' ' : ''}${text}${pad ? ' ' : ''}${fence}`;
+}
+export function taskStatus(value) {
+    const status = TASK_STATUS[value];
+    return status ? `${status.icon} ${status.word}` : `⚪ Unknown (${markdownProse(value)})`;
+}
+export function roomStatus(value) {
+    const status = ROOM_STATUS[value];
+    return status ? `${status.icon} ${status.word}` : `⚪ Unknown (${markdownProse(value)})`;
+}
+function addBlock(blocks, block) {
+    const candidate = [...blocks, block, TRUNCATED].join('\n\n');
+    if (!withinMarkdownBounds(candidate))
+        return false;
+    blocks.push(block);
+    return true;
+}
+function finalize(blocks, truncated) {
+    if (truncated)
+        blocks.push(TRUNCATED);
+    const output = blocks.join('\n\n');
+    if (!withinMarkdownBounds(output))
+        throw new Error('Markdown result exceeded its transport bounds');
+    return output;
+}
+export function renderMarkdownResult(input) {
+    const blocks = [`## ${input.icon} ${markdownHeading(input.title)}`];
+    let truncated = false;
+    for (const field of input.fields ?? []) {
+        const label = markdownHeading(field.label);
+        const value = field.kind === 'code' ? markdownCode(field.value)
+            : field.kind === 'markdown' ? String(field.value)
+                : field.multiline ? markdownMultiline(field.value) : markdownProse(field.value);
+        const rendered = field.multiline
+            ? `**${label}:**\n\n${value.split('\n').map(line => `> ${line}`).join('\n')}`
+            : `- **${label}:** ${value || '—'}`;
+        if (!addBlock(blocks, rendered)) {
+            truncated = true;
+            break;
+        }
+    }
+    if (!truncated)
+        for (const section of input.sections ?? []) {
+            const lines = [];
+            if (section.heading)
+                lines.push(`### ${markdownHeading(section.heading)}`);
+            if (section.prose !== undefined)
+                lines.push(markdownMultiline(section.prose));
+            const items = [
+                ...(section.items ?? []).map(markdownProse),
+                ...(section.markdownItems ?? []),
+            ];
+            let admitted = 0;
+            for (const item of items) {
+                const next = [...lines, `- ${item}`];
+                const remaining = items.length - admitted - 1;
+                const omission = remaining
+                    ? `- _${remaining} more ${remaining === 1 ? 'result' : 'results'} omitted\\._` : undefined;
+                const candidate = [...blocks, [...next, ...(omission ? [omission] : [])].join('\n'), TRUNCATED]
+                    .join('\n\n');
+                if (!withinMarkdownBounds(candidate))
+                    break;
+                lines.push(`- ${item}`);
+                admitted++;
+            }
+            if (admitted < items.length) {
+                const omitted = items.length - admitted;
+                lines.push(`- _${omitted} more ${omitted === 1 ? 'result' : 'results'} omitted\\._`);
+            }
+            if (!addBlock(blocks, lines.join('\n'))) {
+                truncated = true;
+                break;
+            }
+        }
+    return finalize(blocks, truncated);
+}
+export function renderMarkdownList(input) {
+    const blocks = [`## ${input.icon} ${markdownHeading(input.title)}`];
+    if (!input.records.length)
+        return finalize([...blocks, markdownProse(input.empty)], false);
+    let admitted = 0;
+    for (const record of input.records) {
+        const remaining = input.records.length - admitted - 1;
+        const rendered = `- ${record}`;
+        const omission = remaining
+            ? `- _${remaining} more ${remaining === 1 ? 'result' : 'results'} omitted\\._` : '';
+        const candidate = [...blocks, rendered, ...(omission ? [omission] : [])].join('\n\n');
+        if (!withinMarkdownBounds(candidate))
+            break;
+        blocks.push(rendered);
+        admitted++;
+    }
+    if (admitted < input.records.length) {
+        const omitted = input.records.length - admitted;
+        const notice = `- _${omitted} more ${omitted === 1 ? 'result' : 'results'} omitted\\._`;
+        if (!addBlock(blocks, notice))
+            return finalize(blocks, true);
+    }
+    return finalize(blocks, false);
+}
+export function renderMarkdownFailure(input) {
+    const titles = {
+        usage: 'Invalid command',
+        not_found: 'Not found',
+        conflict: 'Conflict',
+        state: 'Action not allowed',
+        pending: 'Action still pending',
+        unexpected: 'Command failed',
+    };
+    return renderMarkdownResult({
+        icon: input.kind === 'pending' ? '⏳' : '⚠️',
+        title: titles[input.kind],
+        fields: [
+            { label: 'Command', value: input.subject, kind: 'code' },
+            ...(input.detail !== undefined && input.kind !== 'unexpected'
+                ? [{ label: 'Reason', value: input.detail }] : []),
+        ],
+        sections: [{ heading: 'Next step', items: [input.action] }],
+    });
+}

package/dist/rooms-tasks/provision.js

@@ -245,7 +245,7 @@ export async function provisionMembers(input) {
         updateMemberSeats(roomId, seats);
     }
     else {
-        // Phase 4: create_members
+        // create_members saga phase
         advanceSaga(roomId, 'create_members', 3);
         try {
             for (const planned of plan) {

package/dist/runner.d.ts

@@ -35,6 +35,15 @@ export interface RunnerDeps {
 }
 /** Environment injected only into the managed harness process. */
 export declare function managedFleetProxyEnv(role: ResolvedRole, stateDir: string): Record<string, string>;
+/**
+ * The environment a managed harness child actually receives, checked at the one
+ * point where it is composed. `role.env` deliberately wins over harness prep,
+ * which is exactly how a stale fleet-wide model pin used to outrank the model
+ * the role was spawned with — so the model pin is verified here rather than
+ * trusted, and a disagreement stops the launch instead of being reported as a
+ * success (see src/model-env.ts).
+ */
+export declare function harnessChildEnv(role: ResolvedRole, launchEnv: Record<string, string> | undefined, stateDir: string): Record<string, string>;
 /**
  * Record who owns wake delivery for this run. Returning true means a fleet
  * monitor is taking ownership back from a native harness and must start at the
@@ -61,6 +70,23 @@ export declare function readExitRecord(path: string): ExitRecord | null;
 export declare const RESTART_LEDGER_FILE = ".restart-ledger.json";
 /** Consecutive immediate failures tolerated before the agent is held down. */
 export declare const RESTART_FAIL_THRESHOLD = 5;
+/**
+ * How the previous supervisor process ended.
+ *
+ * `abrupt` is the case the ledger used to miss entirely: an OOM-kill or any
+ * other external signal takes the supervisor down before it can write anything,
+ * the service manager restarts the unit, and every durable indicator still
+ * describes the run that died. A health check reading them reported "no
+ * restarts" for a role that had died and come back.
+ */
+export interface TerminationRecord {
+    class: 'clean' | 'abrupt' | 'unknown';
+    detail: string;
+    /** When the SURVIVING process observed it, not when it happened. */
+    observedAt: string;
+    /** Start time of the run that ended, when it was recorded. */
+    runStartedAt?: string;
+}
 export interface RestartLedger {
     version: 1;
     consecutiveImmediateFailures: number;
@@ -72,7 +98,29 @@ export interface RestartLedger {
     updatedAt: string;
     /** When the circuit opened, for the held-down status line. */
     openedAt?: string;
+    /** How the previous supervisor process ended, including abnormal exits. */
+    lastTermination?: TerminationRecord;
+    /** Supervisor processes that died without closing their run marker. */
+    abruptTerminations?: number;
+    /** Start of the supervisor run that owns this state directory now. */
+    supervisorStartedAt?: string;
 }
+/**
+ * Carried across a supervisor process's life so its successor can tell an
+ * orderly exit from a kill. Present on disk == "a supervisor believed it was
+ * running"; the next start finding one that is not its own is proof the
+ * previous process died without getting to write anything.
+ */
+export declare const RUN_MARKER_FILE = ".supervisor-run.json";
+/**
+ * Claim this state directory for the current supervisor process and report how
+ * the previous one ended. Runs BEFORE the first attempt, which is the whole
+ * point: after an abrupt kill nothing else writes until an attempt finishes,
+ * and an attempt can take minutes.
+ */
+export declare function claimSupervisorRun(dir: string, startedAt: string, pid?: number): TerminationRecord;
+/** Orderly exit: the successor must not read this run as a kill. */
+export declare function releaseSupervisorRun(dir: string): void;
 /** Bounded exponential backoff for the nth consecutive immediate failure. */
 export declare function backoffFor(consecutiveFailures: number): number;
 /** Read a role's restart ledger; a missing or corrupt one starts clean. */