@phuetz/code-buddy 2.0.0 → 2.1.0

package/dist/fleet/sensory-mission-bridge.js

@@ -0,0 +1,136 @@
+/** Outbound status only. This module never emits perceptions or authorizes actions. */
+import { randomUUID } from 'node:crypto';
+import { logger } from '../utils/logger.js';
+/** Adapt a local signed-room publisher without importing the hub or its keys.
+ * The injected publisher must retain the same signing key across retries, build
+ * a kind-9 message with these exact content/createdAt values, and resolve only
+ * on durable acceptance (including an already-stored duplicate).
+ * JSON includes observation.id, so equal samples from distinct observations
+ * cannot collide; stable receivedAt keeps the signed event id stable on retry.
+ */
+export function createMissionObservationRoomPublisher(room, publish) {
+    if (!/^[a-z0-9][a-z0-9_-]{0,63}$/.test(room))
+        throw new Error('Invalid observation room');
+    return async (observation, signal) => {
+        signal.throwIfAborted();
+        await publish(room, JSON.stringify(observation), Math.floor(observation.receivedAt / 1000), signal);
+    };
+}
+const FIELDS = {
+    heartbeat: ['load1'], // beat/uptime counters intentionally do not defeat change dedupe
+    resource_threshold: ['rssMb', 'heapUsedMb', 'load1', 'vramPct', 'vramUsedMb', 'diskPct', 'diskFreeBytes', 'fleetUtilization', 'fleetSaturated'],
+    disk_low: ['diskPct', 'diskFreeBytes'],
+    fleet_saturated: ['fleetUtilization'],
+};
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/** Disabled or unconfigured means zero subscriptions, timers, and publications.
+ * Exactly four possible keys bound queued status snapshots and dedupe memory.
+ * Replacing a queued snapshot coalesces bursts; this is status, not an audit log
+ * of every physical transition. Incoming remote messages must use a separate bus.
+ */
+export function wireSensoryMissionBridge(options) {
+    const missionId = options.missionId;
+    if (options.enabled !== true || !missionId || !/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/.test(missionId))
+        return () => { };
+    const intervalMs = options.intervalMs ?? 5_000;
+    if (!Number.isFinite(intervalMs) || intervalMs < 1_000 || intervalMs > 60_000) {
+        throw new Error('Observation interval must be between 1000 and 60000 ms');
+    }
+    const now = options.now ?? Date.now;
+    const pending = new Map();
+    const delivered = new Map();
+    const controller = new AbortController();
+    let active = true;
+    let publishing = false;
+    const listenerId = options.bus.on('sensory:perception', (event) => {
+        if (!active || !record(event.metadata))
+            return;
+        const meta = event.metadata;
+        const kind = meta.kind;
+        if (typeof kind !== 'string' || !Object.hasOwn(FIELDS, kind))
+            return;
+        if (event.source === 'buddy-sense') {
+            if (meta.modality !== 'vital' || kind !== 'heartbeat')
+                return;
+        }
+        else if (event.source === 'system-vitals') {
+            if (meta.modality !== 'system' || kind === 'heartbeat')
+                return;
+        }
+        else
+            return; // Includes remote, domain-bridge, and missing sources.
+        if (!record(meta.payload))
+            return;
+        const values = {};
+        for (const field of FIELDS[kind]) {
+            const value = meta.payload[field];
+            if (value === undefined || value === null)
+                continue;
+            if (field === 'fleetSaturated') {
+                if (typeof value !== 'boolean')
+                    return;
+            }
+            else if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > Number.MAX_SAFE_INTEGER
+                || ((field === 'diskPct' || field === 'vramPct') && value > 100))
+                return;
+            values[field] = value;
+        }
+        if (Object.keys(values).length === 0)
+            return;
+        const fingerprint = JSON.stringify(values);
+        if (pending.get(kind)?.fingerprint === fingerprint)
+            return;
+        const receivedAt = now();
+        if (!Number.isFinite(receivedAt) || receivedAt < 0)
+            return;
+        pending.set(kind, {
+            observation: {
+                id: randomUUID(), missionId, type: 'observation', source: event.source,
+                kind: kind, receivedAt,
+                ...(typeof meta.tsMs === 'number' && Number.isFinite(meta.tsMs) && meta.tsMs >= 0 ? { observedAt: meta.tsMs } : {}),
+                values,
+            },
+            fingerprint, attempts: 0,
+        });
+    });
+    const timer = setInterval(() => {
+        if (!active || publishing)
+            return;
+        const first = pending.entries().next().value;
+        if (!first)
+            return;
+        const [key, item] = first;
+        pending.delete(key);
+        if (delivered.get(key) === item.fingerprint)
+            return;
+        publishing = true;
+        // Promise boundary captures synchronous publisher failures too.
+        void Promise.resolve().then(() => {
+            if (active)
+                return options.publish(item.observation, controller.signal);
+            return undefined;
+        }).then(() => {
+            if (active)
+                delivered.set(key, item.fingerprint);
+        }).catch(() => {
+            if (active && !pending.has(key) && ++item.attempts < 3)
+                pending.set(key, item);
+            if (active)
+                logger.warn('[sensory-mission] observation publication failed');
+        }).finally(() => { publishing = false; });
+    }, intervalMs);
+    timer.unref();
+    return () => {
+        if (!active)
+            return;
+        active = false;
+        clearInterval(timer);
+        options.bus.off(listenerId);
+        pending.clear();
+        delivered.clear();
+        controller.abort();
+    };
+}
+//# sourceMappingURL=sensory-mission-bridge.js.map

package/dist/git/worktree-sessions.js

@@ -76,6 +76,7 @@ export class WorktreeSessionManager {
             return false;
         try {
             execSync(`git worktree remove "${session.worktreePath}" --force`, {
+                cwd: session.worktreePath,
                 stdio: 'pipe',
             });
         }

package/dist/harness/contract.d.ts

@@ -137,7 +137,7 @@ export declare const runSchema: z.ZodObject<{
         organ?: string | undefined;
     }>>;
 }, "strict", z.ZodTypeAny, {
-    status: "cancelled" | "running" | "completed" | "failed" | "queued" | "waiting_approval";
+    status: "cancelled" | "failed" | "running" | "completed" | "queued" | "waiting_approval";
     id: string;
     kind: "run";
     schemaVersion: 1;
@@ -167,7 +167,7 @@ export declare const runSchema: z.ZodObject<{
     parentRunId?: string | undefined;
     endedAt?: number | undefined;
 }, {
-    status: "cancelled" | "running" | "completed" | "failed" | "queued" | "waiting_approval";
+    status: "cancelled" | "failed" | "running" | "completed" | "queued" | "waiting_approval";
     id: string;
     kind: "run";
     schemaVersion: 1;
@@ -565,7 +565,7 @@ export declare const harnessArtifactSchema: z.ZodDiscriminatedUnion<"kind", [z.Z
         organ?: string | undefined;
     }>>;
 }, "strict", z.ZodTypeAny, {
-    status: "cancelled" | "running" | "completed" | "failed" | "queued" | "waiting_approval";
+    status: "cancelled" | "failed" | "running" | "completed" | "queued" | "waiting_approval";
     id: string;
     kind: "run";
     schemaVersion: 1;
@@ -595,7 +595,7 @@ export declare const harnessArtifactSchema: z.ZodDiscriminatedUnion<"kind", [z.Z
     parentRunId?: string | undefined;
     endedAt?: number | undefined;
 }, {
-    status: "cancelled" | "running" | "completed" | "failed" | "queued" | "waiting_approval";
+    status: "cancelled" | "failed" | "running" | "completed" | "queued" | "waiting_approval";
     id: string;
     kind: "run";
     schemaVersion: 1;

package/dist/harness/fleet-supervisor.d.ts

@@ -0,0 +1,16 @@
+import type { ToolResult } from '../types/index.js';
+interface SupervisorOperation {
+    command: string;
+    args: string[];
+    timeoutMs: number;
+    description: string;
+}
+export interface SupervisorManifest {
+    workspace: string;
+    operations: Map<string, SupervisorOperation>;
+}
+export declare function parseSupervisorManifest(input: unknown, baseDir: string, maxTimeoutMs?: number): SupervisorManifest;
+export declare function runSupervisor(manifestPath: string, action: string, options?: {
+    signal?: AbortSignal;
+}): Promise<ToolResult>;
+export {};

package/dist/harness/fleet-supervisor.js

@@ -0,0 +1,64 @@
+/** Fixed host operations exposed through Code Buddy's programmatic tool harness.
+ * The manifest is an operator-owned permission boundary, never model-generated input.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { ToolHarness } from './tool-harness.js';
+import { runProc } from '../agent/self-improvement/evolution/variant-fitness.js';
+function record(value) { return !!value && typeof value === 'object' && !Array.isArray(value); }
+export function parseSupervisorManifest(input, baseDir, maxTimeoutMs = 45000) {
+    if (!record(input) || typeof input.workspace !== 'string')
+        throw new Error('workspace is required');
+    const workspace = path.resolve(baseDir, input.workspace);
+    if (!record(input.operations))
+        throw new Error('operations must be an object');
+    const operations = new Map();
+    for (const [name, operation] of Object.entries(input.operations)) {
+        if (!/^[a-z][a-z0-9_]{0,63}$/.test(name) || ['tool_search', 'exec', 'code_exec'].includes(name))
+            throw new Error(`Invalid operation name: ${name}`);
+        if (!record(operation) || typeof operation.command !== 'string' || !operation.command || operation.command.includes('\0'))
+            throw new Error(`Invalid command: ${name}`);
+        if (!Array.isArray(operation.args) || !operation.args.every(arg => typeof arg === 'string' && !arg.includes('\0')))
+            throw new Error(`Invalid arguments: ${name}`);
+        const timeoutMs = operation.timeoutMs ?? 30000;
+        if (typeof timeoutMs !== 'number' || !Number.isInteger(timeoutMs) || timeoutMs < 100 || timeoutMs > maxTimeoutMs)
+            throw new Error(`Invalid timeout: ${name}`);
+        operations.set(name, { command: operation.command, args: [...operation.args], timeoutMs, description: typeof operation.description === 'string' ? operation.description : name });
+    }
+    if (!operations.size || operations.size > 64)
+        throw new Error('Define between 1 and 64 fixed operations');
+    return { workspace, operations };
+}
+export async function runSupervisor(manifestPath, action, options = {}) {
+    const resolved = path.resolve(manifestPath);
+    const manifest = parseSupervisorManifest(JSON.parse(await fs.readFile(resolved, 'utf8')), path.dirname(resolved));
+    if (!manifest.operations.has(action))
+        throw new Error(`Unknown operation: ${action}`);
+    const harness = new ToolHarness({
+        cwd: manifest.workspace,
+        tools: [...manifest.operations].map(([name, operation]) => ({ type: 'function', function: {
+                name, description: operation.description,
+                parameters: { type: 'object', properties: {}, required: [], additionalProperties: false },
+            } })),
+        dispatch: async (name, args, signal) => {
+            const operation = manifest.operations.get(name);
+            if (!operation || Object.keys(args).length)
+                return { success: false, error: 'Only fixed manifest operations are authorized' };
+            if (signal?.aborted)
+                return { success: false, error: 'Cancelled before dispatch' };
+            const result = await runProc(operation.command, operation.args, {
+                checkoutDir: manifest.workspace, timeoutMs: operation.timeoutMs, signal,
+            });
+            return { success: result.code === 0 && !result.timedOut, output: result.stdout,
+                ...(result.code ? { error: result.stderr || `Operation exited with code ${result.code}` } : {}),
+                data: { exitCode: result.code, timedOut: result.timedOut } };
+        },
+    });
+    try {
+        return await harness.exec(`const r=await tools.call(${JSON.stringify(action)},{}); text(r); if(!r.success) throw new Error(r.error);`, { timeoutMs: 60000, signal: options.signal });
+    }
+    finally {
+        await harness.dispose();
+    }
+}
+//# sourceMappingURL=fleet-supervisor.js.map

package/dist/harness/index.d.ts

@@ -1,2 +1,6 @@
 export * from './contract.js';
 export * from './run-store-adapter.js';
+export * from './tool-harness.js';
+export * from './fleet-supervisor.js';
+export * from './mission-store.js';
+export * from './mission-runner.js';

package/dist/harness/index.js

@@ -1,3 +1,7 @@
 export * from './contract.js';
 export * from './run-store-adapter.js';
+export * from './tool-harness.js';
+export * from './fleet-supervisor.js';
+export * from './mission-store.js';
+export * from './mission-runner.js';
 //# sourceMappingURL=index.js.map

package/dist/harness/mission-runner.d.ts

@@ -0,0 +1,3 @@
+import { MissionStore, type Mission, type MissionAuthority } from './mission-store.js';
+/** Runs in the calling process; persisted intent survives a pilot crash, execution is never replayed implicitly. */
+export declare function runMission(store: MissionStore, id: string, authority: MissionAuthority, signal?: AbortSignal): Promise<Mission>;

package/dist/harness/mission-runner.js

@@ -0,0 +1,53 @@
+import { runProc } from '../agent/self-improvement/evolution/variant-fitness.js';
+import { MissionBusyError } from './mission-store.js';
+/** Runs in the calling process; persisted intent survives a pilot crash, execution is never replayed implicitly. */
+export async function runMission(store, id, authority, signal) {
+    const controller = new AbortController();
+    const cancel = () => controller.abort();
+    if (signal?.aborted)
+        throw new Error('Cancelled before starting mission');
+    signal?.addEventListener('abort', cancel, { once: true });
+    let timer;
+    let lostAuthority;
+    try {
+        store.renew(id, authority);
+        const mission = store.start(id, authority);
+        timer = setInterval(() => {
+            try {
+                store.renew(id, authority);
+            }
+            catch (error) {
+                try {
+                    if (error instanceof MissionBusyError && (store.get(id).expiresAt ?? 0) > Date.now() + 20000)
+                        return;
+                }
+                catch { /* An unreadable lease is not authority to keep executing. */ }
+                lostAuthority = error;
+                controller.abort();
+            }
+        }, 15000);
+        const op = mission.operation;
+        const result = await runProc(op.command, op.args, { checkoutDir: op.workspace, timeoutMs: op.timeoutMs, signal: controller.signal });
+        if (lostAuthority)
+            throw lostAuthority;
+        const finish = () => store.complete(id, authority, {
+            success: result.code === 0 && !result.timedOut, stdout: result.stdout, stderr: result.stderr, exitCode: result.code,
+        });
+        for (let retry = 0;; retry++) {
+            try {
+                return finish();
+            }
+            catch (error) {
+                if (!(error instanceof MissionBusyError) || retry >= 20)
+                    throw error;
+                await new Promise(resolve => setTimeout(resolve, 50));
+            }
+        }
+    }
+    finally {
+        if (timer)
+            clearInterval(timer);
+        signal?.removeEventListener('abort', cancel);
+    }
+}
+//# sourceMappingURL=mission-runner.js.map

package/dist/harness/mission-store.d.ts

@@ -0,0 +1,93 @@
+export interface MissionAuthority {
+    owner: string;
+    generation: string;
+}
+export interface MissionHandoff {
+    succeeded: string[];
+    failed: string[];
+    keyFiles: string[];
+    deadEnds: string[];
+    nextAction: string;
+}
+export interface MissionOperation {
+    command: string;
+    args: string[];
+    workspace: string;
+    timeoutMs: number;
+}
+export interface Mission {
+    schema: 1;
+    id: string;
+    revision: number;
+    status: 'ready' | 'claimed' | 'running' | 'handoff' | 'completed';
+    operation: MissionOperation;
+    authority?: MissionAuthority;
+    expiresAt?: number;
+    handoff?: MissionHandoff;
+    result?: {
+        success: boolean;
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+        truncated?: boolean;
+    };
+    review?: {
+        commit: string;
+        author: string;
+        reviewer?: string;
+    };
+    acknowledgedBy?: string;
+    updatedAt: number;
+}
+/** Public catalogue projection: no command, result text, handoff or authority token. */
+export interface MissionSummary {
+    id: string;
+    revision: number;
+    status: Mission['status'];
+    updatedAt: number;
+    owner?: string;
+    expiresAt?: number;
+    leaseExpired?: boolean;
+    success?: boolean;
+    acknowledged: boolean;
+}
+export interface MissionListPage {
+    missions: MissionSummary[];
+    errors: Array<{
+        file: string;
+        error: 'Invalid or unreadable mission record';
+    }>;
+    /** Last scanned filename hash; pages reflect live state, not a frozen snapshot. */
+    nextCursor?: string;
+}
+export declare class MissionBusyError extends Error {
+    constructor();
+}
+export declare class MissionStore {
+    readonly directory: string;
+    private readonly now;
+    constructor(directory: string, now?: () => number);
+    private file;
+    get(id: string): Mission;
+    private read;
+    /** Metadata only in the result. Validate at most one bounded record per page slot. */
+    list(options?: {
+        limit?: number;
+        cursor?: string;
+    }): MissionListPage;
+    /** Synchronous critical section, exclusive across processes; never steal a mutation lock. */
+    private change;
+    create(id: string, operation: MissionOperation): Mission;
+    claim(id: string, owner: string, leaseMs?: number): Mission;
+    private lease;
+    private owned;
+    renew(id: string, a: MissionAuthority, leaseMs?: number): Mission;
+    start(id: string, a: MissionAuthority): Mission;
+    complete(id: string, a: MissionAuthority, result: NonNullable<Mission['result']>): Mission;
+    handoff(id: string, a: MissionAuthority, handoff: MissionHandoff): Mission;
+    /** Explicit operator reconciliation only; an ambiguous effect is never retried automatically. */
+    reconcile(id: string, generation: string, resolution: 'retry' | 'completed', note: string): Mission;
+    acknowledge(id: string, consumer: string): Mission;
+    submit(id: string, a: MissionAuthority, commit: string): Mission;
+    approve(id: string, reviewer: string, expectedCommit: string): Mission;
+}