@openclawbrain/cli 0.4.10 → 0.4.11

package/README.md

@@ -1,31 +1,31 @@
 # @openclawbrain/cli
 
-`@openclawbrain/cli@0.4.10` is the published operator CLI package for OpenClawBrain.
+Operator CLI for OpenClawBrain. Use it with `@openclawbrain/openclaw`.
 
-Primary public flow:
+The public install story is three commands to install or update, then one command to verify.
 
 ```bash
-openclaw plugins install @openclawbrain/openclaw@0.4.0
-npx @openclawbrain/cli@0.4.10 install --openclaw-home ~/.openclaw
+openclaw plugins install @openclawbrain/openclaw
+npx @openclawbrain/cli install --openclaw-home ~/.openclaw
 openclaw gateway restart
-npx @openclawbrain/cli@0.4.10 status --openclaw-home ~/.openclaw --detailed
+npx @openclawbrain/cli status --openclaw-home ~/.openclaw --detailed
 ```
 
-Patch note for `0.4.4`: the CLI now normalizes `plugins.allow` / `plugins.entries.openclawbrain` correctly on reinstall and reports the canonical `openclawbrain` install identity in status output.
+The first three commands install or update OpenClawBrain. The last command verifies the selected OpenClaw home.
 
-Host release note: patched OpenClaw host builds no longer emit the old `openclaw` vs `openclawbrain` mismatch warning. Older host builds may still show that warning until the host-side alias fix is released there.
-
-This package carries the `openclawbrain` CLI, daemon controls, import/export helpers, and install/status/operator management code. `@openclawbrain/openclaw` is the plugin/runtime payload.
-
-## Commands
+## Common commands
 
 ```bash
-npx @openclawbrain/cli@0.4.10 install --openclaw-home ~/.openclaw
-npx @openclawbrain/cli@0.4.10 status --openclaw-home ~/.openclaw --detailed
-npx @openclawbrain/cli@0.4.10 rollback --activation-root /var/openclawbrain/activation --dry-run
-npx @openclawbrain/cli@0.4.10 daemon status --activation-root /var/openclawbrain/activation
+npx @openclawbrain/cli rollback --openclaw-home ~/.openclaw --dry-run
+npx @openclawbrain/cli detach --openclaw-home ~/.openclaw
+npx @openclawbrain/cli uninstall --openclaw-home ~/.openclaw --keep-data
+npx @openclawbrain/cli learn --openclaw-home ~/.openclaw --json
+npx @openclawbrain/cli daemon status --activation-root ~/.openclawbrain/activation
 ```
 
-If the CLI is already on your `PATH`, `openclawbrain ...` is the same command surface. The docs lead with `npx` because that is the clean-host public-registry lane that already passed on `redogfood`.
+## Docs
 
-The old `openclawbrain-ops` alias stays wired to the same entrypoint for compatibility.
+- [Repo README](../../README.md)
+- [Quick start](../../docs/getting-started/quick-start.md)
+- [Lifecycle](../../docs/lifecycle.md)
+- [Troubleshooting](../../docs/operating/troubleshooting.md)

package/dist/src/cli.js

@@ -23,6 +23,7 @@ import { summarizePackVectorEmbeddingState } from "./embedding-status.js";
 import { buildTracedLearningBridgePayloadFromRuntime, buildTracedLearningStatusSurface, persistTracedLearningBridgeState } from "./traced-learning-bridge.js";
 import { discoverOpenClawSessionStores, loadOpenClawSessionIndex, readOpenClawSessionFile } from "./session-store.js";
 import { readOpenClawBrainProviderDefaults, readOpenClawBrainProviderConfig, readOpenClawBrainProviderConfigFromSources, resolveOpenClawBrainProviderDefaultsPath } from "./provider-config.js";
+import { formatOperatorLearningPathSummary } from "./status-learning-path.js";
 const OPENCLAWBRAIN_EMBEDDER_BASE_URL_ENV = "OPENCLAWBRAIN_EMBEDDER_BASE_URL";
 const OPENCLAWBRAIN_EMBEDDER_PROVIDER_ENV = "OPENCLAWBRAIN_EMBEDDER_PROVIDER";
 const OPENCLAWBRAIN_EMBEDDER_MODEL_ENV = "OPENCLAWBRAIN_EMBEDDER_MODEL";
@@ -1396,7 +1397,11 @@ function formatCurrentProfileStatusSummary(status, report, targetInspection, opt
         `scanner     flowing=${yesNo(report.supervision.flowing)} scan=${report.supervision.scanPolicy ?? "none"} surfaces=${formatScannerSurfaces(report)} labels=${report.supervision.humanLabelCount ?? "none"}/${report.supervision.selfLabelCount ?? "none"} attributable=${report.supervision.attributedEventCount ?? "none"}/${report.supervision.totalEventCount ?? "none"} digests=${report.supervision.selectionDigestCount ?? "none"}`,
         `labels      ${formatLabelFlowSummary(report.labelFlow)}`,
         `graph       source=${report.graph.runtimePlasticitySource ?? "none"} blocks=${report.graph.blockCount ?? "none"} strongest=${report.graph.strongestBlockId ?? "none"} ops=${formatStructuralOps(report)} latest=${report.graph.latestMaterialization.packId ?? "none"} latestChanged=${yesNo(report.graph.latestMaterialization.changed)} connect=${formatGraphConnectDiagnostics(report.graph.latestMaterialization.connectDiagnostics ?? report.graph.connectDiagnostics)} summary=${formatGraphSummary(report)}`,
-        `path        ${formatLearningPathSummary(report.learningPath)}`,
+        `path        ${formatOperatorLearningPathSummary({
+            status,
+            learningPath: report.learningPath,
+            tracedLearning
+        })}`,
         `learning    state=${report.learning.backlogState} bootstrapped=${yesNo(report.learning.bootstrapped)} mode=${report.learning.mode} next=${report.learning.nextPriorityLane} priority=${report.learning.nextPriorityBucket} pending=${report.learning.pendingLive ?? "none"}/${report.learning.pendingBackfill ?? "none"} buckets=${formatLearningBuckets(report)} warn=${formatLearningWarnings(report)} lastPack=${report.learning.lastMaterializedPackId ?? "none"} detail=${report.learning.detail}`,
         `traced      ${formatTracedLearningSurface(tracedLearning)}`,
         `teacherProof ${formatTeacherLoopSummary(report)}`,
@@ -4238,7 +4243,8 @@ function runLearnCommand(parsed) {
         maxCycles: 16,
         pgVersion: serveTimeLearning.pgVersion,
         ...(serveTimeLearning.decisionLogCount > 0 ? { serveTimeDecisions: serveTimeLearning.serveTimeDecisions } : {}),
-        ...(serveTimeLearning.baselineState !== undefined ? { baselineState: serveTimeLearning.baselineState } : {})
+        ...(serveTimeLearning.baselineState !== undefined ? { baselineState: serveTimeLearning.baselineState } : {}),
+        activationRoot
     });
     const lastMaterialization = learnerResult.materializations.at(-1) ?? null;
     const plan = describeAlwaysOnLearningRuntimeState(learnerResult.state, lastMaterialization);

package/dist/src/index.js

@@ -887,7 +887,8 @@ export class AsyncTeacherLiveLoop {
                     ...(this.input.cadence !== undefined ? { cadence: this.input.cadence } : {}),
                     ...(learnedRoutingState.pgVersion !== undefined ? { pgVersion: learnedRoutingState.pgVersion } : {}),
                     ...(learnedRoutingState.serveTimeDecisions !== undefined ? { serveTimeDecisions: learnedRoutingState.serveTimeDecisions } : {}),
-                    ...(learnedRoutingState.baselineState !== undefined ? { baselineState: learnedRoutingState.baselineState } : {})
+                    ...(learnedRoutingState.baselineState !== undefined ? { baselineState: learnedRoutingState.baselineState } : {}),
+                    ...(this.input.activationRoot !== undefined ? { activationRoot: this.input.activationRoot } : {})
                 });
                 this.learnerState = structuredClone(learnerResult.state);
                 this.lastMaterialization = cloneAlwaysOnLearningMaterializationJobOrNull(learnerResult.materialization);
@@ -996,6 +997,7 @@ export function scanLiveEventExport(input) {
         learnedRouting: input.learnedRouting ?? true,
         state: createAlwaysOnLearningRuntimeState(),
         builtAt: normalizeIsoTimestamp(input.builtAt, "builtAt", observedAt),
+        ...(input.activationRoot !== undefined ? { activationRoot: input.activationRoot } : {}),
         ...(input.liveSliceSize !== undefined ? { liveSliceSize: input.liveSliceSize } : {}),
         ...(input.backfillSliceSize !== undefined ? { backfillSliceSize: input.backfillSliceSize } : {})
     });
@@ -4037,7 +4039,8 @@ export function runContinuousProductLoopTurn(input) {
             ...(input.sparseFeedback !== undefined ? { sparseFeedback: input.sparseFeedback } : {}),
             ...(input.liveSliceSize !== undefined ? { liveSliceSize: input.liveSliceSize } : {}),
             ...(input.backfillSliceSize !== undefined ? { backfillSliceSize: input.backfillSliceSize } : {}),
-            ...(input.cadence !== undefined ? { cadence: input.cadence } : {})
+            ...(input.cadence !== undefined ? { cadence: input.cadence } : {}),
+            activationRoot
         });
         currentState.learner = structuredClone(learnerResult.state);
         currentState.runtimePlasticity = learnerResult.state.runtimePlasticity === null ? null : structuredClone(learnerResult.state.runtimePlasticity);

package/dist/src/local-learner.d.ts

@@ -29,6 +29,7 @@ export interface CandidatePackBuildInput {
     serveTimeDecisions?: LearningSpineServeRouteDecisionLogEntryV1[];
     /** Baseline state for V2 variance reduction. */
     baselineState?: BaselineStateV1;
+    activationRoot?: string;
 }
 export interface CandidatePackFromNormalizedEventExportInput {
     packLabel: string;
@@ -45,6 +46,7 @@ export interface CandidatePackFromNormalizedEventExportInput {
     pgVersion?: "v1" | "v2";
     serveTimeDecisions?: LearningSpineServeRouteDecisionLogEntryV1[];
     baselineState?: BaselineStateV1;
+    activationRoot?: string;
 }
 export interface BuildTeacherSupervisionArtifactsInput {
     normalizedEventExport: NormalizedEventExportV1;
@@ -66,6 +68,7 @@ interface CandidatePackBridgeInputBase {
     pgVersion?: "v1" | "v2";
     serveTimeDecisions?: LearningSpineServeRouteDecisionLogEntryV1[];
     baselineState?: BaselineStateV1;
+    activationRoot?: string;
 }
 export interface CandidatePackFromNormalizedEventExportSliceInput extends CandidatePackBridgeInputBase {
     normalizedEventExportSlice: NormalizedEventExportSliceV1;
@@ -325,6 +328,7 @@ export interface AdvanceAlwaysOnLearningRuntimeInput {
     pgVersion?: "v1" | "v2";
     serveTimeDecisions?: LearningSpineServeRouteDecisionLogEntryV1[];
     baselineState?: BaselineStateV1;
+    activationRoot?: string;
 }
 export interface AlwaysOnLearningMaterializationJobV1 {
     jobId: string;

package/dist/src/local-learner.js

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
 import { buildRouteArtifactReference, CONTRACT_IDS, PACK_GRAPH_SCHEMAS, ROUTER_PG_PROFILE_V1, ROUTER_PG_PROFILE_V2, checksumJsonPayload, computeRouterCollectedLabelCounts, computeRouterFreshnessChecksum, computeRouterObjectiveChecksum, computeRouterQueryChecksum, computeRouterWeightsChecksum, sortNormalizedEvents, validateTeacherSupervisionArtifact } from "@openclawbrain/contracts";
 import { buildNormalizedEventDedupId, buildNormalizedEventExport, buildNormalizedEventExportBridge, createDefaultLearningSurface, createEventExportCursor, createExplicitEventRange, validateNormalizedEventExport, validateNormalizedEventExportBridge, validateNormalizedEventExportSlice } from "@openclawbrain/event-export";
 import { computePayloadChecksum, loadPack, PACK_LAYOUT, summarizeStructuralGraphEvolution, writePackFile } from "@openclawbrain/pack-format";
@@ -891,7 +892,8 @@ function buildAlwaysOnLearningMaterializationJob(input, current, selectedSlices,
         principalBacklog,
         ...(input.pgVersion !== undefined ? { pgVersion: input.pgVersion } : {}),
         ...(input.serveTimeDecisions !== undefined ? { serveTimeDecisions: [...input.serveTimeDecisions] } : {}),
-        ...(input.baselineState !== undefined ? { baselineState: { ...input.baselineState } } : {})
+        ...(input.baselineState !== undefined ? { baselineState: { ...input.baselineState } } : {}),
+        ...(input.activationRoot !== undefined ? { activationRoot: input.activationRoot } : {})
     };
     const candidate = buildCandidatePackFromNormalizedEventExport(candidateInput);
     const selectedSliceIds = selectedSlices.map((slice) => slice.sliceId);
@@ -4040,6 +4042,201 @@ function createRouterArtifact(packId, builtAt, graph, vectors, eventExport, spar
  * Join serve-time decisions with feedback events to assign outcome rewards.
  * Returns decisionRecordId → outcome (z_T).
  */
+function clampTeacherObservationOutcome(value) {
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    return Math.max(-1, Math.min(1, value));
+}
+function normalizeOutcomeMatchText(value) {
+    return typeof value === "string" && value.trim().length > 0
+        ? value.replace(/\s+/g, " ").trim().toLowerCase()
+        : null;
+}
+function parseObservationRouteMetadata(value) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return {
+            selectedNodeIds: [],
+            selectedPathNodeIds: []
+        };
+    }
+    try {
+        const parsed = JSON.parse(value);
+        const selectedNodeIds = Array.isArray(parsed?.selectedNodeIds)
+            ? parsed.selectedNodeIds.filter((entry) => typeof entry === "string")
+            : [];
+        const selectedPathNodeIds = Array.isArray(parsed?.selectedPathNodeIds)
+            ? parsed.selectedPathNodeIds.filter((entry) => typeof entry === "string")
+            : [];
+        return {
+            selectedNodeIds,
+            selectedPathNodeIds
+        };
+    }
+    catch {
+        return {
+            selectedNodeIds: [],
+            selectedPathNodeIds: []
+        };
+    }
+}
+function loadTeacherObservationOutcomesFromActivation(activationRoot) {
+    const resolvedActivationRoot = typeof activationRoot === "string" && activationRoot.trim().length > 0
+        ? path.resolve(activationRoot)
+        : null;
+    if (resolvedActivationRoot === null) {
+        return [];
+    }
+    const dbPath = path.join(resolvedActivationRoot, "state.db");
+    if (!existsSync(dbPath)) {
+        return [];
+    }
+    let db = null;
+    try {
+        db = new DatabaseSync(dbPath);
+        const table = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'brain_observations' LIMIT 1").get();
+        if (table === undefined) {
+            return [];
+        }
+        const rows = db.prepare(`
+      SELECT id, query_text, route_metadata_json, final_score, confidence, created_at, updated_at, evaluated_at
+      FROM brain_observations
+      WHERE final_score IS NOT NULL
+      ORDER BY created_at DESC
+    `).all();
+        return rows
+            .map((row) => {
+            const routeMetadata = parseObservationRouteMetadata(row.route_metadata_json);
+            return {
+                observationId: typeof row.id === "string" ? row.id : null,
+                queryText: typeof row.query_text === "string" ? row.query_text : "",
+                finalScore: clampTeacherObservationOutcome(Number(row.final_score)),
+                confidence: Number.isFinite(Number(row.confidence)) ? Number(row.confidence) : null,
+                createdAt: Number.isFinite(Number(row.created_at)) ? Number(row.created_at) : null,
+                updatedAt: Number.isFinite(Number(row.updated_at)) ? Number(row.updated_at) : null,
+                evaluatedAt: Number.isFinite(Number(row.evaluated_at)) ? Number(row.evaluated_at) : null,
+                selectedNodeIds: routeMetadata.selectedNodeIds,
+                selectedPathNodeIds: routeMetadata.selectedPathNodeIds
+            };
+        })
+            .filter((row) => row.createdAt !== null && row.finalScore !== 0);
+    }
+    catch {
+        return [];
+    }
+    finally {
+        try {
+            db?.close();
+        }
+        catch {
+        }
+    }
+}
+function decisionTimestampsForObservationMatch(decision) {
+    const timestamps = [];
+    for (const value of [decision.turnCreatedAt, decision.recordedAt]) {
+        if (typeof value !== "string" || value.trim().length === 0) {
+            continue;
+        }
+        const parsed = Date.parse(value);
+        if (Number.isFinite(parsed) && !timestamps.includes(parsed)) {
+            timestamps.push(parsed);
+        }
+    }
+    return timestamps;
+}
+function decisionObservationMatchKey(decision, observation) {
+    const normalizedDecisionText = normalizeOutcomeMatchText(decision.userMessage);
+    const normalizedObservationText = normalizeOutcomeMatchText(observation.queryText);
+    const decisionSelected = new Set([
+        ...(Array.isArray(decision.selectedBrainContextIds) ? decision.selectedBrainContextIds : []),
+        ...(Array.isArray(decision.chosenContextIds) ? decision.chosenContextIds : [])
+    ].filter((entry) => typeof entry === "string"));
+    const observationSelected = new Set([
+        ...observation.selectedNodeIds,
+        ...observation.selectedPathNodeIds
+    ]);
+    let overlapCount = 0;
+    for (const blockId of observationSelected) {
+        if (decisionSelected.has(blockId)) {
+            overlapCount += 1;
+        }
+    }
+    const timestamps = decisionTimestampsForObservationMatch(decision);
+    const observationCreatedAt = observation.createdAt;
+    const bestDelta = observationCreatedAt === null || timestamps.length === 0
+        ? Number.POSITIVE_INFINITY
+        : Math.min(...timestamps.map((timestamp) => Math.abs(timestamp - observationCreatedAt)));
+    const sameQuery = normalizedDecisionText !== null && normalizedDecisionText === normalizedObservationText;
+    if (!sameQuery && overlapCount === 0) {
+        return null;
+    }
+    if (!Number.isFinite(bestDelta) || bestDelta > 300_000) {
+        return null;
+    }
+    return {
+        sameQuery,
+        overlapCount,
+        deltaMs: bestDelta,
+        confidence: observation.confidence ?? 0
+    };
+}
+function compareDecisionObservationMatch(left, right) {
+    if (left.sameQuery !== right.sameQuery) {
+        return left.sameQuery ? -1 : 1;
+    }
+    if (left.overlapCount !== right.overlapCount) {
+        return right.overlapCount - left.overlapCount;
+    }
+    if (left.deltaMs !== right.deltaMs) {
+        return left.deltaMs - right.deltaMs;
+    }
+    if (left.confidence !== right.confidence) {
+        return right.confidence - left.confidence;
+    }
+    return 0;
+}
+function joinDecisionsWithTeacherObservationOutcomes(decisions, observationOutcomes) {
+    const outcomes = new Map();
+    for (const decision of decisions) {
+        outcomes.set(decision.recordId, 0);
+    }
+    if (!Array.isArray(observationOutcomes) || observationOutcomes.length === 0) {
+        return outcomes;
+    }
+    for (const observation of observationOutcomes) {
+        const matches = decisions
+            .map((decision) => {
+            const key = decisionObservationMatchKey(decision, observation);
+            return key === null
+                ? null
+                : {
+                    decision,
+                    key
+                };
+        })
+            .filter((entry) => entry !== null)
+            .sort((left, right) => compareDecisionObservationMatch(left.key, right.key));
+        const best = matches[0] ?? null;
+        const runnerUp = matches[1] ?? null;
+        if (best === null) {
+            continue;
+        }
+        if (runnerUp !== null && compareDecisionObservationMatch(best.key, runnerUp.key) === 0) {
+            continue;
+        }
+        const reward = clampTeacherObservationOutcome(observation.finalScore);
+        if (reward === 0) {
+            continue;
+        }
+        const current = outcomes.get(best.decision.recordId) ?? 0;
+        if (current === 0 || Math.abs(reward) > Math.abs(current)) {
+            outcomes.set(best.decision.recordId, reward);
+        }
+    }
+    return outcomes;
+}
+
 export function joinDecisionsWithFeedback(decisions, eventExport, maxDelayMs = 300_000) {
     const outcomes = new Map();
     for (const decision of decisions) {
@@ -4421,15 +4618,21 @@ function computeTrajectoryPolicyGradientV2(trajectory, adjacency, graph, vectors
  * 6. Aggregates into RouterPolicyUpdateV1[] format
  * 7. Builds the router artifact with ROUTER_PG_PROFILE_V2
  */
-function createRouterArtifactV2(packId, builtAt, graph, vectors, eventExport, serveTimeDecisions, baselineState, sparseFeedback, principalBacklog) {
+function createRouterArtifactV2(packId, builtAt, graph, vectors, eventExport, serveTimeDecisions, baselineState, sparseFeedback, principalBacklog, teacherObservationOutcomes = []) {
     const tau = DEFAULT_TAU;
     const pgScale = 8;
     // 1. Build adjacency map from graph
     const adjacency = buildAdjacencyMap(graph);
     const resolveBlockId = buildGraphBlockIdResolver(graph);
     const remappedServeTimeDecisions = serveTimeDecisions.map((decision) => remapServeTimeDecisionToGraph(decision, resolveBlockId));
-    // 2. Join serve-time decisions with feedback events to get outcomes
+    // 2. Join serve-time decisions with explicit feedback first, then let teacher-v2 observations override when available.
     const outcomeMap = joinDecisionsWithFeedback(remappedServeTimeDecisions, eventExport);
+    const teacherObservationOutcomeMap = joinDecisionsWithTeacherObservationOutcomes(remappedServeTimeDecisions, teacherObservationOutcomes);
+    for (const [decisionId, reward] of teacherObservationOutcomeMap.entries()) {
+        if (reward !== 0) {
+            outcomeMap.set(decisionId, reward);
+        }
+    }
     // 3 & 4. Reconstruct trajectories and update baseline
     let currentBaseline = { ...baselineState };
     const trajectories = [];
@@ -4719,9 +4922,12 @@ export function buildCandidatePack(input) {
     const vectors = createVectorsPayload(graph);
     let router = null;
     let updatedBaseline = null;
+    const teacherObservationOutcomes = input.activationRoot === undefined
+        ? []
+        : loadTeacherObservationOutcomesFromActivation(input.activationRoot);
     if (input.learnedRouting) {
         if (useV2) {
-            const v2Result = createRouterArtifactV2(packId, builtAt, graph, vectors, eventExport, input.serveTimeDecisions, input.baselineState ?? initBaseline(), input.sparseFeedback, input.principalBacklog);
+            const v2Result = createRouterArtifactV2(packId, builtAt, graph, vectors, eventExport, input.serveTimeDecisions, input.baselineState ?? initBaseline(), input.sparseFeedback, input.principalBacklog, teacherObservationOutcomes);
             router = v2Result.artifact;
             updatedBaseline = v2Result.updatedBaseline;
         }
@@ -4883,7 +5089,8 @@ export function buildCandidatePackFromNormalizedEventExport(input) {
         ...(input.principalBacklog !== undefined ? { principalBacklog: input.principalBacklog } : {}),
         ...(input.pgVersion !== undefined ? { pgVersion: input.pgVersion } : {}),
         ...(input.serveTimeDecisions !== undefined ? { serveTimeDecisions: [...input.serveTimeDecisions] } : {}),
-        ...(input.baselineState !== undefined ? { baselineState: { ...input.baselineState } } : {})
+        ...(input.baselineState !== undefined ? { baselineState: { ...input.baselineState } } : {}),
+        ...(input.activationRoot !== undefined ? { activationRoot: input.activationRoot } : {})
     };
     return buildCandidatePack(candidateInput);
 }

package/dist/src/status-learning-path.js

@@ -0,0 +1,28 @@
+function formatRawLearningPathSummary(learningPath) {
+    return `source=${learningPath.source} pg=${learningPath.policyGradientVersion} method=${learningPath.policyGradientMethod ?? "none"} target=${learningPath.targetConstruction ?? "none"} connect=${learningPath.connectOpsFired ?? "none"} trajectories=${learningPath.reconstructedTrajectoryCount ?? "none"}`;
+}
+function isSeedAwaitingFirstPromotion(status) {
+    return status?.brain?.state === "seed_state_authoritative" && status?.brainStatus?.awaitingFirstExport === true;
+}
+function normalizeOptionalString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+export function formatOperatorLearningPathSummary({ status, learningPath, tracedLearning }) {
+    if (!isSeedAwaitingFirstPromotion(status)) {
+        return formatRawLearningPathSummary(learningPath);
+    }
+    const detailParts = [
+        "detail=seed_state_awaiting_first_promotion",
+        `tracedPg=${normalizeOptionalString(tracedLearning?.pgVersionUsed) ?? "none"}`,
+        `tracedPack=${normalizeOptionalString(tracedLearning?.materializedPackId) ?? "none"}`
+    ];
+    return [
+        "source=seed_state",
+        "pg=seed",
+        "method=not_yet_promoted",
+        "target=not_yet_promoted",
+        "connect=none",
+        "trajectories=none",
+        ...detailParts
+    ].join(" ");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclawbrain/cli",
-  "version": "0.4.10",
+  "version": "0.4.11",
   "description": "OpenClawBrain operator CLI package with install/status helpers, daemon controls, and import/export tooling.",
   "type": "module",
   "main": "./dist/src/index.js",
@@ -62,4 +62,3 @@
     "test": "node --test dist/test/*.test.js"
   }
 }
-