bareloop 0.2.0 → 0.4.0

package/types/text.d.ts

@@ -1 +1,35 @@
-export function stripFences(t: string): string;
+/**
+ * Fence-robust artifact extraction (F2 port requirements #1/#2):
+ * - a fenced block opening within the first {@link FENCE_PREAMBLE_LINES} lines
+ *   is the artifact — prose-wrapped and preamble fences extract clean (the F21
+ *   instrument caveat: prose written to the target corrupted the close signal);
+ * - a fence opening deeper is the artifact's own content — the trimmed whole
+ *   text is the artifact (fence-heavy artifacts belong in tool mode, where the
+ *   worker writes files directly and nothing is parsed);
+ * - no fence → the trimmed whole text, with N0's unclosed-leading-fence strip
+ *   as the fallback (reference parity);
+ * - nothing extractable → `code: null` plus a named reason: artifact-red
+ *   material for the caller's OWN axis, never a silent empty write.
+ * Never throws.
+ * @param {string|null|undefined} t
+ * @returns {{ code: string|null, red: string|null }}
+ */
+export function extractArtifact(t: string | null | undefined): {
+    code: string | null;
+    red: string | null;
+};
+/**
+ * The ONE spelling of the F6 honest-null cost read on a bare-agent result.
+ * `metrics.costUsd` is the honest null when NOTHING priced — never fall
+ * through to `cost` when metrics exist: `cost` sums priced rounds only, so an
+ * all-unpriced run reports cost 0 and `?? cost` would launder the explicit
+ * unknown into a silent $0 (the F6 class — four shipped launderings were this
+ * exact fallback chain hand-spelled). `unpricedRounds` makes a PARTIALLY
+ * unpriced run visible (costUsd finite but an under-count).
+ * @param {any} r a Loop.run() result (or null)
+ * @returns {{ costUsd: number|null, unpricedRounds: number }}
+ */
+export function priceOf(r: any): {
+    costUsd: number | null;
+    unpricedRounds: number;
+};

package/types/validate.d.ts

@@ -25,6 +25,18 @@ export function scopeContained(s: string): boolean;
 export function isObj(v: unknown): boolean;
 /** @param {unknown} v @returns {v is string} */
 export function isNonEmptyString(v: unknown): v is string;
+/**
+ * Scan a RAW text stream (a spine file, a close's output, a transcript) for
+ * known secret shapes and return the literal matches. The ONE spelling of the
+ * text-side scan, for the same reason SECRET_PATTERNS is the ONE inventory: a
+ * hand-rolled copy that misses a shape is a leak on the very output it guards
+ * (seven copies of this expression lived in scripts/ before it landed here).
+ * `sweepSecretLiterals` is the config-tree twin — same shapes, tree walk.
+ * Never throws; returns [] for a missing stream.
+ * @param {unknown} raw
+ * @returns {string[]} every match, in stream order per pattern
+ */
+export function scanSecrets(raw: unknown): string[];
 /**
  * Red every string in a config tree that carries a known secret-token shape.
  * @param {any} root
@@ -66,4 +78,5 @@ export function diffPaths(a: object, b: object): string[];
 export const LOOP_SHAPES: readonly string[];
 export const SLOTS: readonly string[];
 export const VERBS: readonly string[];
+export const REMEMBER_KINDS: string[];
 export const SECRET_PATTERNS: RegExp[];