@astrosheep/keiyaku 4.6.7 → 4.6.8

package/build/src/protocol/read/status.js

@@ -57,9 +57,6 @@ function appointedWorkspace(repository, register, state) {
         ? undefined
         : { contractId: state.id, place: appointed.place, workspace: worktreePath(repository, appointed.place) };
 }
-async function readSelectedHandoffs(observation, workspaces) {
-    return await readConflictHandoffs(observation.repository, observation.readBlobs, workspaces.flatMap((workspace) => (workspace === undefined ? [] : [workspace])));
-}
 async function managedWorkspaceFacts(repository, state, appointed, targetObservation, handoff) {
     if (appointed === undefined) {
         return {
@@ -101,10 +98,10 @@ function afterEdges(state, endpoints) {
         endpoint: afterEndpoint(endpoints.get(contractId)),
     }));
 }
-function reverseDependents(id, rows) {
-    return rows
-        .filter((row) => row.disposition === "active" && row.after.some((edge) => edge.contractId === id))
-        .map((row) => ({ contractId: row.id, phase: row.phase }))
+function reverseDependents(id, states) {
+    return states
+        .filter(({ state }) => state.terminal === null && state.terms.after.includes(id))
+        .map(({ state }) => ({ contractId: state.id, phase: phaseFor(state) }))
         .sort((left, right) => left.contractId.localeCompare(right.contractId));
 }
 async function rowFor(input) {
@@ -148,6 +145,25 @@ async function afterEndpointMap(observation, known, ids) {
     const extra = await observeContractsForAdmissionInObservationAt(observation, missing);
     return new Map([...known, ...[...extra.journals].map(([id, record]) => [id, record.state])]);
 }
+async function hydrateRows(observation, states, endpoints, dependentStates = []) {
+    const register = await readPlaceRegister(observation.repository);
+    const selected = states.map((value) => ({
+        ...value,
+        workspace: appointedWorkspace(observation.repository, register, value.state),
+    }));
+    const handoffs = await readConflictHandoffs(observation.repository, observation.readBlobs, selected.flatMap(({ workspace }) => (workspace === undefined ? [] : [workspace])));
+    return await Promise.all(selected.map(async ({ state, bindAt, lastJournalAt, workspace }) => await rowFor({
+        repository: observation.repository,
+        state,
+        bindAt,
+        lastJournalAt,
+        targetObservation: await observeDeliveryTargetAt(observation, state),
+        workspace,
+        handoff: handoffs.get(state.id),
+        after: afterEdges(state, endpoints),
+        dependents: reverseDependents(state.id, dependentStates),
+    })));
+}
 /** Build the Contract board from one immutable git observation. */
 export async function readContractBoard(observation, include) {
     const observedAt = new Date().toISOString();
@@ -165,29 +181,8 @@ export async function readContractBoard(observation, include) {
             endpoints = new Map(await afterEndpointMap(observation, endpoints, record.state.terms.after));
         }
     }
-    const register = await readPlaceRegister(observation.repository);
-    const selected = [...contracts.values()].flatMap((value) => value.state === null
-        ? []
-        : [
-            {
-                ...value,
-                state: value.state,
-                workspace: appointedWorkspace(observation.repository, register, value.state),
-            },
-        ]);
-    const handoffs = await readSelectedHandoffs(observation, selected.map(({ workspace }) => workspace));
-    const projected = await Promise.all(selected.map(async ({ state, entries, workspace }) => await rowFor({
-        repository: observation.repository,
-        state,
-        bindAt: entries[0].at,
-        lastJournalAt: lastJournalAtFor(entries),
-        targetObservation: await observeDeliveryTargetAt(observation, state),
-        workspace,
-        handoff: handoffs.get(state.id),
-        after: afterEdges(state, endpoints),
-        dependents: [],
-    })));
-    const rows = projected.map((row) => ({ ...row, dependents: reverseDependents(row.id, projected) }));
+    const selected = selectedContractStates(contracts);
+    const rows = await hydrateRows(observation, selected, endpoints, selected);
     return {
         root: observation.repository.primaryWorktree,
         state: observed.snapshot,
@@ -199,8 +194,8 @@ function compareRecentContracts(left, right) {
     return (right.lastJournalAt.localeCompare(left.lastJournalAt) ||
         Buffer.compare(Buffer.from(left.state.id), Buffer.from(right.state.id)));
 }
-function activeContractStates(contracts) {
-    return [...contracts.values()].flatMap((record) => record.state === null || record.state.terminal !== null
+function selectedContractStates(contracts) {
+    return [...contracts.values()].flatMap((record) => record.state === null
         ? []
         : [
             {
@@ -210,37 +205,15 @@ function activeContractStates(contracts) {
             },
         ]);
 }
-function reverseDependentsFromStates(id, states) {
-    return states
-        .filter(({ state }) => state.terms.after.includes(id))
-        .map(({ state }) => ({ contractId: state.id, phase: phaseFor(state) }))
-        .sort((left, right) => left.contractId.localeCompare(right.contractId));
-}
 /** Observe a bounded recent active Contract catalogue from one immutable git observation. */
 export async function readContractCatalogue(observation, limit) {
     const observedAt = new Date().toISOString();
     const observed = await observeActiveContractWorld(observation);
-    const active = activeContractStates(observed.contracts);
+    const active = selectedContractStates(observed.contracts).filter(({ state }) => state.terminal === null);
     const selected = projectBoundedList([...active].sort(compareRecentContracts), limit);
     const afterIds = selected.rows.flatMap(({ state }) => state.terms.after);
     const endpoints = await afterEndpointMap(observation, new Map(observed.eligibility), afterIds);
-    const register = await readPlaceRegister(observation.repository);
-    const selectedWorkspaces = selected.rows.map((value) => ({
-        ...value,
-        workspace: appointedWorkspace(observation.repository, register, value.state),
-    }));
-    const handoffs = await readSelectedHandoffs(observation, selectedWorkspaces.map(({ workspace }) => workspace));
-    const rows = await Promise.all(selectedWorkspaces.map(async ({ state, bindAt, lastJournalAt, workspace }) => await rowFor({
-        repository: observation.repository,
-        state,
-        bindAt,
-        lastJournalAt,
-        targetObservation: await observeDeliveryTargetAt(observation, state),
-        workspace,
-        handoff: handoffs.get(state.id),
-        after: afterEdges(state, endpoints),
-        dependents: reverseDependentsFromStates(state.id, active),
-    })));
+    const rows = await hydrateRows(observation, selected.rows, endpoints, active);
     return {
         root: observation.repository.primaryWorktree,
         state: observed.snapshot,
@@ -270,22 +243,10 @@ export async function readContractObservation(observation, id) {
     if (state === null)
         return { kind: "missing", id };
     const endpoints = await afterEndpointMap(observation, new Map([[id, state]]), state.terms.after);
-    const register = await readPlaceRegister(observation.repository);
-    const workspace = appointedWorkspace(observation.repository, register, state);
-    const handoffs = await readSelectedHandoffs(observation, [workspace]);
+    const rows = await hydrateRows(observation, selectedContractStates(observed.journals), endpoints);
     return {
         kind: "present",
-        row: await rowFor({
-            repository: observation.repository,
-            state,
-            bindAt: record.entries[0].at,
-            lastJournalAt: lastJournalAtFor(record.entries),
-            targetObservation: await observeDeliveryTargetAt(observation, state),
-            workspace,
-            handoff: handoffs.get(state.id),
-            after: afterEdges(state, endpoints),
-            dependents: [],
-        }),
+        row: rows[0],
     };
 }
 /** Observe one Contract and its target from one fresh ref epoch. */

package/build/src/protocol/reintegrate.js

@@ -2,18 +2,11 @@ import { contractState } from "../core/facts/observation.js";
 import { decideReintegrate } from "../core/verbs/reintegrate.js";
 import { materializeReintegrationSnapshot, persistedTender, planIntegration, reusableIntegrationSnapshot, } from "../git/integration.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
-import { appendPrivateStateSeatClose, mergePrivateStateSeatClose, withPrivateStatePublicationSeat, } from "../git/private-state-seat.js";
+import { withPrivateStatePublicationSeat } from "../git/private-state-seat.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
 import { recordedIntegrationSnapshots, timestamp } from "./operations.js";
-import { externalPreparation, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
+import { externalPreparation, protocolSeatClose, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
 import { runUnderTargetPlacementFence } from "./placement.js";
-function reintegrationResultWithSeatClose(outcome) {
-    return mergePrivateStateSeatClose(outcome, (value, closeLag) => {
-        if (value.kind !== "accepted")
-            throw new Error(closeLag.diagnostic);
-        return { ...value, seatClose: appendPrivateStateSeatClose(value.seatClose, closeLag) };
-    });
-}
 /** Plan and materialize the target-specific reintegration artifacts outside the publication seat. */
 async function prepareExternalReintegration(input) {
     return await externalPreparation({ ...input, scope: input.repository }, (observation, state) => planReintegrationArtifacts(input, state, recordedIntegrationSnapshots(observation.journals.get(state.id)?.entries ?? [])));
@@ -54,7 +47,7 @@ async function runReintegration(input) {
     for (let index = 0; index < attempts.length; index += 1) {
         const attempt = attempts[index];
         const external = await prepareExternalReintegration(input);
-        const result = reintegrationResultWithSeatClose(await withPrivateStatePublicationSeat(input.repository, async (seat) => {
+        const result = protocolSeatClose(await withPrivateStatePublicationSeat(input.repository, async (seat) => {
             const observation = await observeContractsForAdmissionAt(input.repository, input.channel, [input.contractId]);
             const assembled = assembleReintegrationAttempt(input, observation, external);
             if (assembled.kind === "stale")

package/build/src/protocol/review.js

@@ -4,14 +4,14 @@ import { worktreeChangeId } from "../git/integration.js";
 import { captureTender, dirtyTenderDelta, dirtyTenderRefusal } from "../git/tender.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
 import { unmergedWorkspacePaths, worktreePath } from "../git/workspace.js";
-import { externalPreparation, privateStateSeatAttempt, runBoundedAttempts, sameWorktreeWitness, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
+import { externalPreparation, privateStateSeatAttempt, protocolSeatClose, runBoundedAttempts, sameWorktreeWitness, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
 import { dependencyKeySet } from "../core/subject.js";
 import { contractState } from "../core/facts/observation.js";
 import { gate } from "../core/facts/types.js";
 import { decideAttestation } from "../core/verbs/attestation.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
 import { appointmentFor, readPlaceRegister } from "../workspace-place.js";
-import { attemptDecisionWithSeatClose, timestamp } from "./operations.js";
+import { timestamp } from "./operations.js";
 const REVIEWED = gate("reviewed");
 const reviewWorkspaceEvidenceSchema = workspaceDirtyDeltaSchema
     .extend({ unmergedPaths: z.array(z.string().refine((value) => value.trim() !== "")).readonly() })
@@ -153,7 +153,7 @@ async function reviewAttempt(input, attempt) {
         if (assembled.kind === "stale")
             return STALE_PRIVATE_STATE_PREPARATION;
         return await decideAndAdmitReview(input, attempt, seat, observation, assembled);
-    }, attemptDecisionWithSeatClose);
+    }, protocolSeatClose);
 }
 export async function admitReviewOperation(input) {
     const result = await runBoundedAttempts(mintAttempts({ entryCount: 1 }), (attempt) => reviewAttempt(input, attempt));

package/build/src/protocol/run.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import type { ProtocolProgress } from "./progress.js";
 import { type GitDecisionObservation } from "../git/observe.js";
-import { type PrivateStatePublicationSeat, type PrivateStateSeatOutcome } from "../git/private-state-seat.js";
+import { type PrivateStatePublicationSeat, type PrivateStateSeatCloseLag, type PrivateStateSeatOutcome } from "../git/private-state-seat.js";
 import type { GitDecodeChannel, GitTreeSelection } from "../git/read-observation.js";
 import type { GitRepository } from "../git/process.js";
 import { type GitRefAssertion } from "../git/repository.js";
@@ -177,6 +177,10 @@ export declare function externalPreparation<Artifacts>(input: Readonly<{
     artifacts: Artifacts;
 }>>;
 export declare function privateStateSeatAttempt<T>(repository: GitRepository, action: (seat: PrivateStatePublicationSeat) => Promise<T>, wrap: (outcome: PrivateStateSeatOutcome<T>) => T): Promise<T | AttemptTerminal>;
+export declare function protocolSeatClose<T extends Readonly<{
+    kind: string;
+    seatClose?: readonly PrivateStateSeatCloseLag[];
+}>>(outcome: PrivateStateSeatOutcome<T>): T;
 /** Form one decided offer without admitting or reinterpreting it. */
 export declare function prepareProtocolAttempt<Input extends Readonly<{
     contractId: ContractId;

package/build/src/protocol/run.js

@@ -122,7 +122,7 @@ async function admitDecidedProtocolOffer(admission, primaryContract, seat, decis
         assertions: decided.assertions,
     });
 }
-function protocolAttemptWithSeatClose(outcome) {
+export function protocolSeatClose(outcome) {
     return mergePrivateStateSeatClose(outcome, (value, closeLag) => {
         if (value.kind !== "accepted")
             throw new Error(closeLag.diagnostic);
@@ -137,7 +137,7 @@ async function runDirectProtocolAttempt(input, attempt) {
             input: input.input,
             assertions: [],
         });
-    }, protocolAttemptWithSeatClose);
+    }, protocolSeatClose);
 }
 /**
  * One full attempt: repeatable preparation outside custody, then a single in-custody cycle of
@@ -160,7 +160,7 @@ async function runSplitProtocolAttempt(input, attempt) {
             input: assembled.input,
             assertions,
         });
-    }, protocolAttemptWithSeatClose);
+    }, protocolSeatClose);
 }
 /** Form one decided offer without admitting or reinterpreting it. */
 export async function prepareProtocolAttempt(input, baseAttempt) {

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "4.6.7",
+  "version": "4.6.8",
   "workspaces": [
     "plugins/square"
   ],
   "files": [
-    "build"
+    "build",
+    "plugins/pi",
+    "skills"
   ],
   "main": "./build/src/index.js",
   "types": "./build/src/index.d.ts",
@@ -75,6 +77,8 @@
     "@anthropic-ai/claude-agent-sdk": "^0.3.226",
     "@astrosheep/keiyaku-plugin-square": "0.1.8",
     "@astrosheep/square": "^0.3.70",
+    "@getpaseo/client": "0.11.2",
+    "@getpaseo/protocol": "0.11.2",
     "@opencode-ai/sdk": "1.18.3",
     "cross-spawn": "^7.0.6",
     "diff": "^8.0.4",
@@ -91,10 +95,10 @@
   ],
   "pi": {
     "extensions": [
-      "./build/plugins/pi/keiyaku.ts"
+      "./plugins/pi/keiyaku.ts"
     ],
     "skills": [
-      "./build/skills"
+      "./skills"
     ]
   },
   "author": "",

package/plugins/pi/keiyaku.ts

@@ -0,0 +1,57 @@
+import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
+
+type ExecResult = Readonly<{ stdout: string; stderr: string; code: number }>;
+
+async function runStatus(pi: ExtensionAPI): Promise<ExecResult> {
+  return await pi.exec("keiyaku", ["status"]);
+}
+
+function lineForWidth(value: string, width: number): string {
+  const clean = value.replaceAll(/[\u0000-\u001f\u007f]/gu, " ");
+  return clean.length <= width ? clean : `${clean.slice(0, Math.max(0, width - 1))}…`;
+}
+
+function overlay(lines: readonly string[], theme: Theme, done: () => void) {
+  return {
+    invalidate(): void {},
+    handleInput(data: string): void {
+      if (data === "\u001b" || data === "q" || data === "Q" || data === "\r") done();
+    },
+    render(width: number): string[] {
+      const inner = Math.max(1, Math.min(100, width - 2));
+      const border = theme.fg("border", "+");
+      const rule = theme.fg("border", "-".repeat(inner));
+      return [
+        `${border}${rule}${border}`,
+        `${theme.fg("border", "|")}${lineForWidth("Keiyaku", inner).padEnd(inner)}${theme.fg("border", "|")}`,
+        `${theme.fg("border", "|")}${" ".repeat(inner)}${theme.fg("border", "|")}`,
+        ...lines.map(
+          (line) => `${theme.fg("border", "|")}${lineForWidth(line, inner).padEnd(inner)}${theme.fg("border", "|")}`,
+        ),
+        `${theme.fg("border", "|")}${" ".repeat(inner)}${theme.fg("border", "|")}`,
+        `${theme.fg("border", "|")}${lineForWidth("esc/q/enter close", inner).padEnd(inner)}${theme.fg("border", "|")}`,
+        `${border}${rule}${border}`,
+      ];
+    },
+  };
+}
+
+export default function keiyakuExtension(pi: ExtensionAPI): void {
+  pi.registerCommand("keiyaku", {
+    description: "Open the Kanshi world status",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) return;
+      let body: string[];
+      try {
+        const result = await runStatus(pi);
+        body = result.code === 0 ? result.stdout.trimEnd().split("\n") : [result.stderr.trim() || "status unavailable"];
+      } catch {
+        body = ["status unavailable"];
+      }
+      await ctx.ui.custom<void>((_tui, theme, _keybindings, done) => overlay(body, theme, done), {
+        overlay: true,
+        overlayOptions: { anchor: "center", width: 100, maxHeight: 40 },
+      });
+    },
+  });
+}

package/skills/keiyaku/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: keiyaku
+description: >-
+  Keiyaku is a CLI that records plans, writes handoff terms for deliveries,
+  and calls delegates. Use this skill when you need to figure out which
+  Keiyaku skill or command to reach for.
+---
+
+# Keiyaku
+
+## Model
+
+Keiyaku is three independent pillars, not a bundle: **Task** remembers plans
+and dependencies, **Contract** makes acceptance standing and auditable,
+**Akuma** invokes capability. Use any one alone; combine them only when the
+work calls for it. Behind every Contract in flight there is one holder of its
+fulfillment loop — whoever turns intent into commissions and returns into
+decisions. The flagship holds it by default, and may hand a whole Contract's
+loop to one Aku in a single commission; the harness serves both styles
+equally. See `keiyaku-workflow` for the loop, `keiyaku-bind` for authoring,
+`keiyaku-akuma` for invocation.
+
+## Quick Start
+
+```bash
+keiyaku -C <repo> task add "title"
+keiyaku -C <repo> task start <task-id>
+keiyaku -C <repo> bind [--task <task-id>] -
+keiyaku -C <repo> status
+keiyaku -C <repo> deliver [<contract>|@<contract>]
+keiyaku -C <repo> review [<contract>|@<contract>] --satisfied
+```
+
+`-C` selects the invocation cwd and therefore the World. `--repo <path>` only
+selects the Contract repository; it never retargets that World. `call
+--workdir <path>` selects execution cwd (relative to the effective invocation
+cwd). Without it, the call uses the invocation cwd; `--contract` associates a
+Contract without selecting an execution directory.
+
+`deliver`, `review`, and `audit` may take time after their leading admission.
+Their witnessed progress is ephemeral stderr output; stdout remains one final
+text or JSON result. Ctrl-C asks the owned operation to stop and waits for its
+truthful final receipt, so it is not evidence that an already admitted action
+was rolled back.

package/skills/keiyaku-akuma/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: keiyaku-akuma
+description: >-
+  Use when the work involves Akuma or Aku, or when you want other hands on
+  it: delegating a job, or fanning out research, checks, or other parallel
+  work.
+---
+
+# Keiyaku Akuma
+
+Use Akumas to delegate work to another worker. `call` creates a new Akuma;
+`tell` admits a Tell for an existing Akuma; `ask` admits one and observes its
+exact answer. Keep the complete AkuId, such as `aku/worker/1234abcd`, when you
+need to address the same worker later. An alias such as `@reviewer` is a
+shorter, world-local name.
+
+## Call a new Akuma
+
+```bash
+keiyaku call worker "Summarize the recent changes in src/cli"
+keiyaku call worker --alias @reviewer --wait 10m - < brief.md
+keiyaku call worker
+```
+
+The prompt is optional for prompt-free birth. Otherwise it is the new Akuma's
+first prompt: give it as one argument, or use `-` to read stdin, never both.
+Calls are detached by default: they return the new identity after birth without
+waiting for the first answer. Use explicit `--wait <duration>` when this
+invocation should block while observing that initial work. `--wait` only bounds
+this command; it never stops the Akuma. Read `call --help` for flag syntax,
+defaults, and action vocabulary.
+To hand a Contract role to an Akuma, use the grant table in `keiyaku-workflow`.
+
+The selected Akuma name is a reusable worker configuration, not an individual.
+Calling it again creates an independent Akuma. Use different names for
+capabilities, not merely for parallelism.
+
+## Commission Context
+
+`--contract` only records the association. It does not tell the Akuma the
+Contract or worktree. Put them in the prompt explicitly:
+
+```bash
+keiyaku call worker --contract kei/add-rate-limit-a1b2 --workdir /path/to/worktree - <<'EOF'
+Contract: kei/add-rate-limit-a1b2
+Worktree: /path/to/worktree
+This Arc: implement the limiter and its tests
+EOF
+```
+
+`--contract` does not choose a worktree. Use `--workdir <path>` when needed.
+
+## Tell or ask an existing Akuma
+
+```bash
+keiyaku tell @reviewer "The candidate moved; re-examine the worktree"
+keiyaku tell @reviewer --interrupt - < new-priority.md
+keiyaku ask @reviewer --wait 10m "What is your verdict?"
+keiyaku ask @reviewer --schema verdict.schema.json - < question.md
+```
+
+`tell` admits the next instruction and returns its admission receipt; it does
+not await an answer. `ask` admits a Tell and observes that exact answer,
+unbounded unless `--wait` limits observation. Both require a prompt and accept
+`--interrupt` to put down current work before admitting the new Tell. Schema
+belongs only to `ask`; `tell --schema` and `tell --wait` refuse and point to
+`ask`. A deadline never withdraws an admitted Tell. Read `tell --help` and
+`ask --help` for the complete flag grammar.
+
+## Observe work
+
+```bash
+keiyaku wait @deliverer @reviewer
+keiyaku wait --all --timeout 30m @deliverer @reviewer
+```
+
+Use `wait` for one or more existing Akumas. The default is `--any`; use
+`--all` for every selected Akuma. `--timeout` limits observation and does not
+stop workers. A completed Akuma already counts, so repeating a wait can return
+immediately. See `wait --help` for the complete grammar. Unlike `ask`, `wait`
+observes existing Akuma-wide work, not the answer to a newly admitted Tell.
+
+## Inspect and retrieve results
+
+```bash
+keiyaku status
+keiyaku status @reviewer
+keiyaku ls aku/
+keiyaku ls "aku/*/*"
+keiyaku history @reviewer --last
+keiyaku history @reviewer --id turn/3
+```
+
+`status` shows the roster or one Akuma's workdir and effective actions.
+`ls aku/` shows callable names; `ls "aku/*/*"` shows born workers.
+`history --last` reads the latest complete answer; `history --id` reads an
+exact result named by status or wait. Use the complete AkuId when an alias may
+move; see `history --help` for paging.
+
+## Stop and branch
+
+```bash
+keiyaku kill @reviewer
+keiyaku fork @reviewer --at turn/3
+```
+
+`kill` stops current work without admitting a Tell, deleting the Akuma, or
+removing its history. `fork` creates a new Akuma from one exact retained
+answered history point; the source is unchanged, and providers that cannot
+fork report that refusal. See `kill --help` and `fork --help` for the
+complete grammar.
+
+## JavaScript automation
+
+Use [Automation With The Akuma API](references/automation.md) for a
+task-specific JavaScript coordinator, structured answers, or multi-worker
+orchestration. The CLI is enough for one commission and its return. A
+prompt-free birth followed by one input-bound ask uses the same identity:
+
+```ts
+import { Akuma, Akumas, World } from "@astrosheep/keiyaku";
+
+const root = await World.at(process.cwd());
+const called = await Akumas.of(root).call({ archetype: "worker" });
+const worker = Akuma.select(root, called.akuma);
+const result = await worker.ask("Inspect the change");
+console.log(result.observation);
+```
+
+The automation guide covers schema-based answer handling and longer workflows.