@tealbrick/avm 0.1.2 → 0.2.5

package/README.md

@@ -163,3 +163,22 @@ Deployment authority correction (2026-09-15): live AVMM/Eve/Teal Brick packages
 belong exclusively on Nucbox, the Fedora N150. Neuu attempts above are historical
 and were aimed at the wrong host. Nucbox is reachable and reports AVMM
 0.13.0-alpha.2; its resident Aura still runs Eve 0.49.0. No live upgrade is implied.
+
+### Optional routine wake adapter
+
+`@tealbrick/avm/wake` exports `createAvmmWakeAdapter` for the Portal management
+channel's optional host-wake interface. It requires a fixed trusted transport,
+worker, stable ownerKey, explicit `allowed: true`, and verified Eve `timezone:
+'UTC'`. Wake-only assignments preserve Eve as the execution owner. See the Portal
+package's `MANAGEMENT.md` for supported timings, security boundary and acceptance
+requirements. It is not a generic cron dispatcher or an exe.dev adapter.
+
+### Shared host routine registry
+
+`@tealbrick/avm/routines`, `/routines-client` and `/routines-eve` provide the
+host-owned routine store, bounded RPC client and explicitly mounted Eve tools
+and dispatcher. Desktop and authenticated agent turns edit the same revisioned
+records; optional AVMM wake schedules are derived from those records. See
+[ROUTINES.md](./ROUTINES.md) for mounting, migration, authorization and execution
+semantics. This extends the operator-owned schedule boundary described above;
+it does not grant general host access or provide an exe.dev wake adapter.

package/ROUTINES.md

@@ -0,0 +1,85 @@
+# Shared host routines (Eve 0.58.1)
+
+The AVM package owns the host store, typed client and opt-in Eve routine tool.
+The host store is authoritative. Neither the desktop nor Eve edits a second
+schedule definition. AVMM wake assignments are derived projections of enabled
+rows with `wake: true`; Eve runs one permanent minute dispatcher. Plain VPS and
+exe.dev wake adapters are not supplied by this implementation.
+
+Exports:
+- `@tealbrick/avm/routines`: Node 24 host-only SQLite store and UTC cron validation.
+- `@tealbrick/avm/routines-client`: fixed endpoint client; resolves its scoped
+  bearer at request time, refuses redirects and bounds request duration.
+- `@tealbrick/avm/routines-eve`: `routineTool` and `routineDispatcher` factories.
+
+Explicitly mount a `routineTool({bridge,scope})` as an authored tool and
+`routineDispatcher({bridge,delivery})` as a root authored schedule. No package
+import installs either. The delivery channel must implement proactive receive
+and report completion using the occurrence ID. The Portal management channel
+supports `routines:{...bridge,owner}` for authenticated desktop CRUD and durable
+chat delivery. Keep build/restart configuration for explicit lifecycle actions.
+
+## Scope and authority
+
+A store is configured by the host operator for exactly one organization,
+workspace, logical agent and owning user. Opening it with another scope fails.
+The example host RPC binds an assigned worker IP plus a scoped bearer to that
+store. Portal authenticates the human/agent; this host enrollment grants access
+only to this store and its wake projection. No arbitrary host paths, commands,
+VM selection or model-supplied identity is accepted. Keep the service token
+inside the trusted guest runtime, never model inputs or browser storage.
+
+The Eve tool requires the authenticated managing user in the current turn,
+matching its configured owner and organization. Runtime/app and agent-to-agent
+principals cannot create further routines. An agent can author and edit in
+response to its authenticated user's conversation. Unattended self-modification
+requires a separate deliberate permission design; it is not silently enabled.
+Current deployment uses a fixed owner enrollment, not multi-owner delegation.
+Persisted routines remain authorized host jobs until paused/removed or host
+access is revoked; live Portal membership revocation is not revalidated at each
+cron occurrence in this version.
+
+## Records and operations
+
+Routine: name, five-field UTC cron, instruction, enabled, wake, revision,
+nextRunAt, updatedAt, tombstone. Scope belongs to the store, never request data.
+`apply` supports upsert (create-only), update, delete (tombstone), and wake.
+All changes require a stable requestId; updates require the observed revision.
+Desktop and model retries cannot overwrite newer revisions. Names cannot be
+changed; create a new routine if a new identity is wanted.
+
+Changes commit transactionally before wake reconciliation. A failed wake update
+is visibly pending and retried by the dispatcher. Existing wake registrations
+may remain until reconciliation succeeds, but disabled/deleted rows cannot be
+claimed. The legacy `/reconcile` RPC is disabled once shared storage is enabled.
+
+`claim` atomically advances due rows and records stable occurrence IDs. Concurrent
+claims return an occurrence once. A run can be claimed, dispatched, completed,
+failed, missed or uncertain. Ambiguous dispatch is not replayed automatically:
+this trades missed work for avoiding duplicate consequential actions. A tick more
+than two minutes late is recorded missed; no catch-up burst. Unresolved claims
+become uncertain after ten minutes. Already-running work is unaffected by edits.
+The last 100 runs are returned; disk retention and retry controls remain operator
+work. Completion means a final message was received, not verification of every
+external side effect.
+
+The store's in-process queue serializes async wake projections, and SQLite
+transactions protect records. Run one host service per store (systemd); do not
+run multiple independent wake reconcilers against the same file. Back up the
+SQLite database using its backup facilities or with the service stopped,
+including WAL files when applicable.
+
+## Consumer layout
+
+```
+lib/routines.ts                          fixed client + operator scope
+agent/tools/tealbrick_routines.ts        routineTool factory
+agent/schedules/tealbrick-routine-dispatcher.ts
+agent/channels/management.ts             Portal management + delivery adapter
+```
+
+For migration, preserve existing source and workflow state, seed the host store,
+remove the corresponding old static schedule from discovery, then build/restart
+once. Never leave both static and dynamic execution enabled for the same job.
+Subsequent edits need no rebuild or restart. Desktop reads dynamic rows from
+management discovery and hides the dispatcher implementation from its list.

package/dist/client/routines-client.d.ts

@@ -0,0 +1,6 @@
+import type { RoutineBridge } from './routines.js';
+/** Fixed operator-configured host endpoint. Secret is resolved at request time. */
+export declare function createRoutineClient(options: {
+    url: string;
+    token: () => string | Promise<string>;
+}): RoutineBridge;

package/dist/client/routines-client.js

@@ -0,0 +1,8 @@
+/** Fixed operator-configured host endpoint. Secret is resolved at request time. */
+export function createRoutineClient(options) {
+    const url = new URL(options.url);
+    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.search || url.hash)
+        throw Error('invalid_host_endpoint');
+    return { async call(action, input = {}) { const response = await fetch(url, { method: 'POST', redirect: 'error', signal: AbortSignal.timeout(30000), headers: { 'content-type': 'application/json', authorization: `Bearer ${await options.token()}` }, body: JSON.stringify({ action, input }) }); const body = await response.json(); if (!response.ok)
+            throw Error(typeof body.error === 'string' ? body.error : 'routine_host_unavailable'); return body; } };
+}

package/dist/client/routines-eve.d.ts

@@ -0,0 +1,32 @@
+import type { RoutineBridge, RoutineScope } from './routines.js';
+/** Explicitly mounted tool; no model-selected owner, host URL or shell command. */
+export declare function routineTool(options: {
+    bridge: RoutineBridge;
+    scope: RoutineScope;
+}): import("eve/tools").ToolDefinition<{
+    operation: "list" | "create" | "update" | "pause" | "resume" | "remove";
+    name?: string | undefined;
+    cron?: string | undefined;
+    instruction?: string | undefined;
+    wake?: boolean | undefined;
+    revision?: number | undefined;
+    requestId?: string | undefined;
+}, any> & {
+    execute(input: {
+        operation: "list" | "create" | "update" | "pause" | "resume" | "remove";
+        name?: string | undefined;
+        cron?: string | undefined;
+        instruction?: string | undefined;
+        wake?: boolean | undefined;
+        revision?: number | undefined;
+        requestId?: string | undefined;
+    }, ctx: import("eve/tools").ToolContext): Promise<any>;
+};
+/** Install once; all recurrence definitions are read from the host at execution time. */
+export declare function routineDispatcher(options: {
+    bridge: RoutineBridge;
+    delivery: any;
+}): {
+    cron: string;
+    run({ to, waitUntil, appAuth }: import("eve/schedules").ScheduleHandlerArgs): void;
+};

package/dist/client/routines-eve.js

@@ -0,0 +1,30 @@
+import { defineTool } from 'eve/tools';
+import { defineSchedule } from 'eve/schedules';
+import { z } from 'zod';
+const input = z.object({ operation: z.enum(['list', 'create', 'update', 'pause', 'resume', 'remove']), name: z.string().optional(), cron: z.string().optional(), instruction: z.string().optional(), wake: z.boolean().optional(), revision: z.number().int().positive().optional(), requestId: z.string().min(16).optional() }).strict();
+/** Explicitly mounted tool; no model-selected owner, host URL or shell command. */
+export function routineTool(options) {
+    return defineTool({ description: 'Manage your host-persisted routines shared with desktop. List first to get current revisions. Create needs a unique lowercase hyphenated name, five-field UTC cron and instruction. Update/pause/resume/remove require the revision returned by list. Wake is optional and off by default. Runs deliver into the owner’s desktop chat. requestId must be a stable UUID for each intended change; reuse it only for an identical retry. Do not claim execution from a saved routine.', inputSchema: input, async execute(args, ctx) {
+            const auth = ctx.session.auth.current;
+            if (auth?.authenticator !== 'tealbrick' || auth.principalType !== 'user' || auth.principalId !== options.scope.owner || auth.attributes.org !== options.scope.org || auth.attributes.agentGrantLevel !== 'manage')
+                throw Error('routine_manage_permission_required');
+            if (args.operation === 'list')
+                return options.bridge.call('status');
+            if (!args.requestId)
+                throw Error('request_id_required');
+            const { operation, ...fields } = args;
+            return options.bridge.call('apply', { ...fields, operation: operation === 'create' ? 'upsert' : operation === 'remove' ? 'delete' : 'update', ...(operation === 'pause' ? { enabled: false } : operation === 'resume' ? { enabled: true } : {}) });
+        } });
+}
+/** Install once; all recurrence definitions are read from the host at execution time. */
+export function routineDispatcher(options) {
+    return defineSchedule({ cron: '* * * * *', run({ to, waitUntil, appAuth }) { waitUntil((async () => { const { jobs } = await options.bridge.call('claim'); for (const job of jobs) {
+            try {
+                await to(options.delivery, { owner: job.owner, name: job.name, occurrence: job.occurrence }).send(job.instruction, { auth: appAuth });
+                await options.bridge.call('accepted', { id: job.occurrence });
+            }
+            catch {
+                await options.bridge.call('failed', { id: job.occurrence });
+            }
+        } })()); } });
+}

package/dist/client/routines.d.ts

@@ -0,0 +1,54 @@
+export interface RoutineScope {
+    org: string;
+    workspace: string;
+    agent: string;
+    owner: string;
+}
+export interface Routine {
+    name: string;
+    cron: string;
+    instruction: string;
+    enabled: boolean;
+    wake: boolean;
+    revision: number;
+    nextRunAt: number;
+    deleted?: boolean;
+    updatedAt: number;
+}
+export interface RoutineRun {
+    id: string;
+    name: string;
+    revision: number;
+    dueAt: number;
+    status: string;
+    updatedAt: number;
+    error?: string;
+}
+export interface RoutineSnapshot {
+    scope: RoutineScope;
+    routines: Routine[];
+    runs: RoutineRun[];
+    wake: Record<string, unknown>;
+    dynamic: true;
+}
+export interface RoutineBridge {
+    call(action: string, input?: Record<string, unknown>): Promise<any>;
+}
+export declare function nextRoutineTime(cron: string, after: number): number;
+/** One trusted, fixed agent/workspace/owner scope per store. SQLite is host-side only. */
+export declare function createRoutineStore(options: {
+    path: string;
+    scope: RoutineScope;
+    now?: () => number;
+    wake?: {
+        status(): Promise<any>;
+        validate(rows: {
+            name: string;
+            cron: string;
+        }[]): void;
+        reconcile(rows: {
+            name: string;
+            cron: string;
+        }[]): Promise<void>;
+    };
+}): RoutineBridge;

package/dist/client/routines.js

@@ -0,0 +1,136 @@
+import { DatabaseSync } from 'node:sqlite';
+import { mkdirSync, chmodSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { createHash } from 'node:crypto';
+import { CronExpressionParser } from 'cron-parser';
+import { z } from 'zod';
+const name = z.string().regex(/^[a-z0-9][a-z0-9-]{0,47}$/);
+const change = z.object({ operation: z.enum(['upsert', 'update', 'delete', 'wake']), name, requestId: z.string().min(16).max(80).regex(/^[a-zA-Z0-9-]+$/), revision: z.number().int().positive().optional(), cron: z.string().max(120).optional(), instruction: z.string().trim().min(1).max(12000).optional(), enabled: z.boolean().optional(), wake: z.boolean().optional() }).strict();
+export function nextRoutineTime(cron, after) {
+    if (cron.trim().split(/\s+/).length !== 5)
+        throw Error('invalid_cron');
+    return CronExpressionParser.parse(cron, { currentDate: new Date(after), tz: 'UTC' }).next().getTime();
+}
+/** One trusted, fixed agent/workspace/owner scope per store. SQLite is host-side only. */
+export function createRoutineStore(options) {
+    for (const value of Object.values(options.scope))
+        if (!value)
+            throw Error('invalid_scope');
+    mkdirSync(dirname(options.path), { recursive: true, mode: 0o700 });
+    const db = new DatabaseSync(options.path);
+    chmodSync(options.path, 0o600);
+    db.exec('PRAGMA journal_mode=WAL; PRAGMA busy_timeout=5000; CREATE TABLE IF NOT EXISTS state (id INTEGER PRIMARY KEY CHECK(id=1), json TEXT NOT NULL); CREATE TABLE IF NOT EXISTS receipts (id TEXT PRIMARY KEY,digest TEXT NOT NULL,json TEXT NOT NULL); CREATE TABLE IF NOT EXISTS runs (id TEXT PRIMARY KEY,json TEXT NOT NULL);');
+    db.prepare('INSERT OR IGNORE INTO state VALUES (1,?)').run(JSON.stringify({ scope: options.scope, routines: [], dirty: false }));
+    const read = () => JSON.parse(db.prepare('SELECT json FROM state WHERE id=1').get().json);
+    if (JSON.stringify(read().scope) !== JSON.stringify(options.scope))
+        throw Error('scope_mismatch');
+    const save = (s) => db.prepare('UPDATE state SET json=? WHERE id=1').run(JSON.stringify(s));
+    const now = options.now ?? Date.now;
+    const tx = (fn) => { db.exec('BEGIN IMMEDIATE'); try {
+        const value = fn();
+        db.exec('COMMIT');
+        return value;
+    }
+    catch (e) {
+        db.exec('ROLLBACK');
+        throw e;
+    } };
+    const runs = () => db.prepare('SELECT json FROM runs ORDER BY rowid DESC LIMIT 100').all().map((r) => JSON.parse(r.json));
+    const writeRun = (r) => db.prepare('INSERT OR REPLACE INTO runs VALUES (?,?)').run(r.id, JSON.stringify(r));
+    const reconcile = async () => { const s = read(); if (!s.dirty)
+        return; if (!options.wake)
+        throw Error('wake_unavailable'); await options.wake.reconcile(s.routines.filter(r => !r.deleted && r.enabled && r.wake)); tx(() => { const current = read(); current.dirty = false; save(current); }); };
+    let queue = Promise.resolve();
+    const call = async (action, input = {}) => {
+        if (action === 'status')
+            return { scope: options.scope, dynamic: true, routines: read().routines.filter(r => !r.deleted), runs: runs(), wake: { ...(await options.wake?.status() ?? { supported: false }), pending: read().dirty, managed: read().routines.filter(r => !r.deleted).map(r => r.name), routines: read().routines.filter(r => !r.deleted && r.wake).map(r => r.name) } };
+        if (action === 'apply') {
+            const patch = change.parse(input), digest = createHash('sha256').update(JSON.stringify(patch)).digest('hex');
+            const old = db.prepare('SELECT digest,json FROM receipts WHERE id=?').get(patch.requestId);
+            if (old) {
+                if (old.digest !== digest)
+                    throw Error('request_id_conflict');
+                return JSON.parse(old.json);
+            }
+            const before = read(), prior = before.routines.find(r => r.name === patch.name);
+            if (patch.operation === 'upsert' && prior && !prior.deleted)
+                throw Error('schedule_exists');
+            if (patch.operation !== 'upsert' && (!prior || prior.deleted))
+                throw Error('schedule_not_found');
+            if (patch.operation !== 'upsert' && patch.revision !== prior.revision)
+                throw Error('revision_conflict');
+            const row = { name: patch.name, cron: patch.cron ?? prior?.cron ?? '', instruction: patch.instruction ?? prior?.instruction ?? '', enabled: patch.enabled ?? prior?.enabled ?? true, wake: patch.wake ?? prior?.wake ?? false, revision: (prior?.revision ?? 0) + 1, nextRunAt: 0, updatedAt: now(), deleted: patch.operation === 'delete' };
+            if (!row.instruction)
+                throw Error('instruction_required');
+            const next = nextRoutineTime(row.cron, now());
+            row.nextRunAt = prior && patch.cron === undefined && !(patch.enabled === true && !prior.enabled) ? prior.nextRunAt : next;
+            if (row.wake && row.enabled && !row.deleted) {
+                if (!options.wake || (await options.wake.status()).supported !== true)
+                    throw Error('wake_unavailable');
+                options.wake.validate([row]);
+            }
+            tx(() => { const state = read(); const current = state.routines.find(r => r.name === row.name); if (current?.revision !== prior?.revision)
+                throw Error('revision_conflict'); state.routines = state.routines.filter(r => r.name !== row.name); state.routines.push(row); state.dirty ||= Boolean(row.wake || prior?.wake); save(state); db.prepare('INSERT INTO receipts VALUES (?,?,?)').run(patch.requestId, digest, JSON.stringify({ ok: true, dynamic: true, saved: true, routine: row })); });
+            try {
+                await reconcile();
+            }
+            catch {
+                return { ok: true, dynamic: true, saved: true, routine: row, wakePending: true };
+            }
+            return { ok: true, dynamic: true, saved: true, routine: row };
+        }
+        if (action === 'claim') {
+            try {
+                await reconcile();
+            }
+            catch { /* Persisted pending intent remains observable. */ }
+            return tx(() => {
+                const s = read(), jobs = [];
+                const at = now();
+                // Ambiguous dispatch is not automatically repeated: no duplicate model side effects.
+                for (const run of runs())
+                    if (['claimed', 'dispatched'].includes(run.status) && at - run.updatedAt > 600000) {
+                        run.status = 'uncertain';
+                        run.updatedAt = at;
+                        writeRun(run);
+                    }
+                for (const row of s.routines) {
+                    if (row.deleted || !row.enabled || row.nextRunAt > at)
+                        continue;
+                    const due = row.nextRunAt;
+                    row.nextRunAt = nextRoutineTime(row.cron, at);
+                    const id = createHash('sha256').update(JSON.stringify([s.scope, row.name, row.revision, due])).digest('hex');
+                    const run = { id, name: row.name, revision: row.revision, dueAt: due, status: at - due > 120000 ? 'missed' : 'claimed', updatedAt: at };
+                    if (!db.prepare('SELECT id FROM runs WHERE id=?').get(id)) {
+                        writeRun(run);
+                        if (run.status === 'claimed')
+                            jobs.push({ ...row, occurrence: id, owner: s.scope.owner });
+                    }
+                }
+                save(s);
+                return { jobs };
+            });
+        }
+        if (['accepted', 'complete', 'failed'].includes(action))
+            return tx(() => {
+                if (typeof input.id !== 'string')
+                    throw Error('invalid_occurrence');
+                const raw = db.prepare('SELECT json FROM runs WHERE id=?').get(input.id);
+                if (!raw)
+                    throw Error('unknown_occurrence');
+                const run = JSON.parse(raw.json);
+                if (run.status === 'completed')
+                    return { ok: true };
+                if (action === 'accepted' && run.status !== 'claimed')
+                    return { ok: true };
+                run.status = action === 'complete' ? 'completed' : action === 'failed' ? 'failed' : 'dispatched';
+                run.updatedAt = now();
+                if (action === 'failed')
+                    run.error = 'dispatch_failed';
+                writeRun(run);
+                return { ok: true };
+            });
+        throw Error('unsupported_operation');
+    };
+    return { call(action, input) { const pending = queue.then(() => call(action, input)); queue = pending.catch(() => { }); return pending; } };
+}

package/dist/client/wake.d.ts

@@ -0,0 +1,34 @@
+import type { Transport } from './index.js';
+export interface WakeRoutine {
+    name: string;
+    cron: string;
+}
+/** Fixed-interval AVMM assignments, UTC only. Never invoke the routine payload. */
+export declare function planWake(cron: string, now?: number, leadSeconds?: number): {
+    next: string;
+    every: number;
+}[];
+export declare function createAvmmWakeAdapter(options: {
+    transport: Transport;
+    worker: string;
+    ownerKey: string;
+    allowed: boolean; /** Must match Eve's production cron timezone. */
+    timezone: string;
+    credentialsRefreshOnRequest?: boolean;
+    harness?: string;
+    leadSeconds?: number;
+}): {
+    status(): Promise<{
+        supported: boolean;
+        reason: string;
+        provider?: undefined;
+        timezone?: undefined;
+    } | {
+        supported: boolean;
+        provider: string;
+        timezone: string;
+        reason: string;
+    }>;
+    validate(routines: WakeRoutine[]): void;
+    reconcile(routines: WakeRoutine[]): Promise<void>;
+};

package/dist/client/wake.js

@@ -0,0 +1,97 @@
+import { createHash } from 'node:crypto';
+/** Fixed-interval AVMM assignments, UTC only. Never invoke the routine payload. */
+export function planWake(cron, now = Date.now(), leadSeconds = 60) {
+    const [m, h, d, mo, w, ...rest] = cron.trim().split(/\s+/);
+    if (rest.length || !w || d !== '*' || mo !== '*')
+        throw Error('unsupported_wake_cron');
+    const number = (s, max) => /^\d+$/.test(s) && Number(s) <= max ? Number(s) : null;
+    const minute = number(m, 59), hour = number(h, 23);
+    const after = now + leadSeconds * 1000;
+    const next = (anchor, every) => ({ next: new Date(anchor + Math.max(0, Math.floor((after - anchor) / (every * 1000)) + 1) * every * 1000 - leadSeconds * 1000).toISOString(), every });
+    if (w === '*' && h === '*' && (m === '*' || /^\*\/\d+$/.test(m))) {
+        const n = m === '*' ? 1 : Number(m.slice(2));
+        if (n < 1 || n > 60 || 60 % n)
+            throw Error('unsupported_wake_cron');
+        return [next(0, n * 60)];
+    }
+    if (w === '*' && minute !== null && (h === '*' || /^\*\/\d+$/.test(h))) {
+        const n = h === '*' ? 1 : Number(h.slice(2));
+        if (n < 1 || n > 24 || 24 % n)
+            throw Error('unsupported_wake_cron');
+        return [next(minute * 60000, n * 3600)];
+    }
+    if (minute === null || hour === null)
+        throw Error('unsupported_wake_cron');
+    const time = (hour * 60 + minute) * 60000;
+    if (w === '*')
+        return [next(time, 86400)];
+    const days = w === '1-5' ? [1, 2, 3, 4, 5] : number(w, 6) !== null ? [Number(w)] : null;
+    if (!days)
+        throw Error('unsupported_wake_cron');
+    // 1970-01-04 is a Sunday.
+    return days.map(day => next((3 + day) * 86400000 + time, 604800));
+}
+export function createAvmmWakeAdapter(options) {
+    if (!/^[a-zA-Z0-9_.-]+$/.test(options.worker) || !options.ownerKey)
+        throw Error('invalid_wake_scope');
+    const prefix = 'tealwake-' + createHash('sha256').update(options.ownerKey + '\0' + options.worker).digest('hex').slice(0, 20) + '-';
+    const lead = options.leadSeconds ?? 60;
+    if (!Number.isInteger(lead) || lead < 30 || lead > 300)
+        throw Error('invalid_wake_lead');
+    const run = async (argv) => {
+        const r = await options.transport.run(['--json', ...argv], { signal: AbortSignal.timeout(30000) });
+        if (r.exitCode !== 0)
+            throw Error('host_wake_denied_or_unavailable');
+        const body = JSON.parse(r.stdout);
+        if (body.api_version !== 'agentvm/v1' || body.error)
+            throw Error('host_wake_protocol');
+        return body.result;
+    };
+    return {
+        async status() {
+            if (options.timezone !== 'UTC')
+                return { supported: false, reason: 'Host wake requires Eve schedules configured in UTC.' };
+            if (!options.allowed)
+                return { supported: false, reason: 'Host wake permission has not been granted.' };
+            try {
+                const rows = await run(['schedule', 'ls']);
+                if (!Array.isArray(rows))
+                    throw Error();
+                const worker = await run(['worker', 'status', options.worker]);
+                if (worker.mode !== 'durable' || !Number.isFinite(worker.idle_timeout_seconds) || worker.idle_timeout_seconds <= lead)
+                    throw Error();
+                if (worker.auth?.codex === 'shared' && (!options.credentialsRefreshOnRequest || !worker.capabilities?.includes('model:codex-subscription')))
+                    throw Error();
+                if (!Array.isArray(worker.capabilities) || !worker.capabilities.includes(`harness:${options.harness ?? 'eve'}`))
+                    throw Error();
+                return { supported: true, provider: 'avmm', timezone: 'UTC', reason: 'Minute/hour intervals, daily, weekdays and weekly routines. Host wakes only; Eve executes.' };
+            }
+            catch {
+                return { supported: false, reason: 'Host scheduler, worker capability or idle timeout could not be verified.' };
+            }
+        },
+        validate(routines) { for (const r of routines)
+            planWake(r.cron, Date.now(), lead); },
+        async reconcile(routines) {
+            if (!(await this.status()).supported)
+                throw Error('host_wake_unavailable');
+            this.validate(routines);
+            const desired = new Set();
+            const existing = await run(['schedule', 'ls']);
+            const worker = await run(['worker', 'status', options.worker]);
+            const authCaps = worker.auth?.codex === 'shared' ? ['--cap', 'model:codex-subscription'] : [];
+            for (const routine of routines) {
+                const key = createHash('sha256').update(routine.name).digest('hex').slice(0, 16);
+                const plans = planWake(routine.cron, Date.now(), lead);
+                for (const [i, p] of plans.entries()) {
+                    const id = prefix + key + '-' + i;
+                    desired.add(id);
+                    await run(['schedule', 'put', id, '--agent', options.worker, '--harness', options.harness ?? 'eve', '--next-wake-at', p.next, '--timezone', 'UTC', '--misfire-policy', 'skip', '--target', 'worker', '--worker', options.worker, '--every-seconds', String(p.every), '--keep-running', ...authCaps, '--', '/usr/bin/true']);
+                }
+            }
+            for (const row of existing)
+                if (typeof row.schedule_id === 'string' && row.schedule_id.startsWith(prefix) && !desired.has(row.schedule_id))
+                    await run(['schedule', 'remove', row.schedule_id]);
+        }
+    };
+}

package/dist/extension/_manifest.json

@@ -1,11 +1,11 @@
 {
   "kind": "eve-extension",
   "formatVersion": 2,
-  "builtWithEve": "0.56.0",
+  "builtWithEve": "0.64.1",
   "requires": {
     "extension": 1,
-    "tool": 43,
-    "dynamicTool": 40,
+    "tool": 54,
+    "dynamicTool": 52,
     "config": 1
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tealbrick/avm",
-  "version": "0.1.2",
+  "version": "0.2.5",
   "description": "Typed host-owned AgentVM transport and opt-in Eve capabilities",
   "type": "module",
   "license": "MIT",
@@ -8,7 +8,8 @@
     "dist",
     "README.md",
     "PROVENANCE.md",
-    "LICENSE"
+    "LICENSE",
+    "ROUTINES.md"
   ],
   "engines": {
     "node": ">=24"
@@ -29,6 +30,22 @@
     "./eve": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.mjs"
+    },
+    "./wake": {
+      "types": "./dist/client/wake.d.ts",
+      "import": "./dist/client/wake.js"
+    },
+    "./routines": {
+      "types": "./dist/client/routines.d.ts",
+      "import": "./dist/client/routines.js"
+    },
+    "./routines-client": {
+      "types": "./dist/client/routines-client.d.ts",
+      "import": "./dist/client/routines-client.js"
+    },
+    "./routines-eve": {
+      "types": "./dist/client/routines-eve.d.ts",
+      "import": "./dist/client/routines-eve.js"
     }
   },
   "eve": {
@@ -43,15 +60,16 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
+    "cron-parser": "^5.4.0",
     "zod": "^4.0.0"
   },
   "devDependencies": {
-    "eve": "0.56.0",
-    "typescript": "^5.9.3",
-    "@types/node": "^24.0.0"
+    "@types/node": "^24.0.0",
+    "eve": "0.64.1",
+    "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "eve": ">=0.56.0 <0.57.0"
+    "eve": ">=0.64.1 <0.65.0"
   },
   "peerDependenciesMeta": {
     "eve": {