chati-dev 4.4.1 → 4.5.2

package/framework/i18n/fr.yaml

@@ -22,8 +22,14 @@ installer:
   llm_provider_not_installed: "(CLI non detecte)"
   llm_provider_label: "Fournisseur IA"
   ide_selection_title: "Selectionnez vos IDEs / CLIs (multiples autorises):"
-  primary_provider_title: "Quel est votre fournisseur CLI principal?"
-  primary_provider_label: "Fournisseur Principal"
+  installation_mode_title: "Selectionnez le mode d'installation"
+  installation_mode_open: "Open"
+  installation_mode_open_hint: "Framework public sans integrations d'entreprise obligatoires"
+  installation_mode_internal: "Internal"
+  installation_mode_internal_hint: "Necessite une licence autorisee et active le suivi ClickUp et les politiques internes"
+  installation_mode_label: "Mode d'installation"
+  model_routing_label: "Routage des modeles"
+  model_routing_automatic: "Automatique par tache entre tous les modeles actives"
   providers_label: "Fournisseurs"
   quick_start_switch_hint: "Changez de CLI a tout moment — votre session continue la ou vous l'avez laissee"
   created_overlays: "Crees les repertoires d'overlay des fournisseurs"

package/framework/i18n/pt.yaml

@@ -22,8 +22,14 @@ installer:
   llm_provider_not_installed: "(CLI nao detectada)"
   llm_provider_label: "Provedor de IA"
   ide_selection_title: "Selecione suas IDEs / CLIs (multiplos permitidos):"
-  primary_provider_title: "Qual e seu provedor CLI principal?"
-  primary_provider_label: "Provedor Principal"
+  installation_mode_title: "Selecione o modo de instalacao"
+  installation_mode_open: "Open"
+  installation_mode_open_hint: "Framework publico sem integracoes corporativas obrigatorias"
+  installation_mode_internal: "Internal"
+  installation_mode_internal_hint: "Exige uma licenca autorizada e ativa o tracking no ClickUp e as politicas internas"
+  installation_mode_label: "Modo de instalacao"
+  model_routing_label: "Roteamento de modelos"
+  model_routing_automatic: "Automatico por task entre todos os modelos habilitados"
   providers_label: "Provedores"
   quick_start_switch_hint: "Troque de CLI a qualquer momento — sua sessao continua de onde parou"
   created_overlays: "Criados diretorios de overlay de provedores"

package/framework/manifest.json

@@ -1,5 +1,5 @@
 {
-  "createdAt": "2026-06-11T15:43:15.625Z",
+  "createdAt": "2026-08-27T07:27:47.925Z",
   "files": {
     "agents/build/dev.md": {
       "hash": "5c8da2eee3357bbe84a6c468c76fe60a0c77357575503c3797aa94128282c565",
@@ -52,8 +52,8 @@
       "type": "md"
     },
     "agents/plan/tasks.md": {
-      "hash": "6bbcedde587b891d046c0916ebdf876743eaab314e304a51ce60b0b0bfac3ee8",
-      "size": 26074,
+      "hash": "e43665228fd7ae5a239e2d4b4298a54c5f06f465a89c9b8e939cf6e6b2ac8089",
+      "size": 28251,
       "type": "md"
     },
     "agents/plan/ux-brand-architect.md": {
@@ -97,18 +97,18 @@
       "type": "md"
     },
     "config.yaml": {
-      "hash": "e5abc83a59b4bba4928e9680dd7d789d8e44d678a2656715cd9c3fc9a9e6dd66",
+      "hash": "f7c77483aeaa44f37d8492d85a376304cb24ec28d91dbed3155f41faa627b7ad",
       "size": 2841,
       "type": "yaml"
     },
     "constitution.md": {
-      "hash": "d88a7eb53c10f92ff90e890c236c43ccba2e11a5822ad612e4cb275ed9c74c1c",
-      "size": 68042,
+      "hash": "444fa267ed5f998c428611c61204e390b694ed744913834d06faed9fce543e55",
+      "size": 67858,
       "type": "md"
     },
     "context/governance.md": {
-      "hash": "cee194fef680a0e9efab38dbe233758ea55f7b9512c6a9b390b1f9db890c9095",
-      "size": 5946,
+      "hash": "80b2243a84b3ec0e9066ee51251685605252e4bd47fa94c2ce25f00af688cd79",
+      "size": 6086,
       "type": "md"
     },
     "context/protocols.md": {
@@ -122,8 +122,8 @@
       "type": "md"
     },
     "context/root.md": {
-      "hash": "5fab9ff8f3e4003a797c2d55202ecb2306add553e34ddcd2b652463647da6b8c",
-      "size": 1103,
+      "hash": "1ac04cbce1e85009ecdf224cdbee4fe64bcc80232366c2122805e9c9c3191f9a",
+      "size": 1217,
       "type": "md"
     },
     "data/entity-registry.yaml": {
@@ -377,23 +377,23 @@
       "type": "js"
     },
     "i18n/en.yaml": {
-      "hash": "7fb19ab9fed900f10aeaa5bcffe3a4c2037b92513ec593fffc0509cd25f612fb",
-      "size": 4549,
+      "hash": "5eb0e9dfa7baec166fc12ca8a1c0e9623c9a023c51c09455b80a6d8df1e0205f",
+      "size": 4941,
       "type": "yaml"
     },
     "i18n/es.yaml": {
-      "hash": "f83cc1afbe9e7f1ed0243326d4587ac087f72e5b7f9ba667ae8c65a4842a01f4",
-      "size": 4794,
+      "hash": "1ed8c732c13c23e3fc2d5578526c1285a2a1ffc1d79b85d8e12365c3bcbbd882",
+      "size": 5225,
       "type": "yaml"
     },
     "i18n/fr.yaml": {
-      "hash": "d2b3b9077ee93260133ab83e9d928043d38f454ac28444e6d2dbc87fedc5b84c",
-      "size": 4878,
+      "hash": "ae88b914ea39d6613879aae3a3fcdf92a771d3df0f207def6cbb2cc76455cfe9",
+      "size": 5290,
       "type": "yaml"
     },
     "i18n/pt.yaml": {
-      "hash": "10183e9096376f050350cf5f69d582fae2fb47da4eb18fe72486760d5f965e07",
-      "size": 4747,
+      "hash": "9e766ca8c7eba6362816bdc9d1f6162d615f1b5ca1a9b2f75071a53b7ab9f6b3",
+      "size": 5163,
       "type": "yaml"
     },
     "intelligence/confidence.yaml": {
@@ -472,8 +472,8 @@
       "type": "md"
     },
     "orchestrator/chati.md": {
-      "hash": "1bdf278d7f29b35d1d043f6945240249c34f5995c5c712d8fedfaebfdd25ef4d",
-      "size": 42604,
+      "hash": "c2d895fd342422985b68d4912189f2abcfb2bac536c5cf325d0480faf9db5f9f",
+      "size": 44348,
       "type": "md"
     },
     "patterns/elicitation-library.yaml": {
@@ -1347,5 +1347,5 @@
       "type": "yaml"
     }
   },
-  "version": "4.4.1"
+  "version": "4.5.2"
 }

package/framework/manifest.sig

@@ -1 +1 @@
-EK1FsSHB+n5Dbo2dRSF1DPgRD35si2lygeQvPZZp91Vy069v6AlHbK/delS4LVkj/sAU7Tp5PoulKchOCF75AQ==
+Y5XGGQ07UbiwrVZytFSTJvXNifA8l16S9QI+ret6AVjrYfWvN6E5ChUG0BGKWLsE2wpjVtEW4TVJosYaFDANAg==

package/framework/orchestrator/chati.md

@@ -100,6 +100,7 @@ Parse the JSON output. The `action` field tells you what to do:
 | `spawn_autonomous` | Action: Autonomous Agent |
 | `spawn_parallel` | Action: Parallel Spawn |
 | `spawn_team` | Action: Spawn Team (Article XXI) |
+| `rail_execute` | Action: RAIL Execution |
 | `resume` | Action: Resume |
 | `user_preview` | Action: User Preview |
 | `complete` | Action: Complete |
@@ -118,8 +119,7 @@ Only mention the bracket when it reaches CRITICAL, and only in plain language. E
 - `ux` → "let's design the user experience"
 - `phases` / `tasks` → "let's break this down into phases"
 - `qa-planning` / `qa-implementation` → "let's review what we have"
-- `dev` → "let's build it"
-- `devops` → "let's deploy it"
+- `rail` → "let's execute the approved plan"
 
 ---
 
@@ -314,8 +314,8 @@ Planning phase agents (detail, architect, ux) run simultaneously.
 
 ### Parallelization Rules
 - GROUP 1 (Planning Team): detail, architect, ux, qa-planning - run as team (QA-Planning activates after trio completes)
-- GROUP 2 (Build): Independent dev tasks - SHOULD run in parallel
-- NOT parallelizable: WU, Brief, Phases, Tasks, DevOps (QA-Planning is now inside Planning Team, QA-Implementation inside Build Team)
+- RAIL execution: scheduling, reviews and bounded rework are owned by the sealed project-local RAIL handoff.
+- NOT parallelizable: WU, Brief, Phases, Tasks. After Tasks is sealed, do not create a legacy Build Team.
 
 ---
 
@@ -397,7 +397,11 @@ Agent tool call 4:
     Write your handoff to artifacts/handoffs/qa-planning-handoff.md when done.]
 ```
 
-**For Build Team** (BUILD phase) - Wave-Based Pipeline:
+**Legacy compatibility only, installations without `.chati/v2/installation.json`: For Build Team** (BUILD phase) - Wave-Based Pipeline:
+
+For a v2 installation this section MUST NOT run. The `tasks` handoff returns
+`rail_execute`; use **Action: RAIL Execution** instead. Legacy Build and DevOps
+remain documented only to let older installed projects finish safely.
 
 The Build Team operates in WAVES, not continuous parallel polling.
 Each wave spawns Dev + QA with bounded, independent work.
@@ -610,8 +614,8 @@ Team member {agent} appears stuck in a repetition loop (Article XXII Echo Detect
 After Planning Team (detail + architect + ux + qa-planning) completes and user approves:
 1. Dissolve Planning Team: `team-dissolve --team-id {planning-team-id}`
 2. Continue pipeline normally through Phases, Tasks (these are NOT parallelizable and run sequentially as interactive or autonomous agents). QA-Planning already ran inside the Planning Team.
-3. When BUILD phase activates: attempt to form Build Team (dev + qa-implementation) following the same Steps 1-3 above
-4. Build Team uses Wave Mode: Dev and QA alternate in waves of 5 tasks, with the orchestrator managing the loop.
+3. After Tasks seals a v2 handoff, follow **Action: RAIL Execution**. Do not form a Build Team.
+4. Only a pre-v2 installation may activate the legacy Build Team wave mode.
 
 **Team cleanup order:** Dissolve current team BEFORE creating next team. Never two teams active simultaneously.
 
@@ -619,7 +623,7 @@ After Planning Team (detail + architect + ux + qa-planning) completes and user a
 
 If the Agent tool is unavailable or any sub-agent spawn fails:
 ```
-1. Fall back silently to spawn_parallel (GROUP 1) or spawn_autonomous (BUILD)
+1. Fall back silently to spawn_parallel for Planning. RAIL never falls back to the legacy Build pipeline.
    Use the existing Action: Parallel Spawn or Action: Autonomous Agent flow
 2. Do NOT display any error or fallback message to the user
 3. Run: node .chati.dev/orchestrator/chati-router.js team-dissolve --team-id {team_id}
@@ -631,6 +635,32 @@ If the Agent tool is unavailable or any sub-agent spawn fails:
 
 ---
 
+## Action: RAIL Execution
+
+The planning handoff is sealed. RAIL is now the sole authority for execution,
+review, bounded rework, ClickUp projection and the Release Lane.
+
+1. Read the immutable handoff id returned in `rail_execute`.
+2. Run:
+   ```
+   node .chati.dev/_cli/bin/chati.js rail-next --handoff-id {handoff_id}
+   ```
+3. Execute only a dependency-ready task. Use its selected provider and model
+   binding from `.chati/v2/installation.json`. Never substitute an unselected
+   vendor or model.
+4. Record every claim, review, completion, rework count and ClickUp projection
+   through RAIL. ClickUp is a projection, while the local journal remains
+   canonical during an outage. For the internal profile, a merged completion
+   MUST include `actual_human_effort`, `actual_ai_processing`, `rework_cycles`
+   and one verified review reference per rework cycle. RAIL writes the
+   in-progress, ready-to-merge and closed projections automatically; do not
+   create a parallel manual tracking path.
+5. After two normal rework cycles, use the configured top-tier adjudication
+   route. Escalate to a human only for an authority decision, not an ordinary
+   technical correction.
+6. When `rail-next` has no ready work, check the Release Lane. It may prepare
+   evidence, but cannot deploy or publish without explicit authorization.
+
 ## Action: Resume
 
 The user is returning to an active session.
@@ -682,10 +712,11 @@ DISCOVER:
 PLAN:
   Detail: {score}%  Arch: {score}%  UX: {score}%
   Phases: {score}%  Tasks: {score}%  QA-P: {score}%
-BUILD:
-  Dev: {status}  QA-Impl: {status}
-DEPLOY:
-  DevOps: {status}
+RAIL:
+  Handoff: {handoff_id}  Ready tasks: {count}
+  Rework: {count}  ClickUp projection: {status}
+RELEASE LANE:
+  Evidence: {status}  Authorization: {status}
 
 Current Agent: {current_agent}
 Backlog: {count} items ({high_priority} high priority)

package/node_modules/@chati/browser-capability/README.md

@@ -0,0 +1,10 @@
+# CHATI Browser Capability
+
+G3 implementation of C-10. This package is policy-only and constructs its own
+non-injectable fake adapter. It has no browser launch, MCP, session,
+credential, network or scheduling code. A task that declares `requires_browser: true` must
+pass `assertBrowserCapabilityForTask` before it can reach the fake adapter.
+
+The returned `BrowserEvidenceManifest` contains the task policy, classification,
+redaction and retention constraints. Artifacts are references only and must be
+redacted before recording.

package/node_modules/@chati/browser-capability/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@chati/browser-capability",
+  "version": "0.1.0",
+  "private": true,
+  "description": "Policy-only browser capability contract for CHATI",
+  "type": "module",
+  "exports": "./src/index.js",
+  "dependencies": {
+    "@chati/core": "0.1.0"
+  },
+  "scripts": {
+    "test": "node --test test/**/*.test.js"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/node_modules/@chati/browser-capability/src/index.js

@@ -0,0 +1,165 @@
+import { ContractError, canonicalize, sha256 } from '@chati/core';
+
+const MODES = new Set(['unauthenticated', 'authenticated']);
+const TOOLS = new Set(['playwright-cli', 'playwright-mcp', 'chrome-devtools-mcp', 'approved-other']);
+const CLASSIFICATIONS = new Set(['internal', 'confidential', 'client-restricted', 'personal-restricted']);
+const ACTION_CONFIRMATIONS = new Set(['required', 'not-required-by-policy']);
+const ARTIFACT_KINDS = new Set(['screenshot', 'dom', 'network', 'trace', 'download', 'console']);
+
+function fail(code, message, details = {}) { throw new ContractError(code, message, details); }
+function object(value, code, label) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) fail(code, `${label} must be an object`);
+}
+function string(value, code, label) {
+  if (typeof value !== 'string' || value.trim() === '') fail(code, `${label} must be a non-empty string`);
+}
+function ref(value, code, label) { string(value, code, label); }
+function freeze(value) {
+  if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const child of Object.values(value)) freeze(child);
+  }
+  return value;
+}
+function normalizedDomain(value) {
+  string(value, 'INVALID_ALLOWED_DOMAIN', 'allowed domain');
+  const domain = value.trim().toLowerCase();
+  if (domain.includes('://') || domain.includes('/') || domain.includes('@') || domain.includes(':') || domain === 'localhost' || /^\d{1,3}(?:\.\d{1,3}){3}$/.test(domain)) {
+    fail('INVALID_ALLOWED_DOMAIN', 'allowed_domains must contain a DNS domain, not a URL, host profile, localhost, or IP address');
+  }
+  if (!/^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$/.test(domain)) fail('INVALID_ALLOWED_DOMAIN', 'allowed domain is not a valid DNS name');
+  return domain;
+}
+function urlDomain(url) {
+  string(url, 'INVALID_BROWSER_URL', 'url');
+  let parsed;
+  try { parsed = new URL(url); } catch { fail('INVALID_BROWSER_URL', 'url must be absolute and parseable'); }
+  if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') fail('INVALID_BROWSER_URL', 'only http and https URLs are supported by the fake preflight');
+  if (parsed.username || parsed.password) fail('URL_CREDENTIALS_FORBIDDEN', 'URLs with embedded credentials are forbidden');
+  return parsed.hostname.toLowerCase();
+}
+function domainAllowed(hostname, allowedDomains) {
+  return allowedDomains.some((domain) => hostname === domain || hostname.endsWith(`.${domain}`));
+}
+
+/** C-10 policy. A policy describes permission, it never launches a browser. */
+export function validateBrowserPolicy(policy) {
+  object(policy, 'INVALID_BROWSER_POLICY', 'browser policy');
+  for (const field of ['policy_id', 'task_id', 'mode', 'tool', 'profile_isolation', 'action_confirmation']) string(policy[field], 'INVALID_BROWSER_POLICY', `browser policy.${field}`);
+  if (!MODES.has(policy.mode)) fail('INVALID_BROWSER_MODE', 'mode must be unauthenticated or authenticated');
+  if (!TOOLS.has(policy.tool)) fail('INVALID_BROWSER_TOOL', 'tool is not an approved browser tool identifier');
+  if (policy.profile_isolation !== 'required') fail('PROFILE_ISOLATION_REQUIRED', 'browser policy requires an isolated profile');
+  if (!Array.isArray(policy.allowed_domains) || policy.allowed_domains.length === 0) fail('MISSING_ALLOWED_DOMAINS', 'allowed_domains must be a non-empty array');
+  const allowed_domains = policy.allowed_domains.map(normalizedDomain);
+  if (new Set(allowed_domains).size !== allowed_domains.length) fail('DUPLICATE_ALLOWED_DOMAIN', 'allowed_domains must be unique');
+  object(policy.artifact_policy, 'MISSING_ARTIFACT_POLICY', 'artifact_policy');
+  if (policy.artifact_policy.redaction !== 'required') fail('REDACTION_REQUIRED', 'artifact_policy.redaction must be required');
+  if (policy.artifact_policy.evidence_manifest !== 'required') fail('EVIDENCE_MANIFEST_REQUIRED', 'artifact_policy.evidence_manifest must be required');
+  string(policy.artifact_policy.retention_class, 'RETENTION_REQUIRED', 'artifact_policy.retention_class');
+  if (!ACTION_CONFIRMATIONS.has(policy.action_confirmation)) fail('INVALID_ACTION_CONFIRMATION', 'action_confirmation must be required or not-required-by-policy');
+  return freeze(canonicalize({ ...policy, allowed_domains }));
+}
+
+/** Ensures task declarations cannot reach an adapter without an explicit C-10 policy. */
+export function assertBrowserCapabilityForTask(task = {}) {
+  object(task, 'INVALID_TASK_CAPABILITY', 'task capability declaration');
+  if (task.requires_browser !== true) return null;
+  if (!task.browser_policy) fail('BROWSER_POLICY_REQUIRED', 'a browser task requires browser_policy before any adapter may be called');
+  const policy = validateBrowserPolicy(task.browser_policy);
+  if (task.task_id !== undefined && task.task_id !== policy.task_id) fail('TASK_POLICY_MISMATCH', 'task_id must match browser policy.task_id');
+  return policy;
+}
+
+function validateLaunchRequest(input, policy) {
+  object(input, 'INVALID_BROWSER_REQUEST', 'browser launch request');
+  string(input.browser_session_id, 'INVALID_BROWSER_REQUEST', 'browser_session_id');
+  string(input.task_id, 'INVALID_BROWSER_REQUEST', 'task_id');
+  if (input.task_id !== policy.task_id) fail('TASK_POLICY_MISMATCH', 'launch task_id must match policy.task_id');
+  const hostname = urlDomain(input.url);
+  if (!domainAllowed(hostname, policy.allowed_domains)) fail('DOMAIN_NOT_ALLOWED', 'requested URL hostname is outside policy allowed_domains', { hostname });
+  string(input.classification, 'MISSING_CLASSIFICATION', 'classification');
+  if (!CLASSIFICATIONS.has(input.classification)) fail('INVALID_CLASSIFICATION', 'classification is invalid');
+  if (input.classification === 'client-restricted') ref(input.tenant_ref, 'MISSING_TENANT_REF', 'tenant_ref');
+  if (policy.action_confirmation === 'required') ref(input.action_confirmation_ref, 'ACTION_CONFIRMATION_REQUIRED', 'action_confirmation_ref');
+  return freeze(canonicalize({ ...input, hostname }));
+}
+
+/**
+ * Internal test-only adapter. It cannot perform I/O and is never injectable.
+ * Keeping construction inside BrowserCapability prevents a caller from using a
+ * label such as `fake-browser-adapter` to smuggle an I/O-capable adapter over
+ * the G3 boundary.
+ */
+class InternalFakeBrowserAdapter {
+  #launches = [];
+  get launches() { return freeze(canonicalize(this.#launches)); }
+  launch(preflight) {
+    this.#launches.push(canonicalize(preflight));
+    return freeze(canonicalize({ fake_launch_id: `fake-browser-launch-${this.#launches.length}` }));
+  }
+}
+
+export class BrowserCapability {
+  #adapter;
+  #issuedManifests = new WeakSet();
+  constructor(options = {}) {
+    object(options, 'INVALID_BROWSER_CAPABILITY_OPTIONS', 'browser capability options');
+    if (Object.hasOwn(options, 'adapter')) fail('EXTERNAL_ADAPTER_FORBIDDEN', 'G3 constructs its internal fake adapter and accepts no injected adapter');
+    this.#adapter = new InternalFakeBrowserAdapter();
+  }
+
+  get fakeLaunches() { return this.#adapter.launches; }
+  #issue(manifest) {
+    const issued = freeze(canonicalize(manifest));
+    this.#issuedManifests.add(issued);
+    return issued;
+  }
+
+  preflight(input = {}) {
+    const policy = validateBrowserPolicy(input.policy);
+    const request = validateLaunchRequest(input, policy);
+    const manifestInput = {
+      schema_version: 1,
+      manifest_type: 'BrowserEvidenceManifest',
+      browser_session_id: request.browser_session_id,
+      task_id: request.task_id,
+      policy_ref: policy.policy_id,
+      mode: policy.mode,
+      tool: policy.tool,
+      allowed_domain: request.hostname,
+      profile_isolation: policy.profile_isolation,
+      classification: request.classification,
+      artifact_policy: policy.artifact_policy,
+      action_confirmation: policy.action_confirmation,
+      artifacts: [],
+      launch: { adapter: 'fake-browser-adapter', status: 'preflighted' },
+    };
+    if (request.tenant_ref !== undefined) manifestInput.tenant_ref = request.tenant_ref;
+    if (request.action_confirmation_ref !== undefined) manifestInput.action_confirmation_ref = request.action_confirmation_ref;
+    return this.#issue(manifestInput);
+  }
+
+  launch(input = {}) {
+    const manifest = this.preflight(input);
+    const result = this.#adapter.launch(freeze(canonicalize({ policy_ref: manifest.policy_ref, browser_session_id: manifest.browser_session_id, task_id: manifest.task_id, url: input.url, hostname: manifest.allowed_domain, mode: manifest.mode, profile_isolation: manifest.profile_isolation })));
+    return this.#issue({ ...manifest, launch: { adapter: 'fake-browser-adapter', status: 'launched', fake_launch_ref: result.fake_launch_id } });
+  }
+
+  recordArtifact({ manifest, artifact } = {}) {
+    object(manifest, 'INVALID_BROWSER_MANIFEST', 'BrowserEvidenceManifest');
+    if (manifest.manifest_type !== 'BrowserEvidenceManifest' || manifest.schema_version !== 1) fail('INVALID_BROWSER_MANIFEST', 'manifest is not a supported BrowserEvidenceManifest');
+    if (!this.#issuedManifests.has(manifest)) fail('UNISSUED_BROWSER_MANIFEST', 'manifest must be emitted by this BrowserCapability preflight or launch');
+    object(artifact, 'INVALID_BROWSER_ARTIFACT', 'browser artifact');
+    for (const field of ['artifact_id', 'kind', 'sanitized_ref', 'redaction_status', 'retention_class']) string(artifact[field], 'INVALID_BROWSER_ARTIFACT', `artifact.${field}`);
+    if (!ARTIFACT_KINDS.has(artifact.kind)) fail('INVALID_BROWSER_ARTIFACT', 'artifact.kind is invalid');
+    if (artifact.redaction_status !== 'redacted') fail('ARTIFACT_NOT_REDACTED', 'browser artifact must be redacted before entering the manifest');
+    if (artifact.retention_class !== manifest.artifact_policy.retention_class) fail('RETENTION_MISMATCH', 'artifact retention_class must match browser policy');
+    const artifacts = [...manifest.artifacts];
+    if (artifacts.some((item) => item.artifact_id === artifact.artifact_id)) fail('DUPLICATE_BROWSER_ARTIFACT', 'artifact_id is already present in manifest');
+    artifacts.push(canonicalize(artifact));
+    const output = { ...manifest, artifacts };
+    delete output.manifest_hash;
+    output.manifest_hash = sha256(output);
+    return this.#issue(output);
+  }
+}

package/node_modules/@chati/core/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@chati/core",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "exports": "./src/index.js",
+  "scripts": {
+    "test": "node --test test/**/*.test.js"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/node_modules/@chati/core/src/index.js

@@ -0,0 +1,111 @@
+import { createHash } from 'node:crypto';
+
+export class ContractError extends Error {
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = 'ContractError';
+    this.code = code;
+    this.details = details;
+  }
+}
+
+const RFC3339 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
+const CLASSIFICATIONS = new Set(['internal', 'confidential', 'client-restricted', 'personal-restricted']);
+const ACTOR_TYPES = new Set(['human', 'harness', 'service']);
+const CONTRACT_TYPES = new Set(['installation', 'handoff', 'policy', 'task', 'review']);
+
+function assertObject(value, code, label) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new ContractError(code, `${label} must be an object`);
+  }
+}
+
+function assertString(value, code, label) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new ContractError(code, `${label} must be a non-empty string`);
+  }
+}
+
+/**
+ * Produces a JSON-compatible value whose object keys are recursively sorted.
+ * Arrays retain their declared order because order is semantically meaningful
+ * in contract artifacts.
+ */
+export function canonicalize(value, path = '$') {
+  if (value === null || typeof value === 'string' || typeof value === 'boolean') return value;
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value)) throw new ContractError('NON_CANONICAL_VALUE', `${path} must be finite`);
+    return value;
+  }
+  if (Array.isArray(value)) return value.map((entry, index) => canonicalize(entry, `${path}[${index}]`));
+  if (typeof value === 'object') {
+    const output = {};
+    for (const key of Object.keys(value).sort()) {
+      if (value[key] === undefined) throw new ContractError('NON_CANONICAL_VALUE', `${path}.${key} is undefined`);
+      output[key] = canonicalize(value[key], `${path}.${key}`);
+    }
+    return output;
+  }
+  throw new ContractError('NON_CANONICAL_VALUE', `${path} is not JSON-compatible`);
+}
+
+export function canonicalSerialize(value) {
+  return JSON.stringify(canonicalize(value));
+}
+
+export function sha256(value) {
+  const input = typeof value === 'string' ? value : canonicalSerialize(value);
+  return createHash('sha256').update(input, 'utf8').digest('hex');
+}
+
+export function validateEvidenceEnvelope(envelope) {
+  assertObject(envelope, 'INVALID_ENVELOPE', 'envelope');
+  assertString(envelope.event_id, 'INVALID_ENVELOPE', 'event_id');
+  if (envelope.schema_version !== 1) throw new ContractError('UNSUPPORTED_SCHEMA_VERSION', 'schema_version must be 1');
+  assertString(envelope.occurred_at, 'INVALID_ENVELOPE', 'occurred_at');
+  if (!RFC3339.test(envelope.occurred_at)) throw new ContractError('INVALID_ENVELOPE', 'occurred_at must be RFC3339');
+  assertString(envelope.project_id, 'INVALID_ENVELOPE', 'project_id');
+  assertString(envelope.correlation_id, 'INVALID_ENVELOPE', 'correlation_id');
+  if (envelope.causation_id !== undefined) assertString(envelope.causation_id, 'INVALID_ENVELOPE', 'causation_id');
+  assertObject(envelope.actor, 'INVALID_ENVELOPE', 'actor');
+  if (!ACTOR_TYPES.has(envelope.actor.type)) throw new ContractError('INVALID_ENVELOPE', 'actor.type is invalid');
+  assertString(envelope.actor.id, 'INVALID_ENVELOPE', 'actor.id');
+  assertObject(envelope.contract_ref, 'INVALID_ENVELOPE', 'contract_ref');
+  if (!CONTRACT_TYPES.has(envelope.contract_ref.type)) throw new ContractError('INVALID_ENVELOPE', 'contract_ref.type is invalid');
+  assertString(envelope.contract_ref.id, 'INVALID_ENVELOPE', 'contract_ref.id');
+  assertString(envelope.contract_ref.version, 'INVALID_ENVELOPE', 'contract_ref.version');
+  if (!CLASSIFICATIONS.has(envelope.classification)) throw new ContractError('INVALID_ENVELOPE', 'classification is invalid');
+  if (envelope.classification === 'client-restricted') assertString(envelope.tenant_ref, 'MISSING_TENANT_REF', 'tenant_ref');
+  assertObject(envelope.payload, 'INVALID_ENVELOPE', 'payload');
+  if (!Array.isArray(envelope.evidence_refs) || !envelope.evidence_refs.every((ref) => typeof ref === 'string' && ref)) {
+    throw new ContractError('INVALID_ENVELOPE', 'evidence_refs must be an array of non-empty strings');
+  }
+  return Object.freeze(canonicalize(envelope));
+}
+
+export function buildEvidenceEnvelope(input) {
+  const envelope = {
+    schema_version: 1,
+    evidence_refs: [],
+    ...input,
+  };
+  if (envelope.causation_id === undefined) delete envelope.causation_id;
+  return validateEvidenceEnvelope(envelope);
+}
+
+export function validateInvocationRequest(invocation) {
+  assertObject(invocation, 'INVALID_INVOCATION', 'invocation');
+  for (const field of ['invocation_id', 'attempt_id', 'action', 'provider_id', 'harness_id', 'tool_policy_ref', 'input_ref', 'expected_output_schema']) {
+    assertString(invocation[field], 'INVALID_INVOCATION', field);
+  }
+  assertObject(invocation.model_pin, 'INVALID_INVOCATION', 'model_pin');
+  assertString(invocation.model_pin.model_id, 'INVALID_INVOCATION', 'model_pin.model_id');
+  assertString(invocation.model_pin.catalog_snapshot_ref, 'INVALID_INVOCATION', 'model_pin.catalog_snapshot_ref');
+  if (invocation.model_pin.reasoning_configuration !== undefined && invocation.model_pin.reasoning_configuration !== null) {
+    assertString(invocation.model_pin.reasoning_configuration, 'INVALID_INVOCATION', 'model_pin.reasoning_configuration');
+  }
+  if (invocation.requested_tool_ids !== undefined && (!Array.isArray(invocation.requested_tool_ids) || !invocation.requested_tool_ids.every((id) => typeof id === 'string' && id))) {
+    throw new ContractError('INVALID_INVOCATION', 'requested_tool_ids must be an array of non-empty strings');
+  }
+  return Object.freeze(canonicalize(invocation));
+}

package/node_modules/@chati/knowledge-context/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@chati/knowledge-context",
+  "version": "0.1.0",
+  "private": true,
+  "description": "Scoped Company Brain reads and project-local learning candidate artifacts",
+  "type": "module",
+  "exports": "./src/index.js",
+  "dependencies": {
+    "@chati/core": "0.1.0"
+  },
+  "scripts": {
+    "test": "node --test test/**/*.test.js"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}