@ai-ecoverse/slicc-agent 3.6.0 → 3.8.0

package/dist/types/scoops/cli.d.ts

@@ -0,0 +1,66 @@
+import type { Context } from '@earendil-works/chord';
+import type { Harness } from '@earendil-works/pi-durable';
+import type { ExecutionEnv } from '@earendil-works/pi-durable/env';
+import type { Agents } from '../agents.ts';
+import { type Roles } from '../roles/roles.ts';
+import type { Request, Runner } from './requests.ts';
+import { type Answer, type Scoops } from './service.ts';
+import { type SyncState } from './sync.ts';
+export declare const DEFAULT_WAIT_S = 30;
+export declare const MAX_DEPTH = 3;
+export declare const RUN_DIR = "/var/lib/slicc/agent/scoops";
+export declare const THINKING: Set<string>;
+export declare const USAGE = "usage:\n  agent [options] (--prompt <text> | --file <path> | -)...          run a scoop, wait, print its answer\n  agent --async [options] (--prompt <text> | --file <path> | -)...  start a scoop, print its handle\n  agent <cwd> <allowed-commands> <prompt>                         the same as a synchronous run, in v6's form\n  agent list [--agents] | status <handle> | rename <handle> <name>\n  agent send <handle> [--follow-up] (<message> | --file <path> | -)\n  agent send parent <note>                                        from a scoop: a progress note to its cone\n  agent wait <handle>... [--timeout <seconds>] [--notify]\n  agent stop <handle>\n\noptions:\n  --name <name>  --agent <role>  --model <provider/model>  --thinking <level> | --effort <low|medium|high|max>\n  --tools <a,b>  --read-only <path,path>  --system-prompt <text> | --system-prompt-file <path>\n  --background-after <seconds>  --persist-session | --no-persist-session\n\nA synchronous run removes the scoop's folder afterwards. Its transcript is archived in\n/tmp/agent-sessions/<handle>.md, in /home/sessions/<handle>.md with --persist-session, or nowhere\nwith --no-persist-session. subagent is the same command: subagent spawn = agent --async.\n";
+export interface CliOptions {
+    env: ExecutionEnv;
+    harness: Harness;
+    agents: Agents;
+    scoops: Scoops;
+    roles: () => Promise<Roles>;
+    alive?: (pid: number) => Promise<boolean>;
+    now?: () => number;
+}
+export type Deps = CliOptions & {
+    now: () => number;
+    sync: SyncState;
+};
+export interface Caller {
+    id: string | null;
+    cone: string;
+    fromAgent: boolean;
+    scoop: string | null;
+    depth: number;
+}
+export type Flags = {
+    values: Map<string, string[]>;
+    switches: Set<string>;
+    rest: string[];
+};
+export declare const ok: (out: string) => Answer;
+export declare const fail: (out: string, code?: number) => Answer;
+export declare function isAnswer(value: unknown): value is Answer;
+export declare function flags(argv: readonly string[], withValue: readonly string[]): Flags;
+export declare function last(parsed: Flags, flag: string): string | undefined;
+export declare function callerOf(agents: Agents, request: Request): Caller;
+export declare function readText(deps: Deps, value: string, request: Request, context: Context): Promise<string>;
+export declare function prompts(deps: Deps, argv: readonly string[], request: Request, context: Context): Promise<string[]>;
+export type Choice = {
+    model?: {
+        provider: string;
+        modelId: string;
+    };
+    thinking?: string;
+    tools?: string[];
+};
+export declare function choices(parsed: Flags): Choice | Answer;
+export declare function role(deps: Deps, parsed: Flags): Promise<{
+    roles: Roles;
+    error: Answer;
+    role?: undefined;
+} | {
+    error?: undefined;
+    roles: Roles;
+    role: import("../roles/roles.ts").Role | undefined;
+}>;
+export declare function unsupported(argv: readonly string[]): Answer | undefined;
+export declare function createCli(options: CliOptions): Runner;

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

@@ -0,0 +1,79 @@
+import type { Context } from '@earendil-works/chord';
+import { type ConversationId, type Extension, type Submission, type ToolRegistration, type Tx } from '@earendil-works/pi-durable';
+import { type ScoopRecord } from '../agents.ts';
+import type { LickEvent } from '../licks/licks.ts';
+import type { Role } from '../roles/roles.ts';
+import { type ScoopsHost } from './service.ts';
+export declare const PREVIEW = 1000;
+type Lookup = () => Promise<ScoopsHost>;
+export declare function scoopFacts(record: Pick<ScoopRecord, 'name' | 'folder' | 'role'>): string;
+export type ReportResult = {
+    text: string;
+    failed: string | null;
+    path: string | null;
+};
+export declare function reportLick(record: ScoopRecord, id: string, report: ReportResult, route?: {
+    target?: string | null;
+    channel?: 'scoop-notify' | 'bash';
+}): LickEvent;
+type Noting = {
+    commit: (write: (tx: Tx) => Promise<{
+        status: 'running';
+        checkpoint: {
+            phase: 'deliver';
+            noted: true;
+        };
+    }>, context: Context) => Promise<unknown>;
+};
+export declare function noteWhenPlaced(runtime: Noting, submission: Pick<Submission, 'status'>, conversation: ConversationId, note: {
+    from: string | undefined;
+    noted: boolean | undefined;
+}, context: Context): Promise<void>;
+export declare const NOTE_POLL_MS = 100;
+export declare function waitTask(lookup: Lookup): import("@earendil-works/pi-durable").Task<{
+    scoops: string[];
+    cone: string;
+    deadline: number;
+}, {
+    phase: 'start';
+} | {
+    phase: 'watch';
+}, null, object>;
+export declare function scoopTasks(lookup: Lookup): {
+    anchor: import("@earendil-works/pi-durable").Task<null, {
+        phase: 'done';
+    }, null, object>;
+    reporter: import("@earendil-works/pi-durable").Task<{
+        scoop: string;
+        prompt: string;
+        followUp?: boolean;
+        request?: string;
+    }, {
+        phase: 'deliver';
+        noted?: boolean;
+    } | {
+        phase: 'report';
+        text: string;
+        failed: string | null;
+    }, ReportResult, object>;
+    wait: import("@earendil-works/pi-durable").Task<{
+        scoops: string[];
+        cone: string;
+        deadline: number;
+    }, {
+        phase: 'start';
+    } | {
+        phase: 'watch';
+    }, null, object>;
+};
+export declare function rolesSection(roles: readonly Role[]): string;
+export interface ScoopSections {
+    roles(): readonly Role[];
+    skill(): string;
+}
+export declare function scoopsExtension(tasks: ReturnType<typeof scoopTasks>, sections: ScoopSections): Extension;
+export declare function allowed(record: Pick<ScoopRecord, 'folder'> & {
+    roots?: ScoopRecord['roots'];
+}, coneCwd: string, path: string, writing: boolean): boolean;
+export declare function guardExtension(lookup: Lookup, tools: readonly ToolRegistration[]): Extension;
+export {};

package/dist/types/scoops/from.d.ts

@@ -0,0 +1,5 @@
+export declare const FROM_KIND = "slicc.from";
+export type From = {
+    from: string;
+    entry: number;
+};

package/dist/types/scoops/identity.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from '@earendil-works/chord';
+import { type ModelRef } from '@earendil-works/pi-durable';
+import type { Agents } from '../agents.ts';
+import type { EnvTargetLike } from '../kernel/env.ts';
+export declare function callerOf(agents: Agents | undefined, conversation: number | undefined): string | undefined;
+export declare function identity(agents: () => Agents | undefined, fallback: ModelRef): (target: EnvTargetLike, context: Context) => Promise<Record<string, string>>;

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

@@ -0,0 +1,37 @@
+import type { Context } from '@earendil-works/chord';
+import type { Harness, Registry, ToolRegistration } from '@earendil-works/pi-durable';
+import type { ExecutionEnv } from '@earendil-works/pi-durable/env';
+import { type Agents } from '../agents.ts';
+import type { ProcessGroups } from '../kernel/groups.ts';
+import type { Licks } from '../licks/licks.ts';
+import { type Roles } from '../roles/roles.ts';
+import { type ControlPlane } from './requests.ts';
+import { type Scoops } from './service.ts';
+export declare const BUILTIN_ROLES: string[];
+export declare const PNPM_HOME = "/home/.local/share/pnpm";
+export type Assets = (path: string) => Promise<string>;
+export declare function packageAssets(base?: URL): Assets;
+export interface AttachOptions {
+    harness: Harness;
+    agents: Agents;
+    groups?: ProcessGroups;
+    env: ExecutionEnv;
+    home: string;
+    assets?: Assets;
+    pnpmHome?: string;
+    controlDir?: string;
+    sweepEvery?: number;
+    alive?: (pid: number) => Promise<boolean>;
+}
+export interface ScoopsRuntime {
+    roles(context: Context): Promise<Roles>;
+    plane: ControlPlane;
+    close(context: Context): Promise<void>;
+}
+export interface ScoopsSetup {
+    scoops: Scoops;
+    attach(options: AttachOptions, context: Context): Promise<ScoopsRuntime>;
+}
+export declare const COMMANDS: string[];
+export declare function setupScoops(registry: Registry, licks: Licks, fileTools?: readonly ToolRegistration[]): ScoopsSetup;
+export type { Rewound, Scoops } from './service.ts';

package/dist/types/scoops/requests.d.ts

@@ -0,0 +1,32 @@
+import type { Context } from '@earendil-works/chord';
+import type { ExecutionEnv } from '@earendil-works/pi-durable/env';
+import type { Answer } from './service.ts';
+export declare const CONTROL_DIR = "/var/lib/slicc/agent/requests";
+export declare const PROTOCOL = "slicc-agent/1";
+export declare const STALE_MS: number;
+export interface Request {
+    id: string;
+    as: 'agent' | 'subagent';
+    caller: string;
+    cwd: string;
+    pid: number | null;
+    argv: string[];
+    stdin: string;
+}
+export declare function parseRequest(id: string, bytes: Uint8Array): Request | undefined;
+export interface Runner {
+    run(request: Request, context: Context): Promise<Answer>;
+    blocking(request: Request): boolean;
+}
+export interface ControlPlane {
+    start(context: Context): Promise<void>;
+    sweep(context: Context): Promise<void>;
+    close(context: Context): Promise<void>;
+}
+export interface PlaneOptions {
+    dir?: string;
+    now?: () => number;
+    sweepEvery?: number;
+    mirror?: (context: Context) => Promise<void>;
+}
+export declare function controlPlane(env: ExecutionEnv, runner: Runner, options?: PlaneOptions): ControlPlane;

package/dist/types/scoops/service.d.ts

@@ -0,0 +1,119 @@
+import type { Context } from '@earendil-works/chord';
+import { type AgentChange, type AnyTask, type Conversation, type Harness, type ToolRegistration } from '@earendil-works/pi-durable';
+import { type Agents, type AgentsState, type Mark, type ScoopRecord } from '../agents.ts';
+import type { ProcessGroups } from '../kernel/groups.ts';
+import type { Licks } from '../licks/licks.ts';
+import type { Role } from '../roles/roles.ts';
+export declare const SCOOPS_ROOT = "/scoops";
+export declare const LEDGER_SIZE = 512;
+export type Feed = {
+    scoop: string;
+    created: Mark | null;
+    report: boolean;
+    target: string | null;
+    channel: 'scoop-notify' | 'bash';
+    from?: string;
+};
+type Wait = {
+    scoops: string[];
+    done: Record<string, string>;
+    cone: string;
+};
+export type Answer = {
+    code: number;
+    out: string;
+    tasks?: number[];
+};
+type WorkState = {
+    feeds: Record<string, Feed>;
+    waits: Record<string, Wait>;
+    ledger: Record<string, Answer>;
+    turns: Record<string, {
+        at: number;
+        count: number;
+    }>;
+};
+export declare const ScoopWorkDoc: import("@earendil-works/pi-durable").SessionDocToken<WorkState>;
+export interface ScoopTasks {
+    anchor: AnyTask;
+    reporter: AnyTask;
+    wait: AnyTask;
+}
+export interface ScoopsHost {
+    harness: Harness;
+    agents: Agents;
+    licks: Licks;
+    groups?: ProcessGroups;
+    tools?: readonly ToolRegistration[];
+}
+export interface Rewound {
+    stopped: string[];
+    restored: string[];
+}
+export interface ScoopSummary {
+    id: string;
+    folder: string;
+    name: string;
+    role: string | null;
+    busy: boolean;
+}
+export interface Limits {
+    maxLiveScoops: number;
+    maxPerTurn: number;
+}
+export interface SpawnRequest {
+    cone: string;
+    kind?: 'async' | 'sync';
+    parent?: string;
+    depth?: number;
+    roots?: {
+        write: string[];
+        read: string[];
+    };
+    cwd?: string;
+    instructions?: string;
+    target?: string | null;
+    asker?: string | null;
+    name: string;
+    role?: Role;
+    model?: {
+        provider: string;
+        modelId: string;
+    };
+    thinking?: AgentChange['thinkingLevel'];
+    tools?: string[];
+    prompts: string[];
+    fromAgent: boolean;
+    request?: string;
+    limits: Limits;
+}
+export declare function workspace(folder: string): string;
+export declare function tail(conversation: Conversation, context: Context): Promise<Mark>;
+export declare function turnStart(conversation: Conversation, context: Context): Promise<number>;
+export declare function coneOf(state: Readonly<AgentsState>, conversation: number): string | undefined;
+export declare function findScoop(state: Readonly<AgentsState>, handle: string, cone: string | null): [string, ScoopRecord] | undefined;
+export declare function askerName(state: Readonly<AgentsState>, asker: string | null): string;
+export declare function createScoops(host: Promise<ScoopsHost>, tasks: () => ScoopTasks): {
+    detach: (made: readonly number[], target: string, context: Context) => Promise<void>;
+    note: (id: string, text: string, context: Context) => Promise<Answer>;
+    spawn: (request: SpawnRequest, context: Context) => Promise<Answer>;
+    feed: (id: string, prompt: string, options: {
+        fromAgent: boolean;
+        request: string;
+        followUp: boolean;
+        target: string | null;
+    }, context: Context) => Promise<Answer>;
+    stop: (id: string, fromAgent: boolean, context: Context) => Promise<Answer>;
+    rename: (id: string, name: string, context: Context) => Promise<Answer>;
+    rewound: (coneId: string, fork: Conversation, context: Context) => Promise<Rewound>;
+    list: (coneId: string | null, context: Context) => Promise<ScoopSummary[]>;
+    busy: (conversation: number, context: Context) => Promise<boolean>;
+    working: (ids: readonly string[], context: Context) => Promise<string[]>;
+    notifyWhenDone: (coneId: string, ids: string[], deadline: number, context: Context) => Promise<void>;
+};
+export declare function modelOf(value: string | undefined): {
+    provider: string;
+    modelId: string;
+} | undefined;
+export type Scoops = ReturnType<typeof createScoops>;
+export {};

package/dist/types/scoops/sync.d.ts

@@ -0,0 +1,22 @@
+import type { Context } from '@earendil-works/chord';
+import type { EntryRecord } from '@earendil-works/pi-durable';
+import type { ScoopRecord } from '../agents.ts';
+import { type Caller, type Deps } from './cli.ts';
+import type { Request } from './requests.ts';
+import { type Answer } from './service.ts';
+export declare const SESSIONS: {
+    tmp: string;
+    durable: string;
+};
+type Ending = 'cancel' | 'detach';
+interface Pending {
+    end: (ending: Ending) => void;
+}
+export interface SyncState {
+    pending: Map<string, Pending>;
+}
+export declare function transcript(record: ScoopRecord, entries: readonly EntryRecord[]): string;
+export declare function runSync(deps: Deps, request: Request, who: Caller, context: Context): Promise<Answer>;
+export declare function cancelSync(deps: Deps, requestId: string, _context: Context): Promise<Answer>;
+export declare function detachSync(deps: Deps, requestId: string, _context: Context): Promise<Answer>;
+export {};

package/dist/types/scoops/visible.d.ts

@@ -0,0 +1,4 @@
+import type { ConversationRecord } from '@earendil-works/pi-durable';
+import type { Mark } from '../agents.ts';
+export type ReadConversation = (id: number) => Promise<ConversationRecord | undefined>;
+export declare function visible(read: ReadConversation, conversation: number, mark: Mark): Promise<boolean>;

package/dist/types/services.d.ts

@@ -5,6 +5,7 @@ export interface SendRequest {
     text: string;
     whenBusy: SendMode;
     requestId: string | null;
+    agentId?: string | null;
 }
 export interface OperationError {
     code: string;
@@ -43,6 +44,32 @@ export interface AgentControl {
     webhook(name: string, delivery: WebhookRequest, context: Context): Promise<{
         delivered: boolean;
     }>;
+    stopAgent(agentId: string, context: Context): Promise<void>;
+    selectCone(agentId: string, context: Context): Promise<void>;
+    createCone(name: string, context: Context): Promise<Created>;
+    createScoop(parentId: string, name: string, context: Context): Promise<Created>;
+    drop(agentId: string, context: Context): Promise<Created>;
+    unqueue(agentId: string | null, submissionId: string, context: Context): Promise<{
+        outcome: 'withdrawn' | 'already_placed' | 'not_found';
+    }>;
+}
+export type Created = {
+    id: string;
+    error: null;
+} | {
+    id: null;
+    error: string;
+};
+export interface AgentSummary {
+    id: string;
+    name: string;
+    kind: 'cone' | 'scoop';
+    parentId: string | null;
+    role: string | null;
+}
+export interface AgentsSummary {
+    active: string;
+    agents: AgentSummary[];
 }
 export type LickResolved = {
     done: true;
@@ -73,12 +100,15 @@ export interface AgentSettingsChange {
         modelId: string;
     } | null;
     thinkingLevel: 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max' | null;
+    agentId?: string | null;
 }
 export declare const AgentControl: import("@earendil-works/chord").Service<AgentControl>;
 export type Delivered = 'run' | 'steer' | 'follow-up';
 export interface AgentTranscript {
     readonly state: ReplicatedState<ConversationView>;
     readonly deliveries: ReplicatedState<Record<string, Delivered>>;
+    readonly agents: ReplicatedState<AgentsSummary>;
+    readonly views: ReplicatedState<Record<string, ConversationView>>;
 }
 export declare const AgentTranscript: import("@earendil-works/chord").Service<AgentTranscript>;
 export interface AgentSessions {

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

@@ -8,24 +8,26 @@ export declare class AgentAdapter extends Emitter<AgentEvents> implements AgentP
     ready(): Promise<void>;
     list(): readonly Agent[];
     active(): string;
-    select(): void;
-    messages(): readonly Message[];
-    send(_agentId: string, input: string | Outgoing): Promise<void>;
+    select(id: string): void;
+    messages(agentId?: string): readonly Message[];
+    send(agentId: string, input: string | Outgoing): Promise<void>;
     rewind(_agentId: string, messageId: string): Promise<Outgoing | null>;
-    stop(): void;
-    busy(): boolean;
-    queue(): readonly UserMessage[];
-    unqueue(_agentId: string, messageId: string): void;
+    stop(agentId?: string): void;
+    busy(agentId?: string): boolean;
+    queue(agentId?: string): readonly UserMessage[];
+    unqueue(agentId: string, messageId: string): void;
     suggestion(): string | null;
     answer(): void;
-    resolveLick(_agentId: string, messageId: string, state: 'confirmed' | 'dismissed'): void;
+    resolveLick(agentId: string, messageId: string, state: 'confirmed' | 'dismissed'): void;
     compact(): void;
     clear(): void;
-    setModel(_agentId: string, model: string): void;
-    setThinking(_agentId: string, level: Thinking): void;
+    setModel(agentId: string, model: string): void;
+    setThinking(agentId: string, level: Thinking): void;
     older(): Promise<readonly Message[]>;
     commands(): readonly SlashCommand[];
-    createScoop(): Agent;
+    createScoop(parentId: string, name: string): Agent;
+    drop(agentId: string): Promise<void>;
+    createCone(name: string): Promise<Agent>;
     frozen(): readonly FrozenCone[];
     freeze(): void;
     thaw(): Agent | null;

package/dist/types/spectrum/messages.d.ts

@@ -1,5 +1,5 @@
 import type { AssistantMessage, AssistantStatus, ErrorAction, Message, MessagePart, ToolCall, UserMessage } from '@ai-ecoverse/slicc-spectrum/ui';
-import type { ConversationView } from '@earendil-works/pi-durable';
+import type { ConversationView, EntryRecord } from '@earendil-works/pi-durable';
 import type { Delivered } from '../services.ts';
 type Json = Record<string, unknown>;
 interface Block {
@@ -38,6 +38,7 @@ export declare function fromPatch(patch: string): ToolCall['diff'];
 export declare function errorPart(error: string, provider?: string): MessagePart;
 export declare function errorAction(message: string): ErrorAction;
 export declare function assistant(id: string, message: ModelMessage, status?: AssistantStatus): AssistantMessage;
+export declare function origins(entries: readonly EntryRecord[]): Map<number, string>;
 export declare function toMessages(view: ConversationView | undefined, deliveries?: Readonly<Record<string, Delivered>>): Message[];
 export declare function isBusy(view: ConversationView | undefined): boolean;
 export declare function queued(view: ConversationView | undefined): UserMessage[];

package/dist/types/views.d.ts

@@ -0,0 +1,12 @@
+import { type Context } from '@earendil-works/chord';
+import type { ConversationView } from '@earendil-works/pi-durable';
+import type { Agent } from './agent.ts';
+import { type AgentsState } from './agents.ts';
+import type { AgentsSummary } from './services.ts';
+export declare function summarize(state: Readonly<AgentsState>): AgentsSummary;
+export declare function agentViews(agent: Agent, context: Context): Promise<{
+    agents: import("@earendil-works/chord").MutableReplicatedState<AgentsSummary>;
+    views: import("@earendil-works/chord").MutableReplicatedState<Record<string, ConversationView>>;
+    sync: () => Promise<unknown>;
+    dispose(): void;
+}>;

package/dist/views.js

@@ -0,0 +1,89 @@
+import { replicatedState } from "@earendil-works/chord";
+import { live } from "./agents.js";
+function summarize(state) {
+  const cones = Object.entries(state.cones).map(([id, cone]) => ({
+    id,
+    name: cone.name,
+    kind: "cone",
+    parentId: null,
+    role: null
+  }));
+  const scoops = Object.entries(state.scoops).filter(([, scoop]) => live(scoop)).map(([id, scoop]) => ({
+    id,
+    name: scoop.name,
+    kind: "scoop",
+    parentId: scoop.parent ?? scoop.cone,
+    role: scoop.role
+  }));
+  return { active: state.active, agents: [...cones, ...scoops] };
+}
+function wanted(state) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [id, cone] of Object.entries(state.cones)) out.set(id, cone.conversation);
+  for (const [id, scoop] of Object.entries(state.scoops))
+    if (live(scoop)) out.set(id, scoop.conversation);
+  return out;
+}
+async function agentViews(agent, context) {
+  const agents = replicatedState(summarize(agent.agents.state()));
+  const views = replicatedState({});
+  const mounted = /* @__PURE__ */ new Map();
+  let lock = Promise.resolve();
+  const sync = () => {
+    lock = lock.then(async () => {
+      const state = agent.agents.state();
+      agents.replace(context, summarize(state));
+      const target = wanted(state);
+      for (const [id, entry] of [...mounted]) {
+        if (target.get(id) === entry.conversation) continue;
+        entry.off();
+        entry.attached.dispose();
+        mounted.delete(id);
+        if (!target.has(id))
+          views.change(context, (draft) => {
+            delete draft[id];
+          });
+      }
+      for (const [id, conversation] of target) {
+        if (mounted.has(id)) continue;
+        const handle = await agent.agents.conversation(id, context);
+        if (!handle) continue;
+        const attached = await handle.viewState(context);
+        const put = (value) => views.change(context, (draft) => {
+          draft[id] = value;
+        });
+        put(attached.value);
+        mounted.set(id, {
+          conversation,
+          attached,
+          off: attached.subscribe((value) => put(value))
+        });
+      }
+    }).catch(() => void 0);
+    return lock;
+  };
+  await sync();
+  const offChange = agent.agents.onChange(() => void sync());
+  const offCone = agent.agents.onCone(async () => {
+    await sync();
+  });
+  return {
+    agents,
+    views,
+    sync,
+    dispose() {
+      offChange();
+      offCone();
+      for (const entry of mounted.values()) {
+        entry.off();
+        entry.attached.dispose();
+      }
+      mounted.clear();
+    }
+  };
+}
+export {
+  agentViews,
+  summarize
+};
+//# sourceMappingURL=views.js.map

package/dist/views.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/views.ts"],
+  "sourcesContent": ["import { type AttachedReplicatedState, type Context, replicatedState } from '@earendil-works/chord';\nimport type { ConversationView } from '@earendil-works/pi-durable';\nimport type { Agent } from './agent.ts';\nimport { type AgentsState, live } from './agents.ts';\nimport type { AgentsSummary } from './services.ts';\n\nexport function summarize(state: Readonly<AgentsState>): AgentsSummary {\n  const cones = Object.entries(state.cones).map(([id, cone]) => ({\n    id,\n    name: cone.name,\n    kind: 'cone' as const,\n    parentId: null,\n    role: null,\n  }));\n  const scoops = Object.entries(state.scoops)\n    .filter(([, scoop]) => live(scoop))\n    .map(([id, scoop]) => ({\n      id,\n      name: scoop.name,\n      kind: 'scoop' as const,\n      parentId: scoop.parent ?? scoop.cone,\n      role: scoop.role,\n    }));\n  return { active: state.active, agents: [...cones, ...scoops] };\n}\n\nfunction wanted(state: Readonly<AgentsState>): Map<string, number> {\n  const out = new Map<string, number>();\n  for (const [id, cone] of Object.entries(state.cones)) out.set(id, cone.conversation);\n  for (const [id, scoop] of Object.entries(state.scoops))\n    if (live(scoop)) out.set(id, scoop.conversation);\n  return out;\n}\n\ninterface Mounted {\n  conversation: number;\n  attached: AttachedReplicatedState<ConversationView>;\n  off: () => void;\n}\n\nexport async function agentViews(agent: Agent, context: Context) {\n  const agents = replicatedState<AgentsSummary>(summarize(agent.agents.state()));\n  const views = replicatedState<Record<string, ConversationView>>({});\n  const mounted = new Map<string, Mounted>();\n  let lock: Promise<unknown> = Promise.resolve();\n  const sync = () => {\n    lock = lock\n      .then(async () => {\n        const state = agent.agents.state();\n        agents.replace(context, summarize(state));\n        const target = wanted(state);\n        for (const [id, entry] of [...mounted]) {\n          if (target.get(id) === entry.conversation) continue;\n          entry.off();\n          entry.attached.dispose();\n          mounted.delete(id);\n          if (!target.has(id))\n            views.change(context, (draft) => {\n              delete draft[id];\n            });\n        }\n        for (const [id, conversation] of target) {\n          if (mounted.has(id)) continue;\n          const handle = await agent.agents.conversation(id, context);\n          if (!handle) continue;\n          const attached = await handle.viewState(context);\n          const put = (value: ConversationView) =>\n            views.change(context, (draft) => {\n              (draft as Record<string, unknown>)[id] = value;\n            });\n          put(attached.value);\n          mounted.set(id, {\n            conversation,\n            attached,\n            off: attached.subscribe((value) => put(value)),\n          });\n        }\n      })\n      .catch(() => undefined);\n    return lock;\n  };\n  await sync();\n  const offChange = agent.agents.onChange(() => void sync());\n  const offCone = agent.agents.onCone(async () => {\n    await sync();\n  });\n  return {\n    agents,\n    views,\n    sync,\n    dispose() {\n      offChange();\n      offCone();\n      for (const entry of mounted.values()) {\n        entry.off();\n        entry.attached.dispose();\n      }\n      mounted.clear();\n    },\n  };\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-agent",
-  "version": "3.6.0",
+  "version": "3.8.0",
   "description": "SLICC's agent core on pi durable: an agent worker, session storage, remoting and pi extensions",
   "type": "module",
   "license": "Apache-2.0",
@@ -40,7 +40,9 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "bin",
+    "packages/vfs-root"
   ],
   "scripts": {
     "prepare": "lefthook install",
@@ -60,7 +62,7 @@
   },
   "devDependencies": {
     "@ai-ecoverse/slicc-shared-web": "1.8.0",
-    "@ai-ecoverse/slicc-spectrum": "1.13.0",
+    "@ai-ecoverse/slicc-spectrum": "1.23.0",
     "@ai-ecoverse/wasm-bash": "5.3.0-7",
     "@ai-ecoverse/wasm-coreutils": "9.7.0-3",
     "@biomejs/biome": "2.5.15",

package/packages/vfs-root/agents/delegate.md

@@ -0,0 +1,8 @@
+---
+name: delegate
+description: A general helper that works like the cone itself, for a self-contained piece of work
+tools: read, write, edit, bash
+systemPromptMode: append
+---
+
+You are a delegate: you work the way the cone does, on one self-contained piece of work the cone handed you. Finish it, check it, and answer with what you did, what you found, and anything the cone has to decide.