@astrosheep/keiyaku 1.0.0 → 1.0.2

package/build/agents/call-terms_v2.js

@@ -0,0 +1,103 @@
+import { getConfig } from "../config/env.js";
+function maxCaptureCharsForProvider(provider) {
+    const config = getConfig();
+    switch (provider) {
+        case "codex-sdk":
+        case "codex-app-server":
+        case "pi":
+            return config.codex.execMaxCaptureChars;
+        case "claude-agent-sdk":
+            return config.claude.execMaxCaptureChars;
+        case "opencode-sdk":
+            return config.opencode.execMaxCaptureChars;
+    }
+}
+export function buildCallTermsV2(snapshot, prompt, cwd, options) {
+    const runtimeConfig = getConfig();
+    const baseTerms = {
+        workdir: cwd,
+        prompt,
+        idleTimeoutMs: options.idleTimeoutMs ?? runtimeConfig.subagent.execIdleTimeoutMs,
+        maxCaptureChars: maxCaptureCharsForProvider(snapshot.provider.kind),
+        signal: options.signal,
+        projectionDir: options.projectionDir,
+        projectionExecutionId: options.projectionExecutionId,
+        projectionTellFence: options.projectionTellFence,
+        ...(options.initialTurn !== undefined ? { initialTurn: options.initialTurn } : {}),
+    };
+    const body = snapshot.akuma.body;
+    const replayPrompt = body
+        ? `[Akuma system prompt]\n${body}\n\n[Operator prompt]\n${prompt}`
+        : prompt;
+    switch (snapshot.provider.kind) {
+        case "codex-sdk":
+            return {
+                ...baseTerms,
+                prompt: replayPrompt,
+                provider: "codex-sdk",
+                ...(snapshot.akuma.model !== undefined ? { model: snapshot.akuma.model } : {}),
+                ...(snapshot.provider.profile !== undefined ? { profile: snapshot.provider.profile } : {}),
+                ...(snapshot.provider.config !== undefined
+                    ? { config: snapshot.provider.config }
+                    : {}),
+                threadOptions: snapshot.provider.threadOptions,
+                ...(snapshot.provider.executable !== undefined ? { executable: snapshot.provider.executable } : {}),
+            };
+        case "codex-app-server":
+            return {
+                ...baseTerms,
+                provider: "codex-app-server",
+                ...(snapshot.provider.model !== undefined ? { model: snapshot.provider.model } : {}),
+                ...(snapshot.provider.effort !== undefined ? { effort: snapshot.provider.effort } : {}),
+                ...(snapshot.provider.profile !== undefined ? { profile: snapshot.provider.profile } : {}),
+                ...(snapshot.provider.config !== undefined
+                    ? { config: snapshot.provider.config }
+                    : {}),
+                ...(snapshot.provider.executable !== undefined ? { executable: snapshot.provider.executable } : {}),
+                sandboxPolicy: snapshot.provider.sandboxPolicy,
+                approvalPolicy: snapshot.provider.approvalPolicy,
+                developerInstructions: body || undefined,
+                onCheckpoint() { },
+            };
+        case "claude-agent-sdk":
+            return {
+                ...baseTerms,
+                provider: "claude-agent-sdk",
+                ...(snapshot.provider.model !== undefined ? { model: snapshot.provider.model } : {}),
+                ...(snapshot.provider.effort !== undefined ? { effort: snapshot.provider.effort } : {}),
+                ...(snapshot.provider.executable !== undefined ? { executable: snapshot.provider.executable } : {}),
+                ...(snapshot.provider.settingSources !== undefined ? { settingSources: snapshot.provider.settingSources } : {}),
+                permissionMode: snapshot.provider.permissionMode,
+                ...(snapshot.provider.allowDangerouslySkipPermissions !== undefined
+                    ? { allowDangerouslySkipPermissions: snapshot.provider.allowDangerouslySkipPermissions }
+                    : {}),
+                ...(snapshot.provider.disallowedTools !== undefined
+                    ? { disallowedTools: snapshot.provider.disallowedTools }
+                    : {}),
+                systemPrompt: body
+                    ? { type: "preset", preset: "claude_code", append: body }
+                    : undefined,
+                onCheckpoint() { },
+            };
+        case "opencode-sdk":
+            return {
+                ...baseTerms,
+                prompt: replayPrompt,
+                provider: "opencode-sdk",
+                ...(snapshot.provider.model !== undefined ? { model: snapshot.provider.model } : {}),
+                ...(snapshot.provider.effort !== undefined ? { effort: snapshot.provider.effort } : {}),
+                ...(snapshot.provider.executable !== undefined ? { executable: snapshot.provider.executable } : {}),
+            };
+        case "pi":
+            return {
+                ...baseTerms,
+                provider: "pi",
+                ...(snapshot.provider.model !== undefined ? { model: snapshot.provider.model } : {}),
+                ...(snapshot.provider.thinkingLevel !== undefined
+                    ? { thinkingLevel: snapshot.provider.thinkingLevel }
+                    : {}),
+                appendSystemPromptOverride: body ? () => [body] : undefined,
+                onCheckpoint() { },
+            };
+    }
+}

package/build/agents/harness/activity-values.js

@@ -0,0 +1,54 @@
+import { AGENT_EVENT_TEXT_MAX_CHARS } from "./events.js";
+function toolKey(tool) {
+    return tool.toLowerCase().replace(/[-_\s]/g, "");
+}
+/** Classify already-extracted provider facts. This function never reads a provider payload. */
+export function activityCallFromNamedTool(tool, facts) {
+    switch (toolKey(tool)) {
+        case "bash":
+        case "shell":
+        case "commandexecution":
+            return facts.command
+                ? { kind: "run", command: facts.command, ...(facts.description ? { description: facts.description } : {}) }
+                : { kind: "other", display: tool };
+        case "read":
+            return facts.path
+                ? {
+                    kind: "read",
+                    path: facts.path,
+                    ...(facts.offset === undefined && facts.limit === undefined
+                        ? {}
+                        : { range: { ...(facts.offset === undefined ? {} : { offset: facts.offset }), ...(facts.limit === undefined ? {} : { limit: facts.limit }) } }),
+                }
+                : { kind: "other", display: tool };
+        case "write":
+            return facts.path
+                ? { kind: "fileChange", changes: [{ op: "add", path: facts.path }] }
+                : { kind: "other", display: tool };
+        case "edit":
+            return facts.path
+                ? { kind: "fileChange", changes: [{ op: "update", path: facts.path }] }
+                : { kind: "other", display: tool };
+        case "websearch":
+        case "search":
+            return facts.query
+                ? { kind: "search", query: facts.query }
+                : { kind: "other", display: tool };
+        default:
+            return { kind: "other", display: tool };
+    }
+}
+export function boundActivityExcerpt(value) {
+    return value.slice(-AGENT_EVENT_TEXT_MAX_CHARS);
+}
+export function diffstatFromUnifiedPatch(patch) {
+    let additions = 0;
+    let deletions = 0;
+    for (const line of patch.split("\n")) {
+        if (line.startsWith("+") && !line.startsWith("+++"))
+            additions += 1;
+        if (line.startsWith("-") && !line.startsWith("---"))
+            deletions += 1;
+    }
+    return additions || deletions ? { additions, deletions } : undefined;
+}

package/build/agents/harness/event-channel.js

@@ -15,7 +15,7 @@ export function isEventChannelOverflowError(error) {
 /**
  * Bounded async event channel for adapter -> runtime.
  * Hard cap is exactly 10_000 (shared across lifecycle + coalesce slots).
- * Channel is blind to provider raw shapes; coalesce keys are explicit opaque strings.
+ * Consumer-lag overflow saturates observation without failing the producer or consumer.
  */
 export function createEventChannel(options = {}) {
     const queue = [];
@@ -24,6 +24,9 @@ export function createEventChannel(options = {}) {
     const waiters = [];
     let closed = false;
     let failure;
+    let overflowed = false;
+    let overflowMarker;
+    let overflowMarkerPending = false;
     let drained = false;
     let resolveDrained;
     const drainedPromise = new Promise((resolve) => {
@@ -55,8 +58,6 @@ export function createEventChannel(options = {}) {
         while (waiters.length > 0) {
             const waiter = waiters.shift();
             if (failure !== undefined) {
-                // Rejection path marks drained in the waiter reject wrapper below when next() parks;
-                // for direct delivery, mark here after reject so whenDrained observes consumer receipt.
                 markDrained();
                 waiter.reject(failure);
             }
@@ -67,13 +68,40 @@ export function createEventChannel(options = {}) {
         }
     };
     const depth = () => queue.length;
-    const markOverflow = () => {
-        const error = createEventChannelOverflowError();
-        failure = error;
-        closed = true;
-        options.onOverflow?.(error);
-        if (queue.length === 0) {
-            deliverTerminalToWaiters();
+    const storeOverflowMarker = (dropped) => {
+        if (overflowMarkerPending)
+            return;
+        const marker = options.createOverflowMarker ? options.createOverflowMarker(dropped) : dropped;
+        overflowMarker = marker;
+        overflowMarkerPending = true;
+    };
+    const takeOverflowMarker = () => {
+        if (!overflowMarkerPending || overflowMarker === undefined)
+            return undefined;
+        const marker = overflowMarker;
+        overflowMarker = undefined;
+        overflowMarkerPending = false;
+        return marker;
+    };
+    const markOverflow = (dropped) => {
+        overflowed = true;
+        storeOverflowMarker(dropped);
+        const waiter = waiters.shift();
+        if (waiter && queue.length === 0) {
+            const marker = takeOverflowMarker();
+            if (marker !== undefined) {
+                waiter.resolve({ value: marker, done: false });
+            }
+            else if (closed) {
+                markDrained();
+                if (failure !== undefined)
+                    waiter.reject(failure);
+                else
+                    waiter.resolve({ value: undefined, done: true });
+            }
+            else {
+                waiters.unshift(waiter);
+            }
         }
         return "overflow";
     };
@@ -81,6 +109,8 @@ export function createEventChannel(options = {}) {
         push(value, meta) {
             if (closed)
                 return "closed";
+            if (overflowed)
+                return "overflow";
             const coalesceKey = meta?.coalesceKey;
             if (coalesceKey !== undefined) {
                 const existing = coalesceIndex.get(coalesceKey);
@@ -90,11 +120,10 @@ export function createEventChannel(options = {}) {
                     return "accepted";
                 }
                 if (depth() >= EXEC_EVENT_BUFFER_HARD_CAP) {
-                    return markOverflow();
+                    return markOverflow(value);
                 }
                 const waiter = waiters.shift();
                 if (waiter) {
-                    // Direct delivery to a waiting consumer: nothing remains queued for this key.
                     waiter.resolve({ value, done: false });
                     return "accepted";
                 }
@@ -102,9 +131,9 @@ export function createEventChannel(options = {}) {
                 queue.push({ value, coalesceKey });
                 return "accepted";
             }
-            // Lifecycle: never coalesce or drop.
+            // Lifecycle: never coalesce.
             if (depth() >= EXEC_EVENT_BUFFER_HARD_CAP) {
-                return markOverflow();
+                return markOverflow(value);
             }
             const waiter = waiters.shift();
             if (waiter) {
@@ -118,8 +147,7 @@ export function createEventChannel(options = {}) {
             if (closed)
                 return;
             closed = true;
-            // Empty queue + no waiter: leave whenDrained pending until consumer pulls done.
-            if (queue.length === 0) {
+            if (queue.length === 0 && !overflowMarkerPending) {
                 deliverTerminalToWaiters();
             }
         },
@@ -128,8 +156,7 @@ export function createEventChannel(options = {}) {
                 return;
             closed = true;
             failure = error;
-            // Empty queue + no waiter: leave whenDrained pending until consumer pulls rejection.
-            if (queue.length === 0) {
+            if (queue.length === 0 && !overflowMarkerPending) {
                 deliverTerminalToWaiters();
             }
         },
@@ -137,6 +164,12 @@ export function createEventChannel(options = {}) {
             return drainedPromise;
         },
         depth,
+        peekCoalesced(coalesceKey) {
+            const index = coalesceIndex.get(coalesceKey);
+            if (index === undefined)
+                return undefined;
+            return queue[index]?.value;
+        },
         iterable: {
             [Symbol.asyncIterator]() {
                 return {
@@ -144,10 +177,12 @@ export function createEventChannel(options = {}) {
                         if (queue.length > 0) {
                             const entry = queue.shift();
                             reindexCoalesceKeys();
-                            // After the last item leaves under a closed/failed producer, the next next()
-                            // (or a parked waiter) must still receive the terminal signal.
                             return Promise.resolve({ value: entry.value, done: false });
                         }
+                        const marker = takeOverflowMarker();
+                        if (marker !== undefined) {
+                            return Promise.resolve({ value: marker, done: false });
+                        }
                         if (failure !== undefined) {
                             markDrained();
                             return Promise.reject(failure);

package/build/agents/harness/events.js

@@ -1 +1,47 @@
-export {};
+import { z } from "zod";
+export const AGENT_EVENT_TEXT_MAX_CHARS = 4_096;
+export const AGENT_THOUGHT_TEXT_MAX_CHARS = 4_000;
+export const AGENT_PLAN_MAX_ITEMS = 64;
+export const AGENT_PLAN_ITEM_TEXT_MAX_CHARS = 200;
+export const AGENT_ACTIVITY_MAX_CHANGES = 32;
+export const AGENT_UNKNOWN_PAYLOAD_MAX_CHARS = 4_096;
+export const activityCallSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("run"), command: z.string(), description: z.string().optional() }).strict(),
+    z.object({
+        kind: z.literal("read"),
+        path: z.string(),
+        range: z.object({ offset: z.number().finite().optional(), limit: z.number().finite().optional() }).strict().optional(),
+    }).strict(),
+    z.object({ kind: z.literal("search"), query: z.string() }).strict(),
+    z.object({
+        kind: z.literal("fileChange"),
+        changes: z.array(z.object({ op: z.enum(["add", "update", "delete"]), path: z.string() }).strict()),
+        omittedChanges: z.number().int().nonnegative().optional(),
+    }).strict(),
+    z.object({ kind: z.literal("other"), display: z.string() }).strict(),
+]);
+export const activityResultSchema = z.object({
+    status: z.enum(["ok", "error"]),
+    message: z.string().optional(),
+    exitCode: z.number().finite().optional(),
+    diffstat: z.object({
+        additions: z.number().int().nonnegative(),
+        deletions: z.number().int().nonnegative(),
+    }).strict().optional(),
+}).strict();
+export const activityEventBodySchema = z.object({
+    type: z.literal("activity"),
+    phase: z.enum(["started", "updated", "completed"]),
+    id: z.string(),
+    tool: z.string(),
+    call: activityCallSchema,
+    result: activityResultSchema.optional(),
+    truncated: z.literal(true).optional(),
+}).strict().superRefine((value, context) => {
+    if (value.phase === "started" && value.result !== undefined) {
+        context.addIssue({ code: "custom", path: ["result"], message: "started activity cannot carry a result" });
+    }
+    if (value.phase === "completed" && value.result === undefined) {
+        context.addIssue({ code: "custom", path: ["result"], message: "completed activity requires a result" });
+    }
+});