@humwick/server 0.130.1 → 0.130.2

package/node_modules/@humwick/kernel/workflow.pilot.ts

@@ -1,376 +0,0 @@
-import { workflowCancelTreeOps } from "./workflow-cancel-tree";
-import { isDeepStrictEqual } from "node:util";
-import { createHash } from "node:crypto";
-import { workflowDispatchOps, recordDispatchAgent } from "./workflow-dispatch";
-import { workflowControlOps } from "./workflow-control";
-import { compositionOps, allocateRunId, releaseReservation } from "./workflow-composition";
-import { foreachOps } from "./workflow-foreach";
-import { admissionSchema } from "./workflow-state";
-import { validateWorkflowValue } from "./workflow-values";
-import { workflowActivationSchema, workflowSnapshotSchema, workflowReservationSchema } from "./workflow-activation";
-import { z } from "zod";
-import { OpError, defineModule } from "./contract";
-import { checkWorkflowBackstop, workflowBackstop, workflowBackstopInput } from "./workflow-backstop";
-import { workflowScriptAttemptSchema } from "./workflow-script";
-import { stepReap, workflowAppliedPinSchema, workflowCallPinSchema, workflowDefinitionSchema } from "./workflow-definition";
-import { enter, route, type RunState } from "./workflow-transitions";
-import { SIGNAL_TOPIC, WORKFLOW_SOURCES, ADMIN_GRANT, RUN_STATUSES, json, runSchema, effectSchema, signalSchema, linkSchema, agentSchema, crossProviderSchema, FACT_FIELD, allocationSchema, stores, requireRun, linkTask, writeEffect, workflowEffectId } from "./workflow-state";
-export { workflowEffectId, workflowOwnsAgentCleanup, workflowReapIncludesAgent } from "./workflow-state";
-export type { WorkflowRunRecord, WorkflowEffect, WorkflowSignal, WorkflowAgent, WorkflowCiVerdict, Stores } from "./workflow-state";
-function textField(value: unknown): string | undefined { return typeof value === "string" && value.trim() ? value : undefined; }
-
-export const workflow = defineModule({
-  id: "workflow",
-  title: "Declarative workflows",
-  description: "Repo-declared multi-agent workflows (#3045): build → review → fix → land loops Relay routes itself.",
-  entities: {
-    // The compound indexes serve the dashboard: the run list and stats walk one status newest first, the
-    // Definitions tab one workflow's newest runs (#3076).
-    run: { schema: runSchema, indexes: ["taskId", "status", ["status", "updatedAt", "id"], ["workflow", "updatedAt", "id"], ["parentRunId", "id"], ["taskId", "requestKey"], ["rootRunId", "status", "id"], ["callerAgentId", "status"]] },
-    effect: { schema: effectSchema, indexes: ["status", "runId"] },
-    signal: { schema: signalSchema, indexes: ["runId"] },
-    link: { schema: linkSchema },
-    agent: { schema: agentSchema, indexes: ["runId", "agentId"] },
-    allocation: { schema: allocationSchema },
-    admission: { schema: admissionSchema },
-    activation: { schema: workflowActivationSchema, indexes: [["runId", "id"], ["runId", "state", "id"], ["parentId", "id"], ["parentId", "state", "id"], ["parentId", "state", "active", "id"], ["active", "id"], ["runId", "active", "id"], ["parentId", "active", "id"], ["scheduling", "id"]] },
-    reservation: { schema: workflowReservationSchema, indexes: ["runId", "rootRunId"] },
-    scriptAttempt: { schema: workflowScriptAttemptSchema, indexes: ["runId"] },
-  },
-  events: {
-    "workflow.started": z.object({ runId: z.string(), taskId: z.number().int(), workflow: z.string() }),
-    [SIGNAL_TOPIC]: z.object({ runId: z.string(), correlationId: z.string() }),
-    "workflow.routed": z.object({ runId: z.string(), step: z.string(), outcome: z.string(), target: z.string() }),
-    "workflow.finished": z.object({ runId: z.string(), status: z.enum(RUN_STATUSES) }),
-  },
-  workflows: {
-    run: {
-      input: z.object({ runId: z.string() }),
-      state: z.object({ runId: z.string() }),
-      init: (input): RunState => ({ runId: input.runId }),
-      start: "enter",
-      steps: { enter: { run: enter }, route: { run: route } },
-    },
-  },
-  ops: {
-    ...workflowControlOps,
-    ...workflowCancelTreeOps,
-    ...compositionOps,
-    ...foreachOps,
-    ...workflowDispatchOps,
-    checkOverdue: {
-      kind: "mutation", idempotent: true, grant: ADMIN_GRANT,
-      summary: "Record one backstop escalation per overdue episode (system-only).",
-      expose: { http: false, mcp: false, cli: false },
-      input: workflowBackstopInput, output: z.object({ created: z.boolean(), effectId: z.string().optional() }),
-      handler: (ctx, input) => checkWorkflowBackstop(ctx, input, stores(ctx)),
-    },
-    scriptAttempts: {
-      kind: "query", grant: ADMIN_GRANT, summary: "Page script attempt logs for a run (system-only).",
-      expose: { http: false, mcp: false, cli: false },
-      input: z.object({ runId: z.string(), cursor: z.string().optional() }),
-      output: z.object({ items: z.array(workflowScriptAttemptSchema), cursor: z.string().optional() }),
-      handler: async (ctx, input) => stores(ctx).scriptAttempt.list({ where: { runId: input.runId }, limit: 200, ...(input.cursor ? { cursor: input.cursor } : {}) }),
-    },
-    start: {
-      kind: "mutation",
-      idempotent: true,
-      grant: ADMIN_GRANT,
-      summary: "Start a run of a validated workflow on its input Task; returns the Task's open run instead when one exists (system-only).",
-      emits: ["workflow.started"],
-      expose: { http: false, mcp: false, cli: false },
-      input: z.object({
-        workflow: z.string().min(1),
-        ref: z.string().min(1),
-        sha: z.string().min(1),
-        source: z.enum(WORKFLOW_SOURCES).optional(),
-        taskId: z.number().int(),
-        coordinator: z.string().min(1),
-        callerAgentId: z.string().optional(),
-        maxLiveAgents: z.number().int().min(1).optional(),
-        maxConcurrentRuns: z.number().int().min(1).optional(),
-        tokenBudget: runSchema.shape.tokenBudget,
-        cwd: z.string().min(1),
-        orchestratorId: z.string().min(1),
-        definition: workflowDefinitionSchema,
-        /** Stamped and checked against the definition by the src caller (stampWorkflowPins). */
-        pins: z.record(z.string(), workflowCallPinSchema).optional(),
-        routingDefaults: runSchema.shape.routingDefaults,
-        inputs: json.optional(), snapshot: workflowSnapshotSchema.optional(), requestKey: z.string().optional(),
-        afterEventId: z.number().int().min(0),
-      }),
-      output: z.object({ run: runSchema, created: z.boolean() }),
-      handler: async (ctx, input) => {
-        const runs = stores(ctx).run;
-        const prior = await runs.list({ where: { taskId: input.taskId, status: "running" }, limit: 200 });
-        const parked = input.definition.version === 2 ? await runs.list({ where: { taskId: input.taskId, status: "escalated" }, limit: 200 }) : { items: [] };
-        const replay = input.requestKey ? await runs.list({ where: { taskId: input.taskId, requestKey: input.requestKey }, limit: 1 }) : { items: [] };
-        const open = [...replay.items, ...prior.items, ...parked.items].find(run => !run.parentRunId && (!run.cancel || Boolean(input.requestKey && run.requestKey === input.requestKey)));
-        if (open) {
-          if (input.callerAgentId && open.coordinator !== input.callerAgentId) throw new OpError("conflict", 409, "WORKFLOW_CALLER_CONFLICT: Task already has another caller’s run");
-          if (input.definition.version === 2 && (open.workflow !== input.workflow || !isDeepStrictEqual(open.inputs ?? {}, input.inputs ?? {}))) throw new OpError("conflict", 409, "ROOT_INPUT_CONFLICT: root keeps its original inputs");
-          return { run: open, created: false };
-        }
-        if (input.callerAgentId) {
-          let occupied = 0;
-          for (const status of ["running", "escalated"] as const) {
-            let cursor: string | undefined;
-            do {
-              const page = await runs.list({ where: { callerAgentId: input.callerAgentId, status }, limit: 200, cursor });
-              occupied += page.items.filter(run => !run.parentRunId).length;
-              if (occupied >= (input.maxConcurrentRuns ?? 1)) throw new OpError("conflict", 409, "WORKFLOW_RUN_LIMIT: caller has reached its concurrent run limit");
-              cursor = page.cursor;
-            } while (cursor);
-          }
-        }
-        validateWorkflowValue(input.definition.inputs, input.inputs ?? {}, "INPUT_INVALID");
-        const now = ctx.clock.now();
-        const id = await allocateRunId(ctx, input.taskId);
-        const run = await runs.create({
-          id, workflow: input.workflow, ref: input.ref, sha: input.sha, ...(input.source ? { source: input.source } : {}), taskId: input.taskId, coordinator: input.coordinator,
-          ...(input.callerAgentId ? { callerAgentId: input.callerAgentId, maxLiveAgents: input.maxLiveAgents } : {}),
-          ...(input.tokenBudget ? { tokenBudget: input.tokenBudget } : {}),
-          cwd: input.cwd, orchestratorId: input.orchestratorId, definition: input.definition, ...(input.pins && Object.keys(input.pins).length ? { pins: input.pins } : {}), ...(input.routingDefaults ? { routingDefaults: input.routingDefaults } : {}), status: "running",
-          step: input.definition.start, round: 1, entered: [], counters: {}, waitSeq: 0, awaiting: null,
-          ...(input.definition.version === 2 ? { inputs: input.inputs ?? {}, rootRunId: id, depth: 0, generation: 0, snapshot: input.snapshot, snapshotDigest: createHash("sha256").update(JSON.stringify(input.snapshot ?? {})).digest("hex"), limits: input.definition.limits, requestKey: input.requestKey, budget: { children: 0, activations: 0, agents: 0 } } : {}),
-          cursor: input.afterEventId, feedback: null, rounds: [], ...workflowBackstop({ definition: input.definition, step: input.definition.start }, now), createdAt: now, updatedAt: now,
-        });
-        if (!input.definition.version) await linkTask(ctx, input.taskId, id);
-        await writeEffect(ctx, run, 0, "started", {});
-        await ctx.events.emit("workflow.started", { runId: id, taskId: input.taskId, workflow: input.workflow });
-        await ctx.workflows.start("run", { runId: id }, { idempotencyKey: id, enlist: "op-commit" });
-        return { run, created: true };
-      },
-    },
-    get: {
-      kind: "query",
-      grant: ADMIN_GRANT,
-      summary: "Read one run record (system-only).",
-      expose: { http: false, mcp: false, cli: false },
-      input: z.object({ runId: z.string().min(1) }),
-      output: runSchema,
-      handler: async (ctx, input) => requireRun(ctx, input.runId),
-    },
-    openRuns: {
-      kind: "query",
-      grant: ADMIN_GRANT,
-      summary: "List running runs, for the supervisor's signal reconcile (system-only).",
-      expose: { http: false, mcp: false, cli: false },
-      input: z.object({ taskId: z.number().int().optional(), limit: z.number().int().min(1).max(200).optional(), cursor: z.string().optional() }),
-      output: z.object({ items: z.array(runSchema), cursor: z.string().optional() }),
-      handler: async (ctx, input) => {
-        const page = await stores(ctx).run.list({
-          where: { status: "running", ...(input.taskId !== undefined ? { taskId: input.taskId } : {}) },
-          ...(input.limit !== undefined ? { limit: input.limit } : {}),
-          ...(input.cursor !== undefined ? { cursor: input.cursor } : {}),
-        });
-        return { items: [...page.items], ...(page.cursor ? { cursor: page.cursor } : {}) };
-      },
-    },
-    taskRun: {
-      kind: "query",
-      grant: ADMIN_GRANT,
-      summary: "The running run that routes a Task's deliveries and the Task's verdict gate, if any (system-only).",
-      expose: { http: false, mcp: false, cli: false },
-      input: z.object({ taskId: z.number().int() }),
-      output: z.object({ runId: z.string().optional(), verdictGate: z.string().optional() }),
-      handler: async (ctx, input) => {
-        const link = await stores(ctx).link.get(String(input.taskId));
-        const run = link ? await stores(ctx).run.get(link.runId) : undefined;
-        if (run?.status !== "running") return {};
-        return { runId: run.id, ...(link?.gate ? { verdictGate: link.gate } : {}) };
-      },
-    },
-    signal: {
-      kind: "mutation",
-      idempotent: true,
-      grant: ADMIN_GRANT,
-      summary: "Satisfy a run's current wait with a durable src fact; a repeat or a stale key is a no-op (system-only).",
-      emits: [SIGNAL_TOPIC],
-      expose: { http: false, mcp: false, cli: false },
-      input: z.object({ key: z.string().min(1), runId: z.string().min(1), kind: signalSchema.shape.kind, payload: json }),
-      output: z.object({ created: z.boolean() }),
-      handler: async (ctx, input) => {
-        const run = await requireRun(ctx, input.runId);
-        if (run.status !== "running" || run.awaiting?.key !== input.key) return { created: false };
-        if (await stores(ctx).signal.get(input.key)) return { created: false };
-        await stores(ctx).signal.create({ id: input.key, runId: input.runId, kind: input.kind, payload: input.payload, createdAt: ctx.clock.now() });
-        await ctx.events.emit(SIGNAL_TOPIC, { runId: input.runId, correlationId: input.key });
-        return { created: true };
-      },
-    },
-    amendTokenBudget: {
-      kind: "mutation",
-      idempotent: true,
-      grant: ADMIN_GRANT,
-      summary: "Set a budgeted run's token cap; an absolute value, so a replay is a no-op (system-only).",
-      expose: { http: false, mcp: false, cli: false },
-      input: z.object({ runId: z.string().min(1), tokenCap: z.number().int().positive().max(Number.MAX_SAFE_INTEGER) }),
-      output: runSchema,
-      handler: async (ctx, input) => {
-        const run = await requireRun(ctx, input.runId);
-        if (!run.tokenBudget) throw new OpError("conflict", 409, `workflow run '${run.id}' has no token budget to amend`);
-        return stores(ctx).run.update(run.id, { tokenBudget: { tokenCap: input.tokenCap }, updatedAt: ctx.clock.now() });
-      },
-    },
-    exitedWaitAgent: {
-      kind: "query",
-      grant: ADMIN_GRANT,
-      summary: "The step agent a running run's delivery wait depends on, if it exited: the one its dispatch spawned or its message went to (system-only).",
-      expose: { http: false, mcp: false, cli: false },
-      input: z.object({ runId: z.string().min(1) }),
-      output: z.object({ agent: agentSchema.optional() }),
-      handler: async (ctx, input) => {
-        const run = await requireRun(ctx, input.runId);
-        if (run.status !== "running" || run.awaiting?.kind !== "delivery") return {};
-        const page = await stores(ctx).agent.list({ where: { runId: run.id }, limit: 200 });
-        const exited = page.items.filter((agent) => agent.exitedAt !== undefined || (agent.spawnFailedAt !== undefined && agent.readyAt === undefined));
-        if (!exited.length) return {};
-        // The wait's own effect names its agent: a fresh dispatch's spawn, or the warm builder its findings or resume note reached.
-        const ids = run.awaiting.effectId ? [run.awaiting.effectId] : (["dispatch", "findings"] as const).map((kind) => workflowEffectId(run.id, run.waitSeq, kind));
-        for (const id of ids) {
-          const effect = await stores(ctx).effect.get(id);
-          if (effect?.status !== "done") continue;
-          const spawned = textField(effect.result?.spawnRequestId);
-          const to = textField(effect.result?.to);
-          if (!spawned && !to) return {};
-          const agent = exited.filter((row) => (spawned ? row.id === spawned : row.agentId === to)).sort((a, b) => b.createdAt - a.createdAt)[0];
-          return agent ? { agent } : {};
-        }
-        return {};
-      },
-    },
-    hasSignal: {
-      kind: "query",
-      grant: ADMIN_GRANT,
-      summary: "Whether a wait's signal exists — the runtime's wait evaluator (system-only).",
-      expose: { http: false, mcp: false, cli: false },
-      input: z.object({ key: z.string().min(1) }),
-      output: z.object({ present: z.boolean() }),
-      handler: async (ctx, input) => ({ present: Boolean(await stores(ctx).signal.get(input.key)) }),
-    },
-    pendingEffects: {
-      kind: "query",
-      grant: ADMIN_GRANT,
-      summary: "List effect intents the src supervisor has not performed yet, oldest first per run (system-only).",
-      expose: { http: false, mcp: false, cli: false },
-      input: z.object({ limit: z.number().int().min(1).max(200).optional() }),
-      output: z.object({ items: z.array(effectSchema) }),
-      handler: async (ctx, input) => {
-        const page = await stores(ctx).effect.list({ where: { status: "pending" }, ...(input.limit !== undefined ? { limit: input.limit } : {}) });
-        return { items: [...page.items] };
-      },
-    },
-    resumeCleanup: {
-      kind: "mutation", idempotent: true, grant: ADMIN_GRANT,
-      summary: "Requeue deferred shutdowns for hosts that are online (system-only).",
-      expose: { http: false, mcp: false, cli: false },
-      input: z.object({ orchestratorIds: z.array(z.string()), cursor: z.string().optional() }),
-      output: z.object({ resumed: z.number(), cursor: z.string().optional() }),
-      handler: async (ctx, input) => {
-        const page = await stores(ctx).effect.list({ where: { status: "deferred" }, limit: 100, ...(input.cursor ? { cursor: input.cursor } : {}) });
-        const hosts = new Set(input.orchestratorIds);
-        let resumed = 0;
-        for (const effect of page.items) {
-          const targets = z.array(z.object({ orchestratorId: z.string() })).safeParse(effect.result?.deferred);
-          if (effect.kind !== "reap" || !targets.success || !targets.data.some(target => hosts.has(target.orchestratorId))) continue;
-          await stores(ctx).effect.update(effect.id, { status: "pending" });
-          resumed++;
-        }
-        return { resumed, ...(page.cursor ? { cursor: page.cursor } : {}) };
-      },
-    },
-    getEffect: {
-      kind: "query",
-      grant: ADMIN_GRANT,
-      summary: "Read one effect intent (system-only).",
-      expose: { http: false, mcp: false, cli: false },
-      input: z.object({ id: z.string().min(1) }),
-      output: z.object({ effect: effectSchema.optional() }),
-      handler: async (ctx, input) => {
-        const effect = await stores(ctx).effect.get(input.id);
-        return effect ? { effect } : {};
-      },
-    },
-    runAgents: {
-      kind: "query",
-      grant: ADMIN_GRANT,
-      summary: "The agents a run's steps spawned, oldest first (system-only).",
-      expose: { http: false, mcp: false, cli: false },
-      input: z.object({ runId: z.string().min(1) }),
-      output: z.object({ items: z.array(agentSchema) }),
-      handler: async (ctx, input) => {
-        const page = await stores(ctx).agent.list({ where: { runId: input.runId }, limit: 200 });
-        return { items: [...page.items].sort((a, b) => a.createdAt - b.createdAt) };
-      },
-    },
-    noteAgent: {
-      kind: "mutation",
-      idempotent: true,
-      grant: ADMIN_GRANT,
-      summary: "Record a step agent's lifecycle fact (registered, ready, exited, reaped, kept) on its current generation; a successor's ready rebinds the row (system-only).",
-      expose: { http: false, mcp: false, cli: false },
-      input: z.object({ spawnRequestId: z.string().min(1), fact: z.enum(["registered", "spawn-failed", "ready", "exited", "reaped", "kept"]), runId: z.string().optional(), agentId: z.string().optional(), reason: z.string().optional() }),
-      output: z.object({ recorded: z.boolean() }),
-      handler: async (ctx, input) => {
-        const store = stores(ctx).agent;
-        let agent = await store.get(input.spawnRequestId);
-        if (!agent && input.runId && input.agentId) {
-          const page = await store.list({ where: { runId: input.runId, agentId: input.agentId }, limit: 10 });
-          const prior = page.items.find((row) => row.spawnRequestId !== input.spawnRequestId);
-          // Only a successor's ready proves the new generation is the live one.
-          if (prior && input.fact === "ready") {
-            await store.update(prior.id, { spawnRequestId: input.spawnRequestId, readyAt: ctx.clock.now(), exitedAt: undefined, exitReason: undefined });
-            return { recorded: true };
-          }
-          agent = page.items.find((row) => row.spawnRequestId === input.spawnRequestId);
-        }
-        // A predecessor's late edge (register-before-kill restart) says nothing about the live generation.
-        if (!agent || agent.spawnRequestId !== input.spawnRequestId) return { recorded: false };
-        // #3160 — registration binds the agent id, whether or not a ready edge ever reaches the run.
-        if (input.fact === "registered") {
-          if (agent.agentId || !input.agentId) return { recorded: false };
-          await store.update(agent.id, { agentId: input.agentId });
-          return { recorded: true };
-        }
-        const run = input.fact === "spawn-failed" ? await requireRun(ctx, agent.runId) : undefined;
-        if (agent.reservationId && ["spawn-failed", "exited", "reaped"].includes(input.fact) && !(run?.rootRunId && run.cancel)) await releaseReservation(ctx, agent.reservationId);
-        const field = FACT_FIELD[input.fact as keyof typeof FACT_FIELD];
-        if (agent[field] !== undefined) return { recorded: false };
-        await store.update(agent.id, {
-          [field]: ctx.clock.now(),
-          ...(input.agentId && !agent.agentId ? { agentId: input.agentId } : {}),
-          ...(input.fact === "spawn-failed" && input.reason ? { spawnError: input.reason.slice(0, 500) } : {}),
-          ...(input.fact === "exited" && input.reason ? { exitReason: input.reason.slice(0, 500) } : {}),
-          ...(input.fact === "kept" && input.reason ? { keptReason: input.reason.slice(0, 500) } : {}),
-        });
-        return { recorded: true };
-      },
-    },
-    settleEffect: {
-      kind: "mutation",
-      idempotent: true,
-      grant: ADMIN_GRANT,
-      summary: "Record a performed (done), retryable (pending) or failed effect; a created Task joins the run (system-only).",
-      expose: { http: false, mcp: false, cli: false },
-      input: z.object({ id: z.string().min(1), status: effectSchema.shape.status, result: json.optional(), error: z.string().optional() }),
-      output: effectSchema,
-      handler: async (ctx, input) => {
-        const effect = await stores(ctx).effect.get(input.id);
-        if (!effect) throw new OpError("not_found", 404, `workflow effect '${input.id}' was not found`);
-        if (effect.status !== "pending") return effect;
-        const taskId = input.result?.taskId;
-        const gate = typeof effect.payload.gate === "string" ? effect.payload.gate : undefined;
-        if (input.status === "done" && typeof taskId === "number") await linkTask(ctx, taskId, effect.runId, gate, typeof effect.payload.activationId === "string" ? effect.payload.activationId : undefined);
-        if (input.status === "done" && input.result) await recordDispatchAgent(ctx, effect, input.result);
-        return stores(ctx).effect.update(input.id, {
-          status: input.status,
-          attempts: effect.attempts + 1,
-          ...(input.result ? { result: input.result } : {}),
-          ...(input.error ? { error: input.error } : {}),
-          ...(input.status === "pending" || input.status === "deferred" ? {} : { settledAt: ctx.clock.now() }),
-        });
-      },
-    },
-  },
-});

package/node_modules/@humwick/offload/LICENSE

@@ -1,167 +0,0 @@
-# PolyForm Shield License 1.0.0
-
-<https://polyformproject.org/licenses/shield/1.0.0>
-
-## Acceptance
-
-In order to get any license under these terms, you must agree
-to them as both strict obligations and conditions to all
-your licenses.
-
-## Copyright License
-
-The licensor grants you a copyright license for the
-software to do everything you might do with the software
-that would otherwise infringe the licensor's copyright
-in it for any permitted purpose.  However, you may
-only distribute the software according to [Distribution
-License](#distribution-license) and make changes or new works
-based on the software according to [Changes and New Works
-License](#changes-and-new-works-license).
-
-## Distribution License
-
-The licensor grants you an additional copyright license
-to distribute copies of the software.  Your license
-to distribute covers distributing the software with
-changes and new works permitted by [Changes and New Works
-License](#changes-and-new-works-license).
-
-## Notices
-
-You must ensure that anyone who gets a copy of any part of
-the software from you also gets a copy of these terms or the
-URL for them above, as well as copies of any plain-text lines
-beginning with `Required Notice:` that the licensor provided
-with the software.  For example:
-
-> Required Notice: Copyright Yoyodyne, Inc. (http://example.com)
-
-## Changes and New Works License
-
-The licensor grants you an additional copyright license to
-make changes and new works based on the software for any
-permitted purpose.
-
-## Patent License
-
-The licensor grants you a patent license for the software that
-covers patent claims the licensor can license, or becomes able
-to license, that you would infringe by using the software.
-
-## Noncompete
-
-Any purpose is a permitted purpose, except for providing any
-product that competes with the software or any product the
-licensor or any of its affiliates provides using the software.
-
-## Competition
-
-Goods and services compete even when they provide functionality
-through different kinds of interfaces or for different technical
-platforms.  Applications can compete with services, libraries
-with plugins, frameworks with development tools, and so on,
-even if they're written in different programming languages
-or for different computer architectures.  Goods and services
-compete even when provided free of charge.  If you market a
-product as a practical substitute for the software or another
-product, it definitely competes.
-
-## New Products
-
-If you are using the software to provide a product that does
-not compete, but the licensor or any of its affiliates brings
-your product into competition by providing a new version of
-the software or another product using the software, you may
-continue using versions of the software available under these
-terms beforehand to provide your competing product, but not
-any later versions.
-
-## Discontinued Products
-
-You may begin using the software to compete with a product
-or service that the licensor or any of its affiliates has
-stopped providing, unless the licensor includes a plain-text
-line beginning with `Licensor Line of Business:` with the
-software that mentions that line of business.  For example:
-
-> Licensor Line of Business: YoyodyneCMS Content Management
-System (http://example.com/cms)
-
-## Sales of Business
-
-If the licensor or any of its affiliates sells a line of
-business developing the software or using the software
-to provide a product, the buyer can also enforce
-[Noncompete](#noncompete) for that product.
-
-## Fair Use
-
-You may have "fair use" rights for the software under the
-law. These terms do not limit them.
-
-## No Other Rights
-
-These terms do not allow you to sublicense or transfer any of
-your licenses to anyone else, or prevent the licensor from
-granting licenses to anyone else.  These terms do not imply
-any other licenses.
-
-## Patent Defense
-
-If you make any written claim that the software infringes or
-contributes to infringement of any patent, your patent license
-for the software granted under these terms ends immediately. If
-your company makes such a claim, your patent license ends
-immediately for work on behalf of your company.
-
-## Violations
-
-The first time you are notified in writing that you have
-violated any of these terms, or done anything with the software
-not covered by your licenses, your licenses can nonetheless
-continue if you come into full compliance with these terms,
-and take practical steps to correct past violations, within
-32 days of receiving notice.  Otherwise, all your licenses
-end immediately.
-
-## No Liability
-
-***As far as the law allows, the software comes as is, without
-any warranty or condition, and the licensor will not be liable
-to you for any damages arising out of these terms or the use
-or nature of the software, under any kind of legal claim.***
-
-## Definitions
-
-The **licensor** is the individual or entity offering these
-terms, and the **software** is the software the licensor makes
-available under these terms.
-
-A **product** can be a good or service, or a combination
-of them.
-
-**You** refers to the individual or entity agreeing to these
-terms.
-
-**Your company** is any legal entity, sole proprietorship,
-or other kind of organization that you work for, plus all
-its affiliates.
-
-**Affiliates** means the other organizations than an
-organization has control over, is under the control of, or is
-under common control with.
-
-**Control** means ownership of substantially all the assets of
-an entity, or the power to direct its management and policies
-by vote, contract, or otherwise.  Control can be direct or
-indirect.
-
-**Your licenses** are all the licenses granted to you for the
-software under these terms.
-
-**Use** means anything you do with the software requiring one
-of your licenses.
-
-Required Notice: Copyright 2026 Exelerus AB
-Licensor Line of Business: provider-independent runtimes and coordination software for teams of AI agents

package/node_modules/@humwick/offload/README.md

@@ -1,57 +0,0 @@
-# @humwick/offload
-
-Bounded execution primitives for CPU workers, cooperative async I/O, and subprocesses.
-All runners use `OffloadEnvelope` for timeout, abort, structured logging, labels, typed
-`OffloadError`, and injected escalation.
-
-## Maintenance adoption
-
-`WorkerPool` and `SubprocessRunner` expose `offThread: true`; this is an intentional
-marker, not an automatic scheduler integration. A maintenance job that hands its heavy
-work to either runner must explicitly wire the existing #1757 seam immediately after
-starting it:
-
-```ts
-const work = runner.run("heavy-job", input, { signal: context.signal });
-if (runner.offThread) context.markOffThread?.();
-await work;
-```
-
-`AsyncRunner` is bounded but stays on the process event loop, so it does not advertise
-`offThread`.
-
-## Shutdown
-
-Every runner has a teardown that cancels rather than waits: `WorkerPool.destroy()`,
-`AsyncRunner.destroy()` and `SubprocessRunner.destroy()` reject outstanding work with an
-`aborted` `OffloadError`, kill live subprocess groups, and refuse new work. `drain()` is
-the opposite — it waits for accepted work to finish and cancels nothing.
-
-Because subprocess children run in their own process group, they are reparented rather
-than reaped when the host dies; the runner installs a single process `exit` hook that
-SIGKILLs any group still alive. A host killed with SIGKILL cannot run that hook, so a
-supervisor is still the only guarantee there.
-
-## Bounds worth knowing
-
-- `timeoutMs` (and abort) are hard for subprocesses: SIGTERM, then SIGKILL to the process
-  group after `killGraceMs` (default 2s), so a child that traps SIGTERM cannot outlive
-  its deadline. The concurrency slot is held until the child is actually reaped, so
-  `stats` never reports a slot as free while its work is still running.
-- A non-zero exit is a failure by default (it rejects and takes an escalation strike). Probe
-  callers whose answer *is* the exit code — `tmux has-session`, `which`, `git rev-parse`, a
-  land gate — must declare it with `okExitCodes` (`[0, 1]`, or `"any"` when the failing codes
-  are not enumerable). Without it the escalation signal inverts: the sink pages on a healthy
-  fleet and then latches, so the real outage goes unreported.
-  **`"any"` also accepts signal deaths** — 137 (SIGKILL, typically the OOM killer) and 139
-  (SIGSEGV) come back as successes and re-arm the strike counter. That is deliberate for a
-  land gate, where an OOM-killed gate is just a failed gate, but it means an infrastructure
-  death reads as a healthy answer and never escalates. Prefer an explicit code list unless
-  the failing codes genuinely cannot be enumerated; timeout and abort still throw either way.
-- Subprocess output is captured up to `maxOutputBytes` per stream (default 8 MiB) and the
-  result carries `truncated`. The stream is still drained past the cap so a chatty child
-  never blocks on a full pipe.
-- `AsyncRunner` work that ignores its signal keeps its slot until it returns: the cap
-  degrades toward serial rather than over-admitting. `destroy()` still returns promptly.
-- A worker round-trip costs ~110µs, so tasks below roughly 1ms of CPU are not worth
-  offloading. `run()` has no backpressure: the queue is unbounded by design.

package/node_modules/@humwick/offload/dist/async-runner.d.ts

@@ -1,18 +0,0 @@
-import { type OffloadDefaults, type OffloadEnvelope } from "./types.js";
-export interface AsyncRunnerOptions extends OffloadDefaults {
-    concurrency: number;
-}
-export interface AsyncRunner {
-    run<T>(taskName: string, fn: (signal: AbortSignal) => Promise<T> | T, env?: OffloadEnvelope): Promise<T>;
-    readonly stats: {
-        active: number;
-        queued: number;
-    };
-    /** Resolves when everything accepted so far has finished. Does not cancel anything. */
-    drain(): Promise<void>;
-    /** Cancels in-flight work, settles every outstanding caller, and refuses new work. */
-    destroy(): Promise<void>;
-}
-/** Bounded I/O runner. Work receives the composed signal and must cooperate with aborts. */
-export declare function createAsyncRunner(options: AsyncRunnerOptions): AsyncRunner;
-//# sourceMappingURL=async-runner.d.ts.map

package/node_modules/@humwick/offload/dist/async-runner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"async-runner.d.ts","sourceRoot":"","sources":["../src/async-runner.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgE,KAAK,eAAe,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAEtI,MAAM,WAAW,kBAAmB,SAAQ,eAAe;IACzD,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,WAAW;IAC1B,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACzG,QAAQ,CAAC,KAAK,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACnD,uFAAuF;IACvF,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,sFAAsF;IACtF,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAYD,4FAA4F;AAC5F,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,kBAAkB,GAAG,WAAW,CA6I1E"}