@danceiny/gotry 0.0.1-rc.11 → 0.0.1-rc.13

package/dist/scripts/async-collect.js

@@ -1,7 +1,30 @@
 import { appendFileSync } from 'node:fs';
-import { collectDeepPlanning, loadAsyncTicket, makeJournaledSolvePort, settleAsyncTicket } from '../src/loop.js';
+import { ASYNC_TERMINAL_SCHEMA, collectDeepPlanning, loadAsyncTicket, makeJournaledSolvePort, settleAsyncTicket } from '../src/loop.js';
 import { solveUnified } from '../src/unified.js';
 import { openLedgerIfExists } from '../src/state-ledger.js';
+function isTerminalOutcome(value) {
+    return value?.['schema'] === ASYNC_TERMINAL_SCHEMA && (value['status'] === 'succeeded' || value['status'] === 'failed') && typeof value['passed'] === 'number' && value['total'] === 4 && Array.isArray(value['failed_checks']);
+}
+function legacyTerminalOutcome(ticket, status, deliverable) {
+    const succeeded = status === 'settled' && deliverable.includes('不失望四条:4/4 ✅');
+    return {
+        schema: ASYNC_TERMINAL_SCHEMA,
+        ticket_id: ticket,
+        status: succeeded ? 'succeeded' : 'failed',
+        passed: succeeded ? 4 : 0,
+        total: 4,
+        checks: {
+            legacy_human_marker_only: succeeded
+        },
+        failed_checks: succeeded ? [] : [
+            'legacy_unstructured_terminal'
+        ]
+    };
+}
+function emitTerminal(outcome) {
+    console.log(JSON.stringify(outcome));
+    process.exit(outcome.status === 'succeeded' ? 0 : 2);
+}
 const ticketId = process.argv[2];
 const stateRoot = process.argv[3] ?? '.';
 if (!ticketId) {
@@ -15,9 +38,12 @@ if (!loaded) {
 }
 const ledger = openLedgerIfExists(stateRoot);
 const run = ledger?.getWorkflowRun(ticketId);
-if (run?.status === 'settled' && run.deliverable) {
+if ((run?.status === 'settled' || run?.status === 'failed') && run.deliverable) {
+    const storedOutcome = ledger?.getWorkflowTerminalOutcome(ticketId) ?? null;
+    const outcome = isTerminalOutcome(storedOutcome) ? storedOutcome : legacyTerminalOutcome(ticketId, run.status, run.deliverable);
+    await settleAsyncTicket(ticketId, run.deliverable, stateRoot, outcome);
     console.log(`工单 ${ticketId} 已交付(账本终态,复诵不重算):\n\n${run.deliverable}`);
-    process.exit(0);
+    emitTerminal(outcome);
 }
 if (!ledger) {
     console.error(`工单 ${ticketId}:stateRoot(${stateRoot})无账本——持久化先于回收,不应发生`);
@@ -29,9 +55,11 @@ const solve = makeJournaledSolvePort(ledger, ticketId, solveUnified, {
         if (f) appendFileSync(f, 'solve\n');
     }
 });
-const { reply } = await collectDeepPlanning(loaded.state, loaded.ticket, solve);
-const out = await settleAsyncTicket(ticketId, reply, stateRoot);
+const { reply, outcome } = await collectDeepPlanning(loaded.state, loaded.ticket, solve);
+const out = await settleAsyncTicket(ticketId, reply, stateRoot, outcome);
 console.log(`交付物已落盘:${out}\n\n${reply}`);
+console.log(JSON.stringify(outcome));
+process.exitCode = outcome.status === 'succeeded' ? 0 : 2;
 
 
 //# sourceURL=/Users/bytedance/work/gotry/ts/scripts/async-collect.ts

package/dist/scripts/hbcli-tests.js

@@ -62,7 +62,12 @@ await writeFile(fallback, JSON.stringify({
     meta: 'fake',
     stays: [
         {
-            id: 's1'
+            id: 's1',
+            note: '普吉岛 workation 两周(13 晚)'
+        },
+        {
+            id: 's2',
+            note: '曼谷周末(2 晚)'
         }
     ]
 }));
@@ -83,19 +88,35 @@ await writeFile(fallback, JSON.stringify({
     }
     console.log('5. v0.3.0 旗标(--destination-name/--room-occupancies)对齐 OK');
 }const r4 = await searchHotels({
-    destination: '普吉'
+    destination: '普吉岛'
 }, {
     hbcliBin: failBin2,
     fallbackPath: fallback
 });
 assert.equal(r4.via, 'hbcli-error', 'searchHotels: fails to hbcli → fallback');
 assert.equal(r4.summary.includes('降级到静态包'), true, 'summary 指明降级');
-assert.ok(r4.hotels, 'hotels 字段填上静态包内容');
+assert.deepEqual(r4.hotels, {
+    stays: [
+        {
+            id: 's1',
+            note: '普吉岛 workation 两周(13 晚)'
+        }
+    ]
+}, 'hotels 只含目的地命中的住宿块');
+assert.equal(r4.summary.includes('命中 1 个住宿块'), true, 'summary 指明命中块数');
+const r5 = await searchHotels({
+    destination: '巴黎'
+}, {
+    hbcliBin: failBin2,
+    fallbackPath: fallback
+});
+assert.equal(r5.hotels ?? null, null, '无目的地命中时 hotels 为 null(不整包倾倒)');
+assert.match(r5.summary, /无「巴黎」住宿数据/, 'summary 明示静态包无该目的地');
 await rm(tmp, {
     recursive: true,
     force: true
 });
-console.log('HBCLI TESTS: 5/5 OK (happy / error / no-binary / fallback / v0.3.0 旗标回归)');
+console.log('HBCLI TESTS: 6/6 OK (happy / error / no-binary / fallback-filter / fallback-no-match / v0.3.0 旗标回归)');
 
 
 //# sourceURL=/Users/bytedance/work/gotry/ts/scripts/hbcli-tests.ts

package/dist/scripts/ledger-tests.js

@@ -3,7 +3,9 @@ import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync, mkdirSync
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { spawnSync } from 'node:child_process';
+import { persistAsyncTicket } from '../src/loop.js';
 import { ensureLedger, openLedgerIfExists } from '../src/state-ledger.js';
+import { parseFlightPackToSpec } from '../src/unified.js';
 let pass = 0;
 let fail = 0;
 function assert(cond, msg) {
@@ -15,6 +17,17 @@ function assert(cond, msg) {
         console.error(`  FAIL - ${msg}`);
     }
 }
+function terminalOutcomeOf(stdout) {
+    const line = stdout.trim().split('\n').filter(Boolean).at(-1);
+    if (!line) return null;
+    try {
+        const value = JSON.parse(line);
+        if (value.schema !== 'gotry_async_terminal.v1' || typeof value.ticket_id !== 'string' || value.status !== 'succeeded' && value.status !== 'failed' || typeof value.passed !== 'number' || typeof value.total !== 'number' || typeof value.checks !== 'object' || !Array.isArray(value.failed_checks)) return null;
+        return value;
+    } catch  {
+        return null;
+    }
+}
 const root = mkdtempSync(join(tmpdir(), 'gotry-ledger-'));
 const ledger = ensureLedger(root);
 const r1 = ledger.appendMotivationPatch({
@@ -276,11 +289,16 @@ const resume = spawnSync('npx', [
         GOTRY_SOLVE_COUNT_FILE: countFile
     }
 });
-assert(resume.status === 0, `恢复进程 exit 0(实际 ${resume.status}:${(resume.stderr ?? '').slice(0, 300)})`);
+const failedOutcome = terminalOutcomeOf(resume.stdout ?? '');
+assert(resume.status === 2, `非4/4 恢复进程 exit 2(实际 ${resume.status}:${(resume.stderr ?? '').slice(0, 300)})`);
+assert(failedOutcome?.status === 'failed' && failedOutcome.ticket_id === 'dp-crash1' && failedOutcome.passed < failedOutcome.total && failedOutcome.failed_checks.length > 0, '非4/4 输出 gotry_async_terminal.v1/failed 与失败项');
 const count2 = readFileSync(countFile, 'utf-8').split('\n').filter(Boolean).length;
 assert(count2 === 1, '恢复时 done 步骤零重算(exactly-once:求解计数仍 1,不重复花钱)');
-assert(existsSync(join(wroot, 'gotry-state', 'async', 'dp-crash1.deliverable.md')), '交付物视图已落盘(.deliverable.md)');
-assert(openLedgerIfExists(wroot)?.getWorkflowRun('dp-crash1')?.status === 'settled', '账本终态 settled');
+const failedDeliverablePath = join(wroot, 'gotry-state', 'async', 'dp-crash1.deliverable.md');
+assert(existsSync(failedDeliverablePath), '交付物视图已落盘(.deliverable.md)');
+const failedLedger = openLedgerIfExists(wroot);
+assert(failedLedger?.getWorkflowRun('dp-crash1')?.status === 'failed', '非4/4 账本终态 failed');
+assert(JSON.stringify(failedLedger?.getWorkflowTerminalOutcome('dp-crash1')) === JSON.stringify(failedOutcome), '非4/4 结构化终态随 async.failed 事件落账');
 const replay = spawnSync('npx', [
     'tsx',
     'scripts/async-collect.ts',
@@ -293,9 +311,117 @@ const replay = spawnSync('npx', [
         GOTRY_SOLVE_COUNT_FILE: countFile
     }
 });
-assert(replay.status === 0, '终态复诵 exit 0(幂等)');
+assert(replay.status === 2 && JSON.stringify(terminalOutcomeOf(replay.stdout ?? '')) === JSON.stringify(failedOutcome), 'failed 终态复诵保持 exit 2 与同一结构化结果');
 const count3 = readFileSync(countFile, 'utf-8').split('\n').filter(Boolean).length;
 assert(count3 === 1, '终态复诵零重算');
+const failedDeliverable = readFileSync(failedDeliverablePath, 'utf-8');
+rmSync(failedDeliverablePath);
+const replayAfterMissingView = spawnSync('npx', [
+    'tsx',
+    'scripts/async-collect.ts',
+    'dp-crash1',
+    wroot
+], {
+    encoding: 'utf-8',
+    env: {
+        ...process.env,
+        GOTRY_SOLVE_COUNT_FILE: countFile
+    }
+});
+assert(replayAfterMissingView.status === 2 && JSON.stringify(terminalOutcomeOf(replayAfterMissingView.stdout ?? '')) === JSON.stringify(failedOutcome), 'failed 终态缺失视图时仍复诵同一 exit 2 与结构化结果');
+assert(existsSync(failedDeliverablePath) && readFileSync(failedDeliverablePath, 'utf-8') === failedDeliverable, 'failed 终态复诵重建缺失 .deliverable.md 视图');
+const countAfterViewRepair = readFileSync(countFile, 'utf-8').split('\n').filter(Boolean).length;
+assert(countAfterViewRepair === 1, '终态视图修复零重算');
+const tickRoot = mkdtempSync(join(tmpdir(), 'gotry-wf-tick-failed-'));
+const tickTicket = {
+    id: 'dp-tick-failed1',
+    objective: 'state-cli 非4/4 机器终态回归',
+    requestedAt: new Date().toISOString(),
+    etaLabel: '秒级'
+};
+const tickState = {
+    calendar: {
+        year: 2026,
+        assertedWeekdays: {}
+    },
+    profile: {},
+    gates: [],
+    wishes: []
+};
+await persistAsyncTicket(tickTicket, tickState, tickRoot);
+const tick = spawnSync('npx', [
+    'tsx',
+    'scripts/state-cli.ts',
+    'tick',
+    tickRoot
+], {
+    encoding: 'utf-8'
+});
+assert(tick.status === 0, `state-cli tick 完成回收(实际 ${tick.status}:${(tick.stderr ?? '').slice(0, 200)})`);
+const tickLedger = openLedgerIfExists(tickRoot);
+const tickOutcome = tickLedger?.getWorkflowTerminalOutcome(tickTicket.id);
+assert(tickLedger?.getWorkflowRun(tickTicket.id)?.status === 'failed' && tickOutcome?.schema === 'gotry_async_terminal.v1' && tickOutcome.status === 'failed' && tickOutcome.passed === 0 && tickOutcome.failed_checks.length === 4, 'state-cli tick 未透传 outcome 时仍从权威账本恢复非4/4 failed 终态');
+const tickReplay = spawnSync('npx', [
+    'tsx',
+    'scripts/async-collect.ts',
+    tickTicket.id,
+    tickRoot
+], {
+    encoding: 'utf-8'
+});
+assert(tickReplay.status === 2 && JSON.stringify(terminalOutcomeOf(tickReplay.stdout ?? '')) === JSON.stringify(tickOutcome), 'state-cli 写入的 failed 终态可由 collector 幂等复诵为同一 outcome/exit 2');
+const successRoot = mkdtempSync(join(tmpdir(), 'gotry-wf-success-'));
+const successCountFile = join(successRoot, 'solve-count.txt');
+writeFileSync(successCountFile, '');
+const successTicket = {
+    id: 'dp-success1',
+    objective: '4/4 机器终态回归',
+    requestedAt: new Date().toISOString(),
+    etaLabel: '秒级'
+};
+const successSpec = parseFlightPackToSpec(JSON.parse(readFileSync(join('..', 'data', 'flights_2026.json'), 'utf-8')));
+successSpec.budgetCny = 9000;
+const successState = {
+    calendar: {
+        year: 2026,
+        assertedWeekdays: {}
+    },
+    profile: {},
+    gates: [],
+    wishes: [],
+    spec: successSpec
+};
+await persistAsyncTicket(successTicket, successState, successRoot);
+const success = spawnSync('npx', [
+    'tsx',
+    'scripts/async-collect.ts',
+    successTicket.id,
+    successRoot
+], {
+    encoding: 'utf-8',
+    env: {
+        ...process.env,
+        GOTRY_SOLVE_COUNT_FILE: successCountFile
+    }
+});
+const successOutcome = terminalOutcomeOf(success.stdout ?? '');
+assert(success.status === 0 && successOutcome?.status === 'succeeded' && successOutcome.ticket_id === successTicket.id && successOutcome.passed === 4 && successOutcome.total === 4 && successOutcome.failed_checks.length === 0, `4/4 输出 gotry_async_terminal.v1/succeeded 且 exit 0(实际 ${success.status})`);
+const successLedger = openLedgerIfExists(successRoot);
+assert(successLedger?.getWorkflowRun(successTicket.id)?.status === 'settled' && successLedger.getWorkflowTerminalOutcome(successTicket.id)?.['status'] === 'succeeded', '4/4 账本终态 settled 且结构化结果随 async.settled 落账');
+const successReplay = spawnSync('npx', [
+    'tsx',
+    'scripts/async-collect.ts',
+    successTicket.id,
+    successRoot
+], {
+    encoding: 'utf-8',
+    env: {
+        ...process.env,
+        GOTRY_SOLVE_COUNT_FILE: successCountFile
+    }
+});
+const successCount = readFileSync(successCountFile, 'utf-8').split('\n').filter(Boolean).length;
+assert(successReplay.status === 0 && successCount === 1 && JSON.stringify(terminalOutcomeOf(successReplay.stdout ?? '')) === JSON.stringify(successOutcome), 'succeeded 终态复诵保持 exit 0、同一结构化结果且零重算');
 const pw1 = ledger.requestPendingWrite({
     idemKey: 'booking:demo-1',
     seam: 'flight-order-confirm',
@@ -358,6 +484,10 @@ rmSync(wroot, {
     recursive: true,
     force: true
 });
+rmSync(successRoot, {
+    recursive: true,
+    force: true
+});
 console.log(`\nLEDGER TESTS: ${pass} ok, ${fail} fail`);
 if (fail > 0) process.exit(1);
 

package/dist/scripts/memory-value-report.js

@@ -0,0 +1,379 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function finiteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function round(value) {
+    return Math.round((value + Number.EPSILON) * 1_000_000) / 1_000_000;
+}
+function nearestRank(values, percentile) {
+    if (values.length === 0) return 0;
+    const sorted = [
+        ...values
+    ].sort((a, b)=>a - b);
+    const index = Math.max(0, Math.ceil(percentile * sorted.length) - 1);
+    return round(sorted[index]);
+}
+function parseTimestamp(value, path, errors) {
+    if (!nonEmptyString(value)) {
+        errors.push(`${path} must be a non-empty ISO timestamp`);
+        return null;
+    }
+    const parsed = Date.parse(value);
+    if (!Number.isFinite(parsed)) {
+        errors.push(`${path} is not a valid ISO timestamp`);
+        return null;
+    }
+    return parsed;
+}
+function scoreFlow(value, path, expectedEligibleIndex, allowedWaitCodes, errors) {
+    if (!isObject(value)) {
+        errors.push(`${path} must be an object`);
+        return null;
+    }
+    const flowId = value.flow_id;
+    if (!nonEmptyString(flowId)) errors.push(`${path}.flow_id must be non-empty`);
+    if (value.eligible !== true) errors.push(`${path}.eligible must be true`);
+    if (value.status !== 'completed') errors.push(`${path}.status must be completed`);
+    if (value.eligible_planning_index !== expectedEligibleIndex) {
+        errors.push(`${path}.eligible_planning_index must be ${expectedEligibleIndex}`);
+    }
+    const startedAtMs = parseTimestamp(value.started_at, `${path}.started_at`, errors);
+    const completedAtMs = parseTimestamp(value.completed_at, `${path}.completed_at`, errors);
+    if (startedAtMs === null || completedAtMs === null) return null;
+    if (completedAtMs <= startedAtMs) {
+        errors.push(`${path}.completed_at must be after started_at`);
+        return null;
+    }
+    const rawWaits = value.external_waits;
+    if (!Array.isArray(rawWaits)) {
+        errors.push(`${path}.external_waits must be an array`);
+        return null;
+    }
+    const waits = [];
+    for (const [index, rawWait] of rawWaits.entries()){
+        const waitPath = `${path}.external_waits[${index}]`;
+        if (!isObject(rawWait)) {
+            errors.push(`${waitPath} must be an object`);
+            continue;
+        }
+        const code = rawWait.code;
+        if (!nonEmptyString(code) || !allowedWaitCodes.has(code)) {
+            errors.push(`${waitPath}.code must be predeclared by measurement_policy`);
+            continue;
+        }
+        const waitStartedAtMs = parseTimestamp(rawWait.started_at, `${waitPath}.started_at`, errors);
+        const waitCompletedAtMs = parseTimestamp(rawWait.completed_at, `${waitPath}.completed_at`, errors);
+        if (waitStartedAtMs === null || waitCompletedAtMs === null) continue;
+        if (waitCompletedAtMs <= waitStartedAtMs) {
+            errors.push(`${waitPath}.completed_at must be after started_at`);
+            continue;
+        }
+        if (waitStartedAtMs < startedAtMs || waitCompletedAtMs > completedAtMs) {
+            errors.push(`${waitPath} must stay inside the planning flow`);
+            continue;
+        }
+        waits.push({
+            code,
+            startedAtMs: waitStartedAtMs,
+            completedAtMs: waitCompletedAtMs
+        });
+    }
+    waits.sort((a, b)=>a.startedAtMs - b.startedAtMs);
+    for(let index = 1; index < waits.length; index += 1){
+        if (waits[index].startedAtMs < waits[index - 1].completedAtMs) {
+            errors.push(`${path}.external_waits must not overlap`);
+        }
+    }
+    const externalWaitMs = waits.reduce((total, wait)=>total + wait.completedAtMs - wait.startedAtMs, 0);
+    const activeSeconds = (completedAtMs - startedAtMs - externalWaitMs) / 1_000;
+    if (activeSeconds <= 0) errors.push(`${path} must have positive active planning duration`);
+    return nonEmptyString(flowId) ? {
+        activeSeconds: round(activeSeconds),
+        completedAtMs,
+        flowId,
+        startedAtMs
+    } : null;
+}
+function invalidReport(errors, schema = '', evidenceKind = '') {
+    return {
+        schema: 'memory_value_report.v1',
+        contract_valid: false,
+        errors,
+        source: {
+            fixture_schema: schema,
+            evidence_kind: evidenceKind,
+            quantile_method: 'nearest_rank',
+            active_duration_rule: 'wall_clock_minus_non_overlapping_predeclared_external_waits'
+        },
+        cohort: {
+            eligible_pair_count: 0,
+            first_active_seconds: {
+                p50: 0,
+                p75: 0
+            },
+            returning_active_seconds: {
+                p50: 0,
+                p75: 0
+            },
+            paired_reduction_ratio: {
+                p50: 0,
+                p75: 0
+            },
+            target_median_reduction_ratio: 0,
+            target_met: false,
+            minimum_pair_count_for_exit: 0,
+            sample_size_met: false
+        },
+        experience_reflux: {
+            recalled_experience_count: 0,
+            verified_experience_count: 0,
+            baseline: null,
+            baseline_available: false,
+            real_evidence: false
+        },
+        preference_assertions: {
+            total_count: 0,
+            traceable_count: 0,
+            traceable_ratio: 0,
+            hard_filter_violation_count: 0,
+            contract_met: false
+        },
+        p4: {
+            state: 'unknown',
+            trigger_observed: false,
+            contract_met: false
+        },
+        exit_evidence_eligible: false,
+        exit_ready: false
+    };
+}
+export function scoreMemoryValue(input) {
+    const errors = [];
+    if (!isObject(input)) return invalidReport([
+        'root must be an object'
+    ]);
+    const schema = nonEmptyString(input.schema) ? input.schema : '';
+    const evidenceKind = nonEmptyString(input.evidence_kind) ? input.evidence_kind : '';
+    if (schema !== 'memory_value_fixture.v1') errors.push('schema must be memory_value_fixture.v1');
+    if (![
+        'synthetic_fixture',
+        'observed_private'
+    ].includes(evidenceKind)) {
+        errors.push('evidence_kind must be synthetic_fixture or observed_private');
+    }
+    const policy = input.measurement_policy;
+    if (!isObject(policy)) return invalidReport([
+        ...errors,
+        'measurement_policy must be an object'
+    ], schema, evidenceKind);
+    if (policy.quantile_method !== 'nearest_rank') errors.push('measurement_policy.quantile_method must be nearest_rank');
+    const rawWaitCodes = policy.predeclared_external_wait_codes;
+    const allowedWaitCodes = new Set();
+    if (!Array.isArray(rawWaitCodes) || rawWaitCodes.length === 0) {
+        errors.push('measurement_policy.predeclared_external_wait_codes must be a non-empty array');
+    } else {
+        for (const code of rawWaitCodes){
+            if (nonEmptyString(code)) allowedWaitCodes.add(code);
+            else errors.push('measurement_policy.predeclared_external_wait_codes must contain non-empty strings');
+        }
+    }
+    const minimumPairCount = policy.minimum_pair_count_for_exit;
+    const targetReduction = policy.target_median_reduction_ratio;
+    if (!Number.isInteger(minimumPairCount) || minimumPairCount <= 0) {
+        errors.push('measurement_policy.minimum_pair_count_for_exit must be a positive integer');
+    }
+    if (!finiteNumber(targetReduction) || targetReduction < 0 || targetReduction > 1) {
+        errors.push('measurement_policy.target_median_reduction_ratio must be between 0 and 1');
+    }
+    const rawPairs = input.pairs;
+    if (!Array.isArray(rawPairs) || rawPairs.length === 0) {
+        errors.push('pairs must be a non-empty array');
+    }
+    const firstDurations = [];
+    const returningDurations = [];
+    const reductions = [];
+    const pairIds = new Set();
+    const subjectRefs = new Set();
+    const flowIds = new Set();
+    for (const [index, rawPair] of (Array.isArray(rawPairs) ? rawPairs : []).entries()){
+        const pairPath = `pairs[${index}]`;
+        if (!isObject(rawPair)) {
+            errors.push(`${pairPath} must be an object`);
+            continue;
+        }
+        if (!nonEmptyString(rawPair.pair_id)) errors.push(`${pairPath}.pair_id must be non-empty`);
+        else if (pairIds.has(rawPair.pair_id)) errors.push(`${pairPath}.pair_id must be unique`);
+        else pairIds.add(rawPair.pair_id);
+        if (!nonEmptyString(rawPair.subject_ref)) {
+            errors.push(`${pairPath}.subject_ref must be a non-empty pseudonymous reference`);
+        } else if (subjectRefs.has(rawPair.subject_ref)) {
+            errors.push(`${pairPath}.subject_ref must be unique across the paired cohort`);
+        } else {
+            subjectRefs.add(rawPair.subject_ref);
+        }
+        const first = scoreFlow(rawPair.first, `${pairPath}.first`, 1, allowedWaitCodes, errors);
+        const returning = scoreFlow(rawPair.returning, `${pairPath}.returning`, 2, allowedWaitCodes, errors);
+        for (const flow of [
+            first,
+            returning
+        ]){
+            if (!flow) continue;
+            if (flowIds.has(flow.flowId)) errors.push(`${pairPath} flow_id values must be globally unique`);
+            flowIds.add(flow.flowId);
+        }
+        if (!first || !returning || first.activeSeconds <= 0 || returning.activeSeconds <= 0) continue;
+        if (returning.startedAtMs <= first.completedAtMs) {
+            errors.push(`${pairPath}.returning must start after the first completed flow`);
+        }
+        firstDurations.push(first.activeSeconds);
+        returningDurations.push(returning.activeSeconds);
+        reductions.push(round((first.activeSeconds - returning.activeSeconds) / first.activeSeconds));
+    }
+    const rawRefluxEvents = input.experience_reflux_events;
+    if (!Array.isArray(rawRefluxEvents)) errors.push('experience_reflux_events must be an array');
+    const recalled = new Set();
+    const verified = new Set();
+    for (const [index, rawEvent] of (Array.isArray(rawRefluxEvents) ? rawRefluxEvents : []).entries()){
+        const eventPath = `experience_reflux_events[${index}]`;
+        if (!isObject(rawEvent)) {
+            errors.push(`${eventPath} must be an object`);
+            continue;
+        }
+        if (!nonEmptyString(rawEvent.experience_id)) {
+            errors.push(`${eventPath}.experience_id must be non-empty`);
+            continue;
+        }
+        if (!nonEmptyString(rawEvent.evidence_ref)) errors.push(`${eventPath}.evidence_ref must be non-empty`);
+        if (rawEvent.kind === 'recalled') recalled.add(rawEvent.experience_id);
+        else if (rawEvent.kind === 'verified_outcome') verified.add(rawEvent.experience_id);
+        else errors.push(`${eventPath}.kind must be recalled or verified_outcome`);
+    }
+    for (const experienceId of verified){
+        if (!recalled.has(experienceId)) errors.push(`verified experience ${experienceId} must have a recalled event`);
+    }
+    const verifiedRecalledCount = [
+        ...verified
+    ].filter((id)=>recalled.has(id)).length;
+    const refluxBaseline = recalled.size > 0 ? round(verifiedRecalledCount / recalled.size) : null;
+    const rawAssertions = input.preference_assertions;
+    if (!Array.isArray(rawAssertions)) errors.push('preference_assertions must be an array');
+    let traceableCount = 0;
+    let hardFilterViolationCount = 0;
+    const assertions = Array.isArray(rawAssertions) ? rawAssertions : [];
+    for (const [index, rawAssertion] of assertions.entries()){
+        const assertionPath = `preference_assertions[${index}]`;
+        if (!isObject(rawAssertion)) {
+            errors.push(`${assertionPath} must be an object`);
+            continue;
+        }
+        if (!nonEmptyString(rawAssertion.assertion_id)) errors.push(`${assertionPath}.assertion_id must be non-empty`);
+        if (nonEmptyString(rawAssertion.evidence_ref)) traceableCount += 1;
+        if (rawAssertion.hard_filter === true || rawAssertion.consumer === 'hard_filter') hardFilterViolationCount += 1;
+    }
+    const traceableRatio = assertions.length > 0 ? round(traceableCount / assertions.length) : 0;
+    const assertionContractMet = assertions.length > 0 && traceableRatio === 1 && hardFilterViolationCount === 0;
+    const rawP4 = input.p4;
+    let p4State = 'unknown';
+    let p4TriggerObserved = false;
+    if (!isObject(rawP4) || !isObject(rawP4.triggers)) {
+        errors.push('p4.state and p4.triggers must be declared');
+    } else {
+        if (nonEmptyString(rawP4.state)) p4State = rawP4.state;
+        else errors.push('p4.state must be non-empty');
+        p4TriggerObserved = rawP4.triggers.real_usage === true || rawP4.triggers.multi_user === true;
+    }
+    const p4ContractMet = p4TriggerObserved || p4State === 'closed';
+    if (errors.length > 0) return invalidReport(errors, schema, evidenceKind);
+    const medianReduction = nearestRank(reductions, 0.5);
+    const numericMinimumPairCount = minimumPairCount;
+    const numericTargetReduction = targetReduction;
+    const sampleSizeMet = firstDurations.length >= numericMinimumPairCount;
+    const targetMet = medianReduction >= numericTargetReduction;
+    const exitEvidenceEligible = evidenceKind === 'observed_private';
+    const baselineAvailable = refluxBaseline !== null;
+    const exitReady = exitEvidenceEligible && sampleSizeMet && targetMet && baselineAvailable && assertionContractMet && p4ContractMet;
+    return {
+        schema: 'memory_value_report.v1',
+        contract_valid: true,
+        errors: [],
+        source: {
+            fixture_schema: schema,
+            evidence_kind: evidenceKind,
+            quantile_method: 'nearest_rank',
+            active_duration_rule: 'wall_clock_minus_non_overlapping_predeclared_external_waits'
+        },
+        cohort: {
+            eligible_pair_count: firstDurations.length,
+            first_active_seconds: {
+                p50: nearestRank(firstDurations, 0.5),
+                p75: nearestRank(firstDurations, 0.75)
+            },
+            returning_active_seconds: {
+                p50: nearestRank(returningDurations, 0.5),
+                p75: nearestRank(returningDurations, 0.75)
+            },
+            paired_reduction_ratio: {
+                p50: medianReduction,
+                p75: nearestRank(reductions, 0.75)
+            },
+            target_median_reduction_ratio: numericTargetReduction,
+            target_met: targetMet,
+            minimum_pair_count_for_exit: numericMinimumPairCount,
+            sample_size_met: sampleSizeMet
+        },
+        experience_reflux: {
+            recalled_experience_count: recalled.size,
+            verified_experience_count: verifiedRecalledCount,
+            baseline: refluxBaseline,
+            baseline_available: baselineAvailable,
+            real_evidence: exitEvidenceEligible
+        },
+        preference_assertions: {
+            total_count: assertions.length,
+            traceable_count: traceableCount,
+            traceable_ratio: traceableRatio,
+            hard_filter_violation_count: hardFilterViolationCount,
+            contract_met: assertionContractMet
+        },
+        p4: {
+            state: p4State,
+            trigger_observed: p4TriggerObserved,
+            contract_met: p4ContractMet
+        },
+        exit_evidence_eligible: exitEvidenceEligible,
+        exit_ready: exitReady
+    };
+}
+function main() {
+    const inputPath = process.argv[2];
+    if (!inputPath) {
+        console.error('usage: npx tsx scripts/memory-value-report.ts <fixture-or-private-manifest.json>');
+        process.exitCode = 2;
+        return;
+    }
+    let input;
+    try {
+        input = JSON.parse(readFileSync(resolve(inputPath), 'utf8'));
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`cannot read memory value input: ${message}`);
+        process.exitCode = 2;
+        return;
+    }
+    const report = scoreMemoryValue(input);
+    console.log(JSON.stringify(report, null, 2));
+    if (!report.contract_valid) process.exitCode = 2;
+}
+const invokedPath = process.argv[1] ? pathToFileURL(resolve(process.argv[1])).href : '';
+if (import.meta.url === invokedPath) main();
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/memory-value-report.ts