chainlesschain 0.166.37 → 0.166.39

package/src/commands/evolution-attestor-trust.js

@@ -0,0 +1,113 @@
+import { isGovernedSkillSynthesisAttestorTrustOperationsCliHost } from "../lib/evolution/governed-skill-synthesis-attestor-trust-operations-cli-host.js";
+
+function host(value) {
+  if (!isGovernedSkillSynthesisAttestorTrustOperationsCliHost(value)) {
+    throw new Error(
+      "Attestor trust operations are unavailable: a trusted deployment host is required",
+    );
+  }
+  return value;
+}
+
+function output(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+
+export function registerEvolutionAttestorTrustCommands(
+  evolution,
+  { attestorTrustOperationsHost = null } = {},
+) {
+  const trust = evolution
+    .command("attestor-trust")
+    .description("Operate the governed Skill attestor trust control plane");
+
+  trust
+    .command("prepare <operation-file>")
+    .description("Create an immutable request plan for external approval")
+    .requiredOption(
+      "--out <request-file>",
+      "Exclusively create the request plan",
+    )
+    .action(async (operationPath, options) => {
+      output(
+        await host(attestorTrustOperationsHost).prepare({
+          operationPath,
+          outputPath: options.out,
+        }),
+      );
+    });
+
+  trust
+    .command("execute <request-file> <approval-files...>")
+    .description("Execute a request using externally signed approval files")
+    .action(async (requestPath, approvalPaths) => {
+      output(
+        await host(attestorTrustOperationsHost).execute({
+          requestPath,
+          approvalPaths,
+        }),
+      );
+    });
+
+  trust
+    .command("approve <request-file>")
+    .description("Sign an attestor trust request with the isolated signer")
+    .requiredOption(
+      "--out <approval-file>",
+      "Exclusively create the approval receipt",
+    )
+    .action(async (requestPath, options) => {
+      output(
+        await host(attestorTrustOperationsHost).approve({
+          requestPath,
+          outputPath: options.out,
+        }),
+      );
+    });
+
+  trust
+    .command("operator-prepare <operation-file>")
+    .description(
+      "Create a registry change request for current-operator approval",
+    )
+    .requiredOption(
+      "--out <request-file>",
+      "Exclusively create the operator change request",
+    )
+    .action(async (operationPath, options) => {
+      output(
+        await host(attestorTrustOperationsHost).prepareOperatorChange({
+          operationPath,
+          outputPath: options.out,
+        }),
+      );
+    });
+
+  trust
+    .command("operator-execute <request-file> <approval-files...>")
+    .description("Commit a quorum-approved operator registry change")
+    .action(async (requestPath, approvalPaths) => {
+      output(
+        await host(attestorTrustOperationsHost).executeOperatorChange({
+          requestPath,
+          approvalPaths,
+        }),
+      );
+    });
+
+  trust
+    .command("operator-approve <request-file>")
+    .description("Sign an operator change with the isolated signer")
+    .requiredOption(
+      "--out <approval-file>",
+      "Exclusively create the operator approval receipt",
+    )
+    .action(async (requestPath, options) => {
+      output(
+        await host(attestorTrustOperationsHost).approveOperatorChange({
+          requestPath,
+          outputPath: options.out,
+        }),
+      );
+    });
+}

package/src/commands/evolution.js

@@ -11,6 +11,7 @@ import { logger } from "../lib/logger.js";
 import { parseJsonOption } from "../lib/parse-json-option.js";
 import { bootstrap, shutdown } from "../runtime/bootstrap.js";
 import { registerEvolutionWorkbenchCommands } from "./evolution-workbench.js";
+import { registerEvolutionAttestorTrustCommands } from "./evolution-attestor-trust.js";
 import { registerGovernedKnowledgeCommands } from "./evolution-knowledge.js";
 import { registerWikiSkillBenchmarkCommands } from "./evolution-benchmark.js";
 import {
@@ -52,6 +53,7 @@ export function registerEvolutionCommand(program, dependencies = {}) {
     );
 
   registerEvolutionWorkbenchCommands(evolution, dependencies);
+  registerEvolutionAttestorTrustCommands(evolution, dependencies);
   registerGovernedKnowledgeCommands(evolution, dependencies);
   registerWikiSkillBenchmarkCommands(evolution, dependencies);
 

package/src/commands/learning.js

@@ -7,6 +7,7 @@ import chalk from "chalk";
 import ora from "ora";
 import { logger } from "../lib/logger.js";
 import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import { isGovernedSkillSynthesisCliHost } from "../lib/evolution/governed-skill-synthesis-cli-host.js";
 
 export function classifySynthesisResult(result) {
   if (result?.status === "unavailable") {
@@ -58,7 +59,34 @@ export function classifySynthesisResult(result) {
   };
 }
 
-export function registerLearningCommand(program) {
+export async function executeLearningSynthesis({
+  db,
+  trajectoryStore,
+  learningSynthesisHost = null,
+} = {}) {
+  if (learningSynthesisHost === null) {
+    return {
+      status: "unavailable",
+      code: "LEARNING_SYNTHESIS_UNAVAILABLE",
+      reason: "Synthesis unavailable: a trusted deployment host is required",
+      missingDependencies: ["trusted-deployment-host"],
+      blockers: [],
+      created: [],
+      skipped: [],
+    };
+  }
+  if (!isGovernedSkillSynthesisCliHost(learningSynthesisHost)) {
+    throw new Error(
+      "Learning synthesis is unavailable: a trusted deployment host is required",
+    );
+  }
+  return learningSynthesisHost.synthesize({ db, trajectoryStore });
+}
+
+export function registerLearningCommand(
+  program,
+  { learningSynthesisHost = null } = {},
+) {
   const learning = program
     .command("learning")
     .description(
@@ -330,13 +358,14 @@ export function registerLearningCommand(program) {
         const db = ctx.db.getDatabase();
         const { TrajectoryStore } =
           await import("../lib/learning/trajectory-store.js");
-        const { SkillSynthesizer } =
-          await import("../lib/learning/skill-synthesizer.js");
         const store = new TrajectoryStore(db);
-        const synthesizer = new SkillSynthesizer(db, null, store);
 
         const spinner = ora("Scanning for synthesizable patterns...").start();
-        const result = await synthesizer.synthesize();
+        const result = await executeLearningSynthesis({
+          db,
+          trajectoryStore: store,
+          learningSynthesisHost,
+        });
         const outcome = classifySynthesisResult(result);
 
         if (outcome.exitCode !== 0) {

package/src/data/changelog.json

@@ -1,6 +1,32 @@
 {
   "source": "CHANGELOG.md",
   "releases": [
+    {
+      "productVersion": null,
+      "cliVersion": "0.166.39",
+      "cliVersions": ["0.166.39"],
+      "date": null,
+      "title": "",
+      "sections": [
+        {
+          "heading": "Fixed - cc CLI 0.166.39: stop repeated log reads and stabilize CI",
+          "body": "- Detect repeated local CI-log searches even when each `findstr`, `grep`, `rg`,\n  or `Select-String` command changes its pattern, then recover and stop the agent\n  instead of reading the same downloaded log forever.\n- Treat search exit code 1 as \"no match\" rather than evidence of a new CI failure.\n- Coalesce repeated no-hook audit events so long-running duplex sessions retain\n  authenticated evidence without quadratic file rewrites or runaway RSS growth.\n- Keep the learning skill writer discoverable by the release inventory scanner.\n- Keep attestor Unix sockets below the macOS path limit, bind Windows secure\n  pipes to the current logon SID, and terminate services when capabilities\n  expire."
+        }
+      ]
+    },
+    {
+      "productVersion": null,
+      "cliVersion": "0.166.38",
+      "cliVersions": ["0.166.38"],
+      "date": null,
+      "title": "",
+      "sections": [
+        {
+          "heading": "Fixed - cc CLI 0.166.38: publish audited child package updates",
+          "body": "- Upgrade the CLI dependency to Context Memory Kernel `0.1.1`, including the\n  LLM selector in the writer inventory.\n- Release Agent Protocol `0.1.9` with knowledge revocation prepare/publish methods\n  in the schema and generated Kotlin/Swift bindings.\n- Include Agent Protocol checks and publication in the CLI release workflow,\n  before the CLI is published.\n- Pair the pending IDE releases with CLI `0.166.38` after npm verification."
+        }
+      ]
+    },
     {
       "productVersion": null,
       "cliVersion": "0.166.37",

package/src/lib/evolution/evolution-artifact-ports.js

@@ -94,6 +94,10 @@ export const EVOLUTION_ARTIFACT_LEDGER_RETENTION_TYPES = Object.freeze([
   "governed-knowledge-quarantine-release",
   "governed-knowledge-trust-record",
   "governed-skill-marketplace-state",
+  "governed-skill-synthesis-attestor-trust-authorization",
+  "governed-skill-synthesis-attestor-trust-operator-registry",
+  "governed-skill-synthesis-attestor-trust-record",
+  "governed-skill-synthesis-evaluation",
   "structured-memory-authority-receipt",
   "structured-memory-event",
   "structured-memory-snapshot",
@@ -146,6 +150,10 @@ export const EVOLUTION_ARTIFACT_TYPES = Object.freeze([
   "governed-knowledge-quarantine-release",
   "governed-knowledge-trust-record",
   "governed-skill-marketplace-state",
+  "governed-skill-synthesis-attestor-trust-authorization",
+  "governed-skill-synthesis-attestor-trust-operator-registry",
+  "governed-skill-synthesis-attestor-trust-record",
+  "governed-skill-synthesis-evaluation",
   "evidence",
   "model-projection",
   "policy",
@@ -394,6 +402,19 @@ const LEDGER_RETENTION_PURPOSES_BY_TYPE = new Map([
   ["governed-knowledge-quarantine-release", new Set(["evolution-ledger"])],
   ["governed-knowledge-trust-record", new Set(["evolution-ledger"])],
   ["governed-skill-marketplace-state", new Set(["evolution-ledger"])],
+  [
+    "governed-skill-synthesis-attestor-trust-authorization",
+    new Set(["evolution-ledger"]),
+  ],
+  [
+    "governed-skill-synthesis-attestor-trust-operator-registry",
+    new Set(["evolution-ledger"]),
+  ],
+  [
+    "governed-skill-synthesis-attestor-trust-record",
+    new Set(["evolution-ledger"]),
+  ],
+  ["governed-skill-synthesis-evaluation", new Set(["evolution-ledger"])],
   ["wiki-revision", new Set(["evolution-ledger"])],
   ["wiki-skill-proposal", new Set(["evolution-ledger"])],
   ["wikiskill-benchmark-envelope-manifest", new Set(["evolution-ledger"])],

package/src/lib/evolution/evolution-deployment-loader.js

@@ -17,6 +17,7 @@ const SUPPORTED_COMMANDS = new Set([
   "desktop",
   "evolution",
   "hub",
+  "learning",
   "marketplace",
   "orchestrate",
   "serve",
@@ -126,6 +127,47 @@ function dependencies(value, commandName) {
 
 async function loadBuiltInFactories(commandName) {
   const factories = {};
+  if (commandName === "learning") {
+    const [
+      { createGovernedSkillSynthesisCliHost },
+      { createGovernedSkillSynthesisProviderChat },
+      { createGovernedSkillSynthesisCandidateEvaluator },
+      { createGovernedSkillSynthesisModelEvaluator },
+      { createGovernedSkillSynthesisEvaluationLedgerAdapter },
+      { createGovernedSkillSynthesisProcessGrader },
+      { createGovernedSkillSynthesisProcessAttestationAuthority },
+      { createGovernedSkillSynthesisExternalAttestationAuthority },
+      { createGovernedSkillSynthesisAttestorTrustVerifier },
+    ] = await Promise.all([
+      import("./governed-skill-synthesis-cli-host.js"),
+      import("./governed-skill-synthesis-provider-chat.js"),
+      import("./governed-skill-synthesis-candidate-evaluator.js"),
+      import("./governed-skill-synthesis-model-evaluator.js"),
+      import("./governed-skill-synthesis-evaluation-ledger-adapter.js"),
+      import("./governed-skill-synthesis-process-grader.js"),
+      import("./governed-skill-synthesis-process-attestor.js"),
+      import("./governed-skill-synthesis-external-attestor.js"),
+      import("./governed-skill-synthesis-attestor-trust-ledger.js"),
+    ]);
+    factories.createGovernedSkillSynthesisCliHost =
+      createGovernedSkillSynthesisCliHost;
+    factories.createGovernedSkillSynthesisProviderChat =
+      createGovernedSkillSynthesisProviderChat;
+    factories.createGovernedSkillSynthesisCandidateEvaluator =
+      createGovernedSkillSynthesisCandidateEvaluator;
+    factories.createGovernedSkillSynthesisModelEvaluator =
+      createGovernedSkillSynthesisModelEvaluator;
+    factories.createGovernedSkillSynthesisEvaluationLedgerAdapter =
+      createGovernedSkillSynthesisEvaluationLedgerAdapter;
+    factories.createGovernedSkillSynthesisProcessGrader =
+      createGovernedSkillSynthesisProcessGrader;
+    factories.createGovernedSkillSynthesisProcessAttestationAuthority =
+      createGovernedSkillSynthesisProcessAttestationAuthority;
+    factories.createGovernedSkillSynthesisExternalAttestationAuthority =
+      createGovernedSkillSynthesisExternalAttestationAuthority;
+    factories.createGovernedSkillSynthesisAttestorTrustVerifier =
+      createGovernedSkillSynthesisAttestorTrustVerifier;
+  }
   if (commandName === "marketplace" || commandName === "desktop") {
     const [
       { createGovernedSkillMarketplaceCliHost },
@@ -163,6 +205,9 @@ async function loadBuiltInFactories(commandName) {
       },
       { createWikiSkillBenchmarkLedgerAdapter },
       { createEvolutionEvalProcessSupervisor },
+      { createGovernedSkillSynthesisAttestorTrustApprovalClient },
+      { createGovernedSkillSynthesisAttestorTrustOperationsClient },
+      { createGovernedSkillSynthesisAttestorTrustOperationsCliHost },
     ] = await Promise.all([
       import("./evolution-workbench-cli-host.js"),
       import("./evolution-workbench-review-ledger-adapter.js"),
@@ -176,6 +221,9 @@ async function loadBuiltInFactories(commandName) {
       import("./wikiskill-benchmark-execution-host.js"),
       import("./wikiskill-benchmark-ledger-adapter.js"),
       import("./evolution-eval-process-supervisor.js"),
+      import("./governed-skill-synthesis-attestor-trust-approval-client.js"),
+      import("./governed-skill-synthesis-attestor-trust-operations-client.js"),
+      import("./governed-skill-synthesis-attestor-trust-operations-cli-host.js"),
     ]);
     factories.createEvolutionWorkbenchCliHost = createEvolutionWorkbenchCliHost;
     factories.createEvolutionWorkbenchReviewRuntime =
@@ -204,6 +252,12 @@ async function loadBuiltInFactories(commandName) {
       createWikiSkillBenchmarkLedgerAdapter;
     factories.createEvolutionEvalProcessSupervisor =
       createEvolutionEvalProcessSupervisor;
+    factories.createGovernedSkillSynthesisAttestorTrustApprovalClient =
+      createGovernedSkillSynthesisAttestorTrustApprovalClient;
+    factories.createGovernedSkillSynthesisAttestorTrustOperationsClient =
+      createGovernedSkillSynthesisAttestorTrustOperationsClient;
+    factories.createGovernedSkillSynthesisAttestorTrustOperationsCliHost =
+      createGovernedSkillSynthesisAttestorTrustOperationsCliHost;
     const [
       { SkillCandidateRegistry },
       { SkillReleaseRegistry },
@@ -307,6 +361,8 @@ async function loadBuiltInFactories(commandName) {
 function bindFactoriesToModule(factories, moduleDigest) {
   const result = { ...factories };
   const providerFactories = [
+    "createGovernedSkillSynthesisCliHost",
+    "createGovernedSkillSynthesisModelEvaluator",
     "createEvolutionWorkbenchReviewRuntime",
     "createEvolutionWorkbenchRollbackRuntime",
     "createEvolutionWorkbenchRegistrySource",