brainclaw 1.5.5 → 1.7.0

package/dist/core/schema.js

@@ -232,6 +232,17 @@ export const HandoffSchema = z.object({
      */
     superseded_by: z.string().optional(),
     supersedes: z.string().optional(),
+    /**
+     * pln#365 finalization: opt-in cloud federation. Optional (no default) so
+     * existing on-disk handoffs without the field continue to parse, AND so
+     * an unset value means "stay local" rather than "implicitly shared". To
+     * opt a handoff into cloud push, set `visibility: 'shared'` explicitly
+     * when building it. Session-end push uses literal `visibility === 'shared'`
+     * (cf. session-end.ts:isExplicitlyShared). Risk it mitigates: a session
+     * handoff with `snapshot.diff` carrying secrets would otherwise leak the
+     * moment cloud_sync flips on, by virtue of being created at all.
+     */
+    visibility: MemoryVisibilitySchema.optional(),
 });
 export const PlanStatusSchema = z.enum(['todo', 'in_progress', 'blocked', 'done', 'dropped']);
 export const PlanStepStatusSchema = z.enum(['todo', 'in_progress', 'testing', 'done', 'blocked']);
@@ -243,7 +254,8 @@ export const PlanStepSchema = z.object({
     created_at: z.string(),
     updated_at: z.string(),
 });
-export const PlanTypeSchema = z.enum(['feat', 'fix', 'chore', 'spike', 'doc']).default('feat');
+export const PlanTypeEnumSchema = z.enum(['feat', 'fix', 'chore', 'spike', 'doc']);
+export const PlanTypeSchema = PlanTypeEnumSchema.default('feat');
 export const PlanItemSchema = z.object({
     schema_version: z.number().int().positive().optional(),
     id: z.string(),
@@ -532,6 +544,13 @@ export const CandidateSchema = z.preprocess(candidatePreprocess, z.object({
     resolved_by: z.string().optional(),
     resolution_reason: z.string().optional(),
     provenance: ProvenancePassthroughSchema,
+    /**
+     * pln#365 finalization: opt-in cloud federation. Mirrors HandoffSchema —
+     * optional (no default) so unset means "stay local" and an agent must
+     * explicitly set `visibility: 'shared'` to opt a candidate into cloud
+     * push. Conservative because candidate.text can carry secrets.
+     */
+    visibility: MemoryVisibilitySchema.optional(),
 }));
 export const ReflectiveMemoryConfigSchema = z.object({
     enabled: z.boolean().default(true),
@@ -756,6 +775,7 @@ export const ActionRequiredSchema = z.object({
     tags: TagsWithDefaultSchema,
 });
 // --- Runtime notes schemas ---
+export const RuntimeNoteTypeSchema = z.enum(['observation', 'session_start', 'session_end']);
 export const RuntimeNoteSchema = z.object({
     schema_version: z.number().int().positive().optional(),
     id: z.string(),
@@ -771,7 +791,7 @@ export const RuntimeNoteSchema = z.object({
     visibility: MemoryVisibilitySchema.default('shared'),
     host_id: z.string().optional(),
     expires_at: z.string().optional(),
-    note_type: z.enum(['observation', 'session_start', 'session_end']).default('observation'),
+    note_type: RuntimeNoteTypeSchema.default('observation'),
     model: z.string().optional(),
     provenance: ProvenancePassthroughSchema,
 });
@@ -937,6 +957,11 @@ export const RemoteSyncSchema = z.object({
     ssh_key_path: z.string().optional(),
     sync_strategy: z.enum(['pull-only', 'push-pull', 'pr-based']).default('push-pull'),
 });
+export const CloudSyncConfigSchema = z.object({
+    enabled: z.boolean().default(false),
+    endpoint: z.string().default('https://app.brainclaw.dev'),
+    api_key: z.string().optional(),
+});
 export const SessionSnapshotSchema = z.object({
     schema_version: z.number().int().positive().optional(),
     session_id: z.string(),
@@ -1141,6 +1166,8 @@ export const AgentIntegrationNameSchema = z.enum([
     'continue',
     'roo',
     'kilocode',
+    'mistral-vibe',
+    'hermes',
     'openclaw',
     'nanoclaw',
     'nemoclaw',
@@ -1232,6 +1259,7 @@ export const ConfigSchema = z.object({
     target_audience: z.enum(['human', 'agent']).optional().default('human'),
     openclaw_bridge: z.boolean().optional().default(false),
     remote_sync: RemoteSyncSchema.optional(),
+    cloud_sync: CloudSyncConfigSchema.optional(),
     telemetry: z.literal(false),
     allow_network: z.literal(false),
     redaction: RedactionConfigSchema,

package/dist/core/state.js

@@ -37,6 +37,68 @@ function loadDirectoryItems(dirPath, schema, documentType) {
     }
     return items;
 }
+const ENTITY_LOAD_CONFIG = {
+    constraint: { subdir: 'constraints', documentType: 'constraint', recursive: false },
+    decision: { subdir: 'decisions', documentType: 'decision', recursive: false },
+    trap: { subdir: 'traps', documentType: 'trap', recursive: false },
+    handoff: { subdir: 'handoffs', documentType: 'handoff', recursive: false },
+    plan: { subdir: 'plans', documentType: 'plan', recursive: false },
+    candidate: { subdir: 'inbox', documentType: 'candidate', recursive: false },
+    claim: { subdir: 'claims', documentType: 'claim', recursive: false },
+    assignment: { subdir: 'assignments', documentType: 'assignment', recursive: false },
+    agent_run: { subdir: 'runs', documentType: 'agent_run', recursive: false },
+    action: { subdir: 'actions', documentType: 'action_required', recursive: false },
+    runtime_note: { subdir: 'runtime', documentType: 'runtime_note', recursive: true },
+};
+function listJsonFiles(dirPath, recursive) {
+    if (!fs.existsSync(dirPath))
+        return [];
+    const files = [];
+    for (const entry of fs.readdirSync(dirPath).sort()) {
+        const fullPath = path.join(dirPath, entry);
+        const stat = fs.statSync(fullPath);
+        if (stat.isDirectory()) {
+            if (recursive)
+                files.push(...listJsonFiles(fullPath, true));
+            continue;
+        }
+        if (entry.endsWith('.json'))
+            files.push(fullPath);
+    }
+    return files;
+}
+function validationErrorsFrom(error) {
+    if (error && typeof error === 'object' && 'issues' in error && Array.isArray(error.issues)) {
+        return (error.issues).map((issue) => {
+            const issuePath = Array.isArray(issue.path) && issue.path.length > 0 ? `${issue.path.join('.')}: ` : '';
+            return `${issuePath}${issue.message ?? 'validation failed'}`;
+        });
+    }
+    return [error instanceof Error ? error.message : String(error)];
+}
+export function collectLoadValidationWarnings(entity, cwd) {
+    const config = ENTITY_LOAD_CONFIG[entity];
+    if (!config)
+        return [];
+    const effectiveCwd = cwd ?? process.cwd();
+    const dirPath = resolveEntityDir(config.subdir, effectiveCwd, 'read');
+    return listJsonFiles(dirPath, config.recursive).flatMap((filepath) => {
+        try {
+            loadVersionedJsonFile(config.documentType, filepath);
+            return [];
+        }
+        catch (error) {
+            return [{
+                    entity_id: path.basename(filepath, '.json'),
+                    validation_errors: validationErrorsFrom(error),
+                    path: filepath,
+                }];
+        }
+    });
+}
+export function findLoadValidationWarning(entity, id, cwd) {
+    return collectLoadValidationWarnings(entity, cwd).find((warning) => warning.entity_id === id);
+}
 export function loadState(cwd) {
     // Load from entity-aligned directories (with legacy fallback)
     const effectiveCwd = cwd ?? process.cwd();

package/dist/core/worktree.js

@@ -94,6 +94,64 @@ export function hasGitLock(cwd) {
     const lockPath = path.join(gitDir.stdout.trim(), 'index.lock');
     return fs.existsSync(lockPath);
 }
+/**
+ * Re-points an EXISTING worktree to `ref` via a hard reset of its checked-out
+ * branch + working tree. Used when a dispatch reuses an existing claim/worktree
+ * but pins a base ref: the worktree must reflect that ref, not stale state,
+ * otherwise the dirty-guard ref bypass would let the worker run on stale code
+ * (pln#520 Tier 2 / codex r2). Returns ok=false (with stderr) rather than
+ * throwing, so callers surface a visible warning instead of a hard failure.
+ */
+export function resetWorktreeToRef(worktreePath, ref) {
+    if (!fs.existsSync(worktreePath)) {
+        return { ok: false, stderr: `worktree path does not exist: ${worktreePath}` };
+    }
+    if (hasGitLock(worktreePath)) {
+        return { ok: false, stderr: 'git index.lock present — another git operation is in progress' };
+    }
+    const res = runGit(['reset', '--hard', ref], worktreePath);
+    if (!res.ok) {
+        return { ok: false, stderr: res.stderr };
+    }
+    // `reset --hard` realigns HEAD + tracked files, but leaves UNTRACKED residue
+    // from a prior use of the worktree — files the worker could still compile or
+    // test against even though they don't exist at the pinned ref (codex r3).
+    // We do NOT auto-delete (a blind `git clean` would also remove the brainclaw
+    // sidecar and gitignored shared symlinks); instead we detect non-system
+    // untracked files and report them so the caller surfaces a visible warning
+    // rather than letting the stale state pass silently. Ignored files (e.g.
+    // node_modules) are not listed by --untracked-files=normal, so the symlinked
+    // shared paths are unaffected.
+    const status = runGit(['status', '--porcelain=v1', '-z', '--untracked-files=normal'], worktreePath);
+    if (!status.ok) {
+        // The reset succeeded but we cannot confirm the worktree is residue-free -
+        // surface it rather than silently reporting a clean reset (cardinal rule).
+        return {
+            ok: false,
+            stderr: `reset to ${ref} succeeded but the untracked-residue check (git status) failed: ${status.stderr.trim()}`,
+        };
+    }
+    if (status.stdout.length > 0) {
+        const residue = status.stdout
+            .split('\0')
+            .filter((entry) => entry.startsWith('?? '))
+            .map((entry) => entry.slice(3))
+            .filter((p) => {
+            const norm = p.replace(/\\/g, '/');
+            return norm !== '.brainclaw-worktree.json'
+                && !norm.startsWith('.brainclaw/')
+                && !norm.startsWith('.git/');
+        });
+        if (residue.length > 0) {
+            const sample = residue.slice(0, 5).join(', ');
+            return {
+                ok: false,
+                stderr: `reset to ${ref} succeeded but ${residue.length} untracked file(s) remain from prior worktree use (e.g. ${sample}) — the worker may see state absent at the ref. Remove them or dispatch with a fresh scope.`,
+            };
+        }
+    }
+    return { ok: true, stderr: '' };
+}
 /**
  * Detects whether multiple distinct brainclaw sessions are using the same
  * physical worktree directory (shared-checkout risk).

package/dist/facts.js

@@ -1,11 +1,11 @@
 // Generated by scripts/emit-site-facts.mjs at build time. Do not edit manually.
-// Source: brainclaw v1.5.5 on 2026-05-13T19:24:16.549Z
+// Source: brainclaw v1.7.0 on 2026-05-28T00:12:31.140Z
 export const FACTS = {
-  "version": "1.5.5",
-  "generated_at": "2026-05-13T19:24:16.549Z",
+  "version": "1.7.0",
+  "generated_at": "2026-05-28T00:12:31.140Z",
   "tools": {
-    "count": 60,
-    "published_count": 59,
+    "count": 62,
+    "published_count": 61,
     "names": [
       "bclaw_bootstrap",
       "bclaw_release_notes",
@@ -30,10 +30,12 @@ export const FACTS = {
       "bclaw_check_security",
       "bclaw_read_inbox",
       "bclaw_get_thread",
+      "bclaw_dispatch_status",
       "bclaw_dispatch",
       "bclaw_send_message",
       "bclaw_ack_message",
       "bclaw_setup",
+      "bclaw_init_project",
       "bclaw_write_note",
       "bclaw_quick_capture",
       "bclaw_claim",
@@ -109,6 +111,359 @@ export const FACTS = {
       "action": "act",
       "cross_project_link": "xpl"
     }
+  },
+  "agent_integrations": {
+    "count": 19,
+    "names": [
+      "antigravity",
+      "claude-code",
+      "claude-sonnet",
+      "cline",
+      "codex",
+      "continue",
+      "cursor",
+      "github-copilot",
+      "hermes",
+      "kilocode",
+      "mistral-vibe",
+      "nanoclaw",
+      "nemoclaw",
+      "openclaw",
+      "opencode",
+      "picoclaw",
+      "roo",
+      "windsurf",
+      "zeroclaw"
+    ],
+    "profiles": [
+      {
+        "name": "antigravity",
+        "category": "code-agent",
+        "workflow_model": "interactive",
+        "tier": "B",
+        "has_mcp": true,
+        "has_hooks": false,
+        "has_skills": false,
+        "has_rules": true,
+        "instruction_file": "GEMINI.md",
+        "mcp_config_scope": "machine",
+        "role_capabilities": [
+          "execute",
+          "consult"
+        ],
+        "max_concurrent_tasks": 2
+      },
+      {
+        "name": "claude-code",
+        "category": "code-agent",
+        "workflow_model": "interactive",
+        "tier": "A",
+        "has_mcp": true,
+        "has_hooks": true,
+        "has_skills": true,
+        "has_rules": true,
+        "instruction_file": "CLAUDE.md",
+        "mcp_config_scope": "both",
+        "role_capabilities": [
+          "execute",
+          "coordinate",
+          "review",
+          "consult"
+        ],
+        "max_concurrent_tasks": 3
+      },
+      {
+        "name": "claude-sonnet",
+        "category": "code-agent",
+        "workflow_model": "interactive",
+        "tier": "A",
+        "has_mcp": true,
+        "has_hooks": true,
+        "has_skills": true,
+        "has_rules": true,
+        "instruction_file": "CLAUDE.md",
+        "mcp_config_scope": "both",
+        "role_capabilities": [
+          "execute",
+          "coordinate",
+          "review",
+          "consult"
+        ],
+        "max_concurrent_tasks": 6
+      },
+      {
+        "name": "cline",
+        "category": "code-agent",
+        "workflow_model": "interactive",
+        "tier": "A",
+        "has_mcp": true,
+        "has_hooks": true,
+        "has_skills": true,
+        "has_rules": true,
+        "instruction_file": ".clinerules/brainclaw.md",
+        "mcp_config_scope": "project",
+        "role_capabilities": [
+          "execute",
+          "review"
+        ],
+        "max_concurrent_tasks": 3
+      },
+      {
+        "name": "codex",
+        "category": "code-agent",
+        "workflow_model": "task-based",
+        "tier": "A",
+        "has_mcp": true,
+        "has_hooks": true,
+        "has_skills": true,
+        "has_rules": true,
+        "instruction_file": "AGENTS.md",
+        "mcp_config_scope": "machine",
+        "role_capabilities": [
+          "execute",
+          "review"
+        ],
+        "max_concurrent_tasks": 5
+      },
+      {
+        "name": "continue",
+        "category": "code-agent",
+        "workflow_model": "interactive",
+        "tier": "B",
+        "has_mcp": true,
+        "has_hooks": false,
+        "has_skills": false,
+        "has_rules": true,
+        "instruction_file": ".continue/rules/brainclaw.md",
+        "mcp_config_scope": "both",
+        "role_capabilities": [
+          "execute",
+          "consult"
+        ],
+        "max_concurrent_tasks": 2
+      },
+      {
+        "name": "cursor",
+        "category": "code-agent",
+        "workflow_model": "interactive",
+        "tier": "A",
+        "has_mcp": true,
+        "has_hooks": true,
+        "has_skills": true,
+        "has_rules": true,
+        "instruction_file": ".cursor/rules/brainclaw.md",
+        "mcp_config_scope": "machine",
+        "role_capabilities": [
+          "execute",
+          "review"
+        ],
+        "max_concurrent_tasks": 1
+      },
+      {
+        "name": "github-copilot",
+        "category": "code-agent",
+        "workflow_model": "interactive",
+        "tier": "A",
+        "has_mcp": true,
+        "has_hooks": true,
+        "has_skills": true,
+        "has_rules": true,
+        "instruction_file": ".github/copilot-instructions.md",
+        "mcp_config_scope": "project",
+        "role_capabilities": [
+          "execute",
+          "review",
+          "consult"
+        ],
+        "max_concurrent_tasks": 1
+      },
+      {
+        "name": "hermes",
+        "category": "autonomous-agent",
+        "workflow_model": "task-based",
+        "tier": "B",
+        "has_mcp": true,
+        "has_hooks": false,
+        "has_skills": true,
+        "has_rules": false,
+        "instruction_file": "AGENTS.md",
+        "mcp_config_scope": "machine",
+        "role_capabilities": [
+          "execute",
+          "review",
+          "consult"
+        ],
+        "max_concurrent_tasks": 1
+      },
+      {
+        "name": "kilocode",
+        "category": "code-agent",
+        "workflow_model": "interactive",
+        "tier": "B",
+        "has_mcp": true,
+        "has_hooks": false,
+        "has_skills": true,
+        "has_rules": true,
+        "instruction_file": ".kilo/rules/brainclaw.md",
+        "mcp_config_scope": "project",
+        "role_capabilities": [
+          "execute",
+          "review",
+          "consult"
+        ],
+        "max_concurrent_tasks": 2
+      },
+      {
+        "name": "mistral-vibe",
+        "category": "code-agent",
+        "workflow_model": "task-based",
+        "tier": "B",
+        "has_mcp": true,
+        "has_hooks": false,
+        "has_skills": true,
+        "has_rules": false,
+        "instruction_file": "AGENTS.md",
+        "mcp_config_scope": "both",
+        "role_capabilities": [
+          "execute",
+          "review",
+          "consult"
+        ],
+        "max_concurrent_tasks": 2
+      },
+      {
+        "name": "nanoclaw",
+        "category": "autonomous-agent",
+        "workflow_model": "task-based",
+        "tier": "C",
+        "has_mcp": false,
+        "has_hooks": false,
+        "has_skills": true,
+        "has_rules": false,
+        "instruction_file": "skills/nanoclaw/SKILL.md",
+        "mcp_config_scope": "none",
+        "role_capabilities": [
+          "execute"
+        ],
+        "max_concurrent_tasks": 1
+      },
+      {
+        "name": "nemoclaw",
+        "category": "autonomous-agent",
+        "workflow_model": "task-based",
+        "tier": "C",
+        "has_mcp": false,
+        "has_hooks": false,
+        "has_skills": true,
+        "has_rules": false,
+        "instruction_file": "skills/nemoclaw/SKILL.md",
+        "mcp_config_scope": "none",
+        "role_capabilities": [
+          "execute"
+        ],
+        "max_concurrent_tasks": 1
+      },
+      {
+        "name": "openclaw",
+        "category": "autonomous-agent",
+        "workflow_model": "task-based",
+        "tier": "B",
+        "has_mcp": true,
+        "has_hooks": false,
+        "has_skills": true,
+        "has_rules": false,
+        "instruction_file": "skills/openclaw/SKILL.md",
+        "mcp_config_scope": "machine",
+        "role_capabilities": [
+          "execute",
+          "coordinate"
+        ],
+        "max_concurrent_tasks": 1
+      },
+      {
+        "name": "opencode",
+        "category": "code-agent",
+        "workflow_model": "interactive",
+        "tier": "B",
+        "has_mcp": true,
+        "has_hooks": false,
+        "has_skills": false,
+        "has_rules": true,
+        "instruction_file": "AGENTS.md",
+        "mcp_config_scope": "project",
+        "role_capabilities": [
+          "execute",
+          "review"
+        ],
+        "max_concurrent_tasks": 2
+      },
+      {
+        "name": "picoclaw",
+        "category": "autonomous-agent",
+        "workflow_model": "scheduled",
+        "tier": "C",
+        "has_mcp": false,
+        "has_hooks": false,
+        "has_skills": true,
+        "has_rules": false,
+        "instruction_file": "skills/picoclaw/SKILL.md",
+        "mcp_config_scope": "none",
+        "role_capabilities": [
+          "execute"
+        ],
+        "max_concurrent_tasks": 1
+      },
+      {
+        "name": "roo",
+        "category": "code-agent",
+        "workflow_model": "interactive",
+        "tier": "B",
+        "has_mcp": true,
+        "has_hooks": false,
+        "has_skills": false,
+        "has_rules": true,
+        "instruction_file": ".roo/rules/brainclaw.md",
+        "mcp_config_scope": "project",
+        "role_capabilities": [
+          "execute",
+          "review"
+        ],
+        "max_concurrent_tasks": 2
+      },
+      {
+        "name": "windsurf",
+        "category": "code-agent",
+        "workflow_model": "interactive",
+        "tier": "A",
+        "has_mcp": true,
+        "has_hooks": true,
+        "has_skills": true,
+        "has_rules": true,
+        "instruction_file": ".windsurfrules",
+        "mcp_config_scope": "machine",
+        "role_capabilities": [
+          "execute",
+          "review"
+        ],
+        "max_concurrent_tasks": 1
+      },
+      {
+        "name": "zeroclaw",
+        "category": "autonomous-agent",
+        "workflow_model": "task-based",
+        "tier": "C",
+        "has_mcp": false,
+        "has_hooks": false,
+        "has_skills": true,
+        "has_rules": false,
+        "instruction_file": "skills/zeroclaw/SKILL.md",
+        "mcp_config_scope": "none",
+        "role_capabilities": [
+          "execute"
+        ],
+        "max_concurrent_tasks": 1
+      }
+    ]
   }
 }
 export default FACTS