omkit 0.0.14 → 0.0.15

package/dist/orchestration/assert.d.ts

@@ -15,8 +15,10 @@ export declare class AssertionError extends Error {
 /**
  * Build an {@link Assert} bound to one action (or the spin body): `name` is its
  * launch path (used for attribution in the log line and the error), `logs` is the
- * logger to append to, and `onFail` records a genuine failure into the verdict. The
- * factory is file-agnostic — it only appends `level: "assert"` entries; the
- * dedicated `assertions.log` is a downstream projection of that stream.
+ * logger to append to, and `onResult` is invoked once per call with the pass
+ * boolean (and, on failure, an {@link AssertionError} to record into the verdict) —
+ * so the host can tally passes/failures and record faults in one place. The factory
+ * is file-agnostic — it only appends `level: "assert"` entries; the dedicated
+ * `assertions.log` is a downstream projection of that stream.
  */
-export declare function createAssert(name: string, logs: Logger, onFail: (error: AssertionError) => void): Assert;
+export declare function createAssert(name: string, logs: Logger, onResult: (pass: boolean, error?: AssertionError) => void): Assert;

package/dist/orchestration/assert.js

@@ -8,19 +8,19 @@ export class AssertionError extends Error {
 /**
  * Build an {@link Assert} bound to one action (or the spin body): `name` is its
  * launch path (used for attribution in the log line and the error), `logs` is the
- * logger to append to, and `onFail` records a genuine failure into the verdict. The
- * factory is file-agnostic — it only appends `level: "assert"` entries; the
- * dedicated `assertions.log` is a downstream projection of that stream.
+ * logger to append to, and `onResult` is invoked once per call with the pass
+ * boolean (and, on failure, an {@link AssertionError} to record into the verdict) —
+ * so the host can tally passes/failures and record faults in one place. The factory
+ * is file-agnostic — it only appends `level: "assert"` entries; the dedicated
+ * `assertions.log` is a downstream projection of that stream.
  */
-export function createAssert(name, logs, onFail) {
+export function createAssert(name, logs, onResult) {
     return (value, what) => {
         const pass = value;
         const glyph = pass ? "✓" : "✗";
         const message = `${name} · ${glyph} ${what}`;
         logs.append({ source: "assert", level: "assert", message });
-        if (!pass) {
-            onFail(new AssertionError(`${name}: ${what}`));
-        }
+        onResult(pass, pass ? undefined : new AssertionError(`${name}: ${what}`));
         return pass;
     };
 }

package/dist/orchestration/spin/SpinHost.d.ts

@@ -41,6 +41,8 @@ export declare class SpinHost {
     /** The current lifecycle state — see {@link SpinState}. */
     get state(): SpinState;
     private readonly failures;
+    private assertionsPassed;
+    private assertionsFailed;
     private readonly inFlight;
     private readonly launched;
     private readonly streaming;

package/dist/orchestration/spin/SpinHost.js

@@ -78,6 +78,9 @@ export class SpinHost {
     }
     // Genuine failures (not teardown cascade). Frozen into the verdict at close.
     failures = [];
+    // Running tally of every assertion this run made, for the run.log summary footer.
+    assertionsPassed = 0;
+    assertionsFailed = 0;
     // Every launched action's promise lives here until it settles; the drive loop
     // empties this set. Daemons keep it non-empty until the controller aborts.
     inFlight = new Set();
@@ -240,15 +243,20 @@ export class SpinHost {
             this.nodInto(child, path);
             return child;
         };
-        // A boolean check bound to this action's path: it logs a `⊨` milestone, and a
-        // mismatch records a verdict failure the same way an action's own failure does
-        // — skipped during teardown (cascade, not a fault). Uses `this.logs` (not
-        // `scoped`) the same way `record` below does: the path is already embedded in
-        // the message via `name`, so routing through `scoped` would double-prefix the
-        // `source` field for a nodded child.
-        const assert = createAssert(path, this.logs, (error) => {
-            if (!this.controller.signal.aborted)
-                this.recordFailure(path, error);
+        // A boolean check bound to this action's path: it logs a `⊨` milestone, tallies
+        // the result for the run.log summary, and on failure records a verdict failure
+        // the same way an action's own failure does — skipped during teardown (cascade,
+        // not a fault). Uses `this.logs` (not `scoped`) the same way `record` below does:
+        // the path is already embedded in the message via `name`, so routing through
+        // `scoped` would double-prefix the `source` field for a nodded child.
+        const assert = createAssert(path, this.logs, (pass, error) => {
+            if (pass)
+                this.assertionsPassed++;
+            else {
+                this.assertionsFailed++;
+                if (!this.controller.signal.aborted && error)
+                    this.recordFailure(path, error);
+            }
         });
         this.narrate(`launch ${path}`);
         // The action logs into this run's shared store (entries carry their `source`;
@@ -318,14 +326,14 @@ export class SpinHost {
         // before `writeLog` streams it into the final collapsed run.log.
         this.logs.close();
         await this.streaming;
-        const file = await this.output.runLog.write();
+        // Hand the assertion tally to `write`, which bubbles a summary + the
+        // `assertions.log` link into the run.log footer (only when there were any).
+        const file = await this.output.runLog.write({
+            passed: this.assertionsPassed,
+            failed: this.assertionsFailed,
+        });
         // Direct to the terminal — the file's already written, so this line isn't in it.
         this.term(LogRenderer.marker("run", `log → ${file}`));
-        // If this run logged any assertions, link the dedicated file beside the main one
-        // (only exists when there was at least one assertion). Terminal-only, like `log →`.
-        const assertionsFile = this.output.runLog.assertionsLog;
-        if (assertionsFile)
-            this.term(LogRenderer.marker("assert", `assertions → ${assertionsFile}`));
         const result = { ok: this.failures.length === 0, failures: this.failures };
         // One process = one run = one verdict; reflect pass/fail in the exit code so
         // shells and CI see it without parsing the log. Only set it on failure, so a

package/dist/output/log/RunLog.d.ts

@@ -40,8 +40,15 @@ export declare class RunLog {
      *
      * Call only after {@link stream} has closed (the run's log is ended), so `run.jsonl`
      * is complete and no longer being written.
+     *
+     * When this run logged any assertions, `summary` bubbles a footer into `run.log`
+     * (only) — the pass/fail tally and a link to `assertions.log` — so results surface
+     * in the persistent log rather than the live process output.
      */
-    write(): Promise<string>;
+    write(summary?: {
+        passed: number;
+        failed: number;
+    }): Promise<string>;
     /** A compact header block for the top of run.log — legend + run identity. */
     private header;
 }

package/dist/output/log/RunLog.js

@@ -86,8 +86,12 @@ export class RunLog {
      *
      * Call only after {@link stream} has closed (the run's log is ended), so `run.jsonl`
      * is complete and no longer being written.
+     *
+     * When this run logged any assertions, `summary` bubbles a footer into `run.log`
+     * (only) — the pass/fail tally and a link to `assertions.log` — so results surface
+     * in the persistent log rather than the live process output.
      */
-    async write() {
+    async write(summary) {
         await this.folder.ensure();
         const jsonlFile = this.folder.resolve("run.jsonl");
         const file = this.folder.resolve("run.log");
@@ -126,6 +130,12 @@ export class RunLog {
         }
         for (const item of renderer.end())
             emit(item);
+        // Bubble the assertion summary + the dedicated-log link into the run.log footer —
+        // only when this run logged assertions (`assertionsPath` is set on the first one).
+        if (this.assertionsPath && summary) {
+            out.write(LogRenderer.marker("assert", `assertions · ${summary.passed} passed · ${summary.failed} failed`) + "\n");
+            out.write(LogRenderer.marker("assert", `assertions → ${this.assertionsPath}`) + "\n");
+        }
         await closeStream(out); // flush + close run.log before reporting it written
         await Promise.all(writes); // ensure every off-loaded run is on disk
         return file;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omkit",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "description": "A tiny runtime for developer workflows: typed actions that pass runtime capabilities and emit typed events, under one run and one shared log. The operational/runtime layer to tskb's knowledge layer.",
   "type": "module",
   "main": "./dist/index.js",