@capybara-hq/kernel 0.1.0-rc.25 → 0.1.0-rc.26

package/dist/tools/device-op-resolver.js

@@ -0,0 +1,121 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable } from "@nestjs/common";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { Transactional } from "../infra/database/transactional.decorator.js";
+import { DevicePolicyService, } from "../local-devices/device-policy.service.js";
+import { opVisibleIn, pendingPolicyOpsOf, } from "../local-devices/policy-summary.js";
+import { ApprovalsService } from "./approvals.service.js";
+/**
+ * The `device-op-resolve` job (transactional outbox spec §7): records what became of a device
+ * policy op whose outcome its caller did not record (a crash between the call and the resolve
+ * transaction, an answer that never came). Owed by the op's intent for when the op can no longer
+ * reach the machine, and by a hello that reported the op (`device-op-reported-<opId>`).
+ *
+ * An op without an entry any more is resolved already: a no-op. Otherwise the outcome is the one
+ * the hello reported, else the machine's answer to a read-only `policyStatus`: `applied` →
+ * recorded applied; `refused`, never received (`unknown` to the machine, or `absent` from its
+ * hello, once the op can no longer reach it) → failed; `started` (the machine stopped between
+ * its log and its answer), once the op can no longer reach it → applied when the policy it
+ * reports holds the change, else failed (`interrupted`); no answer (`offline`) → `unknown`, left
+ * for the machine's next hello. It never sends the change
+ * again (a widening after its ask closed is not allowed). An op that answers a network ask
+ * decides it when applied and the ask is still pending, else leaves it pending with the reason
+ * (`ApprovalsService.settleFromResolver`).
+ */
+let DeviceOpResolver = class DeviceOpResolver {
+    db;
+    txHost;
+    policies;
+    approvals;
+    constructor(db, txHost, policies, approvals) {
+        this.db = db;
+        this.txHost = txHost;
+        this.policies = policies;
+        this.approvals = approvals;
+    }
+    async resolve(data) {
+        const row = await this.db
+            .selectFrom("device_machines")
+            .select(["device_id", "pending_policy_ops"])
+            .where("id", "=", data.machineId)
+            .executeTakeFirst();
+        const op = pendingPolicyOpsOf(row?.pending_policy_ops).find((o) => o.id === data.opId);
+        if (row === undefined || op === undefined)
+            return;
+        const result = op.reported !== undefined
+            ? await this.reportedResult(row.device_id, op, op.reported.outcome)
+            : statusResult(op, await this.policies.outcomeOf(row.device_id, op.id));
+        await this.settle(data, op.source.approvalId, result);
+    }
+    /**
+     * The outcome a hello reported; a refusal's message (a hello carries none) is the machine's
+     * answer to `policyStatus` when it is connected.
+     */
+    async reportedResult(deviceId, op, outcome) {
+        if (outcome === "applied")
+            return { outcome: "applied" };
+        if (outcome === "absent")
+            return { outcome: "not_received" };
+        if (outcome === "interrupted")
+            return { outcome: "interrupted" };
+        const s = await this.policies.outcomeOf(deviceId, op.id);
+        const message = s.outcome === "refused" ? s.message : undefined;
+        return { outcome: "refused", message: (message ?? REFUSED_MESSAGE).slice(0, MAX_MESSAGE) };
+    }
+    /**
+     * The resolve transaction: the op's outcome, and the network ask it answers decided or given
+     * the reason in the same transaction (`ApprovalsService.settleFromResolver`).
+     */
+    async settle(data, approvalId, result) {
+        if (approvalId === null)
+            await this.policies.settleIn(data, result);
+        else
+            await this.approvals.settleFromResolver({ ...data, approvalId }, result);
+    }
+};
+__decorate([
+    Transactional()
+], DeviceOpResolver.prototype, "settle", null);
+DeviceOpResolver = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(TransactionHost)),
+    __param(2, Inject(DevicePolicyService)),
+    __param(3, Inject(ApprovalsService))
+], DeviceOpResolver);
+export { DeviceOpResolver };
+const REFUSED_MESSAGE = "The device's machine refused the policy change.";
+/** The longest refusal message kept from the machine (as its own op log keeps it). */
+const MAX_MESSAGE = 500;
+function statusResult(op, s) {
+    switch (s.outcome) {
+        case "applied":
+            return { outcome: "applied", ...(s.policy !== undefined && { policy: s.policy }) };
+        case "refused":
+            return { outcome: "refused", message: (s.message ?? REFUSED_MESSAGE).slice(0, MAX_MESSAGE) };
+        case "started":
+            // logged `started` only: once the op can no longer reach the machine, the policy it reports
+            // tells whether the change was written before it stopped
+            if (Date.now() < op.resolveAt || s.policy === undefined)
+                return { outcome: "unknown" };
+            return opVisibleIn(op, s.policy)
+                ? { outcome: "applied", policy: s.policy }
+                : { outcome: "interrupted" };
+        case "unknown":
+            // unknown to the machine: never received, once the op can no longer reach it (a job run
+            // early, on a clock running ahead, cannot tell yet)
+            return Date.now() >= op.resolveAt ? { outcome: "not_received" } : { outcome: "unknown" };
+        default:
+            // offline: its next hello tells
+            return { outcome: "unknown" };
+    }
+}

package/dist/tools/network-asks.d.ts

@@ -85,7 +85,7 @@ export declare function blockedEventHosts(blocked: readonly NetworkBlockedHost[]
  * the rest:
  * - `address` and `org` layers: a note each (in an unattended run an `org` host is a missing grant);
  *   `unknown`: nothing (the device's trailer explains);
- * - `device` layer on a program without `policyOp`: nothing (no ask, the trailer explains);
+ * - `device` layer on a program without `policyOpId`: nothing (no ask, the trailer explains);
  * - approved by the scheduled task the run serves (`run.taskGranted`) yet refused: a note that
  *   the device ignores the task's grants (never asked, never a missing grant);
  * - refused earlier in the run tree: the denied note; an unattended run in `fail` mode: its note

package/dist/tools/network-asks.js

@@ -90,7 +90,7 @@ export function blockedEventHosts(blocked) {
  * the rest:
  * - `address` and `org` layers: a note each (in an unattended run an `org` host is a missing grant);
  *   `unknown`: nothing (the device's trailer explains);
- * - `device` layer on a program without `policyOp`: nothing (no ask, the trailer explains);
+ * - `device` layer on a program without `policyOpId`: nothing (no ask, the trailer explains);
  * - approved by the scheduled task the run serves (`run.taskGranted`) yet refused: a note that
  *   the device ignores the task's grants (never asked, never a missing grant);
  * - refused earlier in the run tree: the denied note; an unattended run in `fail` mode: its note
@@ -107,9 +107,10 @@ export function planNetworkAsk(blocked, run, ctx) {
     const taskIgnored = [];
     const candidates = [];
     const missingGrants = [];
-    // a machine that reports blocked hosts and takes policy changes (Docker mode has no report)
+    // a machine that reports blocked hosts and takes policy changes under op ids (Docker mode has
+    // no report; a program without op ids cannot take 「一直允许」)
     const canAsk = ctx.device?.features.includes("networkReport") === true &&
-        ctx.device.features.includes("policyOp");
+        ctx.device.features.includes("policyOpId");
     // no run grant or policy change reaches a device whose owner turned remote grants off
     const remote = ctx.device?.policy?.remoteGrants !== "off";
     for (const b of hostsOf(blocked)) {

package/dist/tools/tools.module.js

@@ -34,6 +34,7 @@ import { ConnectorAccountPolicies } from "./connector-account-policies.js";
 import { ConnectorContent } from "./connector-content.js";
 import { ConnectorsService } from "./connectors.service.js";
 import { Credentials } from "./credentials.js";
+import { DeviceOpResolver } from "./device-op-resolver.js";
 import { ToolDrift } from "./drift.js";
 import { ConversationToolInfo, OrgExtensionTools } from "./info.js";
 import { OAuthFlow } from "./oauth/flow.js";
@@ -106,6 +107,8 @@ ToolsModule = __decorate([
             ConversationToolInfo,
             OrgExtensionTools,
             OrgToolSwitches,
+            // the `device-op-resolve` job's body (it may decide the network ask the op answers)
+            DeviceOpResolver,
         ],
         exports: [
             ScheduleToolsPort,
@@ -126,6 +129,7 @@ ToolsModule = __decorate([
             ConversationToolInfo,
             OrgExtensionTools,
             OrgToolSwitches,
+            DeviceOpResolver,
         ],
     })
 ], ToolsModule);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capybara-hq/kernel",
-  "version": "0.1.0-rc.25",
+  "version": "0.1.0-rc.26",
   "description": "Capybara kernel: config, database, plugin host and HTTP API of the Capybara agent platform",
   "license": "Apache-2.0",
   "repository": {
@@ -65,7 +65,7 @@
     "yaml": "^2.9.1",
     "yauzl": "3.4.0",
     "zod": "^4.6.7",
-    "@capybara-hq/plugin-sdk": "^0.1.0-rc.19"
+    "@capybara-hq/plugin-sdk": "^0.1.0-rc.20"
   },
   "devDependencies": {
     "@langchain/langgraph-checkpoint-validation": "^1.2.0",

package/src/migrations/0125_conversation_tree_stopped_at.sql

@@ -0,0 +1,5 @@
+-- Agent map spec §6 (changed in acceptance 2026-11-13): a person's stop of a root conversation
+-- stops its whole sub-agent tree and holds the tree's wakes. Set on the root by that stop, cleared
+-- when the root next starts a run; while set, no sub-agent delivery wakes the root and no
+-- sub-agent of its tree starts a run. Null on every existing row (no stop is held).
+ALTER TABLE conversations ADD COLUMN IF NOT EXISTS tree_stopped_at timestamptz;