brainclaw 1.14.0 → 1.15.0

package/dist/core/federation-signing.js

@@ -0,0 +1,115 @@
+/**
+ * Ed25519 request signing for the Brainclaw Cloud federation bridge (pln#100).
+ *
+ * The cloud verifier (brainclaw-cloud/src/middleware/signature.ts) expects three
+ * headers on a signed runtime write:
+ *   X-Agent-Id:        the cloud agent id whose public_key_pem is stored in D1
+ *   X-Agent-Signature: base64 Ed25519 signature over (body + timestamp)
+ *   X-Agent-Timestamp: ISO-8601 timestamp (5-minute replay window)
+ *
+ * The signing key is the agent's local Ed25519 private key managed by
+ * agent-registry (~/.brainclaw/keys/<id>.ed25519.pem). Its SPKI public-key PEM
+ * is what gets registered with the cloud, and sha256(pem) is the fingerprint
+ * both sides compute — so a local↔remote fingerprint match proves the same key.
+ *
+ * @module
+ */
+import crypto from 'node:crypto';
+import { loadConfig } from './config.js';
+import { loadAgentSigningKey, resolveRegisteredAgentIdentity } from './agent-registry.js';
+import { logger } from './logger.js';
+export const AGENT_ID_HEADER = 'X-Agent-Id';
+export const AGENT_SIGNATURE_HEADER = 'X-Agent-Signature';
+export const AGENT_TIMESTAMP_HEADER = 'X-Agent-Timestamp';
+/**
+ * Sign a request body with an Ed25519 private key, producing the cloud's
+ * signature headers. The signed message is exactly `body + timestamp` (UTF-8),
+ * mirroring the verifier. Node signs Ed25519 with a null algorithm.
+ */
+export function signCloudBody(body, params) {
+    const timestamp = params.timestamp ?? new Date().toISOString();
+    const privateKey = crypto.createPrivateKey(params.privateKeyPem);
+    const signature = crypto.sign(null, Buffer.from(body + timestamp, 'utf-8'), privateKey);
+    return {
+        [AGENT_ID_HEADER]: params.agentId,
+        [AGENT_SIGNATURE_HEADER]: signature.toString('base64'),
+        [AGENT_TIMESTAMP_HEADER]: timestamp,
+    };
+}
+/**
+ * Build the outgoing header set for a cloud runtime write.
+ *
+ * - Always includes Content-Type + X-API-Key.
+ * - Adds the Ed25519 signature headers when a signing identity is available.
+ * - Returns `undefined` (fail-closed) when `requireSigned` is set but no signing
+ *   identity is available — the caller MUST NOT send the request in that case.
+ *
+ * Pure and dependency-injected (no filesystem/network) so it is unit-testable.
+ */
+export function buildCloudWriteHeaders(body, opts) {
+    const headers = {
+        'Content-Type': 'application/json',
+        'X-API-Key': opts.apiKey,
+    };
+    if (opts.signing) {
+        Object.assign(headers, signCloudBody(body, {
+            agentId: opts.signing.cloudAgentId,
+            privateKeyPem: opts.signing.privateKeyPem,
+            timestamp: opts.timestamp,
+        }));
+    }
+    else if (opts.requireSigned) {
+        return undefined;
+    }
+    return headers;
+}
+/**
+ * Resolve the approved agent identity used to sign runtime writes.
+ *
+ * The private key is loaded from the LOCAL brainclaw identity (resolved by
+ * configured agent name / current-agent), while `cloudAgentId` (the value for
+ * X-Agent-Id) comes from the configured cloud agent id when set — the cloud
+ * assigns its own id at registration, distinct from the local identity id. When
+ * no cloud id is configured (self-hosted / id-preserving), the local id is used.
+ *
+ * Returns undefined when no agent is configured or no local Ed25519 key exists.
+ */
+export function resolveCloudSigningIdentity(cwd, env = process.env) {
+    let cfgAgentId;
+    let cfgAgentName;
+    try {
+        const config = loadConfig(cwd);
+        cfgAgentId = config.cloud_sync?.agent_id;
+        cfgAgentName = config.cloud_sync?.agent_name;
+    }
+    catch {
+        // No project config — fall back to env only.
+    }
+    // X-Agent-Id must be the CLOUD agent id, which is distinct from the local
+    // identity id. BRAINCLAW_AGENT_ID is already the LOCAL id everywhere in
+    // brainclaw (current-agent resolution, etc.), so a dedicated
+    // BRAINCLAW_CLOUD_AGENT_ID override avoids sending the local id as the cloud
+    // header when a session exports BRAINCLAW_AGENT_ID (review finding, pln#100).
+    const cloudAgentId = (env.BRAINCLAW_CLOUD_AGENT_ID?.trim() || cfgAgentId || '').trim() || undefined;
+    const agentName = (env.BRAINCLAW_AGENT_NAME?.trim() || env.BRAINCLAW_AGENT?.trim() || cfgAgentName || '').trim() || undefined;
+    // Resolve the LOCAL identity backing the private key: prefer name, then fall
+    // back to a local-id match (self-hosted), then the current agent.
+    const identity = resolveRegisteredAgentIdentity({ agentName, cwd, env, allowCurrent: true, allowEnv: true }) ??
+        (cloudAgentId ? resolveRegisteredAgentIdentity({ agentId: cloudAgentId, cwd, env }) : undefined);
+    if (!identity) {
+        logger.debug('Cloud signing: no local agent identity resolved.');
+        return undefined;
+    }
+    const key = loadAgentSigningKey(identity.agent_id, env);
+    if (!key) {
+        logger.debug(`Cloud signing: agent '${identity.agent_name}' has no local Ed25519 key.`);
+        return undefined;
+    }
+    return {
+        cloudAgentId: cloudAgentId ?? identity.agent_id,
+        localAgentId: identity.agent_id,
+        agentName: identity.agent_name,
+        ...key,
+    };
+}
+//# sourceMappingURL=federation-signing.js.map

package/dist/core/io.js

@@ -34,6 +34,12 @@ const ENTITY_DIR_MAP = {
     'runtime': 'coordination/runtime',
     'runtime-hosts': 'coordination/runtime-hosts',
     'runtime-private': 'coordination/runtime-private',
+    // federation/ — outbound cloud sync queue (pln#101 Phase 2): durable outbox,
+    // archived 'sent' markers, and 'parked' dead-letters.
+    'federation': 'coordination/federation',
+    'federation/outbox': 'coordination/federation/outbox',
+    'federation/sent': 'coordination/federation/sent',
+    'federation/parked': 'coordination/federation/parked',
     'surface-tasks': 'coordination/surface-tasks',
     'assignments': 'coordination/assignments',
     'runs': 'coordination/runs',

package/dist/core/schema.js

@@ -1079,6 +1079,17 @@ export const CloudSyncConfigSchema = z.object({
     enabled: z.boolean().default(false),
     endpoint: z.string().default('https://app.brainclaw.dev'),
     api_key: z.string().optional(),
+    /** Remote project this bridge federates into (scopes signed runtime writes). */
+    project_id: z.string().optional(),
+    /** Approved remote agent identity used to sign runtime writes (pln#100). */
+    agent_id: z.string().optional(),
+    agent_name: z.string().optional(),
+    /**
+     * Fail-closed toggle: when true, the bridge refuses to push a runtime write
+     * unless it can sign it with an approved agent's Ed25519 key. Absent/false
+     * keeps existing API-key-only setups working (signing is additive).
+     */
+    require_signed: z.boolean().optional(),
 });
 export const SessionSnapshotSchema = z.object({
     schema_version: z.number().int().positive().optional(),

package/dist/core/worktree.js

@@ -25,17 +25,38 @@ function gitPath(p) {
  * landed on the dot before `astro`, yielding `…IntegrationHubPage.` — a trailing
  * dot git rejects (`fatal: not a valid branch name`). Truncating first, then
  * stripping, guarantees the cap can never re-introduce an invalid ref.
+ *
+ * trp#950 (dogfood 2026-07-15): a plain truncation makes two DISTINCT scopes
+ * that share a >48-char prefix collapse to the SAME branch → same worktree path
+ * → the second claim/assign is refused. When (and only when) the cleaned slug
+ * exceeds the cap, a deterministic 8-char digest of the FULL cleaned slug is
+ * appended so distinct scopes diverge, while the same scope stays stable
+ * (resume/re-assign still resolves its worktree). Short scopes are unchanged.
+ * 8 hex chars = 32 bits: comfortably collision-safe for the realistic case
+ * (a handful of scopes sharing a deep directory prefix) while keeping a
+ * 39-char readable head.
  */
+const BRANCH_COMPONENT_CAP = 48;
 export function sanitizeBranchComponent(raw, fallback = 'scope') {
-    let slug = raw
+    const cleaned = raw
         .replace(/[\s~^:?*[\]\\]/g, '-') // chars forbidden by check-ref-format
         .replace(/@\{/g, '-') // reflog syntax
         .replace(/\.\.+/g, '.') // no double dots
         .replace(/[^a-zA-Z0-9._-]/g, '-') // conservative whitelist for the rest
         .replace(/-+/g, '-') // collapse dashes
-        .replace(/^[.-]+/, '') // no leading dot/dash
-        .slice(0, 48) // length cap BEFORE the trailing strips
-        .replace(/[.-]+$/, ''); // no trailing dot/dash (cut may have made one)
+        .replace(/^[.-]+/, ''); // no leading dot/dash
+    let slug;
+    if (cleaned.length <= BRANCH_COMPONENT_CAP) {
+        slug = cleaned.replace(/[.-]+$/, ''); // no trailing dot/dash
+    }
+    else {
+        // Truncation drops characters → reserve room for a collision-resistant
+        // suffix derived from the full cleaned slug (trp#950). The digest is hex, so
+        // it can never re-introduce a trailing dot/dash or a `.lock` suffix.
+        const suffix = crypto.createHash('sha1').update(cleaned).digest('hex').slice(0, 8);
+        const head = cleaned.slice(0, BRANCH_COMPONENT_CAP - suffix.length - 1).replace(/[.-]+$/, '');
+        slug = `${head}-${suffix}`;
+    }
     if (/\.lock$/i.test(slug))
         slug = slug.slice(0, -'.lock'.length).replace(/[.-]+$/, '');
     if (!slug)

package/dist/facts.js

@@ -1,8 +1,8 @@
 // Generated by scripts/emit-site-facts.mjs at build time. Do not edit manually.
-// Source: brainclaw v1.14.0 on 2026-07-05T13:38:40.276Z
+// Source: brainclaw v1.15.0 on 2026-07-15T15:24:46.074Z
 export const FACTS = {
-  "version": "1.14.0",
-  "generated_at": "2026-07-05T13:38:40.276Z",
+  "version": "1.15.0",
+  "generated_at": "2026-07-15T15:24:46.074Z",
   "tools": {
     "count": 67,
     "published_count": 66,
@@ -472,7 +472,7 @@ export const FACTS = {
   },
   "bench": {
     "schema": "brainclaw.bench.v1",
-    "generated_at": "2026-07-05T13:38:38.216Z",
+    "generated_at": "2026-07-15T15:24:43.956Z",
     "node_version": "v24.18.0",
     "platform": "linux-x64",
     "repeats": 3,
@@ -481,7 +481,7 @@ export const FACTS = {
         "name": "cold_onboard",
         "volume": "empty",
         "description": "fresh machine → init → first useful context. Baseline for time-to-first-value.",
-        "duration_ms_median": 72,
+        "duration_ms_median": 76,
         "payload_chars_median": 1650,
         "payload_tokens_est_median": 413
       },

package/dist/facts.json

@@ -1,6 +1,6 @@
 {
-  "version": "1.14.0",
-  "generated_at": "2026-07-05T13:38:40.276Z",
+  "version": "1.15.0",
+  "generated_at": "2026-07-15T15:24:46.074Z",
   "tools": {
     "count": 67,
     "published_count": 66,
@@ -470,7 +470,7 @@
   },
   "bench": {
     "schema": "brainclaw.bench.v1",
-    "generated_at": "2026-07-05T13:38:38.216Z",
+    "generated_at": "2026-07-15T15:24:43.956Z",
     "node_version": "v24.18.0",
     "platform": "linux-x64",
     "repeats": 3,
@@ -479,7 +479,7 @@
         "name": "cold_onboard",
         "volume": "empty",
         "description": "fresh machine → init → first useful context. Baseline for time-to-first-value.",
-        "duration_ms_median": 72,
+        "duration_ms_median": 76,
         "payload_chars_median": 1650,
         "payload_tokens_est_median": 413
       },

package/docs/mcp-schema-changelog.md

@@ -10,6 +10,16 @@ guarantees this changelog follows.
 
 ## Unreleased
 
+**Changed — MCP model selection parity (pln#520/#606)**
+- `bclaw_dispatch` and `bclaw_coordinate` gain an optional `model` string that
+  selects the spawned worker's model (e.g. `sonnet`, `gpt-5-codex`), decoupled
+  from agent identity — closing the CLI/MCP gap (the CLI `dispatch run --model`
+  already existed). Injected only for agents that declare a `model_flag`
+  (claude-code / codex / github-copilot); no-op otherwise, and consistent with
+  the dispatcher's resolveModel chain.
+- No tool was removed or renamed; no required argument changed.
+- Surface fingerprint bumped in the `(current)` section below.
+
 **Added — `bclaw_move` cross-project relocation (pln#595)**
 - New canonical-grammar verb `bclaw_move(entity, id, to_project, from_project?, force?)`:
   relocates a brainclaw item to another project in a multi-project workspace,
@@ -122,8 +132,14 @@ will still succeed. A follow-up PR will strip the dead handler code.
   changelog records the published MCP surface fingerprint. When a tool
   name, tier, category, or input schema changes, the test fails until
   this section is updated.
-- MCP public surface fingerprint: `sha256:2b0dfbd62acd71b7`
-  (updated 2026-07-04 for trp#928: explicit `coordinator_override` boolean added
+- MCP public surface fingerprint: `sha256:b53eb56d4391b5a6`
+  (updated 2026-07-15 for pln#520/#606: optional `model` string added to
+  `bclaw_dispatch` and `bclaw_coordinate` input schemas — selects the spawned
+  worker's model, decoupled from agent identity (CLI/MCP parity with
+  `dispatch run --model`). Additive: no tool added, removed, or renamed; no
+  required argument changed.
+  Previous: `sha256:2b0dfbd62acd71b7`
+  updated 2026-07-04 for trp#928: explicit `coordinator_override` boolean added
   to `bclaw_release_claim` and `bclaw_transition` input schemas — the coordinator
   path to release/stale a non-owned claim is now opt-in and audited rather than
   auto-derived from trust level. Additive: no tool added, removed, or renamed; no

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brainclaw",
-  "version": "1.14.0",
+  "version": "1.15.0",
   "description": "Shared project memory for humans and coding agents.",
   "type": "module",
   "repository": {