@ai-ecoverse/slicc-agent 3.3.0 → 3.5.0

package/dist/system.js

@@ -44,9 +44,25 @@ function systemSection(facts) {
     `Not here yet: ${[...missing, "a browser or CDP tool", "GitHub credentials"].join(", ")}.`
   ].join("\n");
 }
+async function kernelBoot(client) {
+  const decoder = new TextDecoder();
+  let out = "";
+  try {
+    const process = await client.spawn(["cat", "/proc/stat"], {
+      onStdout: (bytes) => {
+        out += decoder.decode(bytes, { stream: true });
+      }
+    });
+    await process.exited;
+  } catch {
+    return null;
+  }
+  return /^btime (\d+)$/m.exec(out)?.[1] ?? null;
+}
 export {
   agentVersion,
   commandsOnPath,
+  kernelBoot,
   systemSection,
   transportName
 };

package/dist/system.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/system.ts"],
-  "sourcesContent": ["import type { KernelClient } from './kernel/client.ts';\nimport type { Transport } from './net.ts';\n\nexport interface SystemFacts {\n  version: string;\n  commands: string[];\n  transport: string;\n}\n\nconst LIST_PATH = 'IFS=:; for d in $PATH; do [ -d \"$d\" ] && ls -1 \"$d\"; done';\nconst RUNTIMES = ['node', 'python3'];\n\nexport async function commandsOnPath(client: KernelClient): Promise<string[]> {\n  const decoder = new TextDecoder();\n  let out = '';\n  try {\n    const process = await client.spawn(['bash', '-c', LIST_PATH], {\n      onStdout: (bytes) => {\n        out += decoder.decode(bytes, { stream: true });\n      },\n    });\n    await process.exited;\n  } catch {\n    return [];\n  }\n  const names = out.split('\\n').map((name) => name.trim());\n  return [...new Set(names.filter(Boolean))].sort();\n}\n\nexport function transportName(transport: Transport | undefined): string {\n  const traits = transport?.traits;\n  if (traits?.crossOrigin === 'cors') {\n    return \"the page's own fetch, so only servers that allow CORS answer\";\n  }\n  if (traits?.manualRedirects) return 'a local proxy (slicc-node) that fetches without CORS';\n  return 'a relay that fetches without CORS';\n}\n\nexport async function agentVersion(\n  fetcher: (url: URL) => Promise<Response>,\n  url = new URL('../package.json', import.meta.url)\n): Promise<string> {\n  try {\n    const response = await fetcher(url);\n    const manifest = response.ok ? ((await response.json()) as { version?: string }) : {};\n    return manifest.version ?? 'unknown';\n  } catch {\n    return 'unknown';\n  }\n}\n\nexport function systemSection(facts: SystemFacts): string {\n  const missing = RUNTIMES.filter((name) => !facts.commands.includes(name));\n  return [\n    `You are SLICC's agent in seven: slicc-agent ${facts.version}, installed in /opt/agent. Your bash runs on the page's shared slicc-kernel, a WebAssembly sandbox in the user's browser, not on a server or the user's machine.`,\n    \"Files: / is the browser's private file system (OPFS). Work in /home and /tmp. /os and /opt are the system; change them only when asked.\",\n    `Commands on PATH: ${facts.commands.join(' ') || 'none found'}.`,\n    'Install command-line tools with `pnpm add -g <package>`. There is no ipk.',\n    `Network: requests go through ${facts.transport}. localhost and 127.0.0.1 are this sandbox's own loopback, not the user's computer.`,\n    `Not here yet: ${[...missing, 'a browser or CDP tool', 'GitHub credentials'].join(', ')}.`,\n  ].join('\\n');\n}\n"],
-  "mappings": "AASA,MAAM,YAAY;AAClB,MAAM,WAAW,CAAC,QAAQ,SAAS;AAEnC,eAAsB,eAAe,QAAyC;AAC5E,QAAM,UAAU,IAAI,YAAY;AAChC,MAAI,MAAM;AACV,MAAI;AACF,UAAM,UAAU,MAAM,OAAO,MAAM,CAAC,QAAQ,MAAM,SAAS,GAAG;AAAA,MAC5D,UAAU,CAAC,UAAU;AACnB,eAAO,QAAQ,OAAO,OAAO,EAAE,QAAQ,KAAK,CAAC;AAAA,MAC/C;AAAA,IACF,CAAC;AACD,UAAM,QAAQ;AAAA,EAChB,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACA,QAAM,QAAQ,IAAI,MAAM,IAAI,EAAE,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC;AACvD,SAAO,CAAC,GAAG,IAAI,IAAI,MAAM,OAAO,OAAO,CAAC,CAAC,EAAE,KAAK;AAClD;AAEO,SAAS,cAAc,WAA0C;AACtE,QAAM,SAAS,WAAW;AAC1B,MAAI,QAAQ,gBAAgB,QAAQ;AAClC,WAAO;AAAA,EACT;AACA,MAAI,QAAQ,gBAAiB,QAAO;AACpC,SAAO;AACT;AAEA,eAAsB,aACpB,SACA,MAAM,IAAI,IAAI,mBAAmB,YAAY,GAAG,GAC/B;AACjB,MAAI;AACF,UAAM,WAAW,MAAM,QAAQ,GAAG;AAClC,UAAM,WAAW,SAAS,KAAO,MAAM,SAAS,KAAK,IAA8B,CAAC;AACpF,WAAO,SAAS,WAAW;AAAA,EAC7B,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEO,SAAS,cAAc,OAA4B;AACxD,QAAM,UAAU,SAAS,OAAO,CAAC,SAAS,CAAC,MAAM,SAAS,SAAS,IAAI,CAAC;AACxE,SAAO;AAAA,IACL,+CAA+C,MAAM,OAAO;AAAA,IAC5D;AAAA,IACA,qBAAqB,MAAM,SAAS,KAAK,GAAG,KAAK,YAAY;AAAA,IAC7D;AAAA,IACA,gCAAgC,MAAM,SAAS;AAAA,IAC/C,iBAAiB,CAAC,GAAG,SAAS,yBAAyB,oBAAoB,EAAE,KAAK,IAAI,CAAC;AAAA,EACzF,EAAE,KAAK,IAAI;AACb;",
+  "sourcesContent": ["import type { KernelClient } from './kernel/client.ts';\nimport type { Transport } from './net.ts';\n\nexport interface SystemFacts {\n  version: string;\n  commands: string[];\n  transport: string;\n}\n\nconst LIST_PATH = 'IFS=:; for d in $PATH; do [ -d \"$d\" ] && ls -1 \"$d\"; done';\nconst RUNTIMES = ['node', 'python3'];\n\nexport async function commandsOnPath(client: KernelClient): Promise<string[]> {\n  const decoder = new TextDecoder();\n  let out = '';\n  try {\n    const process = await client.spawn(['bash', '-c', LIST_PATH], {\n      onStdout: (bytes) => {\n        out += decoder.decode(bytes, { stream: true });\n      },\n    });\n    await process.exited;\n  } catch {\n    return [];\n  }\n  const names = out.split('\\n').map((name) => name.trim());\n  return [...new Set(names.filter(Boolean))].sort();\n}\n\nexport function transportName(transport: Transport | undefined): string {\n  const traits = transport?.traits;\n  if (traits?.crossOrigin === 'cors') {\n    return \"the page's own fetch, so only servers that allow CORS answer\";\n  }\n  if (traits?.manualRedirects) return 'a local proxy (slicc-node) that fetches without CORS';\n  return 'a relay that fetches without CORS';\n}\n\nexport async function agentVersion(\n  fetcher: (url: URL) => Promise<Response>,\n  url = new URL('../package.json', import.meta.url)\n): Promise<string> {\n  try {\n    const response = await fetcher(url);\n    const manifest = response.ok ? ((await response.json()) as { version?: string }) : {};\n    return manifest.version ?? 'unknown';\n  } catch {\n    return 'unknown';\n  }\n}\n\nexport function systemSection(facts: SystemFacts): string {\n  const missing = RUNTIMES.filter((name) => !facts.commands.includes(name));\n  return [\n    `You are SLICC's agent in seven: slicc-agent ${facts.version}, installed in /opt/agent. Your bash runs on the page's shared slicc-kernel, a WebAssembly sandbox in the user's browser, not on a server or the user's machine.`,\n    \"Files: / is the browser's private file system (OPFS). Work in /home and /tmp. /os and /opt are the system; change them only when asked.\",\n    `Commands on PATH: ${facts.commands.join(' ') || 'none found'}.`,\n    'Install command-line tools with `pnpm add -g <package>`. There is no ipk.',\n    `Network: requests go through ${facts.transport}. localhost and 127.0.0.1 are this sandbox's own loopback, not the user's computer.`,\n    `Not here yet: ${[...missing, 'a browser or CDP tool', 'GitHub credentials'].join(', ')}.`,\n  ].join('\\n');\n}\n\nexport async function kernelBoot(client: KernelClient): Promise<string | null> {\n  const decoder = new TextDecoder();\n  let out = '';\n  try {\n    const process = await client.spawn(['cat', '/proc/stat'], {\n      onStdout: (bytes) => {\n        out += decoder.decode(bytes, { stream: true });\n      },\n    });\n    await process.exited;\n  } catch {\n    return null;\n  }\n  return /^btime (\\d+)$/m.exec(out)?.[1] ?? null;\n}\n"],
+  "mappings": "AASA,MAAM,YAAY;AAClB,MAAM,WAAW,CAAC,QAAQ,SAAS;AAEnC,eAAsB,eAAe,QAAyC;AAC5E,QAAM,UAAU,IAAI,YAAY;AAChC,MAAI,MAAM;AACV,MAAI;AACF,UAAM,UAAU,MAAM,OAAO,MAAM,CAAC,QAAQ,MAAM,SAAS,GAAG;AAAA,MAC5D,UAAU,CAAC,UAAU;AACnB,eAAO,QAAQ,OAAO,OAAO,EAAE,QAAQ,KAAK,CAAC;AAAA,MAC/C;AAAA,IACF,CAAC;AACD,UAAM,QAAQ;AAAA,EAChB,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACA,QAAM,QAAQ,IAAI,MAAM,IAAI,EAAE,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC;AACvD,SAAO,CAAC,GAAG,IAAI,IAAI,MAAM,OAAO,OAAO,CAAC,CAAC,EAAE,KAAK;AAClD;AAEO,SAAS,cAAc,WAA0C;AACtE,QAAM,SAAS,WAAW;AAC1B,MAAI,QAAQ,gBAAgB,QAAQ;AAClC,WAAO;AAAA,EACT;AACA,MAAI,QAAQ,gBAAiB,QAAO;AACpC,SAAO;AACT;AAEA,eAAsB,aACpB,SACA,MAAM,IAAI,IAAI,mBAAmB,YAAY,GAAG,GAC/B;AACjB,MAAI;AACF,UAAM,WAAW,MAAM,QAAQ,GAAG;AAClC,UAAM,WAAW,SAAS,KAAO,MAAM,SAAS,KAAK,IAA8B,CAAC;AACpF,WAAO,SAAS,WAAW;AAAA,EAC7B,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEO,SAAS,cAAc,OAA4B;AACxD,QAAM,UAAU,SAAS,OAAO,CAAC,SAAS,CAAC,MAAM,SAAS,SAAS,IAAI,CAAC;AACxE,SAAO;AAAA,IACL,+CAA+C,MAAM,OAAO;AAAA,IAC5D;AAAA,IACA,qBAAqB,MAAM,SAAS,KAAK,GAAG,KAAK,YAAY;AAAA,IAC7D;AAAA,IACA,gCAAgC,MAAM,SAAS;AAAA,IAC/C,iBAAiB,CAAC,GAAG,SAAS,yBAAyB,oBAAoB,EAAE,KAAK,IAAI,CAAC;AAAA,EACzF,EAAE,KAAK,IAAI;AACb;AAEA,eAAsB,WAAW,QAA8C;AAC7E,QAAM,UAAU,IAAI,YAAY;AAChC,MAAI,MAAM;AACV,MAAI;AACF,UAAM,UAAU,MAAM,OAAO,MAAM,CAAC,OAAO,YAAY,GAAG;AAAA,MACxD,UAAU,CAAC,UAAU;AACnB,eAAO,QAAQ,OAAO,OAAO,EAAE,QAAQ,KAAK,CAAC;AAAA,MAC/C;AAAA,IACF,CAAC;AACD,UAAM,QAAQ;AAAA,EAChB,QAAQ;AACN,WAAO;AAAA,EACT;AACA,SAAO,iBAAiB,KAAK,GAAG,IAAI,CAAC,KAAK;AAC5C;",
   "names": []
 }

package/dist/types/control.d.ts

@@ -1,6 +1,11 @@
 import { type Conversation, type Harness, type SubmissionId } from '@earendil-works/pi-durable';
 import type { Cones } from './cone.ts';
 import type { Deliveries } from './deliveries.ts';
+import type { LickSources, Licks } from './licks/index.ts';
 import type { AgentControl } from './services.ts';
+export interface HostLicks {
+    licks: Licks;
+    sources: LickSources;
+}
 export declare function submissionId(value: string): SubmissionId | undefined;
-export declare function createAgentControl(harness: Harness, target: Conversation | Cones, deliveries?: Deliveries): AgentControl;
+export declare function createAgentControl(harness: Harness, target: Conversation | Cones, deliveries?: Deliveries, licks?: HostLicks): AgentControl;

package/dist/types/host.d.ts

@@ -1,5 +1,6 @@
 import { type Context } from '@earendil-works/chord';
 import type { Agent } from './agent.ts';
+import { type HostLicks } from './control.ts';
 import { AgentSettings } from './services.ts';
 import type { PortEndpoint } from './wire.ts';
 export interface AgentHost {
@@ -12,4 +13,5 @@ export declare function hostAgent(agent: Agent, options?: {
     serverId?: string;
     context?: Context;
     settings?: AgentSettings;
+    licks?: HostLicks;
 }): Promise<AgentHost>;

package/dist/types/kernel/activity.d.ts

@@ -0,0 +1,10 @@
+export interface Activity {
+    wrote(path: string): void;
+    began(): () => void;
+    agentMade(path: string): boolean;
+}
+export interface ActivityOptions {
+    windowMs?: number;
+    now?: () => number;
+}
+export declare function createActivity(options?: ActivityOptions): Activity;

package/dist/types/kernel/env.d.ts

@@ -1,11 +1,13 @@
 import type { Context } from '@earendil-works/chord';
 import { type BinaryReader, type DirReader, type ExecutionEnv, type ExecutionError, FileError, type FileInfo, type FileWatcher, type Result, type ShellExecOptions, type ShellExecResult, type TextLineReader, type WatchChange, type WatchTarget } from '@earendil-works/pi-durable/env';
+import type { Activity } from './activity.ts';
 import type { KernelClient } from './client.ts';
 import { type PollOptions } from './watch.ts';
 export interface KernelEnvOptions {
     cwd: string;
     id?: string;
     watch?: PollOptions;
+    activity?: Activity;
 }
 type FileResult<T> = Promise<Result<T, FileError>>;
 export declare class SliccKernelEnv implements ExecutionEnv {

package/dist/types/licks/boot.d.ts

@@ -0,0 +1,9 @@
+import type { Context } from '@earendil-works/chord';
+import type { Conversation, EntryRecord, Harness } from '@earendil-works/pi-durable';
+import type { Deliver } from './fswatch.ts';
+export interface BootFacts {
+    version: string;
+    boot: string | null;
+}
+export declare function bashCommands(entries: readonly EntryRecord[], after: number): string[];
+export declare function bootLicks(harness: Harness, cone: Conversation, deliver: Deliver, facts: BootFacts, context: Context): Promise<void>;

package/dist/types/licks/config.d.ts

@@ -0,0 +1,35 @@
+import type { LickTarget } from './lick.ts';
+export interface CronEntry {
+    name: string;
+    schedule: string;
+    target: LickTarget;
+    message: string;
+}
+export interface WatchEntry {
+    name: string;
+    path: string;
+    glob: string;
+    target: LickTarget;
+    message: string;
+    debounce: number;
+}
+export interface WebhookEntry {
+    name: string;
+    target: LickTarget;
+    message: string;
+}
+export interface ConfigError {
+    file: string;
+    line?: number;
+    error: string;
+}
+export interface Parsed<T> {
+    entries: T[];
+    errors: ConfigError[];
+}
+export declare function isName(value: string): boolean;
+export declare function isTarget(value: string): value is LickTarget;
+export declare function parseCrontab(file: string, text: string): Parsed<CronEntry>;
+export declare function nameOf(file: string): string;
+export declare function parseWatch(file: string, source: string, home: string): WatchEntry;
+export declare function parseWebhook(file: string, source: string): WebhookEntry;

package/dist/types/licks/cron.d.ts

@@ -0,0 +1,16 @@
+export interface Schedule {
+    minutes: ReadonlySet<number>;
+    hours: ReadonlySet<number>;
+    days: ReadonlySet<number>;
+    months: ReadonlySet<number>;
+    weekdays: ReadonlySet<number>;
+    anyDay: boolean;
+    anyWeekday: boolean;
+}
+export declare function parseSchedule(expression: string): Schedule;
+export declare function nextFire(schedule: Schedule, after: number): number | null;
+export interface Missed {
+    count: number;
+    more: boolean;
+}
+export declare function missedFires(schedule: Schedule, from: number, until: number, cap?: number): Missed;

package/dist/types/licks/extension.d.ts

@@ -0,0 +1,22 @@
+import type { Context } from '@earendil-works/chord';
+import { type Conversation, type ConversationId } from '@earendil-works/pi-durable';
+import { type Missed } from './cron.ts';
+import type { LickTarget } from './lick.ts';
+import type { Licks } from './licks.ts';
+export declare const LICKS_SECTION: string;
+export type ConversationLookup = (id: ConversationId, context: Context) => Promise<Conversation>;
+export interface CronInput {
+    name: string;
+    schedule: string;
+    target: LickTarget;
+    message: string;
+    from: number;
+}
+type CronState = {
+    phase: 'wait';
+    at: number | null;
+};
+export declare function cronText(schedule: string, at: number, missed: Missed): string;
+export declare function cronTask(licks: Licks): import("@earendil-works/pi-durable").Task<CronInput, CronState, null, object>;
+export declare function licksExtension(licks: Licks, conversation: ConversationLookup, cron?: ReturnType<typeof cronTask>): import("@earendil-works/pi-durable").Extension<import("@earendil-works/pi-durable").ToolRegistration>;
+export {};

package/dist/types/licks/fswatch.d.ts

@@ -0,0 +1,20 @@
+import type { Context } from '@earendil-works/chord';
+import type { ExecutionEnv } from '@earendil-works/pi-durable/env';
+import type { Activity } from '../kernel/activity.ts';
+import { type ConfigError } from './config.ts';
+import type { LickEvent } from './licks.ts';
+export interface ConfigFiles {
+    read(path: string, context: Context): Promise<string | undefined>;
+    list(path: string, context: Context): Promise<string[]>;
+}
+export type Deliver = (event: LickEvent, context: Context) => Promise<void>;
+export declare function relativeTo(base: string, path: string): string | undefined;
+export declare function configFiles(env: ExecutionEnv): ConfigFiles;
+export declare class Watches {
+    #private;
+    constructor(env: ExecutionEnv, deliver: Deliver, home: string, activity?: Activity);
+    get names(): string[];
+    stop(name: string, context: Context): Promise<void>;
+    reconcile(dir: string, context: Context): Promise<ConfigError[]>;
+    close(context: Context): Promise<void>;
+}

package/dist/types/licks/glob.d.ts

@@ -0,0 +1 @@
+export declare function glob(pattern: string): (path: string) => boolean;

package/dist/types/licks/index.d.ts

@@ -0,0 +1,24 @@
+import type { Conversation, Harness, Registry } from '@earendil-works/pi-durable';
+import type { ExecutionEnv } from '@earendil-works/pi-durable/env';
+import type { Activity } from '../kernel/activity.ts';
+import { type Licks } from './licks.ts';
+import { type LickSources } from './sources.ts';
+export interface LicksAgent {
+    harness: Harness;
+    root: Conversation;
+    cone(): Conversation;
+}
+export interface LicksSetup {
+    licks: Licks;
+    attach(agent: LicksAgent, options: {
+        env: ExecutionEnv;
+        home: string;
+        now?: () => number;
+        flushEvery?: number;
+        activity?: Activity;
+    }): LickSources;
+}
+export declare function setupLicks(registry: Registry): LicksSetup;
+export type { Lick, LickChannel } from './lick.ts';
+export type { LickEvent, Licks } from './licks.ts';
+export type { LickSources, WebhookDelivery } from './sources.ts';

package/dist/types/licks/lick.d.ts

@@ -0,0 +1,23 @@
+export declare const LICK_CHANNELS: readonly ['webhook', 'cron', 'sprinkle', 'fswatch', 'session-reload', 'navigate', 'discovery', 'upgrade', 'workflow', 'bash', 'jshd', 'preview', 'cherry', 'scoop-notify', 'scoop-idle', 'scoop-wait', 'sudo-request'];
+export type LickChannel = (typeof LICK_CHANNELS)[number];
+export type LickAction = 'confirm' | 'dismiss';
+export type LickSeverity = 'warn' | 'error';
+export type LickTarget = 'cone' | `scoop:${string}`;
+export type Lick = {
+    id: string;
+    channel: LickChannel;
+    source: string;
+    title: string;
+    text: string;
+    body?: string;
+    count: number;
+    at: number;
+    actions?: LickAction[];
+    severity?: LickSeverity;
+};
+export declare function escapeText(value: string): string;
+export declare function escapeAttribute(value: string): string;
+export declare function unescape(value: string): string;
+export declare function lickId(): string;
+export declare function formatLick(lick: Lick): string;
+export declare function parseLick(text: string): Lick | undefined;

package/dist/types/licks/licks.d.ts

@@ -0,0 +1,58 @@
+import type { Context } from '@earendil-works/chord';
+import { type Conversation, type Harness } from '@earendil-works/pi-durable';
+import { type Lick, type LickAction, type LickChannel, type LickSeverity, type LickTarget } from './lick.ts';
+import { LICK_STATE_KIND, type LickDecision } from './state.ts';
+export interface LickEvent {
+    channel: LickChannel;
+    source: string;
+    title: string;
+    text: string;
+    body?: string;
+    items?: string[];
+    count?: number;
+    target: LickTarget;
+    coalesce?: boolean;
+    severity?: LickSeverity;
+    eventId?: string;
+    at?: number;
+}
+type Pending = {
+    lick: Lick;
+    items: string[];
+    body: string | null;
+};
+type Queue = {
+    submission: number | null;
+    pending: Pending | null;
+};
+type OutboxState = {
+    queues: Record<string, Queue>;
+    events: Record<string, string[]>;
+};
+export declare const LicksOutbox: import("@earendil-works/pi-durable").SessionDocToken<OutboxState>;
+export interface LickHandler {
+    confirm?(lick: Lick, reason: string | undefined, context: Context): Promise<string | undefined>;
+    dismiss?(lick: Lick, reason: string | undefined, context: Context): Promise<string | undefined>;
+}
+export interface LickFound {
+    lick: Lick;
+    decision: LickDecision | undefined;
+}
+export interface Licks {
+    deliver(event: LickEvent, context: Context): Promise<void>;
+    flush(context: Context): Promise<void>;
+    find(conversation: Conversation, id: string, context: Context): Promise<LickFound | undefined>;
+    decide(conversation: Conversation, id: string, action: LickAction, reason: string | undefined, context: Context): Promise<string>;
+    handle(channel: LickChannel, handler: LickHandler): void;
+    pending(context: Context): Promise<number>;
+}
+export interface LicksHost {
+    harness: Harness;
+    resolve(target: LickTarget, context: Context): Promise<Conversation>;
+}
+export declare const MAX_ITEMS = 50;
+export declare const MAX_EVENTS = 64;
+export declare function render(pending: Pending): Lick;
+export declare function strongest(a: LickSeverity | undefined, b: LickSeverity | undefined): LickSeverity | undefined;
+export declare function createLicks(host: Promise<LicksHost>): Licks;
+export { LICK_STATE_KIND };

package/dist/types/licks/schedules.d.ts

@@ -0,0 +1,25 @@
+import type { Context } from '@earendil-works/chord';
+import { type Conversation, type Harness } from '@earendil-works/pi-durable';
+import type { CronEntry } from './config.ts';
+import type { cronTask } from './extension.ts';
+type CronRecord = {
+    schedule: string;
+    target: string;
+    message: string;
+    task: number;
+};
+type HostState = {
+    cron: Record<string, CronRecord>;
+    agent: string | null;
+    boot: string | null;
+    mark: number;
+    upgrades: number;
+};
+export declare const LicksHostDoc: import("@earendil-works/pi-durable").SessionDocToken<HostState>;
+export declare function reconcileCron(options: {
+    harness: Harness;
+    root: Conversation;
+    cron: ReturnType<typeof cronTask>;
+    now: () => number;
+}, entries: readonly CronEntry[], context: Context): Promise<void>;
+export {};

package/dist/types/licks/sources.d.ts

@@ -0,0 +1,38 @@
+import type { Context } from '@earendil-works/chord';
+import type { Conversation, Harness } from '@earendil-works/pi-durable';
+import type { ExecutionEnv } from '@earendil-works/pi-durable/env';
+import type { Activity } from '../kernel/activity.ts';
+import { type BootFacts } from './boot.ts';
+import { type ConfigError, type WebhookEntry } from './config.ts';
+import type { cronTask } from './extension.ts';
+import type { LickEvent, Licks } from './licks.ts';
+export declare const SLICC_DIR = ".slicc";
+export interface LickSourcesOptions {
+    harness: Harness;
+    root: Conversation;
+    cone: () => Conversation;
+    env: ExecutionEnv;
+    home: string;
+    licks: Licks;
+    cron: ReturnType<typeof cronTask>;
+    now?: () => number;
+    flushEvery?: number;
+    activity?: Activity;
+}
+export interface WebhookDelivery {
+    id?: string;
+    headers?: Record<string, string>;
+    body: unknown;
+}
+export interface LickSources {
+    start(context: Context): Promise<void>;
+    reconcile(context: Context): Promise<void>;
+    boot(facts: BootFacts, context: Context): Promise<void>;
+    webhook(name: string, delivery: WebhookDelivery, context: Context): Promise<boolean>;
+    close(context: Context): Promise<void>;
+}
+export declare function hash(text: string): string;
+export declare function shortPath(path: string, home: string): string;
+export declare function configLick(error: ConfigError, home: string): LickEvent;
+export declare function webhookLick(name: string, entry: WebhookEntry, delivery: WebhookDelivery): LickEvent;
+export declare function createLickSources(options: LickSourcesOptions): LickSources;

package/dist/types/licks/state.d.ts

@@ -0,0 +1,14 @@
+import { type Lick } from './lick.ts';
+export type LickDecision = 'confirmed' | 'dismissed';
+export declare const LICK_TOOLS: Record<string, LickDecision>;
+export declare const LICK_STATE_KIND = "slicc.lick-state";
+interface EntryLike {
+    id: number;
+    kind: string;
+    model?: readonly unknown[];
+    data?: unknown;
+}
+export declare function userText(entry: EntryLike): string | undefined;
+export declare function entryLick(entry: EntryLike): Lick | undefined;
+export declare function lickDecisions(entries: readonly EntryLike[]): Map<string, LickDecision>;
+export {};

package/dist/types/services.d.ts

@@ -39,6 +39,24 @@ export interface AgentControl {
     reset(handoff: string | null, context: Context): Promise<void>;
     configure(change: AgentSettingsChange, context: Context): Promise<void>;
     rewind(messageId: string | null, context: Context): Promise<Rewound>;
+    resolveLick(lickId: string, state: 'confirmed' | 'dismissed', context: Context): Promise<LickResolved>;
+    webhook(name: string, delivery: WebhookRequest, context: Context): Promise<{
+        delivered: boolean;
+    }>;
+}
+export type LickResolved = {
+    done: true;
+    text: string;
+    error: null;
+} | {
+    done: false;
+    text: null;
+    error: string;
+};
+export interface WebhookRequest {
+    id: string | null;
+    headers: Record<string, string>;
+    body: string;
 }
 export type Rewound = {
     done: true;

package/dist/types/spectrum/agent-port.d.ts

@@ -18,7 +18,7 @@ export declare class AgentAdapter extends Emitter<AgentEvents> implements AgentP
     unqueue(_agentId: string, messageId: string): void;
     suggestion(): string | null;
     answer(): void;
-    resolveLick(): void;
+    resolveLick(_agentId: string, messageId: string, state: 'confirmed' | 'dismissed'): void;
     compact(): void;
     clear(): void;
     setModel(_agentId: string, model: string): void;

package/dist/types/system.d.ts

@@ -9,3 +9,4 @@ export declare function commandsOnPath(client: KernelClient): Promise<string[]>;
 export declare function transportName(transport: Transport | undefined): string;
 export declare function agentVersion(fetcher: (url: URL) => Promise<Response>, url?: URL): Promise<string>;
 export declare function systemSection(facts: SystemFacts): string;
+export declare function kernelBoot(client: KernelClient): Promise<string | null>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-agent",
-  "version": "3.3.0",
+  "version": "3.5.0",
   "description": "SLICC's agent core on pi durable: an agent worker, session storage, remoting and pi extensions",
   "type": "module",
   "license": "Apache-2.0",
@@ -74,7 +74,7 @@
     "typescript": "7.0.2"
   },
   "dependencies": {
-    "@ai-ecoverse/slicc-kernel": "1.14.0",
+    "@ai-ecoverse/slicc-kernel": "1.16.0",
     "@earendil-works/chord": "1.0.4",
     "@earendil-works/pi-ai": "1.0.4",
     "@earendil-works/pi-client": "1.0.4",