@lsctech/polaris 0.4.0 → 0.4.1

package/dist/loop/parent.js

@@ -110,6 +110,26 @@ function resolveTelemetryFile(state, repoRoot) {
     const artifactDir = state.artifact_dir ?? (0, node_path_1.join)(repoRoot, ".taskchain_artifacts", "polaris-run");
     return (0, node_path_1.join)(artifactDir, "runs", state.run_id, "telemetry.jsonl");
 }
+function estimateTokensFromBytes(bytes) {
+    return Math.round(bytes / 4);
+}
+function emitBootstrapContextSize(telemetryFile, runId, childId, stateFile, packet) {
+    const stateFileBytes = (0, node_fs_1.statSync)(stateFile).size;
+    const bootstrapPacketBytes = Buffer.byteLength(JSON.stringify(packet), "utf-8");
+    const stateEstimatedTokens = estimateTokensFromBytes(stateFileBytes);
+    const bootstrapEstimatedTokens = estimateTokensFromBytes(bootstrapPacketBytes);
+    appendTelemetry(telemetryFile, {
+        event: "bootstrap-context-size",
+        run_id: runId,
+        child_id: childId,
+        state_file_bytes: stateFileBytes,
+        state_estimated_tokens: stateEstimatedTokens,
+        bootstrap_packet_bytes: bootstrapPacketBytes,
+        bootstrap_estimated_tokens: bootstrapEstimatedTokens,
+        combined_estimated_tokens: stateEstimatedTokens + bootstrapEstimatedTokens,
+        timestamp: new Date().toISOString(),
+    });
+}
 /**
  * Select the next open child that is not Done/blocked.
  * Returns null when all children are completed.
@@ -300,6 +320,74 @@ function buildPacket(state, activeChild, stateFile, telemetryFile, repoRoot, res
 function absoluteResultFile(repoRoot, filePath) {
     return (0, node_path_1.isAbsolute)(filePath) ? filePath : (0, node_path_1.resolve)(repoRoot, filePath);
 }
+/**
+ * Flush bodies from open_children_meta to the durable clusters.json snapshot.
+ * Called once before the dispatch loop so that writeStateAtomic (which strips
+ * body from non-next children) does not cause data loss when the loop reloads
+ * state from disk between dispatches.
+ *
+ * Only writes nodes that have a body in open_children_meta but lack one in the
+ * existing snapshot. Never removes or overwrites existing body data.
+ * Never throws.
+ */
+function flushBodiesToClusterSnapshot(state, repoRoot) {
+    const meta = state.open_children_meta;
+    if (!meta)
+        return;
+    const snapshotPath = (0, node_path_1.join)(repoRoot, ".polaris", "clusters", state.cluster_id, "clusters.json");
+    let snapshot = {};
+    try {
+        const raw = (0, node_fs_1.readFileSync)(snapshotPath, "utf-8");
+        snapshot = JSON.parse(raw);
+    }
+    catch (err) {
+        // Distinguish "file not found" from "present but corrupted"
+        if (err && typeof err === 'object' && 'code' in err && err.code === 'ENOENT') {
+            // File absent — start fresh
+            snapshot = {
+                schemaVersion: "v2",
+                source: { id: state.cluster_id, type: "local" },
+                nodes: {},
+                dependencies: {},
+                clusters: { [state.cluster_id]: { id: state.cluster_id, title: state.cluster_id, children: state.open_children } },
+                activeCluster: state.cluster_id,
+            };
+        }
+        else {
+            // File present but corrupted — do not overwrite
+            return;
+        }
+    }
+    if (typeof snapshot.nodes !== "object" || snapshot.nodes === null) {
+        snapshot.nodes = {};
+    }
+    let changed = false;
+    for (const [id, childMeta] of Object.entries(meta)) {
+        const body = childMeta?.body;
+        if (!body || body.trim().length === 0)
+            continue;
+        const existing = snapshot.nodes[id];
+        if (existing && existing.body && existing.body.trim().length > 0)
+            continue;
+        snapshot.nodes[id] = {
+            ...(existing ?? {}),
+            id,
+            title: childMeta.title ?? existing?.title ?? id,
+            body,
+            status: existing?.status ?? "Todo",
+        };
+        changed = true;
+    }
+    if (!changed)
+        return;
+    try {
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(snapshotPath), { recursive: true });
+        (0, node_fs_1.writeFileSync)(snapshotPath, JSON.stringify(snapshot, null, 2), "utf-8");
+    }
+    catch {
+        // Best-effort — do not fail the loop if snapshot write fails
+    }
+}
 function buildClusterArtifactPaths(repoRoot, clusterId, childId, dispatchId) {
     const clusterDir = (0, node_path_1.join)(repoRoot, ".polaris", "clusters", clusterId);
     const filename = `${childId}-${dispatchId}.json`;
@@ -629,6 +717,14 @@ async function runParentLoop(options) {
         }
     }
     let childrenDispatched = 0;
+    // ── Flush bodies to clusters.json before stripping begins ──────────────
+    // writeStateAtomic strips body from all open_children_meta entries except
+    // open_children[0]. Flush any bodies present in open_children_meta to the
+    // durable cluster snapshot so readBodyFromClusterSnapshot can hydrate them
+    // on subsequent iterations after reload from disk.
+    if (!dryRun) {
+        flushBodiesToClusterSnapshot(state, repoRoot);
+    }
     // ── Lifecycle manager: enforce one-active-worker policy ─────────────────
     // forceReleaseAll() clears any orphaned registrations from a previous
     // crashed session. Registrations are session-memory only; they are not
@@ -986,6 +1082,7 @@ async function runParentLoop(options) {
                 dry_run: dryRun,
                 timestamp: new Date().toISOString(),
             });
+            emitBootstrapContextSize(telemetryFile, state.run_id, nextChild, stateFile, packet);
         }
         let dispatchResult;
         try {
@@ -1284,6 +1381,10 @@ async function runParentLoop(options) {
             else {
                 state = reloadedState;
                 reloadedStateValid = true;
+                // Flush bodies from worker-updated state to clusters.json before any stripping
+                if (!dryRun) {
+                    flushBodiesToClusterSnapshot(state, repoRoot);
+                }
             }
         }
         catch (err) {
@@ -1410,9 +1511,28 @@ async function runParentLoop(options) {
             }
         }
         // workerStatus === "done" has already been validated upstream.
+        // Build the durable Role Evidence Contract for this completed child.
+        const nextRecommendedAction = summaryAsRecord?.['next_recommended_action'] === 'continue' ||
+            summaryAsRecord?.['next_recommended_action'] === 'stop' ||
+            summaryAsRecord?.['next_recommended_action'] === 'investigate'
+            ? summaryAsRecord['next_recommended_action']
+            : 'continue';
+        const workerResult = (0, checkpoint_js_1.buildWorkerResultContract)({
+            state,
+            childId: nextChild,
+            resultFile: packet.result_file_contract.result_file,
+            telemetryFile,
+            lastCommit: lastCommit ?? null,
+            validation: validationSummary,
+            packetHash: (0, checkpoint_js_1.computePacketHashFromPath)(packetPath),
+            status: 'done',
+            nextRecommendedAction,
+            resultData: summaryAsRecord?.['result_data'],
+        });
         // If the reloaded state already reflects the completed child,
         // the worker owns the completion checkpoint and the parent
-        // must not rewrite it.
+        // must not rewrite the open/closed lists, but it still records the
+        // Role Evidence Contract so scoring can consume it later.
         if (!workerWroteCompletion) {
             // ── Dispatch boundary: verify dispatch happened before advancing ──────
             // The parent dispatched via adapter, so dispatch_boundary should show
@@ -1444,6 +1564,10 @@ async function runParentLoop(options) {
             state = {
                 ...advanced,
                 dispatch_boundary: (0, dispatch_boundary_js_1.advanceContinueEpoch)(state.dispatch_boundary),
+                completed_children_results: {
+                    ...advanced.completed_children_results,
+                    [nextChild]: workerResult,
+                },
             };
             childrenDispatched += 1;
             // Worker did not write its own completion — orchestrator fills the gap.
@@ -1457,6 +1581,10 @@ async function runParentLoop(options) {
             state = {
                 ...state,
                 dispatch_boundary: (0, dispatch_boundary_js_1.advanceContinueEpoch)(state.dispatch_boundary),
+                completed_children_results: {
+                    ...state.completed_children_results,
+                    [nextChild]: workerResult,
+                },
             };
             childrenDispatched += 1;
             if (!dryRun) {

package/dist/loop/resume.js

@@ -61,7 +61,7 @@ const OPEN_CHILD_STATUSES = new Set([
 ]);
 function findClusterStateForPacket(repoRoot, packet) {
     const clustersDir = (0, node_path_1.resolve)(repoRoot, ".polaris", "clusters");
-    const hints = new Set([packet.last_completed_child, ...packet.open_children].filter((value) => typeof value === "string" && value.length > 0));
+    const hints = new Set([packet.last_completed_child, packet.open_children.next_child].filter((value) => typeof value === "string" && value.length > 0));
     let entries;
     try {
         entries = (0, node_fs_1.readdirSync)(clustersDir, { withFileTypes: true })
@@ -96,12 +96,16 @@ function rebuildLoopStateFromClusterState(packet, clusterState, repoRoot) {
     const completedChildren = clusterState.child_states
         .filter((child) => COMPLETED_CHILD_STATUSES.has(child.status))
         .map((child) => child.id);
-    const openChildren = packet.open_children.filter((childId) => clusterChildren.has(childId));
-    const fallbackOpenChildren = openChildren.length > 0
-        ? openChildren
-        : clusterState.child_states
-            .filter((child) => OPEN_CHILD_STATUSES.has(child.status))
-            .map((child) => child.id);
+    // Reconstruct full open queue from all open child_states
+    const allOpenChildren = clusterState.child_states
+        .filter((child) => OPEN_CHILD_STATUSES.has(child.status))
+        .map((child) => child.id);
+    // Place next_child first if present, then append remaining open children
+    const nextChild = packet.open_children.next_child;
+    const openChildren = nextChild && clusterChildren.has(nextChild)
+        ? [nextChild, ...allOpenChildren.filter((id) => id !== nextChild)]
+        : allOpenChildren;
+    const fallbackOpenChildren = openChildren;
     const activeChild = fallbackOpenChildren.find((childId) => {
         const status = clusterState.child_states.find((child) => child.id === childId)?.status;
         return status === "claimed" || status === "dispatched" || status === "running";
@@ -177,7 +181,9 @@ function appendResumedLedgerEvent(repoRoot, packet, state) {
         : [];
     const openChildren = Array.isArray(state.open_children)
         ? state.open_children
-        : packet.open_children;
+        : packet.open_children.next_child
+            ? [packet.open_children.next_child]
+            : [];
     new ledger_js_1.LedgerWriter((0, node_path_1.join)(repoRoot, ledger_js_1.DEFAULT_LEDGER_PATH)).append({
         schema_version: 1,
         event_id: (0, node_crypto_1.randomUUID)(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lsctech/polaris",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Polaris — standalone taskchain orchestration framework for governed AI agent workflows",
   "bin": {
     "polaris": "dist/cli/index.js",