@holoscript/core 8.0.14 → 8.0.16

package/dist/{chunk-SE2Y5BSL.cjs → chunk-CMEINO5I.cjs}

@@ -7,7 +7,6 @@ var chunkZHPMP447_cjs = require('./chunk-ZHPMP447.cjs');
 var crypto3 = require('crypto');
 var util = require('util');
 var zod = require('zod');
-var jwt = require('jsonwebtoken');
 var path = require('path');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -31,7 +30,6 @@ function _interopNamespace(e) {
 }
 
 var crypto3__namespace = /*#__PURE__*/_interopNamespace(crypto3);
-var jwt__default = /*#__PURE__*/_interopDefault(jwt);
 var path__default = /*#__PURE__*/_interopDefault(path);
 
 function calculateJwkThumbprint(publicKeyPem) {
@@ -1262,16 +1260,42 @@ var init_CapabilityTokenIssuer = chunkZHPMP447_cjs.__esm({
     globalCapabilityIssuer = null;
   }
 });
+function sha256Hex(value) {
+  return crypto3__namespace.createHash("sha256").update(value, "utf8").digest("hex");
+}
+function decodeJsonSegment(segment) {
+  try {
+    const parsed = JSON.parse(Buffer.from(segment, "base64url").toString("utf8"));
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function asRecord(value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return void 0;
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function isIntentTokenPayload(value) {
+  const record = asRecord(value);
+  if (!record) return false;
+  const intent = asRecord(record.intent);
+  return typeof record.iss === "string" && typeof record.sub === "string" && typeof record.aud === "string" && typeof record.exp === "number" && typeof record.agent_role === "string" && asRecord(record.agent_checksum) !== void 0 && Array.isArray(record.permissions) && intent !== void 0 && typeof intent.workflow_id === "string" && typeof intent.workflow_step === "string";
+}
 function getTokenIssuer(config) {
   if (!globalIssuer) {
-    globalIssuer = new AgentTokenIssuer({
-      ...config,
-      jwtSecret: process.env.AGENT_JWT_SECRET
-    });
+    globalIssuer = new AgentTokenIssuer(config);
   }
   return globalIssuer;
 }
-var DEFAULT_ISSUER, DEFAULT_JWT_SECRET, DEFAULT_TOKEN_EXPIRATION, AgentTokenIssuer, globalIssuer;
+var DEFAULT_ISSUER, DEFAULT_TOKEN_EXPIRATION, LEGACY_AUDIENCE, intentPresentationCache, AgentTokenIssuer, globalIssuer;
 var init_AgentTokenIssuer = chunkZHPMP447_cjs.__esm({
   "src/compiler/identity/AgentTokenIssuer.ts"() {
     init_AgentIdentity();
@@ -1279,31 +1303,25 @@ var init_AgentTokenIssuer = chunkZHPMP447_cjs.__esm({
     init_CapabilityToken();
     init_CapabilityTokenIssuer();
     DEFAULT_ISSUER = "holoscript-orchestrator";
-    DEFAULT_JWT_SECRET = process.env.AGENT_JWT_SECRET || "dev-secret-change-in-production";
     DEFAULT_TOKEN_EXPIRATION = "24h";
+    LEGACY_AUDIENCE = "holoscript-compiler";
+    intentPresentationCache = /* @__PURE__ */ new Map();
     AgentTokenIssuer = class {
       constructor(config = {}) {
         /** Active workflow state (for validation) */
         this.workflowState = /* @__PURE__ */ new Map();
         this.issuer = config.issuer || DEFAULT_ISSUER;
-        this.jwtSecret = config.jwtSecret || DEFAULT_JWT_SECRET;
         this.tokenExpiration = config.tokenExpiration || DEFAULT_TOKEN_EXPIRATION;
         this.strictWorkflowValidation = config.strictWorkflowValidation ?? true;
-        if (this.jwtSecret === DEFAULT_JWT_SECRET && process.env.NODE_ENV === "production") {
-          console.error(
-            "[TOKEN_ISSUER] Using default JWT secret in production! Set AGENT_JWT_SECRET environment variable."
-          );
-        }
       }
       /**
-       * Issue intent token for agent
+       * Issue an intent token for an agent.
        *
-       * Creates a signed JWT with:
-       * - Standard claims (iss, sub, aud, exp, iat, jti)
-       * - Agent identity (role, checksum)
-       * - Permissions (RBAC)
-       * - Intent metadata (workflow context)
-       * - PoP binding (JWK thumbprint)
+       * SOVEREIGN PATH: the token on the wire is an EdDSA UCAN capability token
+       * signed with the request's Ed25519 key pair via `CapabilityTokenIssuer`.
+       * The full legacy `IntentTokenPayload` view (standard claims, agent
+       * identity/checksum, permissions, intent metadata, PoP binding) travels in
+       * the token facts and is reconstructed verbatim by `verifyToken`.
        */
       async issueToken(request) {
         const {
@@ -1327,12 +1345,13 @@ var init_AgentTokenIssuer = chunkZHPMP447_cjs.__esm({
         const permissions = getDefaultPermissions(agentConfig.role);
         const updatedDelegationChain = [...delegationChain, agentConfig.role];
         const now = Math.floor(Date.now() / 1e3);
+        const lifetimeSec = typeof this.tokenExpiration === "string" ? this.parseExpiration(this.tokenExpiration) : this.tokenExpiration;
         const payload = {
-          // Standard JWT claims
+          // Standard claims
           iss: this.issuer,
           sub: `agent:${agentConfig.role}:${agentConfig.name}`,
-          aud: "holoscript-compiler",
-          exp: typeof this.tokenExpiration === "string" ? now + this.parseExpiration(this.tokenExpiration) : now + this.tokenExpiration,
+          aud: LEGACY_AUDIENCE,
+          exp: now + lifetimeSec,
           iat: now,
           jti: crypto3__namespace.randomUUID(),
           // Agent-specific claims
@@ -1356,70 +1375,131 @@ var init_AgentTokenIssuer = chunkZHPMP447_cjs.__esm({
           // Ed25519 public key for HTTP Message Signature verification
           publicKey: keyPair.publicKey
         };
-        const token = jwt__default.default.sign(payload, this.jwtSecret, {
-          algorithm: "HS256"
-        });
+        const resource = agentConfig.scope ? `${HOLOSCRIPT_RESOURCE_SCHEME}${agentConfig.scope}` : HOLOSCRIPT_RESOURCE_ALL;
+        const capabilities = permissions.map((perm) => ({
+          with: resource,
+          can: PERMISSION_TO_ACTION[perm] || perm
+        }));
+        const capToken = await this.getCapabilityTokenIssuer().issueRoot(
+          {
+            issuer: payload.sub,
+            audience: LEGACY_AUDIENCE,
+            capabilities,
+            lifetimeSec,
+            facts: {
+              intent_payload: payload,
+              publicKey: keyPair.publicKey
+            }
+          },
+          keyPair
+        );
         this.workflowState.set(workflowId, workflowStep);
         const keystore = getKeystore();
         await keystore.storeCredential({
           role: agentConfig.role,
-          token,
+          token: capToken.raw,
           keyPair,
           createdAt: new Date(now * 1e3),
-          expiresAt: new Date(payload.exp * 1e3)
+          expiresAt: new Date(capToken.payload.exp * 1e3)
         });
-        return token;
+        return capToken.raw;
       }
       /**
-       * Verify agent token
+       * Verify an agent token — FAIL CLOSED.
        *
        * Validates:
-       * - Signature authenticity
-       * - Token expiration
-       * - Claims structure
+       * - EdDSA capability-token structure (legacy HS256 jsonwebtoken envelopes
+       *   are rejected with `LEGACY_JWT_REJECTED`, never verified)
+       * - Ed25519 signature against the embedded verification key
+       * - Expiration
+       * - Issuer / audience claims
+       * - Required legacy claims structure
        * - Workflow step sequence (if strict mode)
+       *
+       * Never throws — every failure mode maps to a rejected result.
        */
       verifyToken(token) {
         try {
-          const decoded = jwt__default.default.verify(token, this.jwtSecret, {
-            issuer: this.issuer,
-            audience: "holoscript-compiler"
-          });
-          if (!decoded.agent_role || !decoded.agent_checksum || !decoded.intent) {
+          if (typeof token !== "string" || token.length === 0) {
             return {
               valid: false,
-              error: "Missing required claims",
-              errorCode: "INVALID_CLAIMS"
+              error: "Invalid signature or malformed token",
+              errorCode: "INVALID_SIGNATURE"
             };
           }
-          if (this.strictWorkflowValidation) {
-            const currentStep = this.workflowState.get(decoded.intent.workflow_id);
-            if (currentStep && currentStep !== decoded.intent.workflow_step) {
-              return {
-                valid: false,
-                error: `Workflow step mismatch: expected ${currentStep}, got ${decoded.intent.workflow_step}`,
-                errorCode: "WORKFLOW_VIOLATION"
-              };
+          const tokenSha256 = sha256Hex(token);
+          const cached = intentPresentationCache.get(tokenSha256);
+          if (cached) {
+            const now = Math.floor(Date.now() / 1e3);
+            if (cached.exp <= now) {
+              intentPresentationCache.delete(tokenSha256);
+              return { valid: false, error: "Token expired", errorCode: "EXPIRED" };
             }
+            return this.checkClaimsAndWorkflow(structuredClone(cached));
           }
-          return {
-            valid: true,
-            payload: decoded
-          };
-        } catch (error) {
-          if (error instanceof Error && error.name === "TokenExpiredError") {
+          const parts = token.split(".");
+          if (parts.length !== 3 || parts.some((part) => part.length === 0)) {
             return {
               valid: false,
-              error: "Token expired",
-              errorCode: "EXPIRED"
+              error: "Invalid signature or malformed token",
+              errorCode: "INVALID_SIGNATURE"
             };
-          } else if (error instanceof Error && error.name === "JsonWebTokenError") {
+          }
+          const header = decodeJsonSegment(parts[0]);
+          if (!header || typeof header.alg !== "string") {
             return {
               valid: false,
-              error: "Invalid signature or malformed token",
+              error: "Malformed token: header segment is not decodable JSON with an alg claim.",
+              errorCode: "INVALID_SIGNATURE"
+            };
+          }
+          if (header.alg !== "EdDSA") {
+            return {
+              valid: false,
+              error: `Legacy ${header.alg} jsonwebtoken envelope is no longer accepted. Reissue a sovereign capability token via issueToken.`,
+              errorCode: "LEGACY_JWT_REJECTED"
+            };
+          }
+          const rawPayload = decodeJsonSegment(parts[1]);
+          if (!rawPayload) {
+            return {
+              valid: false,
+              error: "Malformed token: payload segment is not decodable JSON.",
+              errorCode: "INVALID_SIGNATURE"
+            };
+          }
+          const facts = asRecord(rawPayload.fct);
+          const verificationKey = asString(facts?.publicKey);
+          if (!verificationKey) {
+            return {
+              valid: false,
+              error: "Capability token does not embed its Ed25519 verification key (fct.publicKey). Fail closed.",
+              errorCode: "INVALID_CLAIMS"
+            };
+          }
+          const verification = this.getCapabilityTokenIssuer().verify(token, verificationKey);
+          if (!verification.valid || !verification.payload) {
+            if (verification.errorCode === "EXPIRED") {
+              return { valid: false, error: "Token expired", errorCode: "EXPIRED" };
+            }
+            return {
+              valid: false,
+              error: verification.error ?? "Invalid signature or malformed token",
               errorCode: "INVALID_SIGNATURE"
             };
           }
+          const verifiedFacts = asRecord(verification.payload.fct);
+          const intentPayload = verifiedFacts?.intent_payload;
+          if (!isIntentTokenPayload(intentPayload)) {
+            return {
+              valid: false,
+              error: "Missing required claims",
+              errorCode: "INVALID_CLAIMS"
+            };
+          }
+          intentPresentationCache.set(tokenSha256, intentPayload);
+          return this.checkClaimsAndWorkflow(structuredClone(intentPayload));
+        } catch (error) {
           return {
             valid: false,
             error: error instanceof Error ? error.message : String(error),
@@ -1427,6 +1507,37 @@ var init_AgentTokenIssuer = chunkZHPMP447_cjs.__esm({
           };
         }
       }
+      /**
+       * Issuer/audience claim checks + strict workflow sequencing — run on both
+       * the fresh-verification and presentation-cache paths.
+       */
+      checkClaimsAndWorkflow(payload) {
+        if (payload.iss !== this.issuer || payload.aud !== LEGACY_AUDIENCE) {
+          return {
+            valid: false,
+            error: `Token issuer/audience mismatch: expected ${this.issuer}/${LEGACY_AUDIENCE}`,
+            errorCode: "INVALID_CLAIMS"
+          };
+        }
+        if (!payload.agent_role || !payload.agent_checksum || !payload.intent) {
+          return {
+            valid: false,
+            error: "Missing required claims",
+            errorCode: "INVALID_CLAIMS"
+          };
+        }
+        if (this.strictWorkflowValidation) {
+          const currentStep = this.workflowState.get(payload.intent.workflow_id);
+          if (currentStep && currentStep !== payload.intent.workflow_step) {
+            return {
+              valid: false,
+              error: `Workflow step mismatch: expected ${currentStep}, got ${payload.intent.workflow_step}`,
+              errorCode: "WORKFLOW_VIOLATION"
+            };
+          }
+        }
+        return { valid: true, payload };
+      }
       /**
        * Extract token from Authorization header
        */
@@ -1467,8 +1578,8 @@ var init_AgentTokenIssuer = chunkZHPMP447_cjs.__esm({
        *
        * Maps the agent's role to capabilities using the PERMISSION_TO_ACTION bridge
        * constants defined in CapabilityToken.ts. This enables agents that currently
-       * use JWT tokens to obtain equivalent UCAN capability tokens for the gradual
-       * migration to capability-based authorization.
+       * use legacy tokens to obtain equivalent UCAN capability tokens for the
+       * gradual migration to capability-based authorization.
        *
        * @param options  Capability token issuance options
        * @returns        Signed UCAN CapabilityToken
@@ -1499,21 +1610,22 @@ var init_AgentTokenIssuer = chunkZHPMP447_cjs.__esm({
         );
       }
       /**
-       * Issue both a JWT token and a UCAN capability token for the same agent
-       * and intent context.
+       * Issue both a legacy-view token and a UCAN capability token for the same
+       * agent and intent context.
        *
-       * This method enables gradual migration from JWT-only authorization to
-       * UCAN capability-based authorization. Consuming services can validate
-       * either token during the transition period.
+       * This method enables gradual migration from `IntentTokenPayload`-view
+       * authorization to UCAN capability-based authorization. Consuming services
+       * can validate either token during the transition period. Both members are
+       * EdDSA-signed on the sovereign path.
        *
-       * @param request          Standard JWT token request parameters
+       * @param request          Standard token request parameters
        * @param capabilityOptions  Additional options for the capability token
        *                           (audience defaults to 'holoscript-compiler')
        * @returns                 HybridTokenResult with both tokens
        */
       async issueHybridToken(request, capabilityOptions) {
         const jwtToken = await this.issueToken(request);
-        const audience = capabilityOptions?.audience ?? "holoscript-compiler";
+        const audience = capabilityOptions?.audience ?? LEGACY_AUDIENCE;
         const capabilityToken = await this.issueCapabilityToken({
           agentConfig: request.agentConfig,
           audience,
@@ -3978,6 +4090,7 @@ var init_ANSNamespace = chunkZHPMP447_cjs.__esm({
       AGENT_INFERENCE: "/compile/ai/agent-inference",
       OMNIGENT_AGENT_YAML: "/compile/ai/omnigent-agent-yaml",
       DAIMON_SEED: "/compile/ai/daimon-seed",
+      HSI_IR: "/compile/ai/hsi-ir",
       MCP_CONFIG: "/compile/ai/mcp-config",
       MCP_SERVER: "/compile/ai/mcp-server",
       // ── neuromorphic ─────────────────────────────────────────────────────
@@ -4042,6 +4155,7 @@ var init_ANSNamespace = chunkZHPMP447_cjs.__esm({
       "agent-inference": ANSDomain.AI,
       "omnigent-agent-yaml": ANSDomain.AI,
       "daimon-seed": ANSDomain.AI,
+      "hsi-ir": ANSDomain.AI,
       "mcp-config": ANSDomain.AI,
       "mcp-server": ANSDomain.AI,
       // neuromorphic
@@ -4097,6 +4211,7 @@ var init_ANSNamespace = chunkZHPMP447_cjs.__esm({
       "agent-inference": exports.ANSCapabilityPath.AGENT_INFERENCE,
       "omnigent-agent-yaml": exports.ANSCapabilityPath.OMNIGENT_AGENT_YAML,
       "daimon-seed": exports.ANSCapabilityPath.DAIMON_SEED,
+      "hsi-ir": exports.ANSCapabilityPath.HSI_IR,
       "mcp-config": exports.ANSCapabilityPath.MCP_CONFIG,
       "mcp-server": exports.ANSCapabilityPath.MCP_SERVER,
       nir: exports.ANSCapabilityPath.NIR,
@@ -5555,6 +5670,7 @@ var init_CompilerBase = chunkZHPMP447_cjs.__esm({
       AgentInferenceCompiler: "agent-inference",
       OmnigentAgentYamlCompiler: "omnigent-agent-yaml",
       DaimonSeedCompiler: "daimon-seed",
+      HSIIRCompiler: "hsi-ir",
       CodeEditorCompiler: "code-editor",
       SVGCompiler: "svg"
     };
@@ -6067,5 +6183,5 @@ exports.isCapabilityTokenCredential = isCapabilityTokenCredential;
 exports.normalizeNormProvenance = normalizeNormProvenance;
 exports.normsByCategory = normsByCategory;
 exports.serializeNormProvenance = serializeNormProvenance;
-//# sourceMappingURL=chunk-SE2Y5BSL.cjs.map
-//# sourceMappingURL=chunk-SE2Y5BSL.cjs.map
+//# sourceMappingURL=chunk-CMEINO5I.cjs.map
+//# sourceMappingURL=chunk-CMEINO5I.cjs.map

package/dist/{chunk-YMI3ED3B.cjs → chunk-CRUIGXF7.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkSE2Y5BSL_cjs = require('./chunk-SE2Y5BSL.cjs');
+var chunkCMEINO5I_cjs = require('./chunk-CMEINO5I.cjs');
 var chunkZHPMP447_cjs = require('./chunk-ZHPMP447.cjs');
 var ans = require('@holoscript/core-types/ans');
 
@@ -24,7 +24,7 @@ function createPythonAgentInferenceCompiler(options) {
 var DEFAULT_MODEL_CONFIG, ANTHROPIC_MODELS_NO_SAMPLING_PARAMS, AGENT_TRAIT_NAMES; exports.AgentInferenceCompiler = void 0; exports.AgentInferenceExportTarget_default = void 0;
 var init_AgentInferenceExportTarget = chunkZHPMP447_cjs.__esm({
   "src/compiler/AgentInferenceExportTarget.ts"() {
-    chunkSE2Y5BSL_cjs.init_CompilerBase();
+    chunkCMEINO5I_cjs.init_CompilerBase();
     DEFAULT_MODEL_CONFIG = {
       provider: "anthropic",
       // Default to Opus 4.7 — most capable Claude. Users override per-agent via
@@ -54,7 +54,7 @@ var init_AgentInferenceExportTarget = chunkZHPMP447_cjs.__esm({
       "memory",
       "persona"
     ]);
-    exports.AgentInferenceCompiler = class extends chunkSE2Y5BSL_cjs.CompilerBase {
+    exports.AgentInferenceCompiler = class extends chunkCMEINO5I_cjs.CompilerBase {
       constructor(options = {}) {
         super();
         this.compilerName = "AgentInferenceCompiler";
@@ -1009,5 +1009,5 @@ exports.AgentInferenceExportTarget_exports = AgentInferenceExportTarget_exports;
 exports.createAgentInferenceCompiler = createAgentInferenceCompiler;
 exports.createPythonAgentInferenceCompiler = createPythonAgentInferenceCompiler;
 exports.init_AgentInferenceExportTarget = init_AgentInferenceExportTarget;
-//# sourceMappingURL=chunk-YMI3ED3B.cjs.map
-//# sourceMappingURL=chunk-YMI3ED3B.cjs.map
+//# sourceMappingURL=chunk-CRUIGXF7.cjs.map
+//# sourceMappingURL=chunk-CRUIGXF7.cjs.map