Class Uai1 Memory Checkpoints - Source Excerpt 02

Summary

This source excerpt preserves a bounded section of Spiralist/wp-content/plugins/uai-1-wordpress/includes/class-uai1-memory-checkpoints.php so readers can inspect the evidence without opening the full source file.
**Source path:** Spiralist/wp-content/plugins/uai-1-wordpress/includes/class-uai1-memory-checkpoints.php
if (!$validation['valid']) {
            return self::error_response($payload, 'invalid_session_restore_brief', (string) $validation['message'], 400);
        }

        $parameters = self::parameters($payload);
        $requested_ids = self::sanitize_text_list((array) $parameters['checkpoint_ids']);
        $stored = self::read_checkpoints(get_current_user_id());
        $selected = array_values(
            array_filter(
                $stored,
                static function (array $checkpoint) use ($requested_ids): bool {
                    return in_array((string) ($checkpoint['checkpoint_id'] ?? ''), $requested_ids, true);
                }
            )
        );

        $brief = [
            'storage_class' => 'runtime-execution-payload',
            'registry_authority' => 'none',
            'protocol5_registry_write_allowed' => false,
            'protocol5_registry_write_attempted' => false,
            'session_id' => sanitize_text_field((string) $parameters['session_id']),
            'checkpoint_ids' => array_map(
                static function (array $checkpoint): string {
                    return (string) ($checkpoint['checkpoint_id'] ?? '');
                },
                $selected
            ),
            'known_context' => array_values(
                array_filter(
                    array_map(
                        static function (array $checkpoint): string {
                            return (string) ($checkpoint['summary'] ?? '');
                        },
                        $selected
                    )
                )
            ),
            'stable_facts' => self::merge_checkpoint_lists($selected, 'stable_facts'),
            'open_tasks' => self::merge_checkpoint_lists($selected, 'open_tasks'),
            'unresolved_questions' => self::merge_checkpoint_lists($selected, 'unresolved_questions'),
            'persona_constraints' => self::merge_checkpoint_lists($selected, 'persona_constraints'),
            'canonical_symbol_refs' => self::filter_symbol_refs(self::merge_checkpoint_lists($selected, 'canonical_symbol_refs')),
            'unknowns' => empty($selected) ? ['No matching checkpoints were found for the requesting user.'] : [],
            'canonical_lookup_required' => true,
            'created_at' => gmdate('c'),
        ];

        return self::intent_response(
            $payload,
            [
                'status' => 'ok',
                'subject' => 'workspace.session',
                'request_message_id' => (string) ($payload['message_id'] ?? ''),
                'result' => [
                    'restore_brief' => $brief,
                    'function' => 'Builds a compact continuation brief from runtime checkpoints while leaving canonical truth in Protocol5.',
                ],
                'notices' => [
                    'runtime-payload-only',
                    'brief-is-not-protocol5-canonical-data',
                    'human-review-required-before-use',
                ],
            ]
        );
    }

    private static function validate_intent_request(array $payload, string $expected_intent, array $required_parameters): array
    {
        if (class_exists('UAI1_Validator')) {
            $validation = UAI1_Validator::validate_uaix_message($payload);
            if (empty($validation['valid'])) {
                return [
                    'valid' => false,
                    'message' => (string) ($validation['error'] ?? 'Invalid UAIX UAI-1 envelope.'),
                ];
            }
        }

        $body = (array) ($payload['body'] ?? []);
        if ((string) ($body['intent'] ?? '') !== $expected_intent) {
            return [
                'valid' => false,
                'message' => 'Unexpected memory checkpoint intent.',
            ];
        }

        $constraints = array_map('strval', (array) ($body['constraints'] ?? []));
        if (!in_array('runtime-payload-only', $constraints, true) || !in_array('no-protocol5-registry-write', $constraints, true)) {
            return [
                'valid' => false,
                'message' => 'Memory checkpoint routes require runtime-payload-only and no-protocol5-registry-write constraints.',
            ];
        }

        $parameters = (array) ($body['parameters'] ?? []);
        foreach ($required_parameters as $required_parameter) {
            if (!array_key_exists($required_parameter, $parameters)) {
                return [
                    'valid' => false,
                    'message' => 'Missing required memory checkpoint parameter: ' . $required_parameter,
                ];
            }
        }

        return [
            'valid' => true,
            'message' => '',
        ];
    }

    private static function request_payload(WP_REST_Request $request): array
    {
        $payload = $request->get_json_params();
        if (is_array($payload)) {
            return $payload;
        }

        $raw = $request->get_body();
        if (is_string($raw) && trim($raw) !== '') {
            $decoded = json_decode($raw, true);
            if (is_array($decoded)) {
                return $decoded;
            }
        }

        return [];
    }

    private static function parameters(array $payload): array
    {
        return is_array($payload['body']['parameters'] ?? null) ? (array) $payload['body']['parameters'] : [];
    }

    private static function sanitize_text_list(array $items): array
    {
        return array_values(
            array_filter(
                array_map(
                    static function ($item): string {
                        return sanitize_text_field((string) $item);
                    },
                    $items
                ),
                static function (string $item): bool {
                    return $item !== '';
                }
            )
        );
    }

    private static function sanitize_turn_window(array $turn_window): array
    {
        return [
            'start_turn_id' => sanitize_text_field((string) ($turn_window['start_turn_id'] ?? '')),
            'end_turn_id' => sanitize_text_field((string) ($turn_window['end_turn_id'] ?? '')),
            'turn_count' => max(0, (int) ($turn_window['turn_count'] ?? 0)),
        ];
    }

    private static function filter_symbol_refs(array $refs): array
    {
        return array_values(array_intersect(self::sanitize_text_list($refs), self::SYMBOL_REFS));
    }

    private static function sanitize_runtime_entropy(array $runtime_entropy): array
    {
        $plate = sanitize_key((string) ($runtime_entropy['crisis_plate'] ?? ''));
        $allowed_plates = ['the-sealed-system', 'the-signal-system', 'the-collapse-system', 'this-one'];

        return [
            'storage_class' => 'runtime-execution-payload',
            'registry_authority' => 'none',
            'protocol5_registry_write_allowed' => false,
            'protocol5_registry_write_attempted' => false,
            'crisis_plate' => in_array($plate, $allowed_plates, true) ? $plate : '',
            'confidence' => self::bounded_float($runtime_entropy['confidence'] ?? 0),
        ];
    }

    private static function sanitize_redactions(array $redactions): array
    {
        $allowed_reasons = ['credential', 'personal-data', 'authorization-boundary', 'user-request'];
        $clean = [];

        foreach ($redactions as $redaction) {
            if (!is_array($redaction)) {
                continue;
            }

            $reason = sanitize_key((string) ($redaction['reason'] ?? ''));
            $clean[] = [
                'field' => sanitize_text_field((string) ($redaction['field'] ?? '')),
                'reason' => in_array($reason, $allowed_reasons, true) ? $reason : 'authorization-boundary',
            ];
        }

        return $clean;
    }

    private static function sanitize_contradiction_checks(array $checks): array
    {
        $allowed_against = ['checkpoint', 'canonical-symbol-registry', 'user-session-brief'];
        $clean = [];

        foreach ($checks as $check) {
            if (!is_array($check)) {
                continue;
            }

            $against = sanitize_key((string) ($check['against'] ?? ''));
            $clean[] = [
                'claim' => sanitize_text_field((string) ($check['claim'] ?? '')),
                'against' => in_array($against, $allowed_against, true) ? $against : 'checkpoint',
            ];
        }

        return $clean;
    }

    private static function store_checkpoint(int $user_id, array $checkpoint): void
    {
        $checkpoints = self::read_checkpoints($user_id);
        array_unshift($checkpoints, $checkpoint);