@nebutra/agent-runtime 0.2.0

package/dist/chunk-37BBB2P2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/rollout.ts"],"sourcesContent":["/**\n * Event-sourced rollout / session trace (WRAP — capability #7).\n *\n * Faithful re-expression of the upstream rollout model: an append-only typed\n * event log, state derived by replay, a first-class context-compaction marker\n * (so replay stays bounded), and a per-item persistence policy that sanitizes\n * and size-caps outputs before they are durable.\n *\n * Multi-tenant adaptation: every rollout line carries `tenantId`; the store\n * interface is tenant-scoped so a Postgres/ClickHouse-backed implementation\n * (via `@nebutra/audit` providers / `@nebutra/db`) replaces the upstream\n * single-host jsonl + embedded-SQLite assumptions. Only an in-memory\n * reference store ships here.\n */\n\nimport type { ThreadEvent, ThreadItem, TurnConfig } from \"./model\";\n\n/** Cap mirrors the upstream persisted-output ceiling. */\nexport const PERSISTED_OUTPUT_MAX_BYTES = 10_000;\n\nexport type EventPersistenceMode = \"limited\" | \"extended\";\n\n/** One durable line in a thread's append-only log. */\nexport type RolloutLine =\n  | {\n      readonly tenantId: string;\n      readonly threadId: string;\n      readonly type: \"session_meta\";\n      readonly config: TurnConfig;\n      readonly at: string;\n    }\n  | {\n      readonly tenantId: string;\n      readonly threadId: string;\n      readonly type: \"event\";\n      readonly event: ThreadEvent;\n      readonly at: string;\n    }\n  | {\n      readonly tenantId: string;\n      readonly threadId: string;\n      readonly type: \"turn_context\";\n      readonly config: TurnConfig;\n      readonly at: string;\n    }\n  | {\n      readonly tenantId: string;\n      readonly threadId: string;\n      readonly type: \"compacted\";\n      readonly summary: string;\n      readonly droppedThrough: string;\n      readonly at: string;\n    };\n\n/**\n * Persistence policy: decide per item whether it is durable, and sanitize +\n * size-cap its output first. Executive markers are always persisted.\n */\nexport function isPersisted(item: ThreadItem, mode: EventPersistenceMode): boolean {\n  if (item.type === \"reasoning\") return mode === \"extended\";\n  return true;\n}\n\n/** Truncate aggregated command output to the persisted ceiling. */\nexport function sanitizeForPersist(item: ThreadItem): ThreadItem {\n  if (item.type !== \"command_execution\") return item;\n  const bytes = Buffer.byteLength(item.aggregatedOutput, \"utf8\");\n  if (bytes <= PERSISTED_OUTPUT_MAX_BYTES) return item;\n  const truncated = Buffer.from(item.aggregatedOutput, \"utf8\")\n    .subarray(0, PERSISTED_OUTPUT_MAX_BYTES)\n    .toString(\"utf8\");\n  return { ...item, aggregatedOutput: `${truncated}\\n…[truncated]` };\n}\n\n/** Tenant-scoped append-only store. Replace the impl, keep the interface. */\nexport interface RolloutStore {\n  append(line: RolloutLine): Promise<void>;\n  /** Lines for a thread, in append order. */\n  read(tenantId: string, threadId: string): Promise<readonly RolloutLine[]>;\n}\n\n/** In-memory reference store (dev/test only — never multi-instance safe). */\nexport class InMemoryRolloutStore implements RolloutStore {\n  readonly #lines = new Map<string, RolloutLine[]>();\n\n  #key(tenantId: string, threadId: string): string {\n    return `${tenantId}::${threadId}`;\n  }\n\n  async append(line: RolloutLine): Promise<void> {\n    const key = this.#key(line.tenantId, line.threadId);\n    const list = this.#lines.get(key) ?? [];\n    list.push(line);\n    this.#lines.set(key, list);\n  }\n\n  async read(tenantId: string, threadId: string): Promise<readonly RolloutLine[]> {\n    return [...(this.#lines.get(this.#key(tenantId, threadId)) ?? [])];\n  }\n}\n\n/** Derived thread state — the projection rebuilt by replaying the log. */\nexport interface ThreadProjection {\n  readonly tenantId: string;\n  readonly threadId: string;\n  config?: TurnConfig;\n  readonly items: ThreadItem[];\n  /** Marks where a compaction summary replaced earlier history. */\n  compactionSummary?: string;\n}\n\n/**\n * Replay an append-only log into derived state. A `compacted` line bounds\n * replay: items prior to it are represented by the summary, not re-applied.\n */\nexport function replay(lines: readonly RolloutLine[]): ThreadProjection | null {\n  const first = lines[0];\n  if (!first) return null;\n  const projection: ThreadProjection = {\n    tenantId: first.tenantId,\n    threadId: first.threadId,\n    items: [],\n  };\n  for (const line of lines) {\n    switch (line.type) {\n      case \"session_meta\":\n      case \"turn_context\":\n        projection.config = line.config;\n        break;\n      case \"compacted\":\n        projection.compactionSummary = line.summary;\n        projection.items.length = 0;\n        break;\n      case \"event\": {\n        const e = line.event;\n        if (e.type === \"item.completed\" || e.type === \"item.started\") {\n          const idx = projection.items.findIndex((i) => i.id === e.item.id);\n          if (idx >= 0) projection.items[idx] = e.item;\n          else projection.items.push(e.item);\n        } else if (e.type === \"item.updated\") {\n          const idx = projection.items.findIndex((i) => i.id === e.item.id);\n          if (idx >= 0) projection.items[idx] = e.item;\n          else projection.items.push(e.item);\n        }\n        break;\n      }\n    }\n  }\n  return projection;\n}\n"],"mappings":";AAkBO,IAAM,6BAA6B;AAwCnC,SAAS,YAAY,MAAkB,MAAqC;AACjF,MAAI,KAAK,SAAS,YAAa,QAAO,SAAS;AAC/C,SAAO;AACT;AAGO,SAAS,mBAAmB,MAA8B;AAC/D,MAAI,KAAK,SAAS,oBAAqB,QAAO;AAC9C,QAAM,QAAQ,OAAO,WAAW,KAAK,kBAAkB,MAAM;AAC7D,MAAI,SAAS,2BAA4B,QAAO;AAChD,QAAM,YAAY,OAAO,KAAK,KAAK,kBAAkB,MAAM,EACxD,SAAS,GAAG,0BAA0B,EACtC,SAAS,MAAM;AAClB,SAAO,EAAE,GAAG,MAAM,kBAAkB,GAAG,SAAS;AAAA,mBAAiB;AACnE;AAUO,IAAM,uBAAN,MAAmD;AAAA,EAC/C,SAAS,oBAAI,IAA2B;AAAA,EAEjD,KAAK,UAAkB,UAA0B;AAC/C,WAAO,GAAG,QAAQ,KAAK,QAAQ;AAAA,EACjC;AAAA,EAEA,MAAM,OAAO,MAAkC;AAC7C,UAAM,MAAM,KAAK,KAAK,KAAK,UAAU,KAAK,QAAQ;AAClD,UAAM,OAAO,KAAK,OAAO,IAAI,GAAG,KAAK,CAAC;AACtC,SAAK,KAAK,IAAI;AACd,SAAK,OAAO,IAAI,KAAK,IAAI;AAAA,EAC3B;AAAA,EAEA,MAAM,KAAK,UAAkB,UAAmD;AAC9E,WAAO,CAAC,GAAI,KAAK,OAAO,IAAI,KAAK,KAAK,UAAU,QAAQ,CAAC,KAAK,CAAC,CAAE;AAAA,EACnE;AACF;AAgBO,SAAS,OAAO,OAAwD;AAC7E,QAAM,QAAQ,MAAM,CAAC;AACrB,MAAI,CAAC,MAAO,QAAO;AACnB,QAAM,aAA+B;AAAA,IACnC,UAAU,MAAM;AAAA,IAChB,UAAU,MAAM;AAAA,IAChB,OAAO,CAAC;AAAA,EACV;AACA,aAAW,QAAQ,OAAO;AACxB,YAAQ,KAAK,MAAM;AAAA,MACjB,KAAK;AAAA,MACL,KAAK;AACH,mBAAW,SAAS,KAAK;AACzB;AAAA,MACF,KAAK;AACH,mBAAW,oBAAoB,KAAK;AACpC,mBAAW,MAAM,SAAS;AAC1B;AAAA,MACF,KAAK,SAAS;AACZ,cAAM,IAAI,KAAK;AACf,YAAI,EAAE,SAAS,oBAAoB,EAAE,SAAS,gBAAgB;AAC5D,gBAAM,MAAM,WAAW,MAAM,UAAU,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE;AAChE,cAAI,OAAO,EAAG,YAAW,MAAM,GAAG,IAAI,EAAE;AAAA,cACnC,YAAW,MAAM,KAAK,EAAE,IAAI;AAAA,QACnC,WAAW,EAAE,SAAS,gBAAgB;AACpC,gBAAM,MAAM,WAAW,MAAM,UAAU,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE;AAChE,cAAI,OAAO,EAAG,YAAW,MAAM,GAAG,IAAI,EAAE;AAAA,cACnC,YAAW,MAAM,KAAK,EAAE,IAAI;AAAA,QACnC;AACA;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;","names":[]}

package/dist/chunk-57W3AR43.js

@@ -0,0 +1,52 @@
+// src/adapters/prisma-rollout.ts
+import { z } from "zod";
+var recordSchema = z.object({
+  tenantId: z.string().min(1, "tenantId is required"),
+  threadId: z.string().min(1, "threadId is required"),
+  seq: z.number().int().nonnegative(),
+  at: z.string().min(1),
+  payload: z.string()
+});
+var querySchema = z.object({
+  tenantId: z.string().min(1, "tenantId is required"),
+  threadId: z.string().min(1, "threadId is required")
+});
+async function resolve(resolver, tenantId) {
+  return typeof resolver === "function" ? resolver(tenantId) : resolver;
+}
+function createPrismaRolloutPersistence(delegate) {
+  return {
+    async put(record) {
+      const r = recordSchema.parse(record);
+      const at = new Date(r.at);
+      if (Number.isNaN(at.getTime())) {
+        throw new Error(`invalid timestamp: ${r.at}`);
+      }
+      const db = await resolve(delegate, r.tenantId);
+      await db.create({
+        data: {
+          tenantId: r.tenantId,
+          threadId: r.threadId,
+          seq: r.seq,
+          at,
+          payload: r.payload
+        }
+      });
+    },
+    async list(tenantId, threadId) {
+      const q = querySchema.parse({ tenantId, threadId });
+      const db = await resolve(delegate, q.tenantId);
+      const rows = await db.findMany({
+        where: { tenantId: q.tenantId, threadId: q.threadId },
+        orderBy: { seq: "asc" },
+        select: { seq: true, payload: true }
+      });
+      return rows.map((row) => ({ seq: row.seq, payload: row.payload }));
+    }
+  };
+}
+
+export {
+  createPrismaRolloutPersistence
+};
+//# sourceMappingURL=chunk-57W3AR43.js.map

package/dist/chunk-57W3AR43.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/adapters/prisma-rollout.ts"],"sourcesContent":["/**\n * Durable rollout-store backend: `RolloutPersistencePort` over Prisma.\n *\n * This is the fail-loud system-of-record adapter (table `agent_rollout_lines`,\n * migration `20260519000000_add_agent_rollout_store`). Unlike a best-effort\n * audit log it never swallows a failed write — a rejected `put` propagates so\n * the caller's \"never silently drop\" contract holds.\n *\n * Reusability: it depends only on a minimal injected delegate (the\n * `PrismaAuditDelegate` pattern), NOT on the generated Prisma client or\n * `@nebutra/db`. Any tenant-scoped Prisma client (`getTenantDb(orgId)`)\n * structurally satisfies it, so this package stays dependency-light.\n */\n\nimport { z } from \"zod\";\nimport type { RolloutPersistencePort } from \"../rollout-store-persistent\";\n\n/**\n * Minimal structural slice of `prisma.agentRolloutLine`. Decoupled from the\n * generated client on purpose — only these two operations are needed.\n */\nexport interface PrismaRolloutDelegate {\n  create(args: {\n    data: {\n      tenantId: string;\n      threadId: string;\n      seq: number;\n      at: Date;\n      payload: string;\n    };\n  }): Promise<unknown>;\n  findMany(args: {\n    where: { tenantId: string; threadId: string };\n    orderBy: { seq: \"asc\" };\n    select: { seq: true; payload: true };\n  }): Promise<{ seq: number; payload: string }[]>;\n}\n\n/** Resolves the delegate per call so a request-scoped (RLS) client can be used. */\nexport type RolloutDelegateResolver =\n  | PrismaRolloutDelegate\n  | ((tenantId: string) => PrismaRolloutDelegate | Promise<PrismaRolloutDelegate>);\n\nconst recordSchema = z.object({\n  tenantId: z.string().min(1, \"tenantId is required\"),\n  threadId: z.string().min(1, \"threadId is required\"),\n  seq: z.number().int().nonnegative(),\n  at: z.string().min(1),\n  payload: z.string(),\n});\n\nconst querySchema = z.object({\n  tenantId: z.string().min(1, \"tenantId is required\"),\n  threadId: z.string().min(1, \"threadId is required\"),\n});\n\nasync function resolve(\n  resolver: RolloutDelegateResolver,\n  tenantId: string,\n): Promise<PrismaRolloutDelegate> {\n  return typeof resolver === \"function\" ? resolver(tenantId) : resolver;\n}\n\n/**\n * Build a {@link RolloutPersistencePort} backed by Prisma.\n *\n * @param delegate a `PrismaRolloutDelegate`, or a resolver mapping a tenantId\n *   to one (use the latter to obtain a per-tenant RLS client per call).\n */\nexport function createPrismaRolloutPersistence(\n  delegate: RolloutDelegateResolver,\n): RolloutPersistencePort {\n  return {\n    async put(record): Promise<void> {\n      const r = recordSchema.parse(record);\n      const at = new Date(r.at);\n      if (Number.isNaN(at.getTime())) {\n        throw new Error(`invalid timestamp: ${r.at}`);\n      }\n      const db = await resolve(delegate, r.tenantId);\n      // Fail-loud: any persistence rejection propagates to the caller.\n      await db.create({\n        data: {\n          tenantId: r.tenantId,\n          threadId: r.threadId,\n          seq: r.seq,\n          at,\n          payload: r.payload,\n        },\n      });\n    },\n\n    async list(tenantId, threadId): Promise<{ seq: number; payload: string }[]> {\n      const q = querySchema.parse({ tenantId, threadId });\n      const db = await resolve(delegate, q.tenantId);\n      const rows = await db.findMany({\n        where: { tenantId: q.tenantId, threadId: q.threadId },\n        orderBy: { seq: \"asc\" },\n        select: { seq: true, payload: true },\n      });\n      return rows.map((row) => ({ seq: row.seq, payload: row.payload }));\n    },\n  };\n}\n"],"mappings":";AAcA,SAAS,SAAS;AA6BlB,IAAM,eAAe,EAAE,OAAO;AAAA,EAC5B,UAAU,EAAE,OAAO,EAAE,IAAI,GAAG,sBAAsB;AAAA,EAClD,UAAU,EAAE,OAAO,EAAE,IAAI,GAAG,sBAAsB;AAAA,EAClD,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY;AAAA,EAClC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EACpB,SAAS,EAAE,OAAO;AACpB,CAAC;AAED,IAAM,cAAc,EAAE,OAAO;AAAA,EAC3B,UAAU,EAAE,OAAO,EAAE,IAAI,GAAG,sBAAsB;AAAA,EAClD,UAAU,EAAE,OAAO,EAAE,IAAI,GAAG,sBAAsB;AACpD,CAAC;AAED,eAAe,QACb,UACA,UACgC;AAChC,SAAO,OAAO,aAAa,aAAa,SAAS,QAAQ,IAAI;AAC/D;AAQO,SAAS,+BACd,UACwB;AACxB,SAAO;AAAA,IACL,MAAM,IAAI,QAAuB;AAC/B,YAAM,IAAI,aAAa,MAAM,MAAM;AACnC,YAAM,KAAK,IAAI,KAAK,EAAE,EAAE;AACxB,UAAI,OAAO,MAAM,GAAG,QAAQ,CAAC,GAAG;AAC9B,cAAM,IAAI,MAAM,sBAAsB,EAAE,EAAE,EAAE;AAAA,MAC9C;AACA,YAAM,KAAK,MAAM,QAAQ,UAAU,EAAE,QAAQ;AAE7C,YAAM,GAAG,OAAO;AAAA,QACd,MAAM;AAAA,UACJ,UAAU,EAAE;AAAA,UACZ,UAAU,EAAE;AAAA,UACZ,KAAK,EAAE;AAAA,UACP;AAAA,UACA,SAAS,EAAE;AAAA,QACb;AAAA,MACF,CAAC;AAAA,IACH;AAAA,IAEA,MAAM,KAAK,UAAU,UAAuD;AAC1E,YAAM,IAAI,YAAY,MAAM,EAAE,UAAU,SAAS,CAAC;AAClD,YAAM,KAAK,MAAM,QAAQ,UAAU,EAAE,QAAQ;AAC7C,YAAM,OAAO,MAAM,GAAG,SAAS;AAAA,QAC7B,OAAO,EAAE,UAAU,EAAE,UAAU,UAAU,EAAE,SAAS;AAAA,QACpD,SAAS,EAAE,KAAK,MAAM;AAAA,QACtB,QAAQ,EAAE,KAAK,MAAM,SAAS,KAAK;AAAA,MACrC,CAAC;AACD,aAAO,KAAK,IAAI,CAAC,SAAS,EAAE,KAAK,IAAI,KAAK,SAAS,IAAI,QAAQ,EAAE;AAAA,IACnE;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-5N4644PB.js

@@ -0,0 +1,67 @@
+import {
+  isTurnTerminal
+} from "./chunk-6EGG2OZC.js";
+import {
+  replay
+} from "./chunk-37BBB2P2.js";
+
+// src/durable-turn.ts
+import { z } from "zod";
+var DURABLE_TURN_JOB = "agent-runtime.durable-turn";
+var contextSchema = z.object({
+  tenantId: z.string().min(1),
+  threadId: z.string().min(1)
+});
+var jobPayloadSchema = z.object({
+  tenantId: z.string().min(1),
+  threadId: z.string().min(1),
+  input: z.string()
+});
+function turnIdFor(tenantId, threadId) {
+  return `${DURABLE_TURN_JOB}:${tenantId}:${threadId}`;
+}
+function recordedEvents(lines) {
+  return lines.flatMap((line) => line.type === "event" ? [line.event] : []);
+}
+function createDurableTurn(deps) {
+  const { store, queue, runner } = deps;
+  queue.registerHandler(DURABLE_TURN_JOB, async (payload) => {
+    const { tenantId, threadId, input } = jobPayloadSchema.parse(payload);
+    const gen = runner(input, { tenantId, threadId });
+    for await (const _event of gen) {
+    }
+  });
+  async function start(input, ctx) {
+    const { tenantId, threadId } = contextSchema.parse(ctx);
+    const turnId = turnIdFor(tenantId, threadId);
+    await queue.enqueue({
+      name: DURABLE_TURN_JOB,
+      jobId: turnId,
+      payload: { tenantId, threadId, input }
+    });
+    return { turnId };
+  }
+  async function* resume(tenantId, threadId) {
+    const scope = contextSchema.parse({ tenantId, threadId });
+    const lines = await store.read(scope.tenantId, scope.threadId);
+    const projection = replay(lines);
+    const events = recordedEvents(lines);
+    const last = events[events.length - 1];
+    if (projection && last && isTurnTerminal(last)) {
+      for (const event of events) yield event;
+      return;
+    }
+    const input = "";
+    const gen = runner(input, {
+      tenantId: scope.tenantId,
+      threadId: scope.threadId
+    });
+    for await (const event of gen) yield event;
+  }
+  return { start, resume };
+}
+
+export {
+  createDurableTurn
+};
+//# sourceMappingURL=chunk-5N4644PB.js.map

package/dist/chunk-5N4644PB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/durable-turn.ts"],"sourcesContent":["/**\n * Durable / resumable turn (WRAP — capability #10).\n *\n * Wraps the existing {@link runTurn} async generator so a turn survives a\n * process crash. `start` enqueues a tenant+thread-scoped durable job whose\n * handler drains `runTurn` (the loop runner already appends every event to the\n * tenant-scoped {@link RolloutStore}); the durable layer guarantees the job is\n * replayable if the worker dies mid-turn. `resume` inspects the persisted\n * rollout: if the last recorded event is non-terminal the turn is re-driven to\n * completion, otherwise the recorded terminal stream is replayed.\n *\n * Queue binding is interface-only — callers wire `@nebutra/queue` by\n * implementing {@link DurableTurnQueuePort}; this package never depends on it.\n * Tenant scoping is mandatory and fail-closed: a missing tenant or thread\n * throws, and resume can never read another tenant's rollout.\n */\n\nimport { z } from \"zod\";\nimport type { ThreadEvent } from \"./model\";\nimport { isTurnTerminal } from \"./model\";\nimport { type RolloutLine, type RolloutStore, replay } from \"./rollout\";\n\n/** A durable job handed to the queue. Mirrors `@nebutra/queue` job shape. */\nexport interface DurableTurnJob {\n  /** Logical job name — used for handler routing. */\n  readonly name: string;\n  /** Tenant+thread-scoped id; the queue must de-dupe / make idempotent on it. */\n  readonly jobId: string;\n  /** Opaque Zod-validated payload (kept narrow on purpose). */\n  readonly payload: unknown;\n}\n\n/**\n * Minimal injectable queue seam (enqueue + handler registration). Mirrors\n * `@nebutra/queue`'s `defineQueueJob` / `createJobRouter` contract without a\n * hard dependency, so this package stays provider-agnostic.\n */\nexport interface DurableTurnQueuePort {\n  enqueue(job: DurableTurnJob): Promise<void>;\n  registerHandler(name: string, handler: (payload: unknown) => Promise<void>): void;\n}\n\n/** Drives one turn, yielding the event stream (persists internally). */\nexport type DurableTurnRunner = (input: string, ctx: TurnContext) => AsyncGenerator<ThreadEvent>;\n\nexport interface TurnContext {\n  readonly tenantId: string;\n  readonly threadId: string;\n}\n\nexport interface CreateDurableTurnDeps {\n  readonly store: RolloutStore;\n  readonly queue: DurableTurnQueuePort;\n  readonly runner: DurableTurnRunner;\n}\n\nexport interface DurableTurn {\n  start(input: string, ctx: TurnContext): Promise<{ readonly turnId: string }>;\n  resume(tenantId: string, threadId: string): AsyncGenerator<ThreadEvent>;\n}\n\nconst DURABLE_TURN_JOB = \"agent-runtime.durable-turn\";\n\nconst contextSchema = z.object({\n  tenantId: z.string().min(1),\n  threadId: z.string().min(1),\n});\n\nconst jobPayloadSchema = z.object({\n  tenantId: z.string().min(1),\n  threadId: z.string().min(1),\n  input: z.string(),\n});\n\n/** Tenant+thread-scoped, stable job id (idempotency key on the queue). */\nfunction turnIdFor(tenantId: string, threadId: string): string {\n  return `${DURABLE_TURN_JOB}:${tenantId}:${threadId}`;\n}\n\n/** Recorded `ThreadEvent`s in append order, tenant-scoped via the store read. */\nfunction recordedEvents(lines: readonly RolloutLine[]): ThreadEvent[] {\n  return lines.flatMap((line) => (line.type === \"event\" ? [line.event] : []));\n}\n\nexport function createDurableTurn(deps: CreateDurableTurnDeps): DurableTurn {\n  const { store, queue, runner } = deps;\n\n  // Register the durable handler once: drain the runner so every event is\n  // persisted by the loop runner. Crash before/within = job stays replayable.\n  queue.registerHandler(DURABLE_TURN_JOB, async (payload: unknown) => {\n    const { tenantId, threadId, input } = jobPayloadSchema.parse(payload);\n    const gen = runner(input, { tenantId, threadId });\n    for await (const _event of gen) {\n      // The runner persists each event; nothing to do but exhaust it.\n    }\n  });\n\n  async function start(input: string, ctx: TurnContext): Promise<{ readonly turnId: string }> {\n    const { tenantId, threadId } = contextSchema.parse(ctx);\n    const turnId = turnIdFor(tenantId, threadId);\n    await queue.enqueue({\n      name: DURABLE_TURN_JOB,\n      jobId: turnId,\n      payload: { tenantId, threadId, input },\n    });\n    return { turnId };\n  }\n\n  async function* resume(tenantId: string, threadId: string): AsyncGenerator<ThreadEvent> {\n    const scope = contextSchema.parse({ tenantId, threadId });\n    // Tenant-scoped read — cross-tenant resume is structurally impossible.\n    const lines = await store.read(scope.tenantId, scope.threadId);\n    const projection = replay(lines);\n    const events = recordedEvents(lines);\n    const last = events[events.length - 1];\n\n    if (projection && last && isTurnTerminal(last)) {\n      // Completed turn — replay the recorded stream, append nothing.\n      for (const event of events) yield event;\n      return;\n    }\n\n    // Unfinished (crash) or never-started — re-drive to completion. The runner\n    // appends fresh lines; we recover the original input from the rollout if\n    // present, else an empty resume prompt (turn is replay-driven thereafter).\n    const input = \"\";\n    const gen = runner(input, {\n      tenantId: scope.tenantId,\n      threadId: scope.threadId,\n    });\n    for await (const event of gen) yield event;\n  }\n\n  return { start, resume };\n}\n"],"mappings":";;;;;;;;AAiBA,SAAS,SAAS;AA4ClB,IAAM,mBAAmB;AAEzB,IAAM,gBAAgB,EAAE,OAAO;AAAA,EAC7B,UAAU,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EAC1B,UAAU,EAAE,OAAO,EAAE,IAAI,CAAC;AAC5B,CAAC;AAED,IAAM,mBAAmB,EAAE,OAAO;AAAA,EAChC,UAAU,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EAC1B,UAAU,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EAC1B,OAAO,EAAE,OAAO;AAClB,CAAC;AAGD,SAAS,UAAU,UAAkB,UAA0B;AAC7D,SAAO,GAAG,gBAAgB,IAAI,QAAQ,IAAI,QAAQ;AACpD;AAGA,SAAS,eAAe,OAA8C;AACpE,SAAO,MAAM,QAAQ,CAAC,SAAU,KAAK,SAAS,UAAU,CAAC,KAAK,KAAK,IAAI,CAAC,CAAE;AAC5E;AAEO,SAAS,kBAAkB,MAA0C;AAC1E,QAAM,EAAE,OAAO,OAAO,OAAO,IAAI;AAIjC,QAAM,gBAAgB,kBAAkB,OAAO,YAAqB;AAClE,UAAM,EAAE,UAAU,UAAU,MAAM,IAAI,iBAAiB,MAAM,OAAO;AACpE,UAAM,MAAM,OAAO,OAAO,EAAE,UAAU,SAAS,CAAC;AAChD,qBAAiB,UAAU,KAAK;AAAA,IAEhC;AAAA,EACF,CAAC;AAED,iBAAe,MAAM,OAAe,KAAwD;AAC1F,UAAM,EAAE,UAAU,SAAS,IAAI,cAAc,MAAM,GAAG;AACtD,UAAM,SAAS,UAAU,UAAU,QAAQ;AAC3C,UAAM,MAAM,QAAQ;AAAA,MAClB,MAAM;AAAA,MACN,OAAO;AAAA,MACP,SAAS,EAAE,UAAU,UAAU,MAAM;AAAA,IACvC,CAAC;AACD,WAAO,EAAE,OAAO;AAAA,EAClB;AAEA,kBAAgB,OAAO,UAAkB,UAA+C;AACtF,UAAM,QAAQ,cAAc,MAAM,EAAE,UAAU,SAAS,CAAC;AAExD,UAAM,QAAQ,MAAM,MAAM,KAAK,MAAM,UAAU,MAAM,QAAQ;AAC7D,UAAM,aAAa,OAAO,KAAK;AAC/B,UAAM,SAAS,eAAe,KAAK;AACnC,UAAM,OAAO,OAAO,OAAO,SAAS,CAAC;AAErC,QAAI,cAAc,QAAQ,eAAe,IAAI,GAAG;AAE9C,iBAAW,SAAS,OAAQ,OAAM;AAClC;AAAA,IACF;AAKA,UAAM,QAAQ;AACd,UAAM,MAAM,OAAO,OAAO;AAAA,MACxB,UAAU,MAAM;AAAA,MAChB,UAAU,MAAM;AAAA,IAClB,CAAC;AACD,qBAAiB,SAAS,IAAK,OAAM;AAAA,EACvC;AAEA,SAAO,EAAE,OAAO,OAAO;AACzB;","names":[]}

package/dist/chunk-5YS7WAPS.js

@@ -0,0 +1,177 @@
+// src/subagents.ts
+import { z } from "zod";
+function resolveSubagentTools(fm, allTools) {
+  const deny = new Set(fm.disallowedTools);
+  const allow = fm.allowedTools;
+  if (allow.length === 0) {
+    return allTools.filter((t) => !deny.has(t));
+  }
+  const allowSet = new Set(allow);
+  return allTools.filter((t) => allowSet.has(t) && !deny.has(t));
+}
+function isIncompleteToolCall(item) {
+  if (item.type === "mcp_tool_call" || item.type === "command_execution") {
+    return item.status === "in_progress";
+  }
+  return false;
+}
+function filterIncompleteToolCalls(items) {
+  return items.filter((it) => !isIncompleteToolCall(it));
+}
+function directiveItem(idSeed, brief) {
+  return { id: `brief_${idSeed}`, type: "agent_message", text: brief };
+}
+function prepareDispatch(input) {
+  const { definition, mode, parentItems, brief, ctx, allTools } = input;
+  if (!ctx.tenantId) throw new Error("DispatchCtx.tenantId is required");
+  if (definition.tenantId !== ctx.tenantId) {
+    throw new Error("subagent definition belongs to a different tenant (fail closed)");
+  }
+  const trimmedBrief = brief.trim();
+  const fm = definition.frontmatter;
+  const toolScope = resolveSubagentTools(fm, allTools ?? fm.allowedTools);
+  let initialContext;
+  if (mode === "spawn") {
+    if (!trimmedBrief) {
+      throw new Error(
+        "spawn dispatch requires a non-empty brief \u2014 caller must fully brief the child"
+      );
+    }
+    initialContext = [directiveItem(definition.slug, trimmedBrief)];
+  } else {
+    const inherited = parentItems ? filterIncompleteToolCalls(parentItems) : [];
+    initialContext = trimmedBrief ? [...inherited, directiveItem(definition.slug, trimmedBrief)] : [...inherited];
+  }
+  const modelOverride = fm.model && fm.model !== "inherit" ? fm.model : void 0;
+  return {
+    initialContext,
+    toolScope,
+    systemPromptRef: definition.bodyRef,
+    ...modelOverride ? { modelOverride } : {}
+  };
+}
+var TASK_KINDS = ["subagent", "deferred"];
+var TASK_STATUSES = ["pending", "running", "completed", "failed", "killed"];
+var LEGAL = {
+  pending: ["running", "killed", "failed"],
+  running: ["completed", "failed", "killed"],
+  completed: [],
+  failed: [],
+  killed: []
+};
+var TERMINAL = /* @__PURE__ */ new Set(["completed", "failed", "killed"]);
+var __seq = 0;
+function nextTaskId() {
+  __seq += 1;
+  return `task_${Date.now().toString(36)}_${__seq.toString(36)}`;
+}
+function requireTenant(tenantId) {
+  if (!tenantId) throw new Error("tenantId is required (fail closed)");
+}
+var TaskRegistry = class {
+  #tasks = /* @__PURE__ */ new Map();
+  create(tenantId, kind) {
+    requireTenant(tenantId);
+    const taskId = nextTaskId();
+    this.#tasks.set(taskId, {
+      taskId,
+      tenantId,
+      status: "pending",
+      notified: false,
+      kind,
+      createdAtMs: Date.now()
+    });
+    return taskId;
+  }
+  /** Tenant-checked read. Returns undefined for unknown or cross-tenant ids. */
+  get(taskId, tenantId) {
+    requireTenant(tenantId);
+    const rec = this.#tasks.get(taskId);
+    if (!rec || rec.tenantId !== tenantId) return void 0;
+    return rec;
+  }
+  #ownedOrThrow(taskId, tenantId) {
+    requireTenant(tenantId);
+    const rec = this.#tasks.get(taskId);
+    if (!rec) throw new Error(`task ${taskId} not found`);
+    if (rec.tenantId !== tenantId) {
+      throw new Error("cross-tenant task access denied (fail closed)");
+    }
+    return rec;
+  }
+  transition(taskId, to, tenantId) {
+    const rec = this.#ownedOrThrow(taskId, tenantId);
+    const allowed = LEGAL[rec.status];
+    if (!allowed.includes(to)) {
+      throw new Error(`illegal task transition ${rec.status} \u2192 ${to}`);
+    }
+    const next = { ...rec, status: to };
+    this.#tasks.set(taskId, next);
+    return next;
+  }
+  /** Unified kill — drives any non-terminal task to `killed`. */
+  stop(taskId, tenantId) {
+    const rec = this.#ownedOrThrow(taskId, tenantId);
+    if (TERMINAL.has(rec.status)) return rec;
+    return this.transition(taskId, "killed", tenantId);
+  }
+  markNotified(taskId, tenantId) {
+    const rec = this.#ownedOrThrow(taskId, tenantId);
+    const next = { ...rec, notified: true };
+    this.#tasks.set(taskId, next);
+    return next;
+  }
+};
+function assertNotPeeking(task) {
+  if (!TERMINAL.has(task.status)) {
+    throw new Error(
+      `cannot peek at in-flight task ${task.taskId} (status=${task.status}); await settlement`
+    );
+  }
+}
+var NO_OUTPUT_MARKER = {
+  id: "subagent_no_output",
+  type: "error",
+  message: "subagent completed but returned no output"
+};
+var threadItemShape = z.object({ id: z.string(), type: z.string() });
+function normalizeContent(content) {
+  for (const item of content) threadItemShape.parse(item);
+  return content.length === 0 ? [NO_OUTPUT_MARKER] : content;
+}
+function countToolUses(content) {
+  return content.filter((i) => i.type === "mcp_tool_call" || i.type === "command_execution").length;
+}
+function makeDeferred(taskId, channel) {
+  if (!channel) throw new Error("deferred envelope requires a delivery channel");
+  return { kind: "deferred", taskId, channel };
+}
+function settleDeferred(target, content, usage) {
+  const { taskId, tenantId, registry } = target;
+  const rec = registry.get(taskId, tenantId);
+  if (!rec) throw new Error("cannot settle unknown or cross-tenant task (fail closed)");
+  if (!TERMINAL.has(rec.status)) {
+    registry.transition(taskId, "completed", tenantId);
+  }
+  const normalized = normalizeContent(content);
+  return {
+    kind: "sync",
+    content: normalized,
+    usage,
+    agentId: taskId,
+    toolUses: countToolUses(normalized),
+    durationMs: Math.max(0, Date.now() - rec.createdAtMs)
+  };
+}
+
+export {
+  resolveSubagentTools,
+  prepareDispatch,
+  TASK_KINDS,
+  TASK_STATUSES,
+  TaskRegistry,
+  assertNotPeeking,
+  makeDeferred,
+  settleDeferred
+};
+//# sourceMappingURL=chunk-5YS7WAPS.js.map

package/dist/chunk-5YS7WAPS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/subagents.ts"],"sourcesContent":["/**\n * Subagent / task dispatch (WRAP — isolated-child-agent model, the delta).\n *\n * Faithful re-expression of the source harness's child-agent dispatch grammar:\n * a registry decides WHICH definition runs, a context-boundary contract decides\n * WITH WHAT inherited context it starts, and a typed terminal envelope decides\n * HOW its result re-enters the parent. The child loop, child policy, and\n * rollout store live elsewhere in agent-runtime and are intentionally NOT\n * reimplemented here — this layer is pure decision + data + state machine.\n *\n * Multi-tenant: every task operation is keyed by `tenantId` and fails closed.\n * Pure data/logic — no FS scan, no shell, no network.\n *\n * NOTE on dropped task kinds: the source harness models several local execution\n * task kinds (local_bash / monitor_mcp / worktree). Those are deliberately NOT\n * represented here: this package never executes locally — execution is delegated\n * via the external-sandbox seam — so only the agent-facing `subagent` kind (and\n * its `deferred` sibling) is modelled.\n */\n\nimport { z } from \"zod\";\nimport type { Definition, Frontmatter } from \"./definitions\";\nimport type { ThreadItem, TurnUsage } from \"./model\";\n\n/* ───────────────────────── Subagent definition ─────────────────────────── */\n\n/** A subagent definition is just a `Definition` (same loader as skills/commands). */\nexport type SubagentRecord = Definition;\n\n/**\n * Effective tool set for a subagent: `allowedTools` minus `disallowedTools`,\n * intersected with the runtime tool universe so a definition can never widen\n * its scope past what the host exposes. When `allowedTools` is empty the\n * contract is \"all tools except the denied ones\" (all-except-deny).\n *\n * Pure — order follows `allTools` for determinism.\n */\nexport function resolveSubagentTools(fm: Frontmatter, allTools: readonly string[]): string[] {\n  const deny = new Set(fm.disallowedTools);\n  const allow = fm.allowedTools;\n  if (allow.length === 0) {\n    return allTools.filter((t) => !deny.has(t));\n  }\n  const allowSet = new Set(allow);\n  return allTools.filter((t) => allowSet.has(t) && !deny.has(t));\n}\n\n/* ───────────────────── Context-boundary contract ───────────────────────── */\n\nexport type DispatchMode = \"spawn\" | \"fork\";\n\nexport interface DispatchCtx {\n  readonly tenantId: string;\n}\n\nexport interface PrepareDispatchInput {\n  readonly definition: SubagentRecord;\n  readonly mode: DispatchMode;\n  readonly parentItems?: readonly ThreadItem[];\n  /** Caller's directive. Mandatory & non-empty in `spawn` mode. */\n  readonly brief: string;\n  readonly ctx: DispatchCtx;\n  /** Runtime tool universe; defaults to the definition's own allow list. */\n  readonly allTools?: readonly string[];\n}\n\nexport interface PreparedDispatch {\n  readonly initialContext: readonly ThreadItem[];\n  readonly toolScope: readonly string[];\n  /** Opaque reference to the system prompt body (resolved by the child loop). */\n  readonly systemPromptRef: string;\n  readonly modelOverride?: string;\n}\n\n/** True for a trailing tool-call item that never received a terminal result. */\nfunction isIncompleteToolCall(item: ThreadItem): boolean {\n  if (item.type === \"mcp_tool_call\" || item.type === \"command_execution\") {\n    return item.status === \"in_progress\";\n  }\n  return false;\n}\n\n/**\n * Drop trailing incomplete tool-call items so a forked child never inherits a\n * dangling tool_use without its result. Pure — input array is never mutated.\n */\nfunction filterIncompleteToolCalls(items: readonly ThreadItem[]): ThreadItem[] {\n  return items.filter((it) => !isIncompleteToolCall(it));\n}\n\nfunction directiveItem(idSeed: string, brief: string): ThreadItem {\n  return { id: `brief_${idSeed}`, type: \"agent_message\", text: brief };\n}\n\n/**\n * Decide the child's starting context boundary.\n *\n * - `spawn`: zero inherited context. The caller MUST fully brief the child;\n *   an empty brief is a programming error and throws.\n * - `fork`: inherit a defensive copy of `parentItems` with incomplete tool\n *   calls filtered out, then append the brief as a directive.\n *\n * `parentItems` is never mutated. Cross-tenant dispatch fails closed.\n */\nexport function prepareDispatch(input: PrepareDispatchInput): PreparedDispatch {\n  const { definition, mode, parentItems, brief, ctx, allTools } = input;\n  if (!ctx.tenantId) throw new Error(\"DispatchCtx.tenantId is required\");\n  if (definition.tenantId !== ctx.tenantId) {\n    throw new Error(\"subagent definition belongs to a different tenant (fail closed)\");\n  }\n\n  const trimmedBrief = brief.trim();\n  const fm = definition.frontmatter;\n  const toolScope = resolveSubagentTools(fm, allTools ?? fm.allowedTools);\n\n  let initialContext: ThreadItem[];\n  if (mode === \"spawn\") {\n    if (!trimmedBrief) {\n      throw new Error(\n        \"spawn dispatch requires a non-empty brief — caller must fully brief the child\",\n      );\n    }\n    initialContext = [directiveItem(definition.slug, trimmedBrief)];\n  } else {\n    const inherited = parentItems ? filterIncompleteToolCalls(parentItems) : [];\n    initialContext = trimmedBrief\n      ? [...inherited, directiveItem(definition.slug, trimmedBrief)]\n      : [...inherited];\n  }\n\n  const modelOverride = fm.model && fm.model !== \"inherit\" ? fm.model : undefined;\n\n  return {\n    initialContext,\n    toolScope,\n    systemPromptRef: definition.bodyRef,\n    ...(modelOverride ? { modelOverride } : {}),\n  };\n}\n\n/* ─────────────────── Uniform Task lifecycle registry ───────────────────── */\n\nexport const TASK_KINDS = [\"subagent\", \"deferred\"] as const;\nexport type TaskKind = (typeof TASK_KINDS)[number];\n\nexport const TASK_STATUSES = [\"pending\", \"running\", \"completed\", \"failed\", \"killed\"] as const;\nexport type TaskStatus = (typeof TASK_STATUSES)[number];\n\nexport interface TaskRecord {\n  readonly taskId: string;\n  readonly tenantId: string;\n  readonly status: TaskStatus;\n  readonly notified: boolean;\n  readonly kind: TaskKind;\n  readonly createdAtMs: number;\n}\n\n/** Legal status transitions. Any pair absent here is rejected. */\nconst LEGAL: Readonly<Record<TaskStatus, readonly TaskStatus[]>> = {\n  pending: [\"running\", \"killed\", \"failed\"],\n  running: [\"completed\", \"failed\", \"killed\"],\n  completed: [],\n  failed: [],\n  killed: [],\n};\n\nconst TERMINAL: ReadonlySet<TaskStatus> = new Set([\"completed\", \"failed\", \"killed\"]);\n\nlet __seq = 0;\nfunction nextTaskId(): string {\n  __seq += 1;\n  return `task_${Date.now().toString(36)}_${__seq.toString(36)}`;\n}\n\nfunction requireTenant(tenantId: string): void {\n  if (!tenantId) throw new Error(\"tenantId is required (fail closed)\");\n}\n\n/**\n * Tenant-scoped task registry. Every mutating op verifies the caller's\n * tenant against the stored record; a mismatch is treated as \"not found\"\n * for reads and throws for mutations — cross-tenant access is impossible.\n */\nexport class TaskRegistry {\n  readonly #tasks = new Map<string, TaskRecord>();\n\n  create(tenantId: string, kind: TaskKind): string {\n    requireTenant(tenantId);\n    const taskId = nextTaskId();\n    this.#tasks.set(taskId, {\n      taskId,\n      tenantId,\n      status: \"pending\",\n      notified: false,\n      kind,\n      createdAtMs: Date.now(),\n    });\n    return taskId;\n  }\n\n  /** Tenant-checked read. Returns undefined for unknown or cross-tenant ids. */\n  get(taskId: string, tenantId: string): TaskRecord | undefined {\n    requireTenant(tenantId);\n    const rec = this.#tasks.get(taskId);\n    if (!rec || rec.tenantId !== tenantId) return undefined;\n    return rec;\n  }\n\n  #ownedOrThrow(taskId: string, tenantId: string): TaskRecord {\n    requireTenant(tenantId);\n    const rec = this.#tasks.get(taskId);\n    if (!rec) throw new Error(`task ${taskId} not found`);\n    if (rec.tenantId !== tenantId) {\n      throw new Error(\"cross-tenant task access denied (fail closed)\");\n    }\n    return rec;\n  }\n\n  transition(taskId: string, to: TaskStatus, tenantId: string): TaskRecord {\n    const rec = this.#ownedOrThrow(taskId, tenantId);\n    const allowed = LEGAL[rec.status];\n    if (!allowed.includes(to)) {\n      throw new Error(`illegal task transition ${rec.status} → ${to}`);\n    }\n    const next: TaskRecord = { ...rec, status: to };\n    this.#tasks.set(taskId, next);\n    return next;\n  }\n\n  /** Unified kill — drives any non-terminal task to `killed`. */\n  stop(taskId: string, tenantId: string): TaskRecord {\n    const rec = this.#ownedOrThrow(taskId, tenantId);\n    if (TERMINAL.has(rec.status)) return rec;\n    return this.transition(taskId, \"killed\", tenantId);\n  }\n\n  markNotified(taskId: string, tenantId: string): TaskRecord {\n    const rec = this.#ownedOrThrow(taskId, tenantId);\n    const next: TaskRecord = { ...rec, notified: true };\n    this.#tasks.set(taskId, next);\n    return next;\n  }\n}\n\n/**\n * No-peek / no-race guard. Throws if a parent tries to read an in-flight\n * deferred task's transcript before it has settled.\n */\nexport function assertNotPeeking(task: TaskRecord): void {\n  if (!TERMINAL.has(task.status)) {\n    throw new Error(\n      `cannot peek at in-flight task ${task.taskId} (status=${task.status}); await settlement`,\n    );\n  }\n}\n\n/* ─────────────── Typed terminal-envelope result contract ────────────────── */\n\nexport interface SyncEnvelope {\n  readonly kind: \"sync\";\n  readonly content: readonly ThreadItem[];\n  readonly usage: TurnUsage;\n  readonly agentId: string;\n  readonly toolUses: number;\n  readonly durationMs: number;\n}\n\nexport interface DeferredEnvelope {\n  readonly kind: \"deferred\";\n  readonly taskId: string;\n  readonly channel: string;\n}\n\nexport type DispatchEnvelope = SyncEnvelope | DeferredEnvelope;\n\nconst NO_OUTPUT_MARKER: ThreadItem = {\n  id: \"subagent_no_output\",\n  type: \"error\",\n  message: \"subagent completed but returned no output\",\n};\n\nconst threadItemShape = z.object({ id: z.string(), type: z.string() });\n\n/** Empty content is never silently empty — normalize to one explicit marker. */\nfunction normalizeContent(content: readonly ThreadItem[]): readonly ThreadItem[] {\n  for (const item of content) threadItemShape.parse(item);\n  return content.length === 0 ? [NO_OUTPUT_MARKER] : content;\n}\n\nfunction countToolUses(content: readonly ThreadItem[]): number {\n  return content.filter((i) => i.type === \"mcp_tool_call\" || i.type === \"command_execution\").length;\n}\n\n/** Build a fire-and-forget deferred envelope for a registered task. */\nexport function makeDeferred(taskId: string, channel: string): DeferredEnvelope {\n  if (!channel) throw new Error(\"deferred envelope requires a delivery channel\");\n  return { kind: \"deferred\", taskId, channel };\n}\n\nexport interface SettleDeferredTarget {\n  readonly taskId: string;\n  readonly channel: string;\n  readonly tenantId: string;\n  readonly registry: TaskRegistry;\n}\n\n/**\n * Settle a previously-deferred task: drive it to `completed` (tenant-checked)\n * and produce the eventual sync-shaped result. Empty content is normalized to\n * the explicit no-output marker.\n */\nexport function settleDeferred(\n  target: SettleDeferredTarget,\n  content: readonly ThreadItem[],\n  usage: TurnUsage,\n): SyncEnvelope {\n  const { taskId, tenantId, registry } = target;\n  const rec = registry.get(taskId, tenantId);\n  if (!rec) throw new Error(\"cannot settle unknown or cross-tenant task (fail closed)\");\n  if (!TERMINAL.has(rec.status)) {\n    registry.transition(taskId, \"completed\", tenantId);\n  }\n  const normalized = normalizeContent(content);\n  return {\n    kind: \"sync\",\n    content: normalized,\n    usage,\n    agentId: taskId,\n    toolUses: countToolUses(normalized),\n    durationMs: Math.max(0, Date.now() - rec.createdAtMs),\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-6EGG2OZC.js

@@ -0,0 +1,13 @@
+// src/model.ts
+function mergeTurnConfig(base, overrides) {
+  return overrides ? { ...base, ...overrides } : { ...base };
+}
+function isTurnTerminal(event) {
+  return event.type === "turn.completed" || event.type === "turn.failed";
+}
+
+export {
+  mergeTurnConfig,
+  isTurnTerminal
+};
+//# sourceMappingURL=chunk-6EGG2OZC.js.map

package/dist/chunk-6EGG2OZC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/model.ts"],"sourcesContent":["/**\n * Thread / Turn / Item model + event lifecycle (WRAP — capability #6).\n *\n * Faithful re-expression of the upstream agent-runtime item taxonomy and event\n * stream (generated TS types in the source SDK, themselves derived from the\n * Rust `exec_events` definitions). Renamed to neutral domain terms and made\n * tenant-scoped. No enforcement here — pure data + state machine.\n *\n * Hierarchy: Thread -> Turn -> Item.\n *   Thread : a durable, tenant-scoped conversation (resumable by replay).\n *   Turn   : one user-input -> model-completion cycle.\n *   Item   : the atomic recorded unit inside a turn.\n */\n\n/** Lifecycle of a stateful item that runs over time. */\nexport type RunStatus = \"in_progress\" | \"completed\" | \"failed\";\n\n/** Terminal status for an applied patch (no `in_progress` terminal form). */\nexport type PatchApplyStatus = \"completed\" | \"failed\";\n\n/** Kind of a single file mutation within a patch. */\nexport type PatchChangeKind = \"add\" | \"delete\" | \"update\";\n\nexport interface FileUpdateChange {\n  readonly path: string;\n  readonly kind: PatchChangeKind;\n}\n\ninterface ItemBase {\n  /** Stable identifier, unique within the owning thread. */\n  readonly id: string;\n}\n\n/** Natural-language (or structured-JSON) response from the agent. */\nexport interface AgentMessageItem extends ItemBase {\n  readonly type: \"agent_message\";\n  readonly text: string;\n}\n\n/** The agent's reasoning summary. */\nexport interface ReasoningItem extends ItemBase {\n  readonly type: \"reasoning\";\n  readonly text: string;\n}\n\n/**\n * A command the agent asked to run. The runtime itself never executes it —\n * see {@link ./sandbox} for the external-sandbox delegation seam.\n */\nexport interface CommandExecutionItem extends ItemBase {\n  readonly type: \"command_execution\";\n  readonly command: string;\n  /** Aggregated stdout+stderr captured by the external executor. */\n  readonly aggregatedOutput: string;\n  /** Present once the command exits. */\n  readonly exitCode?: number;\n  readonly status: RunStatus;\n}\n\n/** A patch produced by the agent. Emitted once it succeeds or fails. */\nexport interface FileChangeItem extends ItemBase {\n  readonly type: \"file_change\";\n  readonly changes: readonly FileUpdateChange[];\n  readonly status: PatchApplyStatus;\n}\n\n/** A call to a tool exposed via an MCP server. */\nexport interface McpToolCallItem extends ItemBase {\n  readonly type: \"mcp_tool_call\";\n  readonly server: string;\n  readonly tool: string;\n  readonly arguments: unknown;\n  readonly result?: { readonly content: unknown; readonly structuredContent?: unknown };\n  readonly error?: { readonly message: string };\n  readonly status: RunStatus;\n}\n\n/** A web-search request issued by the agent. */\nexport interface WebSearchItem extends ItemBase {\n  readonly type: \"web_search\";\n  readonly query: string;\n}\n\nexport interface TodoEntry {\n  readonly text: string;\n  readonly completed: boolean;\n}\n\n/** The agent's running to-do list for the turn. */\nexport interface TodoListItem extends ItemBase {\n  readonly type: \"todo_list\";\n  readonly items: readonly TodoEntry[];\n}\n\n/** A non-fatal error surfaced as an item (the turn may continue). */\nexport interface ErrorItem extends ItemBase {\n  readonly type: \"error\";\n  readonly message: string;\n}\n\n/** Canonical closed union of thread items. */\nexport type ThreadItem =\n  | AgentMessageItem\n  | ReasoningItem\n  | CommandExecutionItem\n  | FileChangeItem\n  | McpToolCallItem\n  | WebSearchItem\n  | TodoListItem\n  | ErrorItem;\n\nexport type ThreadItemType = ThreadItem[\"type\"];\n\n/** Token accounting for a completed turn. */\nexport interface TurnUsage {\n  readonly inputTokens: number;\n  readonly cachedInputTokens: number;\n  readonly outputTokens: number;\n  readonly reasoningOutputTokens: number;\n}\n\n/** Fatal error payload emitted by the stream. */\nexport interface ThreadError {\n  readonly message: string;\n}\n\n/**\n * Event lifecycle observed by a client:\n *   thread.started -> turn.started -> (item.started -> item.updated* ->\n *   item.completed)* -> turn.completed | turn.failed, with a terminal `error`.\n */\nexport type ThreadEvent =\n  | { readonly type: \"thread.started\"; readonly threadId: string }\n  | { readonly type: \"turn.started\" }\n  | { readonly type: \"turn.completed\"; readonly usage: TurnUsage }\n  | { readonly type: \"turn.failed\"; readonly error: ThreadError }\n  | { readonly type: \"item.started\"; readonly item: ThreadItem }\n  | { readonly type: \"item.updated\"; readonly item: ThreadItem }\n  | { readonly type: \"item.completed\"; readonly item: ThreadItem }\n  | { readonly type: \"error\"; readonly message: string };\n\nexport type ThreadEventType = ThreadEvent[\"type\"];\n\n/**\n * Per-turn config snapshot. Immutable within a turn; rebindable between turns.\n * Tenant defaults are merged with per-request overrides via {@link mergeTurnConfig}.\n */\nexport interface TurnConfig {\n  readonly model: string;\n  readonly provider: string;\n  /** Stringly-typed approval-policy tag — see {@link ./policy}. */\n  readonly approvalPolicy: string;\n  /** Stringly-typed capability-policy tag — see {@link ./policy}. */\n  readonly capabilityPolicy: string;\n  readonly reasoningEffort?: \"low\" | \"medium\" | \"high\";\n}\n\nexport type TurnConfigOverrides = Partial<TurnConfig>;\n\n/** Freeze a tenant-default config against per-turn overrides. */\nexport function mergeTurnConfig(base: TurnConfig, overrides?: TurnConfigOverrides): TurnConfig {\n  return overrides ? { ...base, ...overrides } : { ...base };\n}\n\n/** Whether an event is a terminal turn outcome. */\nexport function isTurnTerminal(event: ThreadEvent): boolean {\n  return event.type === \"turn.completed\" || event.type === \"turn.failed\";\n}\n"],"mappings":";AAgKO,SAAS,gBAAgB,MAAkB,WAA6C;AAC7F,SAAO,YAAY,EAAE,GAAG,MAAM,GAAG,UAAU,IAAI,EAAE,GAAG,KAAK;AAC3D;AAGO,SAAS,eAAe,OAA6B;AAC1D,SAAO,MAAM,SAAS,oBAAoB,MAAM,SAAS;AAC3D;","names":[]}

package/dist/chunk-7BUOF367.js

@@ -0,0 +1,126 @@
+// src/definitions.ts
+import { z } from "zod";
+var SOURCE_TIERS = [
+  "bundled",
+  "builtin",
+  "workspace",
+  "workflow",
+  "plugin",
+  "dynamic",
+  "policy"
+];
+var tierRank = new Map(SOURCE_TIERS.map((t, i) => [t, i]));
+var frontmatterSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().default(""),
+  /** Tool allowlist this definition self-declares. */
+  allowedTools: z.array(z.string()).default([]),
+  /** Tool denylist (subagents). */
+  disallowedTools: z.array(z.string()).default([]),
+  argumentHint: z.string().optional(),
+  argNames: z.array(z.string()).default([]),
+  whenToUse: z.string().optional(),
+  version: z.string().optional(),
+  /** "inherit" | a model alias. */
+  model: z.string().optional(),
+  effort: z.enum(["low", "medium", "high"]).optional(),
+  /** Model may auto-invoke this. */
+  modelInvocable: z.boolean().default(true),
+  /** A human may invoke this. */
+  userInvocable: z.boolean().default(true),
+  /** inline = expand into current turn; fork = isolated child. */
+  executionMode: z.enum(["inline", "fork"]).default("inline"),
+  agent: z.string().optional(),
+  /** Path-activation globs (surface only after a matching file is touched). */
+  paths: z.array(z.string()).default([])
+});
+var FRONTMATTER_FENCE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+var KEY_ALIASES = {
+  "allowed-tools": "allowedTools",
+  "disallowed-tools": "disallowedTools",
+  "argument-hint": "argumentHint",
+  arguments: "argNames",
+  when_to_use: "whenToUse",
+  "disable-model-invocation": "modelInvocable",
+  // inverted below
+  "user-invocable": "userInvocable",
+  context: "executionMode"
+};
+function coerceScalar(raw) {
+  const v = raw.trim();
+  if (v === "true") return true;
+  if (v === "false") return false;
+  if (v.startsWith("[") && v.endsWith("]")) {
+    return v.slice(1, -1).split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+  }
+  return v.replace(/^["']|["']$/g, "");
+}
+function parseFrontmatter(raw) {
+  const m = FRONTMATTER_FENCE.exec(raw);
+  if (!m) throw new Error("definition is missing a '--- \u2026 ---' frontmatter block");
+  const block = m[1] ?? "";
+  const body = raw.slice(m[0].length);
+  const bag = {};
+  for (const line of block.split(/\r?\n/)) {
+    if (!line.trim() || /^\s*#/.test(line)) continue;
+    const idx = line.indexOf(":");
+    if (idx < 0) continue;
+    const rawKey = line.slice(0, idx).trim();
+    const value = coerceScalar(line.slice(idx + 1));
+    const key = KEY_ALIASES[rawKey] ?? rawKey;
+    if (rawKey === "disable-model-invocation") {
+      bag.modelInvocable = value === true ? false : value === false ? true : true;
+      continue;
+    }
+    if (rawKey === "context") {
+      bag.executionMode = value === "fork" ? "fork" : "inline";
+      continue;
+    }
+    bag[key] = value;
+  }
+  return { frontmatter: frontmatterSchema.parse(bag), body };
+}
+var DefinitionResolver = class _DefinitionResolver {
+  #all;
+  constructor(definitions) {
+    this.#all = [...definitions];
+  }
+  /** Entitlement gate. */
+  static available(def, plan) {
+    if (!def.availabilityPlans || def.availabilityPlans.length === 0) return true;
+    return plan != null && def.availabilityPlans.includes(plan);
+  }
+  resolve(ctx) {
+    if (!ctx.tenantId) throw new Error("ResolveContext.tenantId is required");
+    const winner = /* @__PURE__ */ new Map();
+    for (const def of this.#all) {
+      if (def.tenantId !== ctx.tenantId) continue;
+      if (def.enabled === false) continue;
+      if (!_DefinitionResolver.available(def, ctx.plan)) continue;
+      const cur = winner.get(def.slug);
+      if (!cur || tierRank.get(def.sourceTier) >= tierRank.get(cur.sourceTier)) {
+        winner.set(def.slug, def);
+      }
+    }
+    return [...winner.values()];
+  }
+  /** Resolve a single slug (highest-precedence, gated). */
+  resolveOne(slug, ctx) {
+    return this.resolve(ctx).find((d) => d.slug === slug);
+  }
+};
+function substituteArguments(template, args, variables = {}) {
+  return template.replace(
+    /\$\{(\w+)\}/g,
+    (_, k) => k in args ? args[k] : k in variables ? variables[k] : ""
+  );
+}
+
+export {
+  SOURCE_TIERS,
+  frontmatterSchema,
+  parseFrontmatter,
+  DefinitionResolver,
+  substituteArguments
+};
+//# sourceMappingURL=chunk-7BUOF367.js.map

package/dist/chunk-7BUOF367.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/definitions.ts"],"sourcesContent":["/**\n * Shared definition kernel (WRAP — Claude-Code-class harness, the delta).\n *\n * Faithful re-expression of the source harness's layered-merge + precedence +\n * dual-gate resolver and its frontmatter→record parser. One implementation\n * backs the command registry, the skill catalog, and the subagent-definition\n * registry (the source uses the same loader for all three).\n *\n * Multi-tenant: every resolution is keyed by `tenantId`; tiers from one tenant\n * never merge into another. Pure data/logic — no FS scan, no shell, no TUI.\n */\n\nimport { z } from \"zod\";\n\n/**\n * Source-tier precedence, low → high authority. A later tier overrides an\n * earlier one on slug collision (mirrors the upstream merge order:\n * bundled → builtin → workspace → workflow → plugin → dynamic, with\n * org policy as the final, non-overridable authority).\n */\nexport const SOURCE_TIERS = [\n  \"bundled\",\n  \"builtin\",\n  \"workspace\",\n  \"workflow\",\n  \"plugin\",\n  \"dynamic\",\n  \"policy\",\n] as const;\nexport type SourceTier = (typeof SOURCE_TIERS)[number];\n\nconst tierRank = new Map<SourceTier, number>(SOURCE_TIERS.map((t, i) => [t, i]));\n\n/** Frontmatter shared by skills / commands / subagents (faithful subset). */\nexport const frontmatterSchema = z.object({\n  name: z.string().min(1),\n  description: z.string().default(\"\"),\n  /** Tool allowlist this definition self-declares. */\n  allowedTools: z.array(z.string()).default([]),\n  /** Tool denylist (subagents). */\n  disallowedTools: z.array(z.string()).default([]),\n  argumentHint: z.string().optional(),\n  argNames: z.array(z.string()).default([]),\n  whenToUse: z.string().optional(),\n  version: z.string().optional(),\n  /** \"inherit\" | a model alias. */\n  model: z.string().optional(),\n  effort: z.enum([\"low\", \"medium\", \"high\"]).optional(),\n  /** Model may auto-invoke this. */\n  modelInvocable: z.boolean().default(true),\n  /** A human may invoke this. */\n  userInvocable: z.boolean().default(true),\n  /** inline = expand into current turn; fork = isolated child. */\n  executionMode: z.enum([\"inline\", \"fork\"]).default(\"inline\"),\n  agent: z.string().optional(),\n  /** Path-activation globs (surface only after a matching file is touched). */\n  paths: z.array(z.string()).default([]),\n});\nexport type Frontmatter = z.infer<typeof frontmatterSchema>;\n\nconst FRONTMATTER_FENCE = /^---\\r?\\n([\\s\\S]*?)\\r?\\n---\\r?\\n?/;\n\n/** Aliases mapping kebab/snake frontmatter keys → schema keys. */\nconst KEY_ALIASES: Record<string, keyof Frontmatter> = {\n  \"allowed-tools\": \"allowedTools\",\n  \"disallowed-tools\": \"disallowedTools\",\n  \"argument-hint\": \"argumentHint\",\n  arguments: \"argNames\",\n  when_to_use: \"whenToUse\",\n  \"disable-model-invocation\": \"modelInvocable\", // inverted below\n  \"user-invocable\": \"userInvocable\",\n  context: \"executionMode\",\n};\n\nfunction coerceScalar(raw: string): string | boolean | string[] {\n  const v = raw.trim();\n  if (v === \"true\") return true;\n  if (v === \"false\") return false;\n  if (v.startsWith(\"[\") && v.endsWith(\"]\")) {\n    return v\n      .slice(1, -1)\n      .split(\",\")\n      .map((s) => s.trim().replace(/^[\"']|[\"']$/g, \"\"))\n      .filter(Boolean);\n  }\n  return v.replace(/^[\"']|[\"']$/g, \"\");\n}\n\n/**\n * Parse a `--- … ---` frontmatter block + remaining body. Dependency-light\n * line parser (the package only depends on zod) — sufficient for the simple\n * key: value / list frontmatter the source uses. Throws on missing block.\n */\nexport function parseFrontmatter(raw: string): { frontmatter: Frontmatter; body: string } {\n  const m = FRONTMATTER_FENCE.exec(raw);\n  if (!m) throw new Error(\"definition is missing a '--- … ---' frontmatter block\");\n  const block = m[1] ?? \"\";\n  const body = raw.slice(m[0].length);\n\n  const bag: Record<string, unknown> = {};\n  for (const line of block.split(/\\r?\\n/)) {\n    if (!line.trim() || /^\\s*#/.test(line)) continue;\n    const idx = line.indexOf(\":\");\n    if (idx < 0) continue;\n    const rawKey = line.slice(0, idx).trim();\n    const value = coerceScalar(line.slice(idx + 1));\n    const key = KEY_ALIASES[rawKey] ?? (rawKey as keyof Frontmatter);\n    if (rawKey === \"disable-model-invocation\") {\n      bag.modelInvocable = value === true ? false : value === false ? true : true;\n      continue;\n    }\n    if (rawKey === \"context\") {\n      bag.executionMode = value === \"fork\" ? \"fork\" : \"inline\";\n      continue;\n    }\n    bag[key] = value;\n  }\n  return { frontmatter: frontmatterSchema.parse(bag), body };\n}\n\n/** A resolvable definition of any kind (skill / command / subagent). */\nexport interface Definition {\n  readonly slug: string;\n  readonly tenantId: string;\n  readonly sourceTier: SourceTier;\n  readonly frontmatter: Frontmatter;\n  readonly bodyRef: string;\n  /** Entitlement gate — who may have this at all. */\n  readonly availabilityPlans?: readonly string[];\n  /** Runtime/feature toggle, recomputed per request. */\n  readonly enabled?: boolean;\n}\n\nexport interface ResolveContext {\n  readonly tenantId: string;\n  readonly plan?: string;\n  /** Names already loaded this session (suppressed from re-listing). */\n  readonly loadedSlugs?: ReadonlySet<string>;\n}\n\n/**\n * Tenant-scoped layered resolver. Merges definitions by slug with tier\n * precedence and applies the dual gate (availability ∧ enabled), recomputed\n * per call so entitlement/flag changes apply live. Cross-tenant inputs are\n * rejected — fail closed.\n */\nexport class DefinitionResolver<T extends Definition = Definition> {\n  readonly #all: readonly T[];\n\n  constructor(definitions: readonly T[]) {\n    this.#all = [...definitions];\n  }\n\n  /** Entitlement gate. */\n  static available(def: Definition, plan?: string): boolean {\n    if (!def.availabilityPlans || def.availabilityPlans.length === 0) return true;\n    return plan != null && def.availabilityPlans.includes(plan);\n  }\n\n  resolve(ctx: ResolveContext): T[] {\n    if (!ctx.tenantId) throw new Error(\"ResolveContext.tenantId is required\");\n    const winner = new Map<string, T>();\n    for (const def of this.#all) {\n      if (def.tenantId !== ctx.tenantId) continue; // tenant isolation, fail-closed\n      if (def.enabled === false) continue;\n      if (!DefinitionResolver.available(def, ctx.plan)) continue;\n      const cur = winner.get(def.slug);\n      if (!cur || tierRank.get(def.sourceTier)! >= tierRank.get(cur.sourceTier)!) {\n        winner.set(def.slug, def);\n      }\n    }\n    return [...winner.values()];\n  }\n\n  /** Resolve a single slug (highest-precedence, gated). */\n  resolveOne(slug: string, ctx: ResolveContext): T | undefined {\n    return this.resolve(ctx).find((d) => d.slug === slug);\n  }\n}\n\n/** Substitute `${name}` / positional `$1` args + session/dir variables. */\nexport function substituteArguments(\n  template: string,\n  args: Record<string, string>,\n  variables: Record<string, string> = {},\n): string {\n  return template.replace(/\\$\\{(\\w+)\\}/g, (_, k: string) =>\n    k in args ? args[k]! : k in variables ? variables[k]! : \"\",\n  );\n}\n"],"mappings":"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","names":[]}