patchwork-os 1.1.0-beta.3.canary.436 → 1.1.0-beta.4

package/dist/ta/desk/cells/structureRetest.d.ts

@@ -0,0 +1,78 @@
+/**
+ * kodama-structure-retest @1d — break-and-retest structure cell.
+ *
+ * FROZEN PARAMS (pre-registered off-repo BEFORE any result was computed, at
+ * ~/.patchwork/qumo/kodama-structure-retest-spec.json; any change must bump
+ * methodVersion and reset accrual to zero, and requires a fresh spec v2):
+ *
+ *   FRACTAL_N             = 2      swing confirmation window (reuses src/ta/swings.ts
+ *                                   isFractalHigh/isFractalLow — same definition as
+ *                                   ta-cycles-1, no new swing logic invented here)
+ *   BREAK_PCT             = 0.005  close must clear the level by >=0.5% (close-based,
+ *                                   filters pure wicks; a close-through is the standard
+ *                                   textbook break definition)
+ *   RETEST_WINDOW_BARS    = 10     bars after the break to look for a retest touch
+ *   RETEST_TOLERANCE_PCT  = 0.003  retest bar's low/high must come within 0.3% of the
+ *                                   level (tighter than the 0.5% break threshold —
+ *                                   retest should return closer to the exact level)
+ *   OUTCOME_WINDOW_BARS   = 10     bars the card races before push/unscorable
+ *   R_MULTIPLIER          = 1.0    rRef = entry ± 1× stop-distance
+ *   UNIVERSE              = ["BTCUSDT", "ETHUSDT"] — the only symbols cellBacktest.ts's
+ *                            ALWAYS_LISTED survivorship guard currently permits; fixed
+ *                            BEFORE looking at any results (see spec's sample.universeJustification)
+ *   METHOD_VERSION        = "kodama-structure-retest-1d-v1"
+ *
+ * Hypothesis: a classic break-and-retest — price breaks a confirmed swing level,
+ * retests it, and the retest bar's own close holds the continuation side — resolves
+ * in the continuation direction at a rate greater than a matched-date random-direction
+ * null, over a fixed 10-bar forward outcome window.
+ *
+ * Fire logic (single detect() call per bar-close, walking backward from the latest
+ * closed bar to find the most recent unconsumed break+retest+hold sequence):
+ *   1. Find the most recent confirmed swing (high or low) strictly before the
+ *      current bar, using detectSwings(candles, FRACTAL_N) on the visible slice.
+ *   2. Scan forward from that swing for the first bar whose CLOSE breaks the level
+ *      by >= BREAK_PCT (close-based, direction depends on swing kind: a swing HIGH
+ *      broken upward = bullish break; a swing LOW broken downward = bearish break).
+ *   3. Within RETEST_WINDOW_BARS bars after the break bar, find the first bar whose
+ *      [low, high] comes within RETEST_TOLERANCE_PCT of the level. That is the
+ *      retest bar.
+ *   4. If the retest bar's own close holds the continuation side (bullish break:
+ *      close > level; bearish break: close < level) → HOLD, fire a card at that
+ *      bar's close. If it closes through the wrong side → FAIL, no signal for this
+ *      sequence (never re-tried).
+ *   5. Only the LATEST closed bar in the visible slice may be the fire bar (walk-
+ *      forward discipline: detect() only ever asks "did the retest resolve exactly
+ *      on this last bar?").
+ *
+ * Look-ahead self-test: candles beyond the fire bar are mutated; the fire decision
+ * on the slice ending at the fire bar must be unchanged. Run once at module import.
+ */
+import type { Candle } from "../../types.js";
+import type { CellDetector, DetectResult } from "../accrualEmitter.js";
+import type { CellSpec } from "../cellBacktest.js";
+export declare const METHOD_VERSION = "kodama-structure-retest-1d-v1";
+export declare const PERMUTATION_SEED = 777;
+export declare const NULL_SEED = 4242;
+export declare const FRACTAL_N = 2;
+export declare const BREAK_PCT = 0.005;
+export declare const RETEST_WINDOW_BARS = 10;
+export declare const RETEST_TOLERANCE_PCT = 0.003;
+export declare const OUTCOME_WINDOW_BARS = 10;
+export declare const R_MULTIPLIER = 1;
+export declare const UNIVERSE: readonly ["BTCUSDT", "ETHUSDT"];
+/**
+ * Run on the latest CLOSED candle (candles[n-1]). Returns false if no
+ * break-and-retest-hold resolves exactly on this bar, or the card geometry
+ * if it does.
+ *
+ * @param candles  Chronological 1d candles; last element = latest closed bar.
+ */
+export declare function detectStructureRetest(candles: Candle[]): DetectResult;
+export declare const structureRetestDetector: CellDetector;
+/**
+ * FAMILY_N bumps from 2 -> 3 when this cell joins the battery (per this file's
+ * own header + the pre-registered spec's familyNJustification).
+ */
+export declare const FAMILY_N = 3;
+export declare const structureRetestSpec: CellSpec;

package/dist/ta/desk/cells/structureRetest.js

@@ -0,0 +1,277 @@
+/**
+ * kodama-structure-retest @1d — break-and-retest structure cell.
+ *
+ * FROZEN PARAMS (pre-registered off-repo BEFORE any result was computed, at
+ * ~/.patchwork/qumo/kodama-structure-retest-spec.json; any change must bump
+ * methodVersion and reset accrual to zero, and requires a fresh spec v2):
+ *
+ *   FRACTAL_N             = 2      swing confirmation window (reuses src/ta/swings.ts
+ *                                   isFractalHigh/isFractalLow — same definition as
+ *                                   ta-cycles-1, no new swing logic invented here)
+ *   BREAK_PCT             = 0.005  close must clear the level by >=0.5% (close-based,
+ *                                   filters pure wicks; a close-through is the standard
+ *                                   textbook break definition)
+ *   RETEST_WINDOW_BARS    = 10     bars after the break to look for a retest touch
+ *   RETEST_TOLERANCE_PCT  = 0.003  retest bar's low/high must come within 0.3% of the
+ *                                   level (tighter than the 0.5% break threshold —
+ *                                   retest should return closer to the exact level)
+ *   OUTCOME_WINDOW_BARS   = 10     bars the card races before push/unscorable
+ *   R_MULTIPLIER          = 1.0    rRef = entry ± 1× stop-distance
+ *   UNIVERSE              = ["BTCUSDT", "ETHUSDT"] — the only symbols cellBacktest.ts's
+ *                            ALWAYS_LISTED survivorship guard currently permits; fixed
+ *                            BEFORE looking at any results (see spec's sample.universeJustification)
+ *   METHOD_VERSION        = "kodama-structure-retest-1d-v1"
+ *
+ * Hypothesis: a classic break-and-retest — price breaks a confirmed swing level,
+ * retests it, and the retest bar's own close holds the continuation side — resolves
+ * in the continuation direction at a rate greater than a matched-date random-direction
+ * null, over a fixed 10-bar forward outcome window.
+ *
+ * Fire logic (single detect() call per bar-close, walking backward from the latest
+ * closed bar to find the most recent unconsumed break+retest+hold sequence):
+ *   1. Find the most recent confirmed swing (high or low) strictly before the
+ *      current bar, using detectSwings(candles, FRACTAL_N) on the visible slice.
+ *   2. Scan forward from that swing for the first bar whose CLOSE breaks the level
+ *      by >= BREAK_PCT (close-based, direction depends on swing kind: a swing HIGH
+ *      broken upward = bullish break; a swing LOW broken downward = bearish break).
+ *   3. Within RETEST_WINDOW_BARS bars after the break bar, find the first bar whose
+ *      [low, high] comes within RETEST_TOLERANCE_PCT of the level. That is the
+ *      retest bar.
+ *   4. If the retest bar's own close holds the continuation side (bullish break:
+ *      close > level; bearish break: close < level) → HOLD, fire a card at that
+ *      bar's close. If it closes through the wrong side → FAIL, no signal for this
+ *      sequence (never re-tried).
+ *   5. Only the LATEST closed bar in the visible slice may be the fire bar (walk-
+ *      forward discipline: detect() only ever asks "did the retest resolve exactly
+ *      on this last bar?").
+ *
+ * Look-ahead self-test: candles beyond the fire bar are mutated; the fire decision
+ * on the slice ending at the fire bar must be unchanged. Run once at module import.
+ */
+import { detectSwings, isFractalHigh, isFractalLow } from "../../swings.js";
+// ── Frozen params ─────────────────────────────────────────────────────────────
+export const METHOD_VERSION = "kodama-structure-retest-1d-v1";
+export const PERMUTATION_SEED = 777; // frozen — shared with cellBacktest default
+export const NULL_SEED = 4242; // frozen — null-arm RNG seed
+export const FRACTAL_N = 2;
+export const BREAK_PCT = 0.005;
+export const RETEST_WINDOW_BARS = 10;
+export const RETEST_TOLERANCE_PCT = 0.003;
+export const OUTCOME_WINDOW_BARS = 10;
+export const R_MULTIPLIER = 1.0;
+// Fixed BEFORE looking at any results — the only universe cellBacktest.ts's
+// ALWAYS_LISTED survivorship guard currently permits. See spec's
+// sample.universeJustification for the full rationale.
+export const UNIVERSE = ["BTCUSDT", "ETHUSDT"];
+// ── Detector ──────────────────────────────────────────────────────────────────
+/**
+ * Run on the latest CLOSED candle (candles[n-1]). Returns false if no
+ * break-and-retest-hold resolves exactly on this bar, or the card geometry
+ * if it does.
+ *
+ * @param candles  Chronological 1d candles; last element = latest closed bar.
+ */
+export function detectStructureRetest(candles) {
+    const n = candles.length;
+    if (n < FRACTAL_N * 2 + 3)
+        return false; // need room for a confirmed swing + break + retest
+    const fireIdx = n - 1; // the bar we're asking "did retest-hold resolve here?"
+    // Step 1: most recent confirmed swing strictly before fireIdx. detectSwings only
+    // returns swings confirmable within the given slice (structural no-lookahead
+    // guarantee from swings.ts), so we pass candles[0..fireIdx] (the whole visible slice)
+    // and take the LAST swing whose index is < fireIdx - well before the break.
+    const swings = detectSwings(candles, FRACTAL_N);
+    if (swings.length === 0)
+        return false;
+    // Try candidate swings from most recent backward — but only the most recent
+    // ELIGIBLE one, since retesting the same level twice from different swings
+    // would double-fire. We only accept a sequence whose retest-hold bar IS fireIdx.
+    for (let s = swings.length - 1; s >= 0; s--) {
+        const swing = swings[s];
+        const level = swing.price;
+        const isHighSwing = swing.kind === "high";
+        // Step 2: scan forward from swing.index+1 for the first break bar.
+        let breakIdx = -1;
+        let breakDirection = null;
+        for (let i = swing.index + 1; i <= fireIdx; i++) {
+            const c = candles[i];
+            if (isHighSwing && c.close > level * (1 + BREAK_PCT)) {
+                breakIdx = i;
+                breakDirection = "long"; // broke resistance upward
+                break;
+            }
+            if (!isHighSwing && c.close < level * (1 - BREAK_PCT)) {
+                breakIdx = i;
+                breakDirection = "short"; // broke support downward
+                break;
+            }
+        }
+        if (breakIdx === -1 || !breakDirection)
+            continue; // no break from this swing; try older swing
+        // Step 3: within RETEST_WINDOW_BARS after the break, find first retest-touch bar.
+        let retestIdx = -1;
+        const retestEnd = Math.min(breakIdx + RETEST_WINDOW_BARS, fireIdx);
+        for (let i = breakIdx + 1; i <= retestEnd; i++) {
+            const c = candles[i];
+            if (breakDirection === "long") {
+                // broken resistance now support: retest = low comes back down within tolerance
+                if (c.low <= level * (1 + RETEST_TOLERANCE_PCT)) {
+                    retestIdx = i;
+                    break;
+                }
+            }
+            else {
+                // broken support now resistance: retest = high comes back up within tolerance
+                if (c.high >= level * (1 - RETEST_TOLERANCE_PCT)) {
+                    retestIdx = i;
+                    break;
+                }
+            }
+        }
+        if (retestIdx === -1)
+            continue; // no retest within window from this swing/break; try older swing
+        // Only fire if the retest bar IS the current fire bar (walk-forward: we only
+        // ever ask about resolution happening exactly on the latest closed bar).
+        if (retestIdx !== fireIdx)
+            continue;
+        // Step 4: hold vs fail, decided by the retest bar's own close.
+        const retestBar = candles[retestIdx];
+        const holds = breakDirection === "long"
+            ? retestBar.close > level
+            : retestBar.close < level;
+        if (!holds)
+            continue; // FAIL — invalidated, no signal for this sequence
+        // HOLD — fire the card.
+        if (breakDirection === "long") {
+            const stopDistance = retestBar.close - retestBar.low;
+            if (stopDistance <= 0)
+                continue;
+            return {
+                direction: "long",
+                lastClose: retestBar.close,
+                invalidation: retestBar.low,
+                rRef: retestBar.close + R_MULTIPLIER * stopDistance,
+            };
+        }
+        else {
+            const stopDistance = retestBar.high - retestBar.close;
+            if (stopDistance <= 0)
+                continue;
+            return {
+                direction: "short",
+                lastClose: retestBar.close,
+                invalidation: retestBar.high,
+                rRef: retestBar.close - R_MULTIPLIER * stopDistance,
+            };
+        }
+    }
+    return false;
+}
+// ── Look-ahead self-test (build gate, runs once at import) ────────────────────
+/**
+ * Build a synthetic series with a clean swing-high, a break above it, and a
+ * retest that holds — all resolving exactly on the last bar. Verify the fire
+ * decision is unchanged whether or not future bars (beyond the fire bar) exist.
+ */
+function runLookAheadSelfTest() {
+    const BASE = 50000;
+    const LEVEL = BASE + 500; // swing high price
+    const candles = [];
+    let t = 0;
+    const push = (o, h, l, c, v = 100) => {
+        candles.push({
+            openTime: t * 86_400_000,
+            open: o,
+            high: h,
+            low: l,
+            close: c,
+            volume: v,
+            closeTime: t * 86_400_000 + 86_399_999,
+        });
+        t++;
+    };
+    // Lead-in flat bars so the swing high has FRACTAL_N bars on each side, all lower.
+    for (let i = 0; i < FRACTAL_N; i++)
+        push(BASE - 200, BASE - 100, BASE - 300, BASE - 150);
+    // The swing high bar itself.
+    const swingIdx = candles.length;
+    push(BASE, LEVEL, BASE - 100, BASE + 100);
+    // Trailing bars confirming the swing (lower highs on each side).
+    for (let i = 0; i < FRACTAL_N; i++)
+        push(BASE - 200, BASE - 100, BASE - 300, BASE - 150);
+    // A few quiet bars before the break (keeps break scan simple).
+    push(BASE - 150, BASE - 50, BASE - 250, BASE - 100);
+    // Break bar: closes above LEVEL * (1+BREAK_PCT).
+    const breakClose = LEVEL * (1 + BREAK_PCT + 0.002);
+    push(BASE, breakClose + 50, BASE - 50, breakClose);
+    // Retest bar: low comes back within tolerance of LEVEL (below LEVEL, i.e. a real
+    // touch-down), closes back above LEVEL (HOLD). low must be <= close (valid candle)
+    // and strictly below LEVEL so there's a nonzero long stop-distance.
+    const retestLow = LEVEL * (1 - RETEST_TOLERANCE_PCT + 0.0005);
+    const retestClose = LEVEL + 50;
+    push(retestClose - 20, retestClose + 30, retestLow, retestClose);
+    const fireIdx = candles.length - 1;
+    void swingIdx;
+    const baseline = detectStructureRetest(candles);
+    if (!baseline) {
+        throw new Error("kodama-structure-retest look-ahead self-test FAILED: synthetic break+retest+hold sequence did not fire — " +
+            `check BREAK_PCT (${BREAK_PCT}) / RETEST_TOLERANCE_PCT (${RETEST_TOLERANCE_PCT}) / RETEST_WINDOW_BARS (${RETEST_WINDOW_BARS})`);
+    }
+    // Append corrupted future bars (should not affect the fire decision on the slice
+    // ending at fireIdx, since detect() is called with candles.slice(0, fireIdx+1)
+    // in the real harness — but we test the raw detector directly here for the same
+    // invariant: extra trailing bars must not change the result).
+    const corrupted = candles.slice(0, fireIdx + 1);
+    for (let j = 0; j < 5; j++) {
+        corrupted.push({
+            openTime: (fireIdx + 1 + j) * 86_400_000,
+            open: BASE * 1.37,
+            high: BASE * 1.37 * 1.05,
+            low: BASE * 1.37 * 0.95,
+            close: BASE * 1.37,
+            volume: 100,
+            closeTime: (fireIdx + 1 + j) * 86_400_000 + 86_399_999,
+        });
+    }
+    const afterCorruption = detectStructureRetest(corrupted.slice(0, fireIdx + 1));
+    if (!afterCorruption) {
+        throw new Error("kodama-structure-retest look-ahead self-test FAILED: detector fired on baseline but not after appending future bars — this is a look-ahead leak");
+    }
+    if (afterCorruption.direction !== baseline.direction ||
+        afterCorruption.lastClose !== baseline.lastClose ||
+        afterCorruption.invalidation !== baseline.invalidation ||
+        afterCorruption.rRef !== baseline.rRef) {
+        throw new Error("kodama-structure-retest look-ahead self-test FAILED: detector result changed after appending corrupted future bars — look-ahead contamination detected");
+    }
+    // Sanity: confirm the fractal helpers agree the swing bar is indeed a confirmed high
+    // at the point it's used (defensive — catches an accidental self-test series bug).
+    if (!isFractalHigh(candles, swingIdx, FRACTAL_N) && !isFractalLow(candles, swingIdx, FRACTAL_N)) {
+        throw new Error("kodama-structure-retest look-ahead self-test FAILED: synthetic series' intended swing bar is not a confirmed fractal — test construction bug");
+    }
+}
+runLookAheadSelfTest();
+// ── CellDetector export ───────────────────────────────────────────────────────
+export const structureRetestDetector = {
+    cellType: "kodama-structure-retest",
+    timeframe: "1d",
+    assets: UNIVERSE,
+    outcomeWindowBars: OUTCOME_WINDOW_BARS,
+    detect: detectStructureRetest,
+};
+// ── CellSpec for cellBacktest harness ─────────────────────────────────────────
+/**
+ * FAMILY_N bumps from 2 -> 3 when this cell joins the battery (per this file's
+ * own header + the pre-registered spec's familyNJustification).
+ */
+export const FAMILY_N = 3; // frozen: wp-volume-climax + wp-ma-rejection + kodama-structure-retest
+export const structureRetestSpec = {
+    cellName: "kodama-structure-retest",
+    methodVersion: METHOD_VERSION,
+    timeframe: "1d",
+    universe: UNIVERSE,
+    outcomeWindowBars: OUTCOME_WINDOW_BARS,
+    nullKind: "matched-date-dart",
+    seeds: { rng: 101, permutation: PERMUTATION_SEED, null: NULL_SEED },
+    detect: detectStructureRetest,
+};
+//# sourceMappingURL=structureRetest.js.map

package/dist/ta/desk/cells/structureRetest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"structureRetest.js","sourceRoot":"","sources":["../../../../src/ta/desk/cells/structureRetest.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchwork-os",
-  "version": "1.1.0-beta.3.canary.436",
+  "version": "1.1.0-beta.4",
   "description": "Your personal AI runtime, local-first. Patchwork OS gives any AI model a consistent set of tools, YAML recipes, a delegation policy with approval queue, and a durable trace memory — all on your machine, all under your policy.",
   "type": "module",
   "main": "dist/index.js",