@humwick/server 0.130.2 → 0.130.4

package/src/runtime-install.ts

@@ -0,0 +1,30 @@
+// Install Humwick packages into a runtime prefix: from the registry, or from packed tarballs
+// (`dev install`, and `init --tarball-dir` while the registry set is broken, #2680/#2324).
+import { execFile } from "node:child_process";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const INSTALL_TIMEOUT_MS = 10 * 60_000;
+const SERVER_TARBALL = /^humwick-server-.*\.tgz$/;
+
+/** `npm install` into `prefix`; bounded, and the error carries npm's output. */
+export async function npmInstallIntoPrefix(prefix: string, specs: string[]): Promise<string> {
+  mkdirSync(prefix, { recursive: true });
+  const manifest = join(prefix, "package.json");
+  if (!existsSync(manifest)) writeFileSync(manifest, JSON.stringify({ private: true, name: "humwick-runtime" }, null, 2) + "\n", "utf8");
+  const args = ["install", "--prefix", prefix, "--no-audit", "--no-fund", "--force", ...specs];
+  try {
+    const result = await execFileAsync("npm", args, { cwd: prefix, timeout: INSTALL_TIMEOUT_MS, maxBuffer: 16 * 1024 * 1024 });
+    return result.stdout.trim();
+  } catch (e) {
+    const err = e as Error & { stdout?: string; stderr?: string; killed?: boolean };
+    const tail = `${err.stdout ?? ""}\n${err.stderr ?? ""}`.trim().split("\n").slice(-20).join("\n");
+    throw new Error(`npm ${args.slice(0, 6).join(" ")} … failed${err.killed ? ` (timed out after ${INSTALL_TIMEOUT_MS / 1000} s)` : ""}:\n${tail || err.message}`);
+  }
+}
+
+export function isServerTarball(name: string): boolean {
+  return SERVER_TARBALL.test(name);
+}

package/src/runtime-tokens.ts

@@ -1,4 +1,4 @@
-import { registryToolName } from "@humwick/sdk";
+import { stringValue } from "@humwick/sdk";
 import { writeChildEnv } from "@humwick/sdk/env";
 import { deriveRunnerGrant, successorGrant } from "./runtime-grant";
 export { runnerSpawnGrantForAgent } from "./runtime-grant";
@@ -13,11 +13,9 @@ import { getLaunchFact, recordLaunchFact, type LaunchFact } from "./db/launch-fa
 import type { ComponentToken, SpawnApprovalMode, TokenConstraints, TokenRecord } from "./types";
 import { listManagedOrchestratorsForAgent } from "./orchestrator-lookup";
 import { sameHostIdentity } from "./utils";
-import { stringValue } from "@humwick/sdk";
-import { canonicalAgentProfileName, hasScope } from "@humwick/sdk/types";
+import { canonicalAgentProfileName } from "@humwick/sdk/types";
 import { COORDINATOR_PROFILE_NAMES } from "./agent-system-tags";
 import { SECRETS_DEFAULT_PROFILES, SECRETS_TOOL_GROUP, SECRETS_WRITE_SCOPE } from "./secrets-broker/config";
-import { INCLUDED_TOOL_SCOPE_NEEDS, RELAY_TOOL_GROUPS, resolveRelayTools, SELF_CARE_TOOL_GROUP } from "./mcp/tool-groups";
 
 /**
  * Who vouches for a runner launch's authority (#3110 review). A launch without a positively identified
@@ -194,8 +192,8 @@ export function issueOrchestratorRuntimeToken(input: {
 }
 
 /** #1870 S6c — the mint on the writer thread, for the async routes. */
-export function issueOrchestratorRuntimeTokenAsync(input: Parameters<typeof issueOrchestratorRuntimeToken>[0]): Promise<RuntimeTokenResult> {
-  return createTokenAsync(orchestratorTokenSpec(input));
+export async function issueOrchestratorRuntimeTokenAsync(input: Parameters<typeof issueOrchestratorRuntimeToken>[0]): Promise<RuntimeTokenResult> {
+  return (await createTokenAsync(orchestratorTokenSpec(input)));
 }
 
 function orchestratorTokenSpec(input: Parameters<typeof issueOrchestratorRuntimeToken>[0]): CreateTokenInput {
@@ -269,21 +267,15 @@ function runnerTokenSpec(input: RunnerRuntimeTokenInput): { token: CreateTokenIn
   const grant = authority.kind === "successor" ? successorGrant(input.agentId, profile)
     : { ...deriveRunnerGrant(profile, authority.kind === "delegated" ? { agentInitiated, callerScopes: authority.callerScopes, parentAgentId: input.spawnedBy, projectId: input.projectId, maxSpawnedAgents: input.maxSpawnedAgents } : { agentInitiated }), agentInitiated };
   const { canSpawn, maxSpawnedAgents, toolGroups, toolInclude, toolExclude } = grant;
-  const selected = resolveRelayTools({ groups: toolGroups, include: toolInclude, exclude: toolExclude });
-  for (const authoredName of toolInclude ?? []) {
-    const name = registryToolName(authoredName);
-    if (!selected.has(name)) continue;
-    const needs = INCLUDED_TOOL_SCOPE_NEEDS[name];
-    if (RELAY_TOOL_GROUPS.kernel!.includes(name) || (needs && !needs.some((need) => hasScope(grant.scope, need)))) {
-      throw new Error(`relay.tools.include: ${name} requires ${needs?.join(" or ") ?? "kernel control scopes"}; profile ${profile} cannot grant that scope under this launch authority`);
-    }
-  }
+  // Includes choose the surface, not launch authority. MCP scope filtering hides unavailable tools (#3817).
   // #1570 — provider-split: a Codex worker eager-loads every listed tool schema every turn (no
   // client-native deferral), so trim its always-loaded MCP surface to the lean worker set. Classified
   // by explicit worker profile (not tool-group shape — reviewers share the groups but aren't workers).
   const toolAllowlist = toolInclude !== undefined || toolExclude !== undefined
     ? undefined : toolAllowlistForRunner(input.provider, profile);
-  const hostPinned = grant.agentInitiated ? true : (input.hostPinned ?? hostPinForProfile(input.profile));
+  // #3804 — an agent-spawned child stays on its launch host, except a delegated sub-coordinator: its home host is
+  // often full, so it places spawns wherever its parent can unless the launch pinned it.
+  const hostPinned = grant.agentInitiated && !grant.delegated ? true : (input.hostPinned ?? hostPinForProfile(input.profile));
   const subject = input.policyName
     ? `runner:policy:${input.policyName}`
     : input.spawnRequestId
@@ -339,7 +331,7 @@ export function issueRunnerRuntimeTokenAsync(input: RunnerRuntimeTokenInput): Pr
   return createRunnerTokenAsync(spec.token, spec.launchFact ? { agentId: input.agentId, fact: spec.launchFact } : undefined);
 }
 
-export function issueInteractiveRunnerRuntimeToken(input: {
+export async function issueInteractiveRunnerRuntimeToken(input: {
   provider: string;
   cwd: string;
   runnerId: string;
@@ -351,9 +343,9 @@ export function issueInteractiveRunnerRuntimeToken(input: {
    * authorization, so it must ride the signature rather than the caller-writable agent card. */
   approvalMode?: SpawnApprovalMode;
   createdBy?: string;
-}): RuntimeTokenResult {
+}): Promise<RuntimeTokenResult> {
   const agentId = input.agentId ?? input.runnerId;
-  return createToken({
+  return (await createTokenAsync({
     profileId: "provider-interactive",
     sub: `runner:interactive:${input.host ?? "local"}:${input.runnerId}`,
     role: "provider",
@@ -368,22 +360,22 @@ export function issueInteractiveRunnerRuntimeToken(input: {
       canDelegate: false,
     },
     createdBy: input.createdBy ?? "interactive-runner",
-  });
+  }));
 }
 
-export function issueMcpRuntimeToken(input: {
+export async function issueMcpRuntimeToken(input: {
   sessionId: string;
   agentId?: string;
   targets?: string[];
   channels?: string[];
   createdBy?: string;
-}): RuntimeTokenResult {
+}): Promise<RuntimeTokenResult> {
   const targets = input.targets?.length
     ? input.targets
     : input.agentId
       ? ["user", input.agentId]
       : undefined;
-  return createToken({
+  return (await createTokenAsync({
     profileId: "mcp-client",
     sub: input.agentId ? `mcp:${input.agentId}:${input.sessionId}` : `mcp:session:${input.sessionId}`,
     role: "mcp",
@@ -394,16 +386,16 @@ export function issueMcpRuntimeToken(input: {
       canDelegate: false,
     },
     createdBy: input.createdBy ?? "runtime",
-  });
+  }));
 }
 
-export function issueIntegrationRuntimeToken(input: {
+export async function issueIntegrationRuntimeToken(input: {
   name: string;
   targets?: string[];
   channels?: string[];
   createdBy?: string;
-}): RuntimeTokenResult {
-  return createToken({
+}): Promise<RuntimeTokenResult> {
+  return (await createTokenAsync({
     profileId: "integration-client",
     sub: input.name,
     role: "integration",
@@ -414,7 +406,7 @@ export function issueIntegrationRuntimeToken(input: {
       canDelegate: false,
     },
     createdBy: input.createdBy ?? "runtime",
-  });
+  }));
 }
 
 export function runnerRuntimeTokenEnv(input: RunnerRuntimeTokenInput): Record<string, string> {

package/src/secrets-broker/config.ts

@@ -9,7 +9,7 @@ import { envFilePath } from "@humwick/sdk/child-env";
 export const SECRETS_TOOL_GROUP = "secrets";
 export const SECRETS_WRITE_SCOPE = "secrets:write";
 /** Built-in profiles whose default full surface includes the secrets group. */
-export const SECRETS_DEFAULT_PROFILES: ReadonlySet<string> = new Set(["coordinator", "ops-assistant"]);
+export const SECRETS_DEFAULT_PROFILES: ReadonlySet<string> = new Set(["coordinator"]);
 
 export const UPLOAD_LINK_TTL_MS = 15 * 60_000;
 export const SECRET_UPLOAD_PATH_PREFIX = "/api/secrets/upload/";

package/src/secrets-broker/service.ts

@@ -27,13 +27,13 @@ let client: InfisicalBrokerClient | undefined;
 
 function brokerClient(): InfisicalBrokerClient {
   client ??= new InfisicalBrokerClient(secretsBrokerSettings(), {
-    onLoginBlocked: (detail) => raiseOperatorAlarm({
+    onLoginBlocked: async (detail) => (await raiseOperatorAlarm({
       clientId: "secrets-broker:login-blocked",
       source: "secrets-broker",
       subject: "Secrets broker login blocked",
       detail: `${detail}. Fix the cause, then rotate or touch the credential files to re-arm.`,
       dedupeEvent: true,
-    }),
+    })),
   });
   return client;
 }

package/src/security.ts

@@ -1,3 +1,4 @@
+import { retireHandedOffPredecessor, tokenRetirementPending } from "./db/token-standing-async";
 import { BRIDGED_CORS_HEADERS, relayHeader } from "@humwick/sdk";
 import { versionedPromptsEnabled } from "./versioned-prompts";
 import { serviceAccessRouteScope } from "./service-access/scope";
@@ -242,6 +243,7 @@ const SHARED_UI_ROUTE_SCOPES: Record<string, string> = {
   "/api/metrics/hub": "stats:read",
   "/api/shipping/board": "stats:read",
   "/api/shipping/stats": "stats:read",
+  "/api/shipping/known-failures": "agent:read", // #3362 §11: read by builders' delivery gates
   "/api/stats/token-usage": "stats:read",
   // #3567 — every signed-in user reads their profile and sets their password (the handler requires a session or the admin token).
   "/api/users/me": "agent:read",
@@ -539,7 +541,7 @@ export function verifyComponentToken(token: string, nowSeconds = Math.floor(Date
   const payload = parseBase64urlJson(payloadRaw);
   if (!isComponentToken(payload)) return null;
   if (payload.exp !== undefined && payload.exp <= nowSeconds) return null;
-  if (payload.jti && isTokenRevoked(payload.jti)) return null;
+  if (payload.jti && (tokenRetirementPending(payload.jti) || isTokenRevoked(payload.jti, retireHandedOffPredecessor))) return null;
   return payload;
 }
 

package/src/self-resume-carry.ts

@@ -1,69 +1,35 @@
 import { errMessage, isRecord, stringValue } from "@humwick/sdk";
-import {
-  attachRecoveryCommand, carryingRecoveryObligations, closeRecoveryObligations, getAgent, insertContextReset, openRecoveryObligation, readsToCarry,
-  sendMessageWithResult, writeTransaction, type ContextResetFact, type RecoveryObligation,
-} from "./db";
+import { getAgent } from "./db";
+import type { ContextResetFact } from "./db/context-reset-carry";
+import { commandBoundary } from "./db/context-carry-write";
+import { getGateway } from "./db/gateway";
+import type { SendMessageResult } from "./db/messages";
 import { emitCommandEvent } from "./command-events";
 import { createSelfRestartCommandAsync } from "./services/restart-spawn";
-import { isContinuationSelfResumeCommand } from "./self-resume-command";
 import { emitNewMessage } from "./sse";
 import type { Command, Message } from "./types";
 
-// #3398 (docs/design/self-resume-carry.md) — the one owner of self-resume recovery. An accepted boundary
-// opens an obligation; every provider reset fact after the first capture sends the agent one unread
-// "Possible unread messages" list. At least once: a listed message may already be handled.
-
-const LISTED_IDS = 200;
-// The loss #3398 fixes is reads in the minutes before the self-care call or during it (#3523); earlier ones are in the saved state.
-const CARRY_MARGIN_MS = 10 * 60_000;
-// A failed or swept command proves nothing about its destructive input, so its list is only a fallback.
-const FALLBACK_STATUSES: ReadonlySet<Command["status"]> = new Set(["failed", "canceled", "timed_out", "rejected"]);
-
-/** Opens the obligation at accept, before the boundary command exists. */
-export function openContextRecovery(agentId: string, generation: number, now: number): void {
-  openRecoveryObligation(agentId, generation, now);
+export async function openContextRecovery(agentId: string, generation: number, now: number): Promise<void> {
+  await getGateway().write("contextCarry.open", { agentId, generation, now });
 }
-
-export function attachContextRecoveryCommand(agentId: string, generation: number, commandId: string): void {
-  attachRecoveryCommand(agentId, generation, commandId);
+export async function attachContextRecoveryCommand(agentId: string, generation: number, commandId: string): Promise<void> {
+  await getGateway().write("contextCarry.attach", { agentId, generation, commandId });
 }
-
-/** Ingests one reset fact. Idempotent per reset id; returns the list it sent, if any. */
-export function recordContextReset(fact: ContextResetFact): Message | null {
-  const now = Date.now();
-  return sendAndEmit(() => {
-    if (!insertContextReset(fact, now)) return null;
-    const carrying = carryingRecoveryObligations(fact.agentId);
-    if (!carrying.length) return null;
-    const result = sendCarry(fact.agentId, carrying, `${fact.resetId}:0`, { resetId: fact.resetId, kind: fact.kind });
-    closeRecoveryObligations(fact.agentId, settledBy(fact, carrying), `reset:${fact.resetId}`, now);
-    return result;
-  });
+export async function recordContextReset(fact: ContextResetFact): Promise<Message | null> {
+  return emitCarry(await getGateway().write("contextCarry.reset", { fact }) as unknown as SendMessageResult | null);
 }
-
-/**
- * Terminal-command hook (bus, HTTP and the lease sweep): a failed boundary still sends a list now, and
- * stays open. One whose destructive input reached the provider unsettled is replaced by a fresh process.
- */
-export function settleContextResetCarry(command: Command): Message | null {
-  const boundary = FALLBACK_STATUSES.has(command.status) ? commandBoundary(command) : null;
-  if (!boundary) return null;
-  const message = sendAndEmit(() => {
-    const carrying = carryingRecoveryObligations(boundary.agentId);
-    if (!carrying.some((obligation) => obligation.open && obligation.generation === boundary.generation)) return null;
-    const sent = sendCarry(boundary.agentId, carrying, `${command.id}:fallback`, { boundaryCommandId: command.id, status: command.status });
-    // The runner aborted before any destructive input reached the provider: no reset can follow, so nothing is owed (#3441).
-    if (isRecord(command.result) && command.result.destructiveInputSubmitted === false) {
-      closeRecoveryObligations(boundary.agentId, [boundary.generation], `submit-aborted:${command.id}`, Date.now());
-    }
-    return sent;
-  });
-  if (command.status === "failed" && isRecord(command.result) && command.result.destructiveInputUnsettled === true) {
-    void replaceUnsettledBoundary(command, boundary).catch((error) => console.error(`#3398 self-restart after unsettled ${command.type} ${command.id} failed: ${errMessage(error)}`));
+export async function settleContextResetCarry(command: Command): Promise<Message | null> {
+  const result = emitCarry(await getGateway().write("contextCarry.settle", { command }) as unknown as SendMessageResult | null);
+  const boundary = commandBoundary(command);
+  if (boundary && command.status === "failed" && isRecord(command.result) && command.result.destructiveInputUnsettled === true) {
+    await replaceUnsettledBoundary(command, boundary);
   }
-  return message;
+  return result;
+}
+function emitCarry(result: SendMessageResult | null): Message | null {
+  if (result && (result.created || result.updated)) emitNewMessage(result.message);
+  return result?.message ?? null;
 }
-
 /** The provider may still apply the input without any observable reset: a successor's registration is the reset instead. */
 async function replaceUnsettledBoundary(command: Command, boundary: { agentId: string; generation: number }): Promise<void> {
   const agent = getAgent(boundary.agentId);
@@ -74,58 +40,3 @@ async function replaceUnsettledBoundary(command: Command, boundary: { agentId: s
   const restart = await createSelfRestartCommandAsync(agent, boundary.generation, continuation, fullContextMessageId, "reset-unconfirmed", Date.now());
   emitCommandEvent(restart, "command.requested");
 }
-
-/** A reset settles only the boundary its provider evidence names; a replaced process settles all. */
-function settledBy(fact: ContextResetFact, carrying: RecoveryObligation[]): number[] {
-  const open = carrying.filter((obligation) => obligation.open);
-  if (fact.kind === "restart") return open.map((obligation) => obligation.generation);
-  return open.filter((obligation) => fact.commandId !== undefined && obligation.commandId === fact.commandId).map((obligation) => obligation.generation);
-}
-
-function commandBoundary(command: Command): { agentId: string; generation: number } | null {
-  const selfResume = isRecord(command.params.selfResume) ? command.params.selfResume : undefined;
-  const generation = selfResume?.generation;
-  if (typeof generation !== "number") return null;
-  if (command.type === "agent.restart") {
-    const agentId = stringValue(command.params.agentId);
-    return agentId && isRecord(command.params.selfRestart) ? { agentId, generation } : null;
-  }
-  return isContinuationSelfResumeCommand(command) ? { agentId: command.target, generation } : null;
-}
-
-type SendResult = ReturnType<typeof sendMessageWithResult>;
-
-function sendAndEmit(write: () => SendResult | null): Message | null {
-  const result = writeTransaction(write);
-  if (result && (result.created || result.updated)) emitNewMessage(result.message);
-  return result?.message ?? null;
-}
-
-// Floor: the earliest capture start minus the margin. No upper bound: a read after the reset is a duplicate, never a loss, and needs no clock comparison.
-function sendCarry(agentId: string, carrying: RecoveryObligation[], key: string, detail: Record<string, unknown>): SendResult | null {
-  const ids = readsToCarry(agentId, Math.min(...carrying.map((obligation) => obligation.openedAt)) - CARRY_MARGIN_MS);
-  if (!ids.length) return null;
-  return sendMessageWithResult({
-    from: "system",
-    to: agentId,
-    kind: "system",
-    subject: "Possible unread messages",
-    body: renderCarryBody(ids),
-    payload: { selfResumeCarry: { ...detail, generations: carrying.map((obligation) => obligation.generation), messageIds: ids } },
-    idempotencyKey: `self-resume-carry:${agentId}:${key}`,
-    replyExpected: false,
-    maxAgeSeconds: null,
-  });
-}
-
-function renderCarryBody(ids: number[]): string {
-  const listed = ids.slice(0, LISTED_IDS).map((id) => `#${id}`).join(" ");
-  const rest = ids.length > LISTED_IDS ? `\n…and ${ids.length - LISTED_IDS} more, up to #${ids.at(-1)}; every id is in this message's payload.` : "";
-  return [
-    `Possible unread messages: ${ids.length} message${ids.length === 1 ? "" : "s"} reached you around your context reset, after or shortly before you saved your working state, so your current context may not hold them.`,
-    "Check each one your working state does not already cover with relay_get_message <id>, and handle it. Some may be duplicates of work you have done.",
-    "Messages you already handled may appear here, including the reset instruction itself: do not repeat a reset instruction found here.",
-    "",
-    `${listed}${rest}`,
-  ].join("\n");
-}

package/src/self-resume-supersede.ts

@@ -1,5 +1,6 @@
+import { updateCommandAsync } from "./commands-write";
 import { getContinuationEnvelope } from "./db/continuations";
-import { updateCommand } from "./commands-db";
+
 import type { Command } from "./types";
 
 /** #3662 — a continuation belongs to one generation; once a newer one is captured, an older boundary is
@@ -14,6 +15,6 @@ export function supersedingGeneration(boundary: Command): number | null {
 
 /** Cancel (never fail) the not-yet-started injects of a superseded boundary. Accepted/running ones are
  *  already in the provider's hands and settle on their own. */
-export function cancelSupersededInjects(pendingAttemptIds: string[], current: number): void {
-  for (const id of pendingAttemptIds) updateCommand(id, { status: "canceled", error: `superseded by continuation generation ${current}` });
+export async function cancelSupersededInjects(pendingAttemptIds: string[], current: number): Promise<void> {
+  for (const id of pendingAttemptIds) (await updateCommandAsync(id, { status: "canceled", error: `superseded by continuation generation ${current}` }));
 }