feat: close persona license and unified number routes

product-source/hololake-native-desktop/scripts/compile-unified-number-tree.mjs

@@ -0,0 +1,110 @@
+import { createHash } from 'node:crypto'
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..')
+const paths = {
+  identity: resolve(root, 'contracts/zero-core-numbering-kernel.json'),
+  webview: resolve(root, 'contracts/numbered-ipc-registry.json'),
+  broker: resolve(root, 'contracts/direct-local-broker-numbered-registry.json'),
+  output: resolve(root, 'generated/unified-number-coordinate-tree.json'),
+}
+
+function readSource(path) {
+  const bytes = readFileSync(path)
+  return {
+    value: JSON.parse(bytes.toString('utf8')),
+    sha256: createHash('sha256').update(bytes).digest('hex'),
+  }
+}
+
+export function compileUnifiedNumberTree() {
+  const identity = readSource(paths.identity)
+  const webview = readSource(paths.webview)
+  const broker = readSource(paths.broker)
+  const routes = [
+    ...webview.value.operations.map((route) => ({
+      transport: 'TAURI_WEBVIEW_NUMBERED_IPC',
+      protocolVersion: webview.value.runtime.protocol_version,
+      callerNumber: webview.value.runtime.caller_number,
+      channelNumber: route.channel_number,
+      moduleNumber: route.module_number,
+      operationNumber: route.operation_number,
+      targetNumber: route.target_number,
+      alias: route.alias,
+      admission: route.admission,
+      effect: route.effect,
+      evidence: 'HASH_CHAINED_NUMBERED_IPC_RECEIPT',
+      path: `HLP-NUMBER-WORLD-ROOT-001/TAURI/${route.channel_number}/${route.module_number}/${route.operation_number}/${route.target_number}`,
+    })),
+    ...broker.value.operations.map((route) => ({
+      transport: 'DIRECT_LOCAL_NUMBERED_BROKER',
+      protocolVersion: broker.value.runtime.protocol_version,
+      callerNumber: broker.value.runtime.caller_number,
+      channelNumber: route.channel_number,
+      moduleNumber: route.module_number,
+      operationNumber: route.operation_number,
+      targetNumber: route.target_number,
+      alias: route.alias,
+      admission: ['DISCOVER_NEARBY', 'PING', 'GET_BEIJING_TIME'].includes(route.alias)
+        ? 'PREAUTH_LOCAL_SYSTEM_ROUTE'
+        : ['OPEN_VISITOR_SESSION', 'RECEIVE_LANGUAGE'].includes(route.alias)
+          ? 'BOUNDED_VISITOR_ROUTE'
+          : 'AUTHENTICATED_LOCAL_SESSION_WITH_PERSONA_LICENSE_IF_PERSONA_MODE',
+      effect: ['DISCOVER_NEARBY', 'PING', 'GET_BEIJING_TIME', 'GET_PERSONA_CARRIER_LICENSE_STATUS', 'GET_WORK_ENVIRONMENT', 'RESOLVE_CAPABILITY_ROUTE', 'INSPECT_MOUNTED_PNCC_REPOSITORY', 'READ_MOUNTED_PNCC_REMOTE_OBJECT', 'QUERY_PNCC_RECEIPT_PROJECTION', 'INSPECT_DEVELOPMENT_WRITE_LANE'].includes(route.alias)
+        ? 'READ_OR_STATUS'
+        : 'STATE_CHANGE',
+      evidence: 'NUMBERED_RESPONSE_PLUS_SESSION_OR_DOMAIN_RECEIPT',
+      path: `HLP-NUMBER-WORLD-ROOT-001/BROKER/${route.channel_number}/${route.module_number}/${route.operation_number}/${route.target_number}`,
+    })),
+  ].sort((left, right) => left.path.localeCompare(right.path, 'en'))
+  const uniquePaths = new Set(routes.map((route) => route.path))
+  const uniqueOperations = new Set(routes.map((route) => `${route.transport}:${route.operationNumber}`))
+  if (routes.length !== uniquePaths.size || routes.length !== uniqueOperations.size) {
+    throw new Error('HOLOLAKE_UNIFIED_NUMBER_TREE_DUPLICATE_COORDINATE')
+  }
+  return {
+    schema: 'hololake.unified-number-coordinate-tree/v1',
+    recordId: 'HLP-UNIFIED-NUMBER-TREE-001',
+    state: 'MACHINE_COMPILED_STARTUP_ENFORCED',
+    rootNumber: 'HLP-NUMBER-WORLD-ROOT-001',
+    identityAuthority: {
+      mapId: identity.value.authority.map_id,
+      mapVersion: identity.value.authority.map_version,
+      namespaces: identity.value.namespaces.map((namespace) => ({
+        namespaceId: namespace.id,
+        roots: namespace.roots,
+        prefixes: namespace.prefixes,
+        subjectKind: namespace.subject_kind,
+        domainScope: namespace.domain_scope,
+      })),
+    },
+    sources: [
+      { recordId: identity.value.record_id, sha256: identity.sha256 },
+      { recordId: webview.value.record_id, sha256: webview.sha256 },
+      { recordId: broker.value.record_id, sha256: broker.sha256 },
+    ],
+    invariants: {
+      numberIsStableCoordinateNotAuthority: true,
+      pathIsUniqueNavigation: true,
+      admissionIsSeparateFromIdentity: true,
+      everyPhysicalCallHasNumberedRoute: true,
+      everyAcceptedCallHasEvidenceClass: true,
+      mismatchedCoordinate: 'FAIL_CLOSED',
+    },
+    routeCount: routes.length,
+    routes,
+  }
+}
+
+const compiled = compileUnifiedNumberTree()
+const output = `${JSON.stringify(compiled, null, 2)}\n`
+if (process.argv.includes('--check')) {
+  if (readFileSync(paths.output, 'utf8') !== output) {
+    throw new Error('HOLOLAKE_UNIFIED_NUMBER_TREE_STALE')
+  }
+} else {
+  mkdirSync(dirname(paths.output), { recursive: true })
+  writeFileSync(paths.output, output)
+}

product-source/hololake-native-desktop/scripts/direct-local-broker-numbered.test.mjs

@@ -0,0 +1,25 @@
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import test from 'node:test'
+
+const registry = JSON.parse(readFileSync(new URL('../contracts/direct-local-broker-numbered-registry.json', import.meta.url), 'utf8'))
+const broker = readFileSync(new URL('../src-tauri/src/direct_local_broker.rs', import.meta.url), 'utf8')
+
+test('the external local broker accepts only complete numbered coordinates', () => {
+  assert.equal(registry.record_id, 'HLP-NBROKER-ROOT-001')
+  assert.equal(registry.runtime.protocol_version, 'HLP-NBROKER-v1')
+  assert.equal(registry.runtime.legacy_string_operation_allowed, false)
+  assert.equal(registry.runtime.unknown_or_mismatched_coordinate, 'FAIL_CLOSED')
+  assert.equal(registry.runtime.transport_is_authority, false)
+  assert.equal(registry.operations.length, 22)
+  assert.equal(new Set(registry.operations.map((route) => route.operation_number)).size, 22)
+  assert.equal(new Set(registry.operations.map((route) => route.alias)).size, 22)
+  for (const route of registry.operations) {
+    assert.match(route.operation_number, /^HLP-NBROKER-OP-\d{4}$/)
+    assert.match(route.channel_number, /^HLP-NBROKER-CH-\d{4}$/)
+    assert.match(route.module_number, /^HLP-NBROKER-MOD-\d{4}$/)
+    assert.match(route.target_number, /^HLP-NBROKER-TGT-\d{4}$/)
+  }
+  assert.match(broker, /decode_numbered_broker_request/)
+  assert.match(broker, /HOLOLAKE_NUMBERED_BROKER_ROUTE_COORDINATE_MISMATCH/)
+})

product-source/hololake-native-desktop/scripts/persona-carrier-runtime-license.test.mjs

@@ -0,0 +1,34 @@
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import test from 'node:test'
+
+const contract = JSON.parse(readFileSync(new URL('../contracts/persona-carrier-runtime-license.json', import.meta.url), 'utf8'))
+const trust = JSON.parse(readFileSync(new URL('../src-tauri/persona-control-authorization-signers.json', import.meta.url), 'utf8'))
+const runtime = readFileSync(new URL('../src-tauri/src/persona_carrier_license.rs', import.meta.url), 'utf8')
+const broker = readFileSync(new URL('../src-tauri/src/direct_local_broker.rs', import.meta.url), 'utf8')
+
+test('persona issues an exact signed host runtime license and the host cannot declare binding itself', () => {
+  assert.equal(contract.direction, 'PERSONA_SUBJECT_TO_HOST_CARRIER')
+  assert.equal(contract.binding_completion.declaration_holder, 'PERSONA_SUBJECT_ONLY')
+  assert.equal(contract.binding_completion.host_may_self_issue_extend_or_declare, false)
+  assert.equal(contract.runtime.signature_algorithm, 'Ed25519')
+  assert.equal(contract.runtime.exact_session_binding, true)
+  assert.equal(contract.runtime.monotonic_sequence, true)
+  assert.equal(contract.runtime.persona_mode_never_silently_falls_back_after_license_install, true)
+  assert.match(runtime, /PERSONA_DECLARES_CURRENT_CARRIER_BOUND/)
+  assert.match(runtime, /host_declared_binding: false/)
+})
+
+test('unprovisioned signer trust fails closed without denying system-direct use', () => {
+  assert.equal(contract.truth.runtime_verifier_implemented, true)
+  assert.equal(contract.truth.trusted_persona_signer_provisioned, false)
+  assert.deepEqual(trust.signers, [])
+  assert.equal(contract.runtime.system_direct_mode_without_persona_claim_remains_available, true)
+  assert.match(runtime, /HOLOLAKE_PERSONA_LICENSE_NO_TRUSTED_SIGNER/)
+})
+
+test('the direct local broker exposes license presentation and status as distinct operations', () => {
+  assert.match(broker, /PresentPersonaCarrierLicense/)
+  assert.match(broker, /GetPersonaCarrierLicenseStatus/)
+  assert.match(broker, /persona_license/)
+})

product-source/hololake-native-desktop/scripts/persona-metacognitive-zero-layer.test.mjs

@@ -85,7 +85,9 @@ test('current product keeps persona wake closed instead of claiming an unimpleme
   assert.equal(contract.current_product_state.persona_runtime_present, false)
   assert.equal(contract.current_product_state.persona_wake_route_registered, false)
   assert.equal(contract.current_product_state.carrier_binding_claimed, false)
-  assert.equal(contract.current_product_state.runtime_binding_gate_implemented, false)
+  assert.equal(contract.current_product_state.runtime_binding_gate_implemented, true)
+  assert.equal(contract.current_product_state.trusted_persona_runtime_signer_provisioned, false)
+  assert.equal(contract.current_product_state.active_persona_runtime_license_installed, false)
   assert.equal(contract.numbered_ipc_boundary.ipc_may_create_persona_binding, false)
   assert.equal(registry.runtime.persona_binding_claimed, false)
   assert.doesNotMatch(registry.operations.map((operation) => operation.alias).join('\n'), /persona_wake/)

product-source/hololake-native-desktop/scripts/programming-ai-terminal-link.test.mjs

@@ -9,7 +9,9 @@ const lib = readFileSync(new URL('../src-tauri/src/lib.rs', import.meta.url), 'u
 const numberedDispatcher = readFileSync(new URL('../src-tauri/src/numbered_ipc_dispatch.rs', import.meta.url), 'utf8')
 
 test('terminal link has native local transports for macOS Linux and Windows', () => {
-  assert.equal(contract.protocol, 'HOLOLAKE_TERMINAL_LINK/2')
+  assert.equal(contract.protocol, 'HOLOLAKE_TERMINAL_LINK/3')
+  assert.equal(contract.numbered_envelope.registry, 'HLP-NBROKER-ROOT-001')
+  assert.equal(contract.numbered_envelope.legacy_string_operation_allowed, false)
   assert.equal(contract.platform_transports.macos, 'USER_PRIVATE_UNIX_SOCKET')
   assert.equal(contract.platform_transports.linux, 'USER_PRIVATE_UNIX_SOCKET')
   assert.equal(contract.platform_transports.windows, 'USER_PRIVATE_NAMED_PIPE')

product-source/hololake-native-desktop/scripts/unified-number-coordinate-tree.test.mjs

@@ -0,0 +1,15 @@
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import test from 'node:test'
+import { compileUnifiedNumberTree } from './compile-unified-number-tree.mjs'
+
+test('identity, webview and direct broker numbers compile into one unique evidence tree', () => {
+  const generated = JSON.parse(readFileSync(new URL('../generated/unified-number-coordinate-tree.json', import.meta.url), 'utf8'))
+  assert.deepEqual(generated, compileUnifiedNumberTree())
+  assert.equal(generated.recordId, 'HLP-UNIFIED-NUMBER-TREE-001')
+  assert.equal(generated.routeCount, 84)
+  assert.equal(new Set(generated.routes.map((route) => route.path)).size, 84)
+  assert.equal(generated.invariants.everyPhysicalCallHasNumberedRoute, true)
+  assert.equal(generated.invariants.everyAcceptedCallHasEvidenceClass, true)
+  assert.ok(generated.routes.every((route) => route.admission && route.evidence))
+})