@kognai/orchestrator-core 0.2.2 → 0.2.4

package/dist/lib/sovereign-agent-factory.d.ts

@@ -136,6 +136,27 @@ export declare function spawnCitizen(req: SpawnRequest, opts?: {
     decision: SpawnDecision;
     citizen?: CitizenRecord;
 };
+/**
+ * TICKET-334e — backfill an initial ACP for every citizen in the registry that
+ * has no entry in acp/trust-scores.json yet. These are pre-SAF citizens that were
+ * born scoreless (minted via bare mintCitizen before the canonical issuer seeded
+ * ACP at birth — see TICKET-334b). The router PASS-THROUGHs unscored agents, so
+ * this gives them a real routing profile instead of an implicit bypass.
+ *
+ * Classification reuses the SAF path (classifyRequest → initialAcp) keyed on the
+ * citizen's owner lineage + agent_name, so a backfilled score is identical to the
+ * one the same agent would receive if spawned today. Idempotent: writeInitialAcp
+ * skips any agent_name that already has a score, so re-running only fills gaps.
+ */
+export declare function backfillAcpForRegistry(): {
+    scanned: number;
+    seeded: {
+        agent_name: string;
+        classification: SpawnClass;
+        score: number;
+    }[];
+    skipped: number;
+};
 /**
  * Emergency bypass — Founder only. Overrides all gates including health and
  * constitutional conditional findings. Logs prominently to KSL.

package/dist/lib/sovereign-agent-factory.js

@@ -24,6 +24,7 @@ exports.issueSpawnDecision = issueSpawnDecision;
 exports.sovereignSpawn = sovereignSpawn;
 exports.deriveOwner = deriveOwner;
 exports.spawnCitizen = spawnCitizen;
+exports.backfillAcpForRegistry = backfillAcpForRegistry;
 exports.founderEmergencySpawn = founderEmergencySpawn;
 exports.getSpawnRegistry = getSpawnRegistry;
 exports.batchSpawn = batchSpawn;
@@ -353,6 +354,68 @@ function spawnCitizen(req, opts = {}) {
     writeInitialAcp(citizen.agent_name, decision.initial_acp_score);
     return { decision, citizen };
 }
+/**
+ * TICKET-334e — derive the constitutional requester DID for an EXISTING citizen
+ * from its owner lineage, so classifyRequest() sorts it the same way a fresh
+ * spawn from that owner would (external → EXTERNAL sub-floor; everything else by
+ * role). Mirrors the DID shapes deriveOwner() reads.
+ */
+function requesterDidForCitizen(c) {
+    const id = c.owner_id || c.company || 'kognai';
+    switch (c.owner_kind) {
+        case 'external': return `did:external:${id}:${c.agent_name}`;
+        case 'user': return `did:kognai:citizen:${id}`;
+        case 'scs': return `did:kognai:scs:${id}:${c.agent_name}`;
+        default: return `did:kognai:${id}`; // company / legacy
+    }
+}
+/** Read the agent_name keys already present in acp/trust-scores.json. */
+function readAcpScoreKeys() {
+    try {
+        const { readFileSync } = require('fs');
+        const { join } = require('path');
+        const acpPath = join((0, engine_paths_1.resolveEnginePaths)().root, 'acp', 'trust-scores.json');
+        const data = JSON.parse(readFileSync(acpPath, 'utf-8'));
+        return new Set(Object.keys(data?.scores ?? {}));
+    }
+    catch {
+        return new Set();
+    }
+}
+/**
+ * TICKET-334e — backfill an initial ACP for every citizen in the registry that
+ * has no entry in acp/trust-scores.json yet. These are pre-SAF citizens that were
+ * born scoreless (minted via bare mintCitizen before the canonical issuer seeded
+ * ACP at birth — see TICKET-334b). The router PASS-THROUGHs unscored agents, so
+ * this gives them a real routing profile instead of an implicit bypass.
+ *
+ * Classification reuses the SAF path (classifyRequest → initialAcp) keyed on the
+ * citizen's owner lineage + agent_name, so a backfilled score is identical to the
+ * one the same agent would receive if spawned today. Idempotent: writeInitialAcp
+ * skips any agent_name that already has a score, so re-running only fills gaps.
+ */
+function backfillAcpForRegistry() {
+    const reg = (0, citizenship_1.readRegistry)();
+    const alreadyScored = readAcpScoreKeys();
+    const seeded = [];
+    let skipped = 0;
+    for (const c of reg.citizens) {
+        if (!c.agent_name || alreadyScored.has(c.agent_name)) {
+            skipped++;
+            continue;
+        }
+        const classification = classifyRequest({
+            requester_did: requesterDidForCitizen(c),
+            requested_role: c.agent_name,
+            requested_capabilities: [],
+            purpose: `TICKET-334e ACP backfill for pre-SAF citizen ${c.agent_name}`,
+        });
+        const score = initialAcp(classification);
+        writeInitialAcp(c.agent_name, score);
+        seeded.push({ agent_name: c.agent_name, classification, score });
+    }
+    return { scanned: reg.citizens.length, seeded, skipped };
+}
 /**
  * Emergency bypass — Founder only. Overrides all gates including health and
  * constitutional conditional findings. Logs prominently to KSL.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kognai/orchestrator-core",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Kognai sovereign orchestrator — core engine (template-agnostic). Shared by all products (Kognai/coding, Voxight/market-intel, Invoica/fin-compliance); each supplies only its template. Replaces per-repo forks of orchestrate-agents-v2 / sprint-runner / lib.",
   "license": "MIT",
   "author": "SkinGem",