@intentic/sandbox-contract 1.326.0 → 1.328.0

package/src/{front/generated/front-wire.json → netd/generated/netd-wire.json}

@@ -1,7 +1,9 @@
 {
   "askPatienceMs": 5000,
   "env": {
-    "frontSocket": "INTENTIC_FRONT_SOCKET",
+    "generation": "INTENTIC_NODE_GENERATION",
+    "instance": "INTENTIC_INSTANCE",
+    "netdSocket": "INTENTIC_NETD_SOCKET",
     "nodeSocket": "INTENTIC_NODE_SOCKET"
   },
   "frame": {
@@ -99,33 +101,8 @@
         ],
         "type": "object"
       },
-      "FrontQuestion": {
-        "description": "A question Node asks the front.",
-        "oneOf": [
-          {
-            "description": "Where each checkout's count stands, once every write that finished before this was sent is counted.",
-            "properties": {
-              "dirs": {
-                "items": {
-                  "type": "string"
-                },
-                "type": "array"
-              },
-              "question": {
-                "const": "sync",
-                "type": "string"
-              }
-            },
-            "required": [
-              "question",
-              "dirs"
-            ],
-            "type": "object"
-          }
-        ]
-      },
       "ListenConfig": {
-        "description": "Every port the front binds, as Node's config names them; an absent one is not bound.",
+        "description": "Every port netd binds, as Node's config names them; an absent one is not bound.",
         "properties": {
           "daemon": {
             "$ref": "#/$defs/Endpoint"
@@ -176,8 +153,33 @@
         ],
         "type": "object"
       },
+      "NetdQuestion": {
+        "description": "A question Node asks netd.",
+        "oneOf": [
+          {
+            "description": "Where each checkout's count stands, once every write that finished before this was sent is counted.",
+            "properties": {
+              "dirs": {
+                "items": {
+                  "type": "string"
+                },
+                "type": "array"
+              },
+              "question": {
+                "const": "sync",
+                "type": "string"
+              }
+            },
+            "required": [
+              "question",
+              "dirs"
+            ],
+            "type": "object"
+          }
+        ]
+      },
       "Page": {
-        "description": "An answer Node renders whole when asked, for the front to write as it stands: a refusal page, or the probe's report.",
+        "description": "An answer Node renders whole when asked, for netd to write as it stands: a refusal page, or the probe's report.",
         "properties": {
           "body": {
             "type": "string"
@@ -206,7 +208,7 @@
         "description": "What becomes of a preview host's request, decided by Node once, when asked.",
         "oneOf": [
           {
-            "description": "The front relays it to this upstream.",
+            "description": "netd relays it to this upstream.",
             "properties": {
               "to": {
                 "const": "upstream",
@@ -223,7 +225,7 @@
             "type": "object"
           },
           {
-            "description": "The front answers it with this page.",
+            "description": "netd answers it with this page.",
             "properties": {
               "page": {
                 "$ref": "#/$defs/Page"
@@ -265,7 +267,7 @@
         "description": "What a terminal socket opens onto, as Node decided from its ticket, session name and working directory.",
         "oneOf": [
           {
-            "description": "The tmux session `name`, created in `create_in` when it does not exist yet; without a directory it is only ever\nattached, so a session that is gone fails as itself rather than as a bare shell in its place. The front composes\nthe command.",
+            "description": "The tmux session `name`, created in `create_in` when it does not exist yet; without a directory it is only ever\nattached, so a session that is gone fails as itself rather than as a bare shell in its place. netd composes\nthe command.",
             "properties": {
               "createIn": {
                 "type": [
@@ -409,7 +411,7 @@
         "type": "object"
       },
       "WatchedCheckout": {
-        "description": "A checkout whose changes the front counts: its working tree, the git dir holding its index and HEAD, and the common\ndir holding refs and excludes (the git dir itself for a repository's main checkout).",
+        "description": "A checkout whose changes netd counts: its working tree, the git dir holding its index and HEAD, and the common\ndir holding refs and excludes (the git dir itself for a repository's main checkout).",
         "properties": {
           "commonDir": {
             "type": "string"
@@ -429,14 +431,22 @@
         "type": "object"
       }
     },
-    "description": "Everything Node sends the front.",
+    "description": "Everything Node sends netd.",
     "oneOf": [
       {
-        "description": "Node's HTTP socket is accepting; once per Node process.",
+        "description": "Node's HTTP socket is accepting; once per Node process. `generation` is the `GENERATION_ENV` it was started with,\nabsent from a Node that predates it.",
         "properties": {
           "build": {
             "type": "string"
           },
+          "generation": {
+            "format": "uint64",
+            "minimum": 0,
+            "type": [
+              "integer",
+              "null"
+            ]
+          },
           "kind": {
             "const": "hello",
             "type": "string"
@@ -526,7 +536,7 @@
             "type": "string"
           },
           "question": {
-            "$ref": "#/$defs/FrontQuestion"
+            "$ref": "#/$defs/NetdQuestion"
           }
         },
         "required": [
@@ -642,10 +652,10 @@
   ],
   "toNode": {
     "$defs": {
-      "FrontAnswer": {
+      "NetdAnswer": {
         "oneOf": [
           {
-            "description": "Each asked checkout's generation, in the order asked: a number that moves whenever anything a `git status` there\nreads may have changed, and null for a checkout the front is not counting.",
+            "description": "Each asked checkout's generation, in the order asked: a number that moves whenever anything a `git status` there\nreads may have changed, and null for a checkout netd is not counting.",
             "properties": {
               "answer": {
                 "const": "sync",
@@ -672,7 +682,7 @@
         ]
       },
       "Question": {
-        "description": "A question the front asks Node.",
+        "description": "A question netd asks Node.",
         "oneOf": [
           {
             "description": "What becomes of a request to a preview host; `probe` when it asks the preview probe's path.",
@@ -713,7 +723,7 @@
             "type": "object"
           },
           {
-            "description": "Whether Node's event loop turns, and how fast: answered `pong` at once, by the link itself. The front sends one\nevery 2 s once the previous one is answered, and reports the round trip as the vitals' lag. An older Node answers\nwith a refusal, or with an answer the front cannot read, and either still counts as answered.",
+            "description": "Whether Node's event loop turns, and how fast: answered `pong` at once, by the link itself. netd sends one\nevery 2 s once the previous one is answered, and reports the round trip as the vitals' lag. An older Node answers\nwith a refusal, or with an answer netd cannot read, and either still counts as answered.",
             "properties": {
               "question": {
                 "const": "ping",
@@ -726,9 +736,44 @@
             "type": "object"
           }
         ]
+      },
+      "TunnelRefusal": {
+        "description": "Why netd stopped dialling the ingress at its usual pace, past an ordinary drop it redials at once.",
+        "oneOf": [
+          {
+            "description": "Another copy of this sandbox (a container holding the same grant) holds its tunnel, running on `host` as the\nedge named it: the edge refused this netd three times in a row, and netd now dials every 15 minutes.",
+            "properties": {
+              "host": {
+                "type": "string"
+              },
+              "refusal": {
+                "const": "elsewhere",
+                "type": "string"
+              }
+            },
+            "required": [
+              "refusal",
+              "host"
+            ],
+            "type": "object"
+          },
+          {
+            "description": "The platform deleted this sandbox: the edge closed its tunnel for that, and netd stopped dialling.",
+            "properties": {
+              "refusal": {
+                "const": "deleted",
+                "type": "string"
+              }
+            },
+            "required": [
+              "refusal"
+            ],
+            "type": "object"
+          }
+        ]
       }
     },
-    "description": "Everything the front sends Node.",
+    "description": "Everything netd sends Node.",
     "oneOf": [
       {
         "properties": {
@@ -755,7 +800,7 @@
       {
         "properties": {
           "answer": {
-            "$ref": "#/$defs/FrontAnswer"
+            "$ref": "#/$defs/NetdAnswer"
           },
           "id": {
             "format": "uint32",
@@ -797,6 +842,7 @@
         "type": "object"
       },
       {
+        "description": "Where the ingress tunnel's interactive socket stands, told on every change and again to each Node that says\nhello. `reason` says why it is not held, in netd's words (a drop, the edge's refusal), and `refused` when\nnetd stopped redialling at its usual pace (2026-10-05).",
         "properties": {
           "connected": {
             "type": "boolean"
@@ -804,6 +850,22 @@
           "kind": {
             "const": "tunnel",
             "type": "string"
+          },
+          "reason": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "refused": {
+            "anyOf": [
+              {
+                "$ref": "#/$defs/TunnelRefusal"
+              },
+              {
+                "type": "null"
+              }
+            ]
           }
         },
         "required": [

package/src/{front → netd}/generated/tunnel.json

@@ -1,7 +1,10 @@
 {
   "close": {
     "away": 1001,
+    "deleted": 4010,
+    "demoted": 4008,
     "displaced": 4001,
+    "heldElsewhere": 4009,
     "refused": 4003
   },
   "headers": {
@@ -10,23 +13,34 @@
     "lane": "x-intentic-lane",
     "transports": "x-intentic-transports"
   },
+  "identity": {
+    "holder": "x-intentic-holder",
+    "host": "x-intentic-host",
+    "instance": "x-intentic-instance"
+  },
   "lanes": [
     "interactive",
     "bulk"
   ],
   "liveness": {
     "deadAfterMs": 45000,
-    "pingEveryMs": 15000
+    "helloPatienceMs": 15000,
+    "pingEveryMs": 15000,
+    "probeEveryMs": 15000,
+    "probePatienceMs": 10000
   },
   "mux": "yamux",
   "path": "/tunnel/v2",
   "quic": {
     "alpn": "intentic-tunnel/1",
     "hello": {
+      "acknowledged": 1,
       "gone": 2,
       "held": 0,
+      "heldElsewhere": 3,
       "refused": 1
     },
+    "probe": "\u0000intentic-probe\n",
     "yieldAfterBytes": 1048576
   },
   "transports": [

package/src/{front → netd}/generated/wire.ts

@@ -14,25 +14,12 @@ export type Certificate = { certificate: string, privateKey: string, };
 export type Endpoint = { host: string, port: number, };
 
 /**
- * Everything Node sends the front.
+ * Everything Node sends netd.
  */
-export type FromNode = { "kind": "hello", build: string, pid: number, } | { "kind": "listen", config: ListenConfig, } | { "kind": "certificate", certificate?: Certificate, } | { "kind": "tunnel", tunnel?: TunnelConfig, } | { "kind": "ask", id: number, question: FrontQuestion, } | { "kind": "answer", id: number, answer: Answer, } | { "kind": "refused", id: number, message: string, } | { "kind": "revoke", member?: string, } | { "kind": "watch", checkout: WatchedCheckout, } | { "kind": "unwatch", dir: string, };
-
-export type FrontAnswer = { "answer": "sync", generations: Array<number | null>, };
-
-/**
- * Request headers only the front sets on what it forwards to Node; it strips them from everything arriving outside.
- * Exported as a literal type, so a Node constant naming one that drifts from this spelling fails to compile.
- */
-export type FrontHeader = "x-intentic-preview" | "x-intentic-preview-unreachable";
+export type FromNode = { "kind": "hello", build: string, pid: number, generation?: number, } | { "kind": "listen", config: ListenConfig, } | { "kind": "certificate", certificate?: Certificate, } | { "kind": "tunnel", tunnel?: TunnelConfig, } | { "kind": "ask", id: number, question: NetdQuestion, } | { "kind": "answer", id: number, answer: Answer, } | { "kind": "refused", id: number, message: string, } | { "kind": "revoke", member?: string, } | { "kind": "watch", checkout: WatchedCheckout, } | { "kind": "unwatch", dir: string, };
 
 /**
- * A question Node asks the front.
- */
-export type FrontQuestion = { "question": "sync", dirs: Array<string>, };
-
-/**
- * Every port the front binds, as Node's config names them; an absent one is not bound.
+ * Every port netd binds, as Node's config names them; an absent one is not bound.
  */
 export type ListenConfig = { daemon: Endpoint, preview?: Endpoint, loopback?: Endpoint, 
 /**
@@ -48,8 +35,21 @@ frameAncestors: Array<string>,
  */
 previewProbePath: string, };
 
+export type NetdAnswer = { "answer": "sync", generations: Array<number | null>, };
+
 /**
- * An answer Node renders whole when asked, for the front to write as it stands: a refusal page, or the probe's report.
+ * Request headers only netd sets on what it forwards to Node; it strips them from everything arriving outside.
+ * Exported as a literal type, so a Node constant naming one that drifts from this spelling fails to compile.
+ */
+export type NetdHeader = "x-intentic-preview" | "x-intentic-preview-unreachable";
+
+/**
+ * A question Node asks netd.
+ */
+export type NetdQuestion = { "question": "sync", dirs: Array<string>, };
+
+/**
+ * An answer Node renders whole when asked, for netd to write as it stands: a refusal page, or the probe's report.
  */
 export type Page = { status: number, headers: { [key in string]: string }, body: string, };
 
@@ -59,7 +59,7 @@ export type Page = { status: number, headers: { [key in string]: string }, body:
 export type PreviewRoute = { "to": "upstream", upstream: Upstream, } | { "to": "page", page: Page, } | { "to": "outbox" };
 
 /**
- * A question the front asks Node.
+ * A question netd asks Node.
  */
 export type Question = { "question": "preview", host: string, probe: boolean, } | { "question": "terminal", query: string, } | { "question": "ping" };
 
@@ -71,9 +71,9 @@ export type Scheme = "http" | "https";
 export type TerminalPlan = { "plan": "session", name: string, createIn?: string, } | { "plan": "tail", path: string, } | { "plan": "exit", code: number, reason: string, } | { "plan": "refused", code: number, reason: string, };
 
 /**
- * Everything the front sends Node.
+ * Everything netd sends Node.
  */
-export type ToNode = { "kind": "ask", id: number, question: Question, } | { "kind": "answer", id: number, answer: FrontAnswer, } | { "kind": "refused", id: number, message: string, } | { "kind": "tunnel", connected: boolean, };
+export type ToNode = { "kind": "ask", id: number, question: Question, } | { "kind": "answer", id: number, answer: NetdAnswer, } | { "kind": "refused", id: number, message: string, } | { "kind": "tunnel", connected: boolean, reason?: string, refused?: TunnelRefusal, };
 
 /**
  * The ingress tunnel's door, the reachability grant it presents there, and the daemon's transfer routes it announces
@@ -81,6 +81,11 @@ export type ToNode = { "kind": "ask", id: number, question: Question, } | { "kin
  */
 export type TunnelConfig = { url: string, grant: string, bulk: Array<string>, };
 
+/**
+ * Why netd stopped dialling the ingress at its usual pace, past an ordinary drop it redials at once.
+ */
+export type TunnelRefusal = { "refusal": "elsewhere", host: string, } | { "refusal": "deleted" };
+
 /**
  * A local upstream a preview host relays to.
  */
@@ -95,7 +100,7 @@ localhost: boolean,
 frameable: boolean, };
 
 /**
- * A checkout whose changes the front counts: its working tree, the git dir holding its index and HEAD, and the common
+ * A checkout whose changes netd counts: its working tree, the git dir holding its index and HEAD, and the common
  * dir holding refs and excludes (the git dir itself for a repository's main checkout).
  */
 export type WatchedCheckout = { dir: string, gitDir: string, commonDir: string, };

package/src/netd/netd-wire.ts

@@ -0,0 +1,24 @@
+// The control socket between intentic-netd and the daemon. The Rust crate `netd-wire` is the definition: its types
+// arrive as TypeScript in generated/, and every value here is held to the manifest it writes beside it
+// (wire-manifests.test.ts), which contract.lock.json pins.
+
+export type * from "./generated/wire.js";
+
+// Set by intentic-netd on the daemon it spawns: where to dial the control socket, and where to serve HTTP.
+export const NETD_SOCKET_ENV = "INTENTIC_NETD_SOCKET";
+export const NODE_SOCKET_ENV = "INTENTIC_NODE_SOCKET";
+// Also set by intentic-netd on each daemon it starts: which start this is, counted from 1 and said back in the hello, so
+// netd hands the control socket to a newer start and never to a copy of the same one.
+export const NODE_GENERATION_ENV = "INTENTIC_NODE_GENERATION";
+// Which copy of the sandbox is speaking, set once per container start when netd can, so a daemon restarted inside one
+// container stays the same copy.
+export const INSTANCE_ENV = "INTENTIC_INSTANCE";
+
+// How long either side waits for the answer to a question it asked before giving up on it.
+export const ASK_PATIENCE_MS = 5000;
+
+// A frame is this many bytes of big-endian length, then that many bytes of JSON.
+export const FRAME_LENGTH_BYTES = 4;
+// The largest frame either side accepts. A length past it means the stream is corrupt, never a large message, and the
+// link is dropped rather than buffering toward it.
+export const FRAME_MAX_BYTES = 64 * 1024 * 1024;

package/src/{front → netd}/wire-manifests.test.ts

@@ -1,9 +1,17 @@
 import { readFileSync } from "node:fs";
 import { EDGE_VERDICT_HEADER, edgeVerdictOf } from "../protocol/edge-verdict.js";
 import { INGRESS_GRANT_HEADER, INGRESS_TUNNEL_PATH } from "../protocol/ingress-contract.js";
-import { VITALS_PATH } from "../protocol/vitals.js";
+import { VITALS_FILE, VITALS_PATH } from "../protocol/vitals.js";
 import { EDGE_TRANSPORTS, TERMINAL_PATH, WEBTRANSPORT_PATH } from "./browser-wire.js";
-import { ASK_PATIENCE_MS, FRAME_LENGTH_BYTES, FRONT_SOCKET_ENV, NODE_SOCKET_ENV } from "./front-wire.js";
+import {
+    ASK_PATIENCE_MS,
+    FRAME_LENGTH_BYTES,
+    FRAME_MAX_BYTES,
+    INSTANCE_ENV,
+    NETD_SOCKET_ENV,
+    NODE_GENERATION_ENV,
+    NODE_SOCKET_ENV,
+} from "./netd-wire.js";
 
 // The manifests `cargo test` writes from the Rust crates that define this wire: every value TypeScript restates is read
 // back against them, so the two languages cannot drift and contract.lock.json pins what both agree on.
@@ -15,16 +23,16 @@ const tunnel = manifest("tunnel") as {
     headers: { grant: string; transports: string };
     transports: string[];
 };
-// SAFETY: front-wire's own test writes this manifest with exactly these keys, and the lock pins them.
-const socket = manifest("front-wire") as {
-    env: { frontSocket: string; nodeSocket: string };
+// SAFETY: netd-wire's own test writes this manifest with exactly these keys, and the lock pins them.
+const socket = manifest("netd-wire") as {
+    env: { netdSocket: string; nodeSocket: string; generation: string; instance: string };
     askPatienceMs: number;
-    frame: { lengthBytes: number };
+    frame: { lengthBytes: number; maxBytes: number };
 };
 const browser = manifest("browser-wire") as {
     edge: { verdictHeader: string; verdicts: { oneOf: { const: string }[] } };
     terminal: { path: string; upgrade: string };
-    vitals: { path: string; body: { $defs: { NodeLink: { oneOf: { const: string }[] } } } };
+    vitals: { path: string; file: string; body: { $defs: { NodeLink: { oneOf: { const: string }[] } } } };
     webTransport: { path: string };
 };
 
@@ -36,12 +44,23 @@ describe("the wire outside oRPC, as the Rust crates define it", () => {
         });
     });
 
-    it("names the control socket's env vars, its patience and its framing as front-wire does", () => {
-        expect({ front: FRONT_SOCKET_ENV, node: NODE_SOCKET_ENV, patience: ASK_PATIENCE_MS, length: FRAME_LENGTH_BYTES }).toEqual({
-            front: socket.env.frontSocket,
+    it("names the control socket's env vars, its patience and its framing as netd-wire does", () => {
+        expect({
+            netd: NETD_SOCKET_ENV,
+            node: NODE_SOCKET_ENV,
+            generation: NODE_GENERATION_ENV,
+            instance: INSTANCE_ENV,
+            patience: ASK_PATIENCE_MS,
+            length: FRAME_LENGTH_BYTES,
+            max: FRAME_MAX_BYTES,
+        }).toEqual({
+            netd: socket.env.netdSocket,
             node: socket.env.nodeSocket,
+            generation: socket.env.generation,
+            instance: socket.env.instance,
             patience: socket.askPatienceMs,
             length: socket.frame.lengthBytes,
+            max: socket.frame.maxBytes,
         });
     });
 
@@ -61,8 +80,9 @@ describe("the wire outside oRPC, as the Rust crates define it", () => {
         });
     });
 
-    it("finds the front's vitals where browser-wire says it answers them, in the states it names", () => {
+    it("finds netd's vitals where browser-wire says it answers them, in the states it names", () => {
         expect(VITALS_PATH).toBe(browser.vitals.path);
+        expect(VITALS_FILE).toBe(browser.vitals.file);
         expect(browser.vitals.body.$defs.NodeLink.oneOf.map((state) => state.const)).toEqual(["starting", "up", "restarting"]);
     });
 });

package/src/policy/credential-material.ts

@@ -13,17 +13,21 @@ const PLACEHOLDER =
 // Shorter than any credential a service issues; clears dev-compose defaults like POSTGRES_PASSWORD=dev.
 const MIN_VALUE = 6;
 
-// Credentials recognisable without a key: issuer-prefixed tokens, PEM/PuTTY headers, a URL's userinfo password.
+// Credentials recognisable without a key: issuer-prefixed tokens, PEM/PuTTY headers, a URL's userinfo password. Each one
+// already masked is excluded (a header followed by the mask, a `***@` userinfo), so masked text never reads as holding a
+// credential: the share page masks with this table and the public outbox then sniffs it with the same one.
 const STRUCTURAL_SHAPES = [
-    /-----BEGIN (?:[A-Z0-9]+ )*PRIVATE KEY-----/,
-    /PuTTY-User-Key-File-\d/,
+    // A header followed by a body line (base64 or a `Proc-Type:` header) or nothing at all, the way a read cut short ends;
+    // lines split by newlines or by `\n` escapes, as a key inside JSON is.
+    /-----BEGIN (?:[A-Z0-9]+ )*PRIVATE KEY(?: BLOCK)?-----(?=(?:\s|\\[nr])*(?:$|[A-Za-z0-9+/]{4}|[A-Za-z-]+:))/,
+    /PuTTY-User-Key-File-\d:(?![ \t]*\*\*\*)/,
     // scheme://user:password@host; a DSN's bare key@host (no colon) or an already-masked ***@ userinfo is excluded.
     /\b[a-z][a-z0-9+.-]*:\/\/[^\s/:@]+:(?!\*+@)[^\s/@]{3,}@/i,
 ];
 
 const ISSUED_TOKENS = [
     /\bnpm_[A-Za-z0-9]{30,}/,
-    /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{30,}/,
+    /\bgh[pousr]_[A-Za-z0-9]{20,}/,
     /\bgithub_pat_[A-Za-z0-9_]{50,}/,
     /\bglpat-[A-Za-z0-9_-]{16,}/,
     /\bxox[baprs]-[A-Za-z0-9-]{10,}/,
@@ -43,11 +47,16 @@ const TOKEN_SHAPES = [...STRUCTURAL_SHAPES, ...ISSUED_TOKENS];
 // Deferred references, stripped first: unstripped, each reads as a credential twice over.
 const DEFERRED_VALUE = /\{\{[^}\n]*\}\}|\$\{[^}\n]*\}/g;
 
+// The self-identifying half of the detector: only shapes that name their own issuer or structure, never a key=value
+// guess. For text that is not known to be a credential file, where precision matters more than recall: the public
+// outbox sniffs published files with this, and a minified bundle's `apiKey:process.env.API_KEY` must not refuse it.
+export const holdsCredentialToken = (text: string): boolean => TOKEN_SHAPES.some((pattern) => pattern.test(text));
+
 // Does this file's text hold something worth a card? Handed the whole file; the caller decides how much of a large one
 // to read.
 export const holdsCredentialMaterial = (file: string): boolean => {
     const text = file.replace(DEFERRED_VALUE, "");
-    if (TOKEN_SHAPES.some((pattern) => pattern.test(text))) {
+    if (holdsCredentialToken(text)) {
         return true;
     }
     for (const match of text.matchAll(CREDENTIAL_ASSIGNMENT)) {
@@ -59,24 +68,43 @@ export const holdsCredentialMaterial = (file: string): boolean => {
     return false;
 };
 
-// Blunt because scoped to reads already known to be of a credential file; a .ppk body is the one known gap.
-const MASK = "***";
+// What a masked credential reads as; the detectors above skip it wherever it stands in for a value.
+export const CREDENTIAL_MASK = "***";
+const MASK = CREDENTIAL_MASK;
 
 // The g twins, built once: the tables above skip g since `test` wants none, but replace/replaceAll demands one.
 const globally = (patterns: readonly RegExp[]): readonly RegExp[] => patterns.map((pattern) => new RegExp(pattern.source, `${pattern.flags}g`));
 const ISSUED_TOKENS_G = globally(ISSUED_TOKENS);
 const CREDENTIAL_ASSIGNMENT_G = new RegExp(CREDENTIAL_ASSIGNMENT.source, CREDENTIAL_ASSIGNMENT.flags);
 
-// The two shapes that mask to something else: a PEM keeps its header/footer, a URL keeps scheme, user and host.
-const PRIVATE_KEY_BLOCK = /(-----BEGIN ((?:[A-Z0-9]+ )*)PRIVATE KEY-----)[\s\S]*?(-----END \2PRIVATE KEY-----)/g;
+// Already masked, so masking twice changes nothing.
+const MASKED_NEXT = String.raw`(?!(?:\s|\\[nr])*\*\*\*)`;
+// One armored body line after a newline or a `\n` escape: a whole line of base64 (ended by the line or by the string or
+// markup quoting it, never by more words), or a `Proc-Type: 4,ENCRYPTED` style header.
+const ARMOR_LINES = String.raw`(?:(?:\s|\\[nr])+(?:[A-Za-z-]+:[^\n\\]*|[A-Za-z0-9+/=]+(?=[ \t]*(?:[\r\n"'\`<>,;})\]]|\\[nr]|$))))*`;
+// The shapes that mask to something else: a PEM keeps its header and footer, its body masked through to the matching
+// footer, or through its last body line when the text was cut short before one; a PuTTY key keeps its first line's
+// label; a URL keeps scheme, user and host.
+const PRIVATE_KEY_BLOCK = new RegExp(
+    String.raw`(-----BEGIN ((?:[A-Z0-9]+ )*)PRIVATE KEY( BLOCK)?-----)${MASKED_NEXT}(?:[\s\S]*?(-----END \2PRIVATE KEY\3-----)|${ARMOR_LINES})`,
+    "g",
+);
+const PUTTY_KEY = new RegExp(String.raw`(PuTTY-User-Key-File-\d:)${MASKED_NEXT}[^\n\\]*${ARMOR_LINES}`, "g");
 const URL_PASSWORD = /(\b[a-z][a-z0-9+.-]*:\/\/[^\s/:@]+:)(?!\*+@)[^\s/@]{3,}@/gi;
 
 // The truncated opener left once the bare-value arm stops at its first `}`, anchored at the start.
 const DEFERRED_OPENER = /^(?:\{\{|\$)/;
 
+// Keys first: a token shape matched inside a key's body would cut the body short before the key pass reached it.
 export const maskCredentialMaterial = (text: string): string =>
-    ISSUED_TOKENS_G.reduce((masked, token) => masked.replace(token, MASK), text)
-        .replace(PRIVATE_KEY_BLOCK, `$1\n${MASK}\n$3`)
+    ISSUED_TOKENS_G.reduce(
+        (masked, token) => masked.replace(token, MASK),
+        text
+            .replace(PRIVATE_KEY_BLOCK, (_block, header: string, _label, _kind, footer: string | undefined) =>
+                footer === undefined ? `${header}\n${MASK}` : `${header}\n${MASK}\n${footer}`,
+            )
+            .replace(PUTTY_KEY, `$1 ${MASK}`),
+    )
         .replace(URL_PASSWORD, `$1${MASK}@`)
         // Masks just the value, leaving key/separator/quoting readable; skips mirror the detector's own.
         .replace(CREDENTIAL_ASSIGNMENT_G, (match, ...groups: unknown[]) => {

package/src/policy/message-limits.ts

@@ -0,0 +1,25 @@
+// The longest one message may be on each platform, declared once: the approvals inbox counts a post against it (over it,
+// a post does not post), the daemon refuses a direct publish past it, and each messaging gateway spills a reply into a
+// follow-up message there. Measured in JavaScript string length (UTF-16 code units), which never undercounts a
+// platform that counts characters. A platform absent here has no known cap.
+export const MESSAGE_LIMITS = {
+    bluesky: 300,
+    discord: 2_000,
+    instagram: 2_200,
+    linkedin: 3_000,
+    mastodon: 500,
+    // Slack's own advice is to keep a message under 4,000 characters; past 40,000 it truncates.
+    slack: 4_000,
+    // sendMessage refuses anything longer outright.
+    telegram: 4_096,
+    // A linked device (what the WhatsApp extension is) sends up to 65,536; the 4,096 often quoted is the Business API's.
+    whatsapp: 65_536,
+    x: 280,
+    youtube: 5_000,
+} as const satisfies Readonly<Record<string, number>>;
+
+// `platform` is a bare string by contract, matched case-insensitively. A Map, so only the table's own keys answer: a
+// record lookup answered `constructor` with Object.prototype's function.
+const LIMITS = new Map<string, number>(Object.entries(MESSAGE_LIMITS));
+
+export const messageLimitOf = (platform: string): number | undefined => LIMITS.get(platform.toLowerCase());

package/src/policy/request-status.ts

@@ -24,7 +24,7 @@ const permissionStatusOf = (reply: AgentReply | undefined): PermissionStatus =>
 
 export const settledRequests = (cards: TranscriptRequests, reply: AgentReply | undefined): TranscriptRequests => {
     const out: Cards = {};
-    const { plan, question, permission, browserHelp, terminalHelp, capabilityOffer, paymentOffer, credentialOffer } = cards;
+    const { plan, question, permission, browserHelp, terminalHelp, capabilityOffer, paymentOffer, credentialOffer, pageAsk } = cards;
     if (plan !== undefined) {
         out.plan = { ...plan, status: reply?.kind !== "plan" ? "cancelled" : reply.approve ? "approved" : "rejected" };
     }
@@ -68,6 +68,15 @@ export const settledRequests = (cards: TranscriptRequests, reply: AgentReply | u
             status: reply?.kind !== "credential_offer" ? "cancelled" : reply.approve ? "approved" : "skipped",
         };
     }
+    // The page's answer rides the card, as the agent was handed it; a dismissal keeps none.
+    if (pageAsk !== undefined) {
+        const answered = reply?.kind === "page_ask" && reply.cancelled !== true;
+        out.pageAsk = {
+            ...pageAsk,
+            status: answered ? "answered" : "cancelled",
+            ...(answered && reply.value !== undefined ? { value: reply.value } : {}),
+        };
+    }
     return out;
 };