@phuetz/code-buddy 1.1.0 → 1.3.0

package/dist/scheduler/cron-scheduler.d.ts

@@ -140,6 +140,10 @@ export interface JobRun {
     result?: unknown;
     error?: string;
     duration?: number;
+    /** Structured output from this job run, passed as inputData to chained jobs. */
+    outputData?: string;
+    /** Input data received from a parent job in a chain. */
+    inputData?: string;
 }
 export interface CronSchedulerConfig {
     /** Jobs persist path */
@@ -174,7 +178,7 @@ export declare class CronScheduler extends EventEmitter {
     /**
      * Set the task executor (for CronAgentBridge integration)
      */
-    setTaskExecutor(executor: (job: CronJob) => Promise<unknown>): void;
+    setTaskExecutor(executor: (job: CronJob, inputData?: string) => Promise<unknown>): void;
     /**
      * Load persisted jobs into memory without starting the tick loop. Useful for
      * one-shot CLI commands (`buddy cron list/add/remove`) that must see the
@@ -182,7 +186,7 @@ export declare class CronScheduler extends EventEmitter {
      * overwrite the file with only the in-memory jobs.
      */
     loadFromDisk(): Promise<void>;
-    start(taskExecutor?: (job: CronJob) => Promise<unknown>): Promise<void>;
+    start(taskExecutor?: (job: CronJob, inputData?: string) => Promise<unknown>): Promise<void>;
     stop(): Promise<void>;
     /**
      * Add a new job
@@ -232,11 +236,19 @@ export declare class CronScheduler extends EventEmitter {
     /**
      * Run a job immediately
      */
-    runJobNow(jobId: string): Promise<JobRun | null>;
+    runJobNow(jobId: string, inputData?: string): Promise<JobRun | null>;
     private scheduleJob;
     private cancelJobTimer;
     private calculateNextRun;
     private executeJob;
+    /** Max bytes for outputData passed between chained jobs. */
+    private static readonly MAX_OUTPUT_DATA_BYTES;
+    /**
+     * Extract a string `outputData` from the executor result. Looks for an
+     * explicit `outputData` field first, then falls back to `output`, then
+     * stringifies the whole result. Always capped at 64KB.
+     */
+    static extractOutputData(result: unknown): string | undefined;
     /**
      * Resolve and execute a chained (`then`) job after its parent succeeds.
      *

package/dist/scheduler/cron-scheduler.js

@@ -304,11 +304,11 @@ export class CronScheduler extends EventEmitter {
     /**
      * Run a job immediately
      */
-    async runJobNow(jobId) {
+    async runJobNow(jobId, inputData) {
         const job = this.jobs.get(jobId);
         if (!job)
             return null;
-        return await this.executeJob(job);
+        return await this.executeJob(job, 0, inputData);
     }
     // ==========================================================================
     // Scheduling
@@ -379,19 +379,20 @@ export class CronScheduler extends EventEmitter {
     // ==========================================================================
     // Execution
     // ==========================================================================
-    async executeJob(job, chainDepth = 0) {
+    async executeJob(job, chainDepth = 0, inputData) {
         const run = {
             id: crypto.randomUUID(),
             jobId: job.id,
             startedAt: new Date(),
             status: 'running',
+            ...(inputData !== undefined ? { inputData } : {}),
         };
         this.emit('job:run:start', run);
         try {
             // Execute task
             let result;
             if (this.taskExecutor) {
-                result = await this.taskExecutor(job);
+                result = await this.taskExecutor(job, inputData);
             }
             else {
                 // Default execution (just log)
@@ -401,6 +402,10 @@ export class CronScheduler extends EventEmitter {
             run.status = 'success';
             run.result = result;
             run.duration = run.completedAt.getTime() - run.startedAt.getTime();
+            // Extract outputData from the executor result for cross-job data passing.
+            // The executor may return an object with an `output` or `outputData`
+            // field; we cap at 64KB to keep run history manageable.
+            run.outputData = CronScheduler.extractOutputData(result);
             job.lastRunAt = run.startedAt;
             job.runCount++;
             // Reset backoff on success
@@ -444,10 +449,50 @@ export class CronScheduler extends EventEmitter {
         // successful run, so the chain runs inside a guarded helper that swallows
         // (and logs) any error from the chained job.
         if (run.status === 'success' && job.then) {
-            await this.runChainedJob(job, chainDepth);
+            await this.runChainedJob(job, chainDepth, run.outputData);
         }
         return run;
     }
+    /** Max bytes for outputData passed between chained jobs. */
+    static MAX_OUTPUT_DATA_BYTES = 65_536; // 64 KiB
+    /**
+     * Extract a string `outputData` from the executor result. Looks for an
+     * explicit `outputData` field first, then falls back to `output`, then
+     * stringifies the whole result. Always capped at 64KB.
+     */
+    static extractOutputData(result) {
+        if (result == null)
+            return undefined;
+        let raw;
+        if (typeof result === 'string') {
+            raw = result;
+        }
+        else if (typeof result === 'object') {
+            const obj = result;
+            if (typeof obj.outputData === 'string') {
+                raw = obj.outputData;
+            }
+            else if (typeof obj.output === 'string') {
+                raw = obj.output;
+            }
+            else {
+                try {
+                    raw = JSON.stringify(result);
+                }
+                catch {
+                    return undefined;
+                }
+            }
+        }
+        else {
+            raw = String(result);
+        }
+        if (!raw || raw.length === 0)
+            return undefined;
+        return raw.length > CronScheduler.MAX_OUTPUT_DATA_BYTES
+            ? raw.slice(0, CronScheduler.MAX_OUTPUT_DATA_BYTES)
+            : raw;
+    }
     /**
      * Resolve and execute a chained (`then`) job after its parent succeeds.
      *
@@ -455,7 +500,7 @@ export class CronScheduler extends EventEmitter {
      * authored out of order. A missing/disabled target, a self-reference, or a
      * depth-cap breach is logged and stops the chain — it never throws.
      */
-    async runChainedJob(parent, chainDepth) {
+    async runChainedJob(parent, chainDepth, outputData) {
         const target = parent.then;
         if (!target)
             return;
@@ -493,7 +538,8 @@ export class CronScheduler extends EventEmitter {
             return;
         }
         try {
-            await this.executeJob(next, chainDepth + 1);
+            // Pass the parent job's outputData as the chained job's inputData.
+            await this.executeJob(next, chainDepth + 1, outputData);
         }
         catch (err) {
             // A chained failure is captured in the chained job's own run record; it

package/dist/scheduler/script-runner.d.ts

@@ -26,6 +26,8 @@ export interface CronScriptResult {
     exitCode: number | null;
     /** Combined stdout + stderr, capped. */
     output: string;
+    /** Stdout only, capped at 64KB. Used for cross-job data passing. */
+    stdout: string;
     /** True when the timeout fired and the process was killed. */
     timedOut: boolean;
 }

package/dist/scheduler/script-runner.js

@@ -16,6 +16,7 @@ import { spawn } from 'child_process';
 import path from 'path';
 const DEFAULT_SCRIPT_TIMEOUT_MS = 600_000;
 const MAX_OUTPUT_BYTES = 1_048_576; // 1 MiB cap on captured output
+const MAX_STDOUT_BYTES = 65_536; // 64 KiB cap on stdout for data passing
 const DEFAULT_ALLOWED_EXECUTABLES = new Set([
     'bash',
     'cargo',
@@ -68,27 +69,41 @@ function spawnScript(command, timeoutMs) {
             windowsHide: true,
         });
         let output = '';
+        let stdoutOnly = '';
         let timedOut = false;
-        const append = (chunk) => {
+        const appendOutput = (chunk) => {
             if (output.length < MAX_OUTPUT_BYTES) {
                 output += chunk;
             }
         };
+        const appendStdout = (chunk) => {
+            if (stdoutOnly.length < MAX_STDOUT_BYTES) {
+                stdoutOnly += chunk;
+            }
+        };
         const timer = setTimeout(() => {
             timedOut = true;
             child.kill('SIGTERM');
         }, timeoutMs);
         child.stdout.setEncoding('utf8');
-        child.stdout.on('data', append);
+        child.stdout.on('data', (chunk) => {
+            appendOutput(chunk);
+            appendStdout(chunk);
+        });
         child.stderr.setEncoding('utf8');
-        child.stderr.on('data', append);
+        child.stderr.on('data', appendOutput);
         child.on('error', (error) => {
             clearTimeout(timer);
             reject(error);
         });
         child.on('close', (exitCode) => {
             clearTimeout(timer);
-            resolve({ exitCode, output: output.trimEnd(), timedOut });
+            resolve({
+                exitCode,
+                output: output.trimEnd(),
+                stdout: stdoutOnly.trimEnd(),
+                timedOut,
+            });
         });
     });
 }

package/dist/scheduler/watchdog-handlers.js

@@ -16,8 +16,8 @@
  * The aggregate `ok` is true only when there are no alerts and no errors.
  */
 import { spawn } from 'child_process';
-import fs from 'fs';
 import path from 'path';
+import { getFreeSpaceInfo } from '../utils/disk-guard.js';
 const DEFAULT_HTTP_TIMEOUT_MS = 10_000;
 const DEFAULT_BUILD_ALLOWED_EXECUTABLES = new Set([
     'bash',
@@ -115,32 +115,19 @@ async function runSingleCheck(check, allowedExecutables) {
 }
 function checkDisk(check, name) {
     const target = check.path || process.cwd();
-    const statfs = fs.statfsSync;
-    if (typeof statfs !== 'function') {
+    // Single source of truth for free space (uses bavail); null when statfs is
+    // unavailable or the path can't be stat'd.
+    const info = getFreeSpaceInfo(target);
+    if (info === null) {
         return {
             type: 'disk',
             name,
             status: 'error',
-            summary: 'fs.statfsSync is not available in this Node runtime',
+            summary: `cannot determine free space at ${target} (fs.statfsSync unavailable or path unreadable)`,
             details: { path: target },
         };
     }
-    let stats;
-    try {
-        stats = statfs(target);
-    }
-    catch (err) {
-        return {
-            type: 'disk',
-            name,
-            status: 'error',
-            summary: `cannot stat filesystem at ${target}: ${errMsg(err)}`,
-            details: { path: target },
-        };
-    }
-    const totalBytes = stats.blocks * stats.bsize;
-    const freeBytes = stats.bavail * stats.bsize;
-    const freePercent = totalBytes > 0 ? (freeBytes / totalBytes) * 100 : 0;
+    const { freeBytes, totalBytes, freePercent } = info;
     const breaches = [];
     if (typeof check.minFreeBytes === 'number' && freeBytes < check.minFreeBytes) {
         breaches.push(`free ${formatBytes(freeBytes)} < min ${formatBytes(check.minFreeBytes)}`);

package/dist/search/usearch-index.js

@@ -89,8 +89,13 @@ export class USearchVectorIndex extends EventEmitter {
      */
     async loadUSearch() {
         try {
-            // Dynamic import for optional dependency
-            const usearch = (await import('usearch'));
+            // Dynamic import for an OPTIONAL native dependency (see optionalDependencies).
+            // Use a non-literal specifier so `tsc` doesn't require 'usearch' to be
+            // resolvable on every platform — it isn't installed on some CI runners
+            // (e.g. windows-latest), which otherwise fails type-check with TS2307.
+            // Types come from the local USearchModule interface, not the package.
+            const usearchSpecifier = 'usearch';
+            const usearch = (await import(usearchSpecifier));
             return usearch;
         }
         catch (_err) {

package/dist/security/tool-policy/tool-groups.js

@@ -42,6 +42,8 @@ export const TOOL_GROUPS = {
     // Runtime - Process
     spawn_process: ['group:runtime', 'group:runtime:process'],
     kill_process: ['group:runtime', 'group:runtime:process', 'group:dangerous'],
+    // Runtime - Office macros (arbitrary VBA/PowerShell via COM, Windows only)
+    office_macro_execute: ['group:runtime', 'group:runtime:shell', 'group:dangerous'],
     // Web - Fetch
     web_fetch: ['group:web', 'group:web:fetch'],
     http_request: ['group:web', 'group:web:fetch'],

package/dist/sensory/dreaming.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Dreaming — heartbeat-paced memory consolidation. Every N beats, the short-term
+ * sensory buffer is drained and consolidated into a compact "dream" summary
+ * (counts by kind, salient events, time window, average load) appended to a
+ * long-term dream journal. The heartbeat-paced analogue of OpenClaw's dreaming
+ * (short-term recall → consolidated long-term memory).
+ *
+ * @module sensory/dreaming
+ */
+import type { Perception } from './reactions.js';
+export interface DreamSummary {
+    dreamedAt: number;
+    windowStartMs: number | null;
+    windowEndMs: number | null;
+    total: number;
+    /** "audio/speech_start" → count, "vital/heartbeat" → count, … */
+    byKind: Record<string, number>;
+    salient: Array<{
+        modality?: string;
+        kind?: string;
+        salience?: number;
+        tsMs?: number;
+    }>;
+    avgLoad: number | null;
+}
+/** Pure consolidation: summarize a window of perceptions into a dream. */
+export declare function consolidate(perceptions: Perception[], now: number): DreamSummary;
+export interface DreamingOptions {
+    cwd?: string;
+    now?: number;
+    /** Injectable promotion (tests); defaults to promoteSalientDream. */
+    promote?: (summary: DreamSummary) => Promise<void>;
+}
+/**
+ * One dreaming pass: drain the short-term buffer, consolidate, append to the
+ * dream journal, and promote a SALIENT dream into long-term persistent memory.
+ * Returns the summary, or null if there was nothing to consolidate.
+ */
+export declare function runDreamingPass(options?: DreamingOptions): Promise<DreamSummary | null>;
+/**
+ * Promote a salient dream into Code Buddy's persistent memory under a STABLE key
+ * (`dream:recent`) so repeated promotions UPDATE rather than accumulate (stays
+ * within the memory char budget). Never throws.
+ */
+export declare function promoteSalientDream(summary: DreamSummary): Promise<void>;

package/dist/sensory/dreaming.js

@@ -0,0 +1,114 @@
+/**
+ * Dreaming — heartbeat-paced memory consolidation. Every N beats, the short-term
+ * sensory buffer is drained and consolidated into a compact "dream" summary
+ * (counts by kind, salient events, time window, average load) appended to a
+ * long-term dream journal. The heartbeat-paced analogue of OpenClaw's dreaming
+ * (short-term recall → consolidated long-term memory).
+ *
+ * @module sensory/dreaming
+ */
+import { appendFile, mkdir, stat, rename } from 'fs/promises';
+import path from 'path';
+import { getSensoryMemory } from './sensory-memory.js';
+import { logger } from '../utils/logger.js';
+const SALIENT_THRESHOLD = 128;
+/** Pure consolidation: summarize a window of perceptions into a dream. */
+export function consolidate(perceptions, now) {
+    const byKind = {};
+    const salient = [];
+    let loadSum = 0;
+    let loadN = 0;
+    let minTs = null;
+    let maxTs = null;
+    for (const p of perceptions) {
+        const key = `${p.modality}/${p.kind}`;
+        byKind[key] = (byKind[key] ?? 0) + 1;
+        if ((p.salience ?? 0) >= SALIENT_THRESHOLD) {
+            salient.push({ modality: p.modality, kind: p.kind, salience: p.salience, tsMs: p.tsMs });
+        }
+        const load = p.payload?.load1;
+        if (typeof load === 'number') {
+            loadSum += load;
+            loadN += 1;
+        }
+        // Window on the ingest wall-clock (consistent across senses), not the
+        // sense-relative tsMs (frame-relative for audio vs unix for vital).
+        if (typeof p.receivedAt === 'number') {
+            minTs = minTs === null ? p.receivedAt : Math.min(minTs, p.receivedAt);
+            maxTs = maxTs === null ? p.receivedAt : Math.max(maxTs, p.receivedAt);
+        }
+    }
+    return {
+        dreamedAt: now,
+        windowStartMs: minTs,
+        windowEndMs: maxTs,
+        total: perceptions.length,
+        byKind,
+        salient: salient.slice(0, 20),
+        avgLoad: loadN > 0 ? loadSum / loadN : null,
+    };
+}
+/**
+ * One dreaming pass: drain the short-term buffer, consolidate, append to the
+ * dream journal, and promote a SALIENT dream into long-term persistent memory.
+ * Returns the summary, or null if there was nothing to consolidate.
+ */
+export async function runDreamingPass(options = {}) {
+    const perceptions = getSensoryMemory().drain();
+    if (perceptions.length === 0)
+        return null;
+    const summary = consolidate(perceptions, options.now ?? Date.now());
+    try {
+        const dir = path.join(options.cwd ?? process.cwd(), '.codebuddy', 'companion');
+        await mkdir(dir, { recursive: true });
+        const file = path.join(dir, 'dreams.jsonl');
+        // Rotate when large (the disk-guard lesson): keep one .1 backup, never grow unbounded.
+        try {
+            const info = await stat(file);
+            if (info.size > 512 * 1024)
+                await rename(file, `${file}.1`);
+        }
+        catch {
+            /* no file yet */
+        }
+        await appendFile(file, `${JSON.stringify(summary)}\n`, 'utf8');
+    }
+    catch (err) {
+        logger.warn(`[dreaming] could not persist dream: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    // Deep consolidation — salient dreams become long-term memory the agent reads.
+    if (summary.salient.length > 0) {
+        await (options.promote ?? promoteSalientDream)(summary);
+    }
+    logger.info(`[dreaming] consolidated ${summary.total} perception(s) → ${Object.keys(summary.byKind).length} kind(s), ${summary.salient.length} salient, avg load ${summary.avgLoad ?? '?'}`);
+    return summary;
+}
+/**
+ * Promote a salient dream into Code Buddy's persistent memory under a STABLE key
+ * (`dream:recent`) so repeated promotions UPDATE rather than accumulate (stays
+ * within the memory char budget). Never throws.
+ */
+export async function promoteSalientDream(summary) {
+    try {
+        const { getMemoryManager } = await import('../memory/persistent-memory.js');
+        const manager = getMemoryManager();
+        await manager.initialize();
+        // Cap the kinds string (a daemon could emit many distinct kinds → an
+        // oversized write that the memory char-limit would reject).
+        const kindEntries = Object.entries(summary.byKind).sort((a, b) => b[1] - a[1]);
+        const kinds = kindEntries
+            .slice(0, 12)
+            .map(([k, n]) => `${k}×${n}`)
+            .join(', ') + (kindEntries.length > 12 ? `, +${kindEntries.length - 12} more` : '');
+        const top = summary.salient
+            .slice(0, 5)
+            .map((s) => `${s.modality}/${s.kind}`)
+            .join(', ');
+        const value = `Recent salient perception: ${summary.total} events (${kinds}); salient: ${top}; avg load ${summary.avgLoad ?? '?'}.`;
+        await manager.remember('dream:recent', value, { scope: 'project', category: 'context', tags: ['dream', 'sensory'] });
+    }
+    catch (err) {
+        logger.warn(`[dreaming] could not promote dream to memory: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+//# sourceMappingURL=dreaming.js.map

package/dist/sensory/heartbeat-scheduler.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Heartbeat scheduler — turns the nervous-system heartbeat into a PACEMAKER for
+ * periodic processing in Code Buddy. Register "treatments" that fire every N
+ * beats; the daemon's heart rate (BUDDY_SENSE_HEARTBEAT_MS) dials how often they
+ * run — a faster heart triggers more processing, a slower one less.
+ *
+ * This is the heartbeat-paced analogue of Hermes's curator/cron and OpenClaw's
+ * cron-jobs + dreaming: scheduled background work, but driven by the heart rather
+ * than a wall clock. Each beat carries vital signs (uptime, load) the treatments
+ * can read — so a treatment can also adapt to the body's state.
+ *
+ * @module sensory/heartbeat-scheduler
+ */
+export interface HeartbeatContext {
+    beat: number;
+    uptimeMs?: number;
+    load1?: number | null;
+}
+export type HeartbeatHandler = (ctx: HeartbeatContext) => void | Promise<void>;
+export interface HeartbeatTask {
+    name: string;
+    /** Fire when `beat % everyBeats === 0` (1 = every beat). */
+    everyBeats: number;
+    handler: HeartbeatHandler;
+}
+export declare class HeartbeatScheduler {
+    private readonly tasks;
+    private listenerId?;
+    /** Register a treatment to run every N beats. Re-registering replaces it. */
+    register(task: HeartbeatTask): void;
+    unregister(name: string): void;
+    list(): HeartbeatTask[];
+    /** Subscribe to the sensory bus and start pacing. Idempotent. */
+    start(): void;
+    stop(): void;
+    private onBeat;
+}
+export declare function getHeartbeatScheduler(): HeartbeatScheduler;

package/dist/sensory/heartbeat-scheduler.js

@@ -0,0 +1,72 @@
+/**
+ * Heartbeat scheduler — turns the nervous-system heartbeat into a PACEMAKER for
+ * periodic processing in Code Buddy. Register "treatments" that fire every N
+ * beats; the daemon's heart rate (BUDDY_SENSE_HEARTBEAT_MS) dials how often they
+ * run — a faster heart triggers more processing, a slower one less.
+ *
+ * This is the heartbeat-paced analogue of Hermes's curator/cron and OpenClaw's
+ * cron-jobs + dreaming: scheduled background work, but driven by the heart rather
+ * than a wall clock. Each beat carries vital signs (uptime, load) the treatments
+ * can read — so a treatment can also adapt to the body's state.
+ *
+ * @module sensory/heartbeat-scheduler
+ */
+import { getGlobalEventBus } from '../events/event-bus.js';
+import { logger } from '../utils/logger.js';
+export class HeartbeatScheduler {
+    tasks = new Map();
+    listenerId;
+    /** Register a treatment to run every N beats. Re-registering replaces it. */
+    register(task) {
+        if (!Number.isInteger(task.everyBeats) || task.everyBeats < 1) {
+            throw new Error(`heartbeat task "${task.name}": everyBeats must be an integer >= 1`);
+        }
+        this.tasks.set(task.name, task);
+    }
+    unregister(name) {
+        this.tasks.delete(name);
+    }
+    list() {
+        return [...this.tasks.values()];
+    }
+    /** Subscribe to the sensory bus and start pacing. Idempotent. */
+    start() {
+        if (this.listenerId)
+            return;
+        const bus = getGlobalEventBus();
+        this.listenerId = bus.on('sensory:perception', (evt) => {
+            const m = evt.metadata;
+            if (m?.modality !== 'vital' || m?.kind !== 'heartbeat')
+                return;
+            const beat = Number(m.payload?.beat ?? 0);
+            if (!Number.isFinite(beat) || beat < 1)
+                return;
+            void this.onBeat({ beat, uptimeMs: m.payload?.uptime_ms, load1: m.payload?.load1 });
+        });
+    }
+    stop() {
+        if (this.listenerId) {
+            getGlobalEventBus().off(this.listenerId);
+            this.listenerId = undefined;
+        }
+    }
+    async onBeat(ctx) {
+        for (const task of this.tasks.values()) {
+            if (ctx.beat % task.everyBeats !== 0)
+                continue;
+            try {
+                await task.handler(ctx);
+            }
+            catch (err) {
+                logger.warn(`[heartbeat] treatment "${task.name}" failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+}
+let singleton;
+export function getHeartbeatScheduler() {
+    if (!singleton)
+        singleton = new HeartbeatScheduler();
+    return singleton;
+}
+//# sourceMappingURL=heartbeat-scheduler.js.map

package/dist/sensory/reactions.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Sensory reactions — subscribers that turn `sensory:perception` events from the
+ * nervous-system daemon into Code Buddy behaviour. Phase 1 logs + exposes a hook;
+ * Phase 2 will route (speech_end → STT → turn; motion → camera_analyze).
+ *
+ * @module sensory/reactions
+ */
+import type { BaseEvent } from '../events/types.js';
+export interface Perception {
+    modality?: string;
+    kind?: string;
+    salience?: number;
+    /** Sense-relative timestamp (frame-relative for audio, unix-millis for vital). */
+    tsMs?: number;
+    /** Ingest wall-clock (one consistent clock across senses — used for dream windows). */
+    receivedAt?: number;
+    payload?: unknown;
+}
+export declare function perceptionOf(evt: BaseEvent): Perception;
+/**
+ * Wire reactions to the sensory bus. Returns an unsubscribe fn. `onPerception`
+ * is an injectable hook (tests + future routing).
+ */
+export declare function wireSensoryReactions(onPerception?: (p: Perception, evt: BaseEvent) => void): () => void;

package/dist/sensory/reactions.js

@@ -0,0 +1,31 @@
+/**
+ * Sensory reactions — subscribers that turn `sensory:perception` events from the
+ * nervous-system daemon into Code Buddy behaviour. Phase 1 logs + exposes a hook;
+ * Phase 2 will route (speech_end → STT → turn; motion → camera_analyze).
+ *
+ * @module sensory/reactions
+ */
+import { getGlobalEventBus } from '../events/event-bus.js';
+import { logger } from '../utils/logger.js';
+import { getSensoryMemory } from './sensory-memory.js';
+export function perceptionOf(evt) {
+    const meta = evt.metadata ?? {};
+    return { ...meta, receivedAt: evt.timestamp };
+}
+/**
+ * Wire reactions to the sensory bus. Returns an unsubscribe fn. `onPerception`
+ * is an injectable hook (tests + future routing).
+ */
+export function wireSensoryReactions(onPerception) {
+    const bus = getGlobalEventBus();
+    const id = bus.on('sensory:perception', (evt) => {
+        const p = perceptionOf(evt);
+        logger.info(`[sensory] ${p.modality}/${p.kind} (salience ${p.salience ?? 0})`);
+        getSensoryMemory().push(p); // short-term memory → consolidated by dreaming
+        onPerception?.(p, evt);
+    });
+    return () => {
+        bus.off(id);
+    };
+}
+//# sourceMappingURL=reactions.js.map

package/dist/sensory/screen-reaction.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Screen reaction — on a `screen/change` event from the nervous-system daemon,
+ * record a companion percept and (optionally) run an injected analyzer (OCR /
+ * vision describe). DEBOUNCED, opt-in (`CODEBUDDY_SENSORY_SCREEN=true`),
+ * never-throws. The heavy OCR/describe is pluggable so we don't duplicate Code
+ * Buddy's existing OCR/vision; inject an analyzer to wire it.
+ *
+ * @module sensory/screen-reaction
+ */
+export interface ScreenAnalysis {
+    description?: string;
+}
+export interface ScreenAnalyzer {
+    analyze(): Promise<ScreenAnalysis>;
+}
+export interface ScreenReactionOptions {
+    /** Injectable OCR/vision describe (default: none — just record the change). */
+    analyzer?: ScreenAnalyzer;
+    debounceMs?: number;
+    cwd?: string;
+    now?: () => number;
+}
+export declare function wireScreenReaction(options?: ScreenReactionOptions): () => void;