@undefineds.co/linx 0.3.5 → 0.3.8

package/vendor/agent-runtime/dist/thread-reconciler-controller.js

@@ -0,0 +1,137 @@
+import { reconcileThreadEvent, summarizeReconcileDecision, } from './reconciler.js';
+import { createWakeJobScheduler, defaultWakeJobDedupeKey, summarizeWakeJobExecutionRecord, summarizeWakeJobSchedulerSnapshot, } from './wake-scheduler.js';
+export function createThreadReconcilerController(options) {
+    return new ConfiguredThreadReconcilerController(options);
+}
+export function decideThreadControlEvent(input) {
+    const decision = reconcileThreadEvent(input);
+    return {
+        decision,
+        summary: summarizeReconcileDecision(decision),
+    };
+}
+export async function runThreadReconcilerCycle(options) {
+    const { event, dispatchOptions, onDispatched, ...controllerOptions } = options;
+    const controller = createThreadReconcilerController({
+        ...controllerOptions,
+        autoStart: false,
+    });
+    const dispatch = controller.dispatch(event, dispatchOptions);
+    await onDispatched?.(dispatch);
+    const drain = await controller.startAndDrain();
+    return {
+        ...dispatch,
+        ...drain,
+    };
+}
+class ConfiguredThreadReconcilerController {
+    options;
+    scheduler;
+    contexts = new Map();
+    constructor(options) {
+        this.options = options;
+        this.scheduler = createWakeJobScheduler({
+            concurrency: options.concurrency,
+            now: options.now,
+            dedupeKey: defaultWakeJobDedupeKey,
+            handler: async (job, record) => {
+                const context = this.contexts.get(record.key);
+                if (!context) {
+                    throw new Error(`No reconciler decision found for wake job ${record.key}`);
+                }
+                return options.handleWakeJob({
+                    job,
+                    record,
+                    decision: context.decision,
+                    decisionSummary: context.summary,
+                });
+            },
+            onQueued: (record) => this.emitWakeHook('queued', record),
+            onStarted: (record) => this.emitWakeHook('started', record),
+            onCompleted: (record) => this.emitWakeHook('completed', record),
+            onFailed: (record) => this.emitWakeHook('failed', record),
+        });
+        if (options.autoStart !== false) {
+            this.scheduler.start();
+        }
+    }
+    dispatch(event, options = {}) {
+        const { decision, summary } = decideThreadControlEvent({
+            ...options,
+            policy: this.options.policy,
+            event,
+        });
+        this.options.onDecision?.(summary);
+        for (const job of decision.wakeJobs) {
+            const key = defaultWakeJobDedupeKey(job);
+            if (!this.contexts.has(key)) {
+                this.contexts.set(key, {
+                    decision,
+                    summary,
+                });
+            }
+        }
+        const wakeRecords = this.scheduler.submit(decision.wakeJobs);
+        for (const record of wakeRecords) {
+            if (!this.contexts.has(record.key)) {
+                this.contexts.set(record.key, {
+                    decision,
+                    summary,
+                });
+            }
+        }
+        return {
+            decision,
+            summary,
+            wakeRecords,
+            wakeRecordSummaries: wakeRecords.map(summarizeWakeJobExecutionRecord),
+        };
+    }
+    async dispatchAndDrain(event, options = {}) {
+        const dispatch = this.dispatch(event, options);
+        const drain = await this.startAndDrain();
+        return {
+            ...dispatch,
+            ...drain,
+        };
+    }
+    async startAndDrain() {
+        this.start();
+        await this.drain();
+        const scheduler = this.snapshot();
+        return {
+            scheduler,
+            schedulerSummary: summarizeWakeJobSchedulerSnapshot(scheduler),
+        };
+    }
+    start() {
+        this.scheduler.start();
+    }
+    stop() {
+        this.scheduler.stop();
+    }
+    drain() {
+        return this.scheduler.drain();
+    }
+    snapshot() {
+        return this.scheduler.snapshot();
+    }
+    emitWakeHook(status, record) {
+        const context = this.contexts.get(record.key);
+        if (!context) {
+            return;
+        }
+        if (status === 'queued') {
+            this.options.onWakeJobQueued?.(record, context.summary);
+        }
+        else if (status === 'started') {
+            this.options.onWakeJobStarted?.(record, context.summary);
+        }
+        else if (status === 'completed') {
+            this.options.onWakeJobCompleted?.(record, context.summary);
+        }
+        else {
+            this.options.onWakeJobFailed?.(record, context.summary);
+        }
+    }
+}

package/vendor/agent-runtime/dist/turn-controller.js

@@ -90,7 +90,7 @@ export const GROUP_AGENT_TURN_RULE = {
 export const AUTO_MODE_SECRETARY_APPROVAL_RULE = {
     id: 'auto-mode.secretary.approval',
     trigger: 'approval.required',
-    targetAgent: 'ai-secretary',
+    targetAgent: '__secretary__',
     targetRole: 'secretary',
     requiredCapabilities: ['approval.request', 'approval.options'],
     context: {
@@ -108,7 +108,7 @@ export const AUTO_MODE_SECRETARY_APPROVAL_RULE = {
 export const AUTO_MODE_SECRETARY_INPUT_RULE = {
     id: 'auto-mode.secretary.input',
     trigger: 'input.required',
-    targetAgent: 'ai-secretary',
+    targetAgent: '__secretary__',
     targetRole: 'secretary',
     requiredCapabilities: ['input.structured'],
     context: {

package/vendor/agent-runtime/dist/wake-scheduler.d.ts

@@ -0,0 +1,67 @@
+import type { WakeJob, WakeJobPriority } from './reconciler.js';
+type MaybePromise<T> = T | Promise<T>;
+export type WakeJobExecutionStatus = 'queued' | 'running' | 'completed' | 'failed' | 'cancelled' | 'skipped';
+export interface WakeJobExecutionRecord {
+    key: string;
+    job: WakeJob;
+    status: WakeJobExecutionStatus;
+    queuedAt: string;
+    startedAt?: string;
+    completedAt?: string;
+    error?: string;
+    result?: unknown;
+}
+export type WakeJobHandler = (job: WakeJob, record: WakeJobExecutionRecord) => MaybePromise<unknown>;
+export interface WakeJobSchedulerOptions {
+    handler: WakeJobHandler;
+    concurrency?: number;
+    now?: () => Date;
+    dedupeKey?: (job: WakeJob) => string;
+    onQueued?: (record: WakeJobExecutionRecord) => void;
+    onStarted?: (record: WakeJobExecutionRecord) => void;
+    onCompleted?: (record: WakeJobExecutionRecord) => void;
+    onFailed?: (record: WakeJobExecutionRecord) => void;
+}
+export interface WakeJobSchedulerSnapshot {
+    queued: WakeJobExecutionRecord[];
+    running: WakeJobExecutionRecord[];
+    completed: WakeJobExecutionRecord[];
+    failed: WakeJobExecutionRecord[];
+    cancelled: WakeJobExecutionRecord[];
+    skipped: WakeJobExecutionRecord[];
+    all: WakeJobExecutionRecord[];
+}
+export interface WakeJobExecutionRecordSummary {
+    key: string;
+    status: WakeJobExecutionStatus;
+    targetAgent: string;
+    targetRole: string;
+    trigger: string;
+    priority: WakeJobPriority;
+    queuedAt: string;
+    startedAt?: string;
+    completedAt?: string;
+    error?: string;
+    result?: unknown;
+}
+export interface WakeJobSchedulerSnapshotSummary {
+    queued: WakeJobExecutionRecordSummary[];
+    running: WakeJobExecutionRecordSummary[];
+    completed: WakeJobExecutionRecordSummary[];
+    failed: WakeJobExecutionRecordSummary[];
+    cancelled: WakeJobExecutionRecordSummary[];
+    skipped: WakeJobExecutionRecordSummary[];
+}
+export interface WakeJobScheduler {
+    submit(job: WakeJob | WakeJob[]): WakeJobExecutionRecord[];
+    start(): void;
+    stop(): void;
+    drain(): Promise<void>;
+    snapshot(): WakeJobSchedulerSnapshot;
+    get(key: string): WakeJobExecutionRecord | undefined;
+}
+export declare function createWakeJobScheduler(options: WakeJobSchedulerOptions): WakeJobScheduler;
+export declare function defaultWakeJobDedupeKey(job: WakeJob): string;
+export declare function summarizeWakeJobExecutionRecord(record: WakeJobExecutionRecord): WakeJobExecutionRecordSummary;
+export declare function summarizeWakeJobSchedulerSnapshot(snapshot: WakeJobSchedulerSnapshot): WakeJobSchedulerSnapshotSummary;
+export {};

package/vendor/agent-runtime/dist/wake-scheduler.js

@@ -0,0 +1,194 @@
+const PRIORITY_RANK = {
+    high: 3,
+    normal: 2,
+    low: 1,
+};
+export function createWakeJobScheduler(options) {
+    return new InMemoryWakeJobScheduler(options);
+}
+export function defaultWakeJobDedupeKey(job) {
+    const source = job.sourceEventId ?? job.id ?? job.sourceEventType;
+    return [
+        job.thread,
+        job.chat ?? '',
+        job.targetAgent,
+        job.targetRole,
+        source,
+        job.trigger,
+    ].join('|');
+}
+export function summarizeWakeJobExecutionRecord(record) {
+    return {
+        key: record.key,
+        status: record.status,
+        targetAgent: record.job.targetAgent,
+        targetRole: record.job.targetRole,
+        trigger: record.job.trigger,
+        priority: record.job.priority,
+        queuedAt: record.queuedAt,
+        startedAt: record.startedAt,
+        completedAt: record.completedAt,
+        error: record.error,
+        result: record.result,
+    };
+}
+export function summarizeWakeJobSchedulerSnapshot(snapshot) {
+    return {
+        queued: snapshot.queued.map(summarizeWakeJobExecutionRecord),
+        running: snapshot.running.map(summarizeWakeJobExecutionRecord),
+        completed: snapshot.completed.map(summarizeWakeJobExecutionRecord),
+        failed: snapshot.failed.map(summarizeWakeJobExecutionRecord),
+        cancelled: snapshot.cancelled.map(summarizeWakeJobExecutionRecord),
+        skipped: snapshot.skipped.map(summarizeWakeJobExecutionRecord),
+    };
+}
+class InMemoryWakeJobScheduler {
+    options;
+    handler;
+    concurrency;
+    now;
+    dedupeKey;
+    records = new Map();
+    queue = [];
+    running = new Set();
+    drainResolvers = [];
+    started = false;
+    sequence = 0;
+    constructor(options) {
+        this.options = options;
+        this.handler = options.handler;
+        this.concurrency = normalizeConcurrency(options.concurrency);
+        this.now = options.now ?? (() => new Date());
+        this.dedupeKey = options.dedupeKey ?? defaultWakeJobDedupeKey;
+    }
+    submit(input) {
+        const jobs = Array.isArray(input) ? input : [input];
+        const records = jobs.map((job) => this.enqueue(job));
+        this.pump();
+        return records.map(cloneRecord);
+    }
+    start() {
+        this.started = true;
+        this.pump();
+    }
+    stop() {
+        this.started = false;
+    }
+    drain() {
+        if (this.isDrained()) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            this.drainResolvers.push(resolve);
+            this.pump();
+        });
+    }
+    snapshot() {
+        const all = [...this.records.values()].map(cloneRecord);
+        return {
+            queued: all.filter((record) => record.status === 'queued'),
+            running: all.filter((record) => record.status === 'running'),
+            completed: all.filter((record) => record.status === 'completed'),
+            failed: all.filter((record) => record.status === 'failed'),
+            cancelled: all.filter((record) => record.status === 'cancelled'),
+            skipped: all.filter((record) => record.status === 'skipped'),
+            all,
+        };
+    }
+    get(key) {
+        const record = this.records.get(key);
+        return record ? cloneRecord(record) : undefined;
+    }
+    enqueue(job) {
+        const key = this.dedupeKey(job);
+        const existing = this.records.get(key);
+        if (existing) {
+            return existing;
+        }
+        const record = {
+            key,
+            job,
+            status: 'queued',
+            queuedAt: this.now().toISOString(),
+        };
+        this.records.set(key, record);
+        this.sequence += 1;
+        this.queue.push({
+            record,
+            sequence: this.sequence,
+        });
+        this.options.onQueued?.(cloneRecord(record));
+        return record;
+    }
+    pump() {
+        while (this.started && this.running.size < this.concurrency && this.queue.length > 0) {
+            const queued = this.takeNextQueued();
+            this.startRecord(queued.record);
+        }
+        this.resolveDrainIfIdle();
+    }
+    takeNextQueued() {
+        let bestIndex = 0;
+        for (let index = 1; index < this.queue.length; index += 1) {
+            if (compareQueuedJobs(this.queue[index], this.queue[bestIndex]) < 0) {
+                bestIndex = index;
+            }
+        }
+        const [queued] = this.queue.splice(bestIndex, 1);
+        return queued;
+    }
+    startRecord(record) {
+        record.status = 'running';
+        record.startedAt = this.now().toISOString();
+        this.running.add(record.key);
+        this.options.onStarted?.(cloneRecord(record));
+        void Promise.resolve()
+            .then(() => this.handler(record.job, cloneRecord(record)))
+            .then((result) => {
+            record.status = 'completed';
+            record.completedAt = this.now().toISOString();
+            record.result = result;
+            this.options.onCompleted?.(cloneRecord(record));
+        })
+            .catch((cause) => {
+            const error = cause instanceof Error ? cause.message : String(cause);
+            record.status = 'failed';
+            record.completedAt = this.now().toISOString();
+            record.error = error;
+            this.options.onFailed?.(cloneRecord(record));
+        })
+            .finally(() => {
+            this.running.delete(record.key);
+            this.pump();
+        });
+    }
+    isDrained() {
+        return this.queue.length === 0 && this.running.size === 0;
+    }
+    resolveDrainIfIdle() {
+        if (!this.isDrained()) {
+            return;
+        }
+        while (this.drainResolvers.length > 0) {
+            this.drainResolvers.shift()?.();
+        }
+    }
+}
+function compareQueuedJobs(left, right) {
+    const priority = PRIORITY_RANK[right.record.job.priority] - PRIORITY_RANK[left.record.job.priority];
+    return priority === 0 ? left.sequence - right.sequence : priority;
+}
+function normalizeConcurrency(value) {
+    if (value === undefined || !Number.isFinite(value)) {
+        return 1;
+    }
+    return Math.max(1, Math.floor(value));
+}
+function cloneRecord(record) {
+    return {
+        ...record,
+        job: {
+            ...record.job,
+        },
+    };
+}

package/vendor/agent-runtime/package.json

@@ -7,7 +7,14 @@
     "./acp": "./dist/acp.js",
     "./auto-mode": "./dist/auto-mode.js",
     "./companion-model": "./dist/companion-model.js",
+    "./control-plane": "./dist/control-plane.js",
+    "./file-sync": "./dist/file-sync.js",
+    "./reconciler": "./dist/reconciler.js",
     "./runtime": "./dist/runtime.js",
-    "./turn-controller": "./dist/turn-controller.js"
+    "./symphony": "./dist/symphony.js",
+    "./sync": "./dist/sync.js",
+    "./thread-reconciler-controller": "./dist/thread-reconciler-controller.js",
+    "./turn-controller": "./dist/turn-controller.js",
+    "./wake-scheduler": "./dist/wake-scheduler.js"
   }
 }