wendkeep 0.80.2 → 0.85.0

package/schema/mcp-tool-result-v1.schema.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "wendkeep://schema/mcp-tool-result-v1",
+  "title": "WendKeep MCP tool result v1",
+  "type": "object",
+  "required": ["schema_version"],
+  "properties": {
+    "schema_version": { "const": 1 },
+    "items": { "type": "array" },
+    "next_cursor": { "type": "string" },
+    "error": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["code", "message", "retryable"],
+      "properties": {
+        "code": { "type": "string", "pattern": "^MCP_[A-Z0-9_]+$" },
+        "message": { "type": "string", "maxLength": 500 },
+        "retryable": { "type": "boolean" }
+      }
+    }
+  }
+}

package/schema/portable-active-work-v1.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://wendkeep.dev/schema/portable-active-work-v1.schema.json",
+  "title": "WendKeep portable active-work v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schema_version", "active_work_id", "project_id", "repository_id", "change_slug",
+    "task_id", "branch", "base_sha", "head_sha", "spec_sha256", "tasks_sha256",
+    "status", "completed", "current_action", "next_actions", "blockers", "evidence_refs",
+    "updated_at", "revision"
+  ],
+  "properties": {
+    "schema_version": { "const": 1 },
+    "active_work_id": { "type": "string", "pattern": "^[a-f0-9]{24}$" },
+    "project_id": { "type": "string", "minLength": 1, "maxLength": 160 },
+    "repository_id": { "type": "string", "minLength": 1, "maxLength": 160 },
+    "change_slug": { "type": "string", "maxLength": 160 },
+    "task_id": { "type": "string", "maxLength": 160 },
+    "branch": { "type": "string", "maxLength": 240 },
+    "base_sha": { "type": "string", "pattern": "^(|[a-f0-9]{40,64})$" },
+    "head_sha": { "type": "string", "pattern": "^(|[a-f0-9]{40,64})$" },
+    "spec_sha256": { "$ref": "#/$defs/hash" },
+    "tasks_sha256": { "$ref": "#/$defs/hash" },
+    "status": { "enum": ["in_progress", "completed", "blocked"] },
+    "completed": { "$ref": "#/$defs/strings" },
+    "current_action": { "type": "object" },
+    "next_actions": { "$ref": "#/$defs/strings" },
+    "blockers": { "$ref": "#/$defs/strings" },
+    "evidence_refs": { "$ref": "#/$defs/strings" },
+    "updated_at": { "type": "string", "format": "date-time" },
+    "revision": { "type": "integer", "minimum": 0 }
+  },
+  "$defs": {
+    "hash": { "type": "string", "pattern": "^sha256:[a-f0-9]{64}$" },
+    "strings": { "type": "array", "items": { "type": "string" }, "uniqueItems": true }
+  }
+}

package/schema/portable-state-v1.schema.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://wendkeep.dev/schema/portable-state-v1.schema.json",
+  "title": "WendKeep portable authored state v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "kind", "project_id", "repository_id", "authored_sha256", "artifacts", "active_work"],
+  "properties": {
+    "schema_version": { "const": 1 },
+    "kind": { "const": "wendkeep-portable-state" },
+    "project_id": { "type": "string", "minLength": 1, "maxLength": 160 },
+    "repository_id": { "type": "string", "minLength": 1, "maxLength": 160 },
+    "authored_sha256": { "$ref": "#/$defs/hash" },
+    "artifacts": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["path", "category", "content_sha256", "content"],
+        "properties": {
+          "path": { "type": "string", "pattern": "^(?:\\.brain/CORE\\.md|(?:04-Decisões|04-Decisions|07-Specs|08-Mudanças|08-Changes)/[^.][^\\u0000]*)$" },
+          "category": { "enum": ["authored", "derived"] },
+          "content_sha256": { "$ref": "#/$defs/hash" },
+          "content": { "type": "string" }
+        }
+      }
+    },
+    "active_work": {
+      "type": "array",
+      "items": { "$ref": "portable-active-work-v1.schema.json" }
+    }
+  },
+  "$defs": {
+    "hash": { "type": "string", "pattern": "^sha256:[a-f0-9]{64}$" }
+  }
+}

package/schema/sync-event-v1.schema.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://wendkeep.dev/schema/sync-event-v1.schema.json",
+  "title": "WendKeep sync event v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "event_id", "project_id", "record_key", "revision", "base_revision", "content_hash", "causal_parent_ids", "actor_id", "device_id", "lease_id", "observed_at", "operation", "privacy", "payload"],
+  "properties": {
+    "schema_version": { "const": 1 },
+    "event_id": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+    "project_id": { "type": "string", "minLength": 1, "maxLength": 160 },
+    "record_key": { "type": "string", "minLength": 1, "maxLength": 2048 },
+    "revision": { "type": "integer", "minimum": 1 },
+    "base_revision": { "type": "integer", "minimum": 0 },
+    "content_hash": { "type": "string", "pattern": "^sha256:[a-f0-9]{64}$" },
+    "causal_parent_ids": { "type": "array", "uniqueItems": true, "items": { "type": "string", "maxLength": 128 } },
+    "actor_id": { "type": "string", "minLength": 1, "maxLength": 160 },
+    "device_id": { "type": "string", "minLength": 1, "maxLength": 160 },
+    "lease_id": { "type": "string", "maxLength": 160 },
+    "observed_at": { "type": "string", "format": "date-time" },
+    "operation": { "enum": ["put", "tombstone", "resolve"] },
+    "privacy": { "enum": ["shared", "private"] },
+    "payload": {}
+  }
+}

package/schema/sync-private-envelope-v1.schema.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://wendkeep.dev/schema/sync-private-envelope-v1.schema.json",
+  "title": "WendKeep private sync envelope v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "algorithm", "key_id", "iv", "ciphertext", "auth_tag"],
+  "properties": {
+    "schema_version": { "const": 1 },
+    "algorithm": { "const": "AES-256-GCM" },
+    "key_id": { "type": "string", "minLength": 1, "maxLength": 160 },
+    "iv": { "type": "string", "contentEncoding": "base64" },
+    "ciphertext": { "type": "string", "contentEncoding": "base64" },
+    "auth_tag": { "type": "string", "contentEncoding": "base64" }
+  }
+}

package/schema/sync-state-v1.schema.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://wendkeep.dev/schema/sync-state-v1.schema.json",
+  "title": "WendKeep sync state v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "project_id", "records", "conflicts", "pending", "leases", "decisions", "applied_event_ids"],
+  "properties": {
+    "schema_version": { "const": 1 },
+    "project_id": { "type": "string", "minLength": 1, "maxLength": 160 },
+    "records": { "type": "object", "additionalProperties": { "type": "object" } },
+    "conflicts": { "type": "object", "additionalProperties": { "type": "object" } },
+    "pending": { "type": "object", "additionalProperties": { "type": "array", "items": { "$ref": "sync-event-v1.schema.json" } } },
+    "leases": { "type": "object", "additionalProperties": { "type": "object" } },
+    "decisions": { "type": "array", "items": { "type": "object" } },
+    "applied_event_ids": { "type": "array", "uniqueItems": true, "items": { "type": "string", "pattern": "^[a-f0-9]{64}$" } }
+  }
+}

package/schema/task-contract-v1.schema.json

@@ -28,6 +28,8 @@
     "owner": { "type": ["string", "null"] },
     "work_session_id": { "type": ["string", "null"] },
     "evidence_envelope_id": { "type": ["string", "null"] },
+    "tdd_required": { "type": "boolean" },
+    "tdd_attestation_id": { "type": ["string", "null"] },
     "checked": { "type": "boolean" },
     "authored_sha256": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
     "binding": {

package/schema/tdd-attestation-v1.schema.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://wendkeep.dev/schema/tdd-attestation-v1.schema.json",
+  "title": "WendKeep TDD Attestation v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schema_version", "attestation_id", "project_id", "repository_id", "worktree_id",
+    "work_session_id", "change_slug", "task_id", "requirement_id", "profile", "state",
+    "test_paths", "red", "green", "green_history", "waiver", "review_flags", "invalid_reason"
+  ],
+  "properties": {
+    "schema_version": { "const": 1 },
+    "attestation_id": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+    "project_id": { "type": "string", "minLength": 1 },
+    "repository_id": { "type": "string", "minLength": 1 },
+    "worktree_id": { "type": "string", "minLength": 1 },
+    "work_session_id": { "type": "string", "minLength": 1 },
+    "change_slug": { "type": "string", "minLength": 1 },
+    "task_id": { "type": "string", "minLength": 1 },
+    "requirement_id": { "type": "string", "minLength": 1 },
+    "profile": { "enum": ["OFF", "FLOW", "GUIDE", "GOVERN", "ASSURE"] },
+    "state": { "enum": ["red-observed", "green-observed", "invalid", "waived"] },
+    "test_paths": { "$ref": "#/$defs/stringArray" },
+    "red": { "type": ["object", "null"] },
+    "green": { "type": ["object", "null"] },
+    "green_history": { "type": "array", "items": { "type": "object" } },
+    "waiver": { "type": ["object", "null"] },
+    "review_flags": { "$ref": "#/$defs/stringArray" },
+    "invalid_reason": { "type": ["string", "null"] }
+  },
+  "$defs": {
+    "stringArray": {
+      "type": "array",
+      "items": { "type": "string" },
+      "uniqueItems": true
+    }
+  }
+}

package/schema/wendkeep.evidence-envelope-v2.schema.json

@@ -51,11 +51,28 @@
     "sensors": {
       "type": "array",
       "items": { "$ref": "#/$defs/sensor" }
+    },
+    "host_coverage": { "$ref": "host-coverage-v1.schema.json" },
+    "tdd_attestations": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/tddAttestation" }
     }
   },
   "$defs": {
     "gitObject": { "type": "string", "pattern": "^[a-f0-9]{40,64}$" },
     "sha256": { "type": "string", "pattern": "^sha256:[a-f0-9]{64}$" },
+    "tddAttestation": {
+      "type": "object",
+      "required": ["schema_version", "attestation_id", "task_id", "requirement_id", "state", "test_paths"],
+      "properties": {
+        "schema_version": { "const": 1 },
+        "attestation_id": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+        "task_id": { "type": "string", "minLength": 1 },
+        "requirement_id": { "type": "string", "minLength": 1 },
+        "state": { "enum": ["red-observed", "green-observed", "invalid", "waived"] },
+        "test_paths": { "type": "array", "items": { "type": "string" } }
+      }
+    },
     "sensor": {
       "type": "object",
       "required": [

package/schema/wendkeep.sensors.schema.json

@@ -9,6 +9,25 @@
     "$schema": { "type": "string" },
     "version": { "const": 1 },
     "source": { "type": "string" },
+    "requires_host_capabilities": {
+      "type": "array",
+      "uniqueItems": true,
+      "items": { "$ref": "host-capability-manifest-v1.schema.json#/$defs/capabilityName" }
+    },
+    "host_capability_waivers": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["capability", "authority", "approved_by", "reason"],
+        "properties": {
+          "capability": { "$ref": "host-capability-manifest-v1.schema.json#/$defs/capabilityName" },
+          "authority": { "const": "human" },
+          "approved_by": { "type": "string", "minLength": 1 },
+          "reason": { "type": "string", "minLength": 1 }
+        }
+      }
+    },
     "sensors": {
       "type": "array",
       "items": {

package/src/active-context-runtime.mjs

@@ -103,6 +103,7 @@ export function resolveRuntimeActiveContext({
     branch: selected.actual.branch,
     headSha: selected.actual.head,
     sessionId: selected.sessionId,
+    ...(selected.entry.host_coverage ? { hostCoverage: structuredClone(selected.entry.host_coverage) } : {}),
   };
 }
 

package/src/capabilities.mjs

@@ -0,0 +1,50 @@
+import { HOST_CAPABILITY_MANIFESTS } from '../packages/integrations/src/capabilities.mjs';
+import { buildHostCoverage } from './host-capabilities.mjs';
+
+export const CAPABILITIES_HELP = `wendkeep capabilities [options]
+
+  --host <id>            claude | codex | pi | generic-mcp (default: all)
+  --host-version <v>     observed host version for support classification
+  --json                 structured coverage
+`;
+
+function option(argv, name) {
+  const rows = argv.filter((item) => item === name || item.startsWith(`${name}=`));
+  if (rows.length > 1) throw Object.assign(new Error(`${name} must be supplied once`), { code: 'HOST_ARGUMENT_INVALID' });
+  const index = argv.indexOf(name);
+  if (index >= 0) return argv[index + 1] || '';
+  return argv.find((item) => item.startsWith(`${name}=`))?.slice(name.length + 1) || '';
+}
+
+export function runCapabilities(argv = []) {
+  const json = argv.includes('--json');
+  try {
+    const known = new Set(['--host', '--host-version', '--json']);
+    for (let index = 0; index < argv.length; index += 1) {
+      const item = argv[index];
+      const flag = item.split('=', 1)[0];
+      if (!known.has(flag)) throw Object.assign(new Error(`unknown option: ${item}`), { code: 'HOST_ARGUMENT_INVALID' });
+      if (['--host', '--host-version'].includes(item)) {
+        const value = argv[index + 1];
+        if (!value || value.startsWith('--')) {
+          throw Object.assign(new Error(`${item} requires a value`), { code: 'HOST_ARGUMENT_INVALID' });
+        }
+        index += 1;
+      }
+    }
+    const host = option(argv, '--host');
+    const hostVersion = option(argv, '--host-version');
+    const ids = host ? [host] : Object.keys(HOST_CAPABILITY_MANIFESTS);
+    const rows = ids.map((hostId) => buildHostCoverage({ hostId, hostVersion }));
+    const payload = host ? rows[0] : { schema_version: 1, hosts: rows };
+    if (json) process.stdout.write(`${JSON.stringify(payload)}\n`);
+    else for (const coverage of rows) {
+      process.stdout.write(`${coverage.host_id}: ${coverage.degraded ? 'degraded' : 'complete'}\n`);
+      for (const item of coverage.capabilities) process.stdout.write(`  ${item.capability}: ${item.state} (${item.authority})\n`);
+    }
+    return 0;
+  } catch (error) {
+    process.stderr.write(`wendkeep capabilities: ${error?.code || 'HOST_CAPABILITIES_FAILED'}: ${error?.message || error}\n`);
+    return 2;
+  }
+}

package/src/doctor.mjs

@@ -11,6 +11,9 @@ import {
   inspectActiveContextHealth,
   renderActiveContextHealthLines,
 } from './active-context-health.mjs';
+import { inspectPortableState } from './portable.mjs';
+import { inspectSyncOutbox, readLocalSyncState } from './sync-outbox.mjs';
+import { readProjectForValidation } from '../packages/vault/src/validate-memory.mjs';
 
 const healthStatusLabel = (status) => ({
   healthy: 'saudável', warning: 'atenção', degraded: 'degradada', blocked: 'bloqueada', legacy: 'legado',
@@ -147,6 +150,28 @@ export function runDoctor(argv) {
   const activeContexts = inspectActiveContextHealth({ vaultBase, projectRoot });
   process.stdout.write(`\n${renderActiveContextHealthLines(activeContexts).join('\n')}\n`);
 
+  const portable = inspectPortableState({ vaultBase, projectRoot });
+  process.stdout.write(`\n[portable] ${portable.status}${portable.issues.length ? ` — ${portable.issues.length} divergência(s)` : ''}\n`);
+  if (portable.status === 'diverged') process.stdout.write('  → wendkeep portable diff; revise e rode `wendkeep portable export`\n');
+  if (portable.status === 'invalid') process.stdout.write(`  ✗ ${portable.issues.join(', ')}\n`);
+
+  const sync = inspectSyncOutbox(vaultBase);
+  let syncConflicts = 0;
+  if (sync.status !== 'disabled' && sync.status !== 'corrupt') {
+    try {
+      const projectIdentity = readProjectForValidation(vaultBase);
+      const syncState = readLocalSyncState(vaultBase, resolution.projectId || projectIdentity.projectId || 'unknown');
+      syncConflicts = Object.values(syncState.conflicts || {}).filter((item) => item?.status === 'open').length;
+    } catch {
+      sync.status = 'corrupt';
+      sync.code = 'WENDKEEP_SYNC_STATE_CORRUPT';
+    }
+  }
+  process.stdout.write(`\n[sync] ${sync.status} · ${sync.pending} pendente(s) · ${syncConflicts} conflito(s) aberto(s)\n`);
+  if (sync.status === 'pending') process.stdout.write('  → wendkeep sync push --remote <diretório> (ou --url <endpoint>)\n');
+  if (sync.status === 'corrupt') process.stdout.write(`  ✗ ${sync.code || 'WENDKEEP_SYNC_OUTBOX_CORRUPT'}\n`);
+  if (syncConflicts) process.stdout.write('  → wendkeep sync conflicts; resolva cada conflito explicitamente\n');
+
   // 3. Link/graph health — órfãos que o grafo do Obsidian mostraria, com o comando de reparo.
   const links = checkVaultLinks(vaultBase);
   const graphLabel = links.graphColors === true ? 'com cores' : links.graphColors === false ? 'sem cores' : 'sem graph.json';
@@ -197,6 +222,9 @@ export function runDoctor(argv) {
     || warnings.length
     || worktrees.issues.length
     || activeContexts.issues.length
+    || ['diverged', 'invalid'].includes(portable.status)
+    || sync.status === 'corrupt'
+    || syncConflicts
     || links.derivedOrphans
     || links.artifactOrphans
     || links.graphColors === false

package/src/evidence-envelope.mjs

@@ -17,10 +17,12 @@ import {
 
 export { canonicalSha256, evaluateEvidenceBinding, evidenceSensors };
 
-const PACKAGE_VERSION = JSON.parse(readFileSync(
-  join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json'),
-  'utf8',
-)).version;
+function packageVersion() {
+  return JSON.parse(readFileSync(
+    join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json'),
+    'utf8',
+  )).version;
+}
 
 export function sensorConfigSha256(sensors, ids) {
   const selected = new Set(ids || []);
@@ -260,10 +262,12 @@ export function buildEvidenceEnvelope({
   effectiveSpecSha256,
   sensorConfigSha256: configSha256,
   sensors,
+  tddAttestations = [],
   startedAt,
   finishedAt,
-  version = PACKAGE_VERSION,
+  version = '',
   runtimePlatform = `${process.platform}-${process.arch}`,
+  hostCoverage = null,
 } = {}) {
   const envelope = {
     schema_version: 2,
@@ -278,11 +282,13 @@ export function buildEvidenceEnvelope({
     tasks_sha256: tasksSha256,
     effective_spec_sha256: effectiveSpecSha256,
     sensor_config_sha256: configSha256,
-    wendkeep_version: version,
+    wendkeep_version: version || packageVersion(),
     platform: runtimePlatform,
     started_at: startedAt,
     finished_at: finishedAt,
     sensors,
+    ...(hostCoverage ? { host_coverage: structuredClone(hostCoverage) } : {}),
+    tdd_attestations: tddAttestations,
   };
   return { ...envelope, envelope_id: canonicalSha256(envelope) };
 }

package/src/host-capabilities.mjs

@@ -0,0 +1,34 @@
+import {
+  buildCoverageFromManifest,
+} from '../packages/integrations/src/capabilities.mjs';
+import {
+  MCP_EFFECT_MANIFEST,
+  verifyMcpEffectManifest,
+} from '../packages/mcp/src/effects.mjs';
+
+function summarizeToolEffects(manifest) {
+  const validation = verifyMcpEffectManifest(manifest);
+  const effects = new Set(validation.valid ? manifest.tools.map((tool) => tool.effect) : []);
+  return {
+    manifest_valid: validation.valid,
+    catalog_version: validation.valid ? manifest.catalog_version : '',
+    read: effects.has('read'),
+    write: effects.has('write'),
+    destructive: effects.has('destructive'),
+    unknown: 'fail-closed',
+  };
+}
+
+export function buildHostCoverage({
+  hostId,
+  hostVersion = '',
+  effectManifest = MCP_EFFECT_MANIFEST,
+  observedAt,
+} = {}) {
+  return buildCoverageFromManifest({
+    hostId,
+    hostVersion,
+    observedAt,
+    toolEffects: summarizeToolEffects(effectManifest),
+  });
+}

package/src/init.mjs

@@ -1,6 +1,6 @@
 // `wendkeep init` — cross-platform replacement for setup-vault.ps1.
 // Creates the vault taxonomy + provider-neutral project binding, NON-DESTRUCTIVELY
-// merges the session hooks into .claude/settings.json, and adds the mcpvault server to
+// merges the session hooks into .claude/settings.json, and adds the native MCP server to
 // .mcp.json. Idempotent: re-running only adds what is missing.
 import { spawnSync } from 'node:child_process';
 import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
@@ -516,7 +516,7 @@ export async function runInit(argv) {
   log(M.header);
   log(`${M.lProject}: ${projectPath}`);
   log(`${M.lVault}: ${vaultPath}`);
-  log(`${M.lMcp}: ${args.mcp ? 'mcpvault (wendkeep-vault)' : M.skipped}`);
+  log(`${M.lMcp}: ${args.mcp ? 'wendkeep native (wendkeep-vault)' : M.skipped}`);
   log(`${M.lCompanions}: ${companions.length ? companions.join(', ') : M.none}`);
   log(`${M.lColors}: ${args.noColors ? M.skipped : M.colorsOn}\n`);
 
@@ -640,7 +640,7 @@ export async function runInit(argv) {
   log(M.codexTrust);
 
   // 3. .mcp.json --------------------------------------------------------------
-  // Written when mcpvault is wanted OR a selected companion ships an MCP server.
+  // Written when the native WendKeep MCP is wanted OR a selected companion ships an MCP server.
   const companionMcp = companionMcpPatch(companions, skipMcp);
   if (args.mcp || Object.keys(companionMcp).length) {
     const mcpPath = join(projectPath, '.mcp.json');

package/src/mcp.mjs

@@ -0,0 +1,7 @@
+// Compatibility facade keeps the CLI and hooks from depending directly on a sibling adapter.
+export { MCP_HELP, runMcp } from '../packages/mcp/src/cli.mjs';
+export {
+  MCP_EFFECT_MANIFEST,
+  resolveMcpToolEffect,
+  verifyMcpEffectManifest,
+} from '../packages/mcp/src/effects.mjs';

package/src/observer-snapshot.mjs

@@ -5,6 +5,7 @@ import { allChangesState } from '../hooks/change-core.mjs';
 import { readControl, readSessionRegistry } from '../hooks/obsidian-common.mjs';
 import { runVaultHealth } from '../hooks/vault-health.mjs';
 import { readProjectForValidation } from '../packages/vault/src/validate-memory.mjs';
+import { inspectSyncOutbox, readLocalSyncState } from './sync-outbox.mjs';
 
 export const OBSERVER_SCHEMA_VERSION = 1;
 export const MAX_SNAPSHOT_BYTES = 32 * 1024;
@@ -46,12 +47,21 @@ function activeSessionSummary(vaultBase, control, registry) {
     .sort((a, b) => String(b.entry?.last_seen || b.entry?.updated_at || '').localeCompare(String(a.entry?.last_seen || a.entry?.updated_at || '')));
   const selected = entries.find(({ sessionId }) => sessionId === control?.session_id) || entries[0];
   const entry = selected?.entry || {};
+  const coverage = entry.host_coverage;
   return {
     status: safeText(control?.status || entry.status || 'inactive', 32),
     session_id: safeText(control?.session_id || selected?.sessionId || '', 100),
     provider: safeText(entry.provider || '', 32),
     change_slug: safeText(entry.change_slug || '', 100),
     last_seen: safeText(entry.last_seen || entry.updated_at || '', 40),
+    ...(coverage ? {
+      coverage: {
+        host_id: safeText(coverage.host_id || 'unknown', 32),
+        degraded: coverage.degraded === true,
+        unavailable: (coverage.capabilities || []).filter((item) => item?.state === 'unavailable').length,
+        manual: (coverage.capabilities || []).filter((item) => item?.state === 'manual').length,
+      },
+    } : {}),
   };
 }
 
@@ -83,6 +93,20 @@ function hashEvent(snapshot) {
   return `obs-${createHash('sha256').update(canonical).digest('hex').slice(0, 24)}`;
 }
 
+function syncSummary(vaultBase, projectId) {
+  const outbox = inspectSyncOutbox(vaultBase);
+  let openConflicts = 0;
+  if (!['disabled', 'corrupt'].includes(outbox.status)) {
+    try {
+      const state = readLocalSyncState(vaultBase, projectId);
+      openConflicts = Object.values(state.conflicts || {}).filter((item) => item?.status === 'open').length;
+    } catch {
+      return { status: 'corrupt', pending: outbox.pending, open_conflicts: 0 };
+    }
+  }
+  return { status: outbox.status, pending: outbox.pending, open_conflicts: openConflicts };
+}
+
 function hasForbiddenKey(value) {
   if (!value || typeof value !== 'object') return false;
   for (const [key, child] of Object.entries(value)) {
@@ -145,6 +169,7 @@ export function buildProjectSnapshot({ vaultBase, projectRoot = process.cwd(), n
     session: activeSessionSummary(vaultBase, control, registry),
     changes,
     health: healthSummary(vaultBase),
+    sync: syncSummary(vaultBase, project.projectId),
   };
   snapshot.event_id = hashEvent(snapshot);
   const validation = validateObserverSnapshot(snapshot, { projectId: project.projectId });