@aiwg/cockpit 2026.8.5 → 2026.8.7

package/README.md

@@ -411,7 +411,11 @@ safe version/build fields in the report. When the executor build does not expose
 that metadata, set `AIWG_COCKPIT_EXECUTOR_VERSION=<tag-or-commit>` so release
 evidence still names the tested agentic-sandbox build. A manual run against
 agentic-sandbox `v2026.6.15` or newer should attach its markdown/JSON result to
-epic roctinam/aiwg#1588 before the epic is considered done-done.
+epic roctinam/aiwg#1588 before the epic is considered done-done. The latest
+immutable fleet/activity qualification is
+[Agentic Sandbox v2026.8.3](../../docs/cockpit/qualifications/agentic-sandbox-v2026.8.3.md);
+older v2026.7.x entries below are historical feature-floor evidence, not the
+latest whole-integration claim.
 
 The executable release-validation procedure is
 `.aiwg/testing/cockpit-real-integration-uat-runbook.md`. Use that runbook for
@@ -575,7 +579,7 @@ agentic-sandbox executor through `AIWG_COCKPIT_EXECUTOR_URL`. The host target
 (agentic-sandbox#461) have landed upstream; the Bridge seam is now the
 AIWG-side integration point for #1589. Runtime-tier provisioning and
 host-daemon surfacing (roctinam/aiwg#1615) and transport-trust visibility (#1618)
-**landed and are verified against `v2026.7.4`** — transport posture and
+**landed with a compatibility floor verified against `v2026.7.4`** — transport posture and
 host-daemon now render per instance (a host-daemon *detail-status* payload
 remains a residual under #1615). Direct/managed PTY negotiation (#1616) and the
 live real-sandbox gate (#1617) continue. Secure transport details map back to agentic-sandbox#409/#410/#412; local

package/bridge/contracts/activity-event-v1.schema.json

@@ -0,0 +1,70 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/jmagly/agentic-sandbox/blob/main/docs/schemas/activity-event-v1.schema.json",
+  "title": "Agentic Sandbox Activity Event v1",
+  "description": "Stable metadata-first, loss-aware activity event envelope.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "event_id", "event_name", "plane", "occurred_at", "observed_at", "source", "correlation", "sensitivity", "retention_class", "payload", "integrity"],
+  "properties": {
+    "schema_version": {"const": "activity.event/v1"},
+    "event_id": {"type": "string", "format": "uuid", "description": "Source-generated UUIDv7."},
+    "event_name": {"type": "string", "pattern": "^[a-z][a-z0-9_]*(\\.[a-z][a-z0-9_]*)+$"},
+    "plane": {"enum": ["session", "action", "network", "runtime", "system", "integrity"]},
+    "occurred_at": {"type": "string", "format": "date-time"},
+    "observed_at": {"type": "string", "format": "date-time"},
+    "source": {"$ref": "#/$defs/source"},
+    "correlation": {"$ref": "#/$defs/correlation"},
+    "actor": {"$ref": "#/$defs/entity"},
+    "target": {"$ref": "#/$defs/entity"},
+    "outcome": {"$ref": "#/$defs/outcome"},
+    "sensitivity": {"enum": ["metadata", "restricted-content", "secret-prohibited"]},
+    "retention_class": {"enum": ["standard", "security", "forensic-hold", "ephemeral"]},
+    "payload": {"type": "object", "description": "Event-specific allowlisted metadata after source filtering."},
+    "integrity": {"$ref": "#/$defs/integrity"}
+  },
+  "$defs": {
+    "source": {
+      "type": "object", "additionalProperties": false,
+      "required": ["collector", "layer", "runtime", "trust"],
+      "properties": {
+        "collector": {"type": "string", "minLength": 1},
+        "layer": {"enum": ["guest", "runtime", "host", "control-plane", "provider"]},
+        "runtime": {"enum": ["qemu-kvm", "cloud-hypervisor", "docker", "host", "unknown"]},
+        "trust": {"enum": ["observed", "attested", "self-reported", "derived"]},
+        "clock_id": {"type": "string"},
+        "clock_error_ms": {"type": "number", "minimum": 0}
+      }
+    },
+    "correlation": {
+      "type": "object", "additionalProperties": false,
+      "required": ["tenant_id", "host_id", "instance_id", "agent_id"],
+      "properties": {
+        "tenant_id": {"type": "string", "minLength": 1}, "host_id": {"type": "string", "minLength": 1},
+        "instance_id": {"type": "string", "minLength": 1}, "agent_id": {"type": "string", "minLength": 1},
+        "session_id": {"type": "string"}, "mission_id": {"type": "string"}, "task_id": {"type": "string"},
+        "tool_call_id": {"type": "string"}, "command_id": {"type": "string"}, "process_id": {"type": "string"},
+        "parent_event_id": {"type": "string", "format": "uuid"},
+        "trace_id": {"type": "string", "pattern": "^[0-9a-f]{32}$"},
+        "span_id": {"type": "string", "pattern": "^[0-9a-f]{16}$"}
+      }
+    },
+    "entity": {
+      "type": "object", "additionalProperties": false, "required": ["type", "id"],
+      "properties": {"type": {"type": "string"}, "id": {"type": "string"}, "uid": {"type": "integer", "minimum": 0}, "gid": {"type": "integer", "minimum": 0}, "pid": {"type": "integer", "minimum": 0}}
+    },
+    "outcome": {
+      "type": "object", "additionalProperties": false, "required": ["status"],
+      "properties": {"status": {"enum": ["started", "success", "failure", "allowed", "denied", "degraded", "unknown"]}, "exit_code": {"type": "integer"}, "reason": {"type": "string"}}
+    },
+    "integrity": {
+      "type": "object", "additionalProperties": false, "required": ["collector_sequence"],
+      "properties": {
+        "collector_sequence": {"type": "integer", "minimum": 1},
+        "source_hash": {"type": "string", "pattern": "^[0-9a-f]{64}$"}, "source_previous_hash": {"type": "string", "pattern": "^[0-9a-f]{64}$"},
+        "timeline_hash": {"type": "string", "pattern": "^[0-9a-f]{64}$"}, "timeline_previous_hash": {"type": "string", "pattern": "^[0-9a-f]{64}$"},
+        "signature": {"type": "string"}, "key_id": {"type": "string"}
+      }
+    }
+  }
+}

package/bridge/contracts/activity-operational-evidence-v1.schema.json

@@ -0,0 +1,88 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://agentic-sandbox.local/schemas/activity-operational-evidence-v1.schema.json",
+  "title": "Agentic Sandbox daily operational evidence record v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schema_version",
+    "record_date",
+    "sealed_at",
+    "window",
+    "identity_digests",
+    "input_digest",
+    "previous_record_digest",
+    "summary",
+    "record_digest"
+  ],
+  "properties": {
+    "schema_version": {
+      "const": "agentic.activity-operational-evidence/v1"
+    },
+    "record_date": {
+      "type": "string",
+      "format": "date"
+    },
+    "sealed_at": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "window": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["start", "end", "actual_span_seconds"],
+      "properties": {
+        "start": {"type": "string", "format": "date-time"},
+        "end": {"type": "string", "format": "date-time"},
+        "actual_span_seconds": {"type": "number", "minimum": 0}
+      }
+    },
+    "identity_digests": {
+      "type": "array",
+      "items": {"type": "string", "pattern": "^[0-9a-f]{64}$"},
+      "minItems": 1,
+      "uniqueItems": true
+    },
+    "input_digest": {
+      "type": "string",
+      "pattern": "^[0-9a-f]{64}$"
+    },
+    "previous_record_digest": {
+      "oneOf": [
+        {"type": "null"},
+        {"type": "string", "pattern": "^[0-9a-f]{64}$"}
+      ]
+    },
+    "summary": {
+      "type": "object",
+      "required": [
+        "sample_count",
+        "evidence_class_counts",
+        "source_availability",
+        "latency_ms",
+        "metrics"
+      ],
+      "properties": {
+        "sample_count": {"type": "integer", "minimum": 1},
+        "evidence_class_counts": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["organic", "canary", "drill"],
+          "properties": {
+            "organic": {"type": "integer", "minimum": 0},
+            "canary": {"type": "integer", "minimum": 0},
+            "drill": {"type": "integer", "minimum": 0}
+          }
+        },
+        "source_availability": {"type": "object"},
+        "latency_ms": {"type": "object"},
+        "metrics": {"type": "object"}
+      },
+      "additionalProperties": false
+    },
+    "record_digest": {
+      "type": "string",
+      "pattern": "^[0-9a-f]{64}$"
+    }
+  }
+}

package/bridge/src/activity-contract.mjs

@@ -0,0 +1,101 @@
+import { readFileSync } from 'node:fs';
+
+const EVENT_SCHEMA = JSON.parse(readFileSync(
+  new URL('../contracts/activity-event-v1.schema.json', import.meta.url),
+  'utf8',
+));
+
+const RESTRICTED_KEY = /(?:^|_)(?:content|terminal|prompt|environment|env|credential|secret|password|authorization|bearer|token|private_key|certificate|restricted_(?:url|uri|link))(?:$|_)/i;
+
+function resolveRef(root, ref) {
+  if (!ref.startsWith('#/')) throw new Error(`unsupported external schema reference: ${ref}`);
+  return ref.slice(2).split('/').reduce((value, segment) => value?.[segment.replaceAll('~1', '/').replaceAll('~0', '~')], root);
+}
+
+function typeMatches(value, type) {
+  if (type === 'null') return value === null;
+  if (type === 'array') return Array.isArray(value);
+  if (type === 'object') return value !== null && typeof value === 'object' && !Array.isArray(value);
+  if (type === 'integer') return Number.isInteger(value);
+  if (type === 'number') return typeof value === 'number' && Number.isFinite(value);
+  return typeof value === type;
+}
+
+function formatMatches(value, format) {
+  if (format === 'uuid') return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+  if (format === 'date') return /^\d{4}-\d{2}-\d{2}$/.test(value) && !Number.isNaN(Date.parse(`${value}T00:00:00Z`));
+  if (format === 'date-time') return !Number.isNaN(Date.parse(value));
+  return true;
+}
+
+function validateNode(value, schema, root, path, errors) {
+  if (schema.$ref) return validateNode(value, resolveRef(root, schema.$ref), root, path, errors);
+  if (schema.oneOf) {
+    const matches = schema.oneOf.filter((candidate) => {
+      const candidateErrors = [];
+      validateNode(value, candidate, root, path, candidateErrors);
+      return candidateErrors.length === 0;
+    });
+    if (matches.length !== 1) errors.push(`${path} must match exactly one schema`);
+    return;
+  }
+  if (schema.const !== undefined && value !== schema.const) errors.push(`${path} must equal ${JSON.stringify(schema.const)}`);
+  if (schema.enum && !schema.enum.includes(value)) errors.push(`${path} is not an allowed value`);
+  if (schema.type && !typeMatches(value, schema.type)) {
+    errors.push(`${path} must be ${schema.type}`);
+    return;
+  }
+  if (typeof value === 'string') {
+    if (schema.minLength !== undefined && value.length < schema.minLength) errors.push(`${path} is too short`);
+    if (schema.pattern && !new RegExp(schema.pattern, 'u').test(value)) errors.push(`${path} has invalid format`);
+    if (schema.format && !formatMatches(value, schema.format)) errors.push(`${path} has invalid ${schema.format} format`);
+  }
+  if (typeof value === 'number' && schema.minimum !== undefined && value < schema.minimum) errors.push(`${path} is below minimum`);
+  if (Array.isArray(value)) {
+    if (schema.minItems !== undefined && value.length < schema.minItems) errors.push(`${path} has too few items`);
+    if (schema.uniqueItems && new Set(value.map((item) => JSON.stringify(item))).size !== value.length) errors.push(`${path} items must be unique`);
+    if (schema.items) value.forEach((item, index) => validateNode(item, schema.items, root, `${path}/${index}`, errors));
+  }
+  if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+    for (const key of schema.required ?? []) if (!(key in value)) errors.push(`${path}/${key} is required`);
+    if (schema.additionalProperties === false) {
+      for (const key of Object.keys(value)) if (!(key in (schema.properties ?? {}))) errors.push(`${path}/${key} is not allowed`);
+    }
+    for (const [key, childSchema] of Object.entries(schema.properties ?? {})) {
+      if (key in value) validateNode(value[key], childSchema, root, `${path}/${key}`, errors);
+    }
+  }
+}
+
+function containsRestrictedField(value) {
+  if (Array.isArray(value)) return value.some(containsRestrictedField);
+  if (!value || typeof value !== 'object') return false;
+  return Object.entries(value).some(([key, child]) => RESTRICTED_KEY.test(key) || containsRestrictedField(child));
+}
+
+export function validateActivityEvent(event, expectedScope = undefined) {
+  const errors = [];
+  validateNode(event, EVENT_SCHEMA, EVENT_SCHEMA, '$', errors);
+  if (event?.sensitivity !== 'metadata') errors.push('$/sensitivity must be metadata at the Cockpit boundary');
+  if (containsRestrictedField(event)) errors.push('$ contains a restricted field');
+  if (expectedScope) {
+    for (const [key, value] of Object.entries(expectedScope)) {
+      if (event?.correlation?.[key] !== value) errors.push(`$/correlation/${key} scope mismatch`);
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+export function assertActivityEvent(event, expectedScope = undefined) {
+  const result = validateActivityEvent(event, expectedScope);
+  if (!result.valid) {
+    const scopeMismatch = result.errors.some((error) => error.includes('scope mismatch'));
+    const restricted = result.errors.some((error) => error.includes('restricted') || error.includes('sensitivity'));
+    const error = new Error(result.errors.join('; '));
+    error.code = scopeMismatch ? 'activity_scope_mismatch' : restricted ? 'activity_restricted_data' : 'activity_malformed_envelope';
+    throw error;
+  }
+  return event;
+}
+
+export { EVENT_SCHEMA };

package/bridge/src/server.mjs

@@ -16,6 +16,7 @@ import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { dirname, join, basename, extname, resolve, sep } from 'node:path';
 import { storeCockpitToken } from '../../shell-core/keychain.mjs';
+import { assertActivityEvent } from './activity-contract.mjs';
 
 const __dir = dirname(fileURLToPath(import.meta.url));
 // Primary seam for roctinam/aiwg#1589: Cockpit talks to a real agentic-sandbox
@@ -1606,7 +1607,6 @@ const ACTIVITY_SCOPE_HEADERS = {
   instance_id: 'x-agentic-instance-id', agent_id: 'x-agentic-agent-id',
 };
 const ACTIVITY_FILTERS = new Set(['event_name', 'collector', 'trust', 'plane', 'outcome', 'session_id', 'mission_id', 'task_id', 'tool_call_id', 'command_id', 'process_id', 'trace_id', 'since', 'until', 'limit']);
-const RESTRICTED_ACTIVITY_KEY = /(?:^|_)(?:content|terminal|prompt|environment|env|credential|secret|password|authorization|bearer|token|private_key|certificate|restricted_(?:url|uri|link))(?:$|_)/i;
 
 export function activityRequest(input = {}) {
   if (!input || typeof input !== 'object' || Array.isArray(input)) throw Object.assign(new Error('activity request must be an object'), { code: 'activity_invalid_request' });
@@ -1630,12 +1630,6 @@ export function activityRequest(input = {}) {
   return { headers, scope, filter };
 }
 
-function hasRestrictedActivityField(value) {
-  if (Array.isArray(value)) return value.some(hasRestrictedActivityField);
-  if (!value || typeof value !== 'object') return false;
-  return Object.entries(value).some(([key, child]) => RESTRICTED_ACTIVITY_KEY.test(key) || hasRestrictedActivityField(child));
-}
-
 export function validateActivityEnvelope(body, expectedScope, { includeEvents = false, exportEnvelope = false } = {}) {
   if (!body || typeof body !== 'object' || Array.isArray(body)) throw Object.assign(new Error('malformed activity envelope'), { code: 'activity_malformed_envelope' });
   if (!exportEnvelope && body.schema_version !== 'activity.event/v1') throw Object.assign(new Error('unsupported activity schema'), { code: 'activity_malformed_envelope' });
@@ -1664,14 +1658,18 @@ export function validateActivityEnvelope(body, expectedScope, { includeEvents =
     throw Object.assign(new Error('activity envelope has malformed collector coverage'), { code: 'activity_malformed_envelope' });
   }
   for (const event of events) {
-    if (event?.schema_version !== 'activity.event/v1' || event?.sensitivity !== 'metadata' || hasRestrictedActivityField(event)) {
-      throw Object.assign(new Error('activity envelope contains restricted or unsupported event data'), { code: 'activity_restricted_data' });
-    }
-    for (const [key, value] of Object.entries(expectedScope)) {
-      if (event?.correlation?.[key] !== value) throw Object.assign(new Error('activity event scope mismatch'), { code: 'activity_scope_mismatch' });
-    }
-  }
-  if (exportEnvelope && (!body.manifest || typeof body.manifest.key_id !== 'string' || typeof body.manifest.merkle_root !== 'string')) {
+    assertActivityEvent(event, expectedScope);
+  }
+  const manifest = body.manifest;
+  if (exportEnvelope && (!manifest
+    || typeof manifest.batch_id !== 'string' || !manifest.batch_id
+    || manifest.tenant_id !== expectedScope.tenant_id
+    || typeof manifest.collector_id !== 'string' || !manifest.collector_id
+    || !Number.isInteger(manifest.event_count) || manifest.event_count < 0
+    || !/^[0-9a-f]{64}$/.test(manifest.merkle_root ?? '')
+    || typeof manifest.key_id !== 'string' || !manifest.key_id
+    || typeof manifest.signature !== 'string' || !manifest.signature
+    || (manifest.previous_root !== null && manifest.previous_root !== undefined && !/^[0-9a-f]{64}$/.test(manifest.previous_root)))) {
     throw Object.assign(new Error('signed activity export has no valid manifest'), { code: 'activity_malformed_export' });
   }
   return body;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwg/cockpit",
-  "version": "2026.8.5",
+  "version": "2026.8.7",
   "description": "AIWG Cockpit — UX-first control plane over AIWG + multi-stack agentic sessions. Opt-in, separately published; NOT shipped in the base aiwg npm package (guarded by test/smoke/cockpit-base-footprint.test.js).",
   "type": "module",
   "license": "MIT",