002 cross session discharge

// Test: Cross-session handle discharge
// The core bridge scenario: create handle in run 1, discharge in run 2
//
// This is the Hollywood OS pattern - state persists across turns,
// human or AI can act on resources created in previous turns.

~import std/runtime
~import std/io

const std = @import("std");
const HandlePool = @import("root").koru_std.koru_interpreter.HandlePool;

// External pool - the bridge
var bridge_pool = HandlePool.init(std.heap.page_allocator);

// Events with obligations
~pub tor open { path: string } -> string<opened!>

~open -> "file_1"

~pub tor close { handle: string<!opened> }

~proc close|zig {
    std.debug.print("close() called for handle\n", .{});
}

~std/runtime:register(scope: "files") {
    open(10)
    close(1)
}

// Session 1: Open a file (creates obligation). `open` is a bare return, so the
// value binds — there is no `| opened` branch to ask for, and asking for one
// was what killed this test from the day it was written.
const SESSION_1 = "open(path: \"test.txt\")";

// Session 2: Close the file (discharges obligation). `close` returns nothing,
// so there is no branch here either.
const SESSION_2 = "close(handle: \"file_1\")";

// Run session 1 - creates handle on bridge
~std/runtime:run(source: SESSION_1, scope: "files", budget: 100, handle_pool: &bridge_pool, auto_discharge: false)
| result r1 |> run-session-2(handles_after_open: r1.handles)
    | done d |> std/io:print.ln("PASS: open={{ d.after_open:d }}, close={{ d.after_close:d }}")
    | fail f |> std/io:print.ln("FAIL: {{ f:s }}")
| exhausted _ |> std/io:print.ln("FAIL: session 1 exhausted")
| parse-error _ |> std/io:print.ln("FAIL: session 1 parse_error")
| validation-error _ |> std/io:print.ln("FAIL: session 1 validation_error")
| shape-error _ |> std/io:print.ln("FAIL: session 1 shape_error")
| event-denied _ |> std/io:print.ln("FAIL: session 1 event_denied")
| dispatch-error _ |> std/io:print.ln("FAIL: session 1 dispatch_error")
| scope-not-found _ |> std/io:print.ln("FAIL: session 1 scope_not_found")

// Helper event to run session 2 and report both counts
~tor run-session-2 { handles_after_open: u32 }
| done { after_open: u32, after_close: u32 }
| fail string

~proc run-session-2|zig {
    std.debug.print("Session 1 left {} handle(s) on bridge\n", .{handles_after_open});

    // Run session 2 to discharge the handle
    const result = @import("root").koru_std.koru_runtime.run_event.handler(.{
        .source = SESSION_2,
        .scope = "files",
        .budget = 100,
        .handle_pool = &bridge_pool,
        .auto_discharge = false,
    });

    switch (result) {
        .result => |r| {
            std.debug.print("Session 2 complete, {} handle(s) remaining\n", .{r.handles});
            return .{ .done = .{ .after_open = handles_after_open, .after_close = r.handles } };
        },
        .exhausted => return .{ .fail = "session 2 exhausted" },
        .parse_error => return .{ .fail = "session 2 parse error" },
        .validation_error => return .{ .fail = "session 2 validation error" },
        .shape_error => return .{ .fail = "session 2 shape error" },
        .event_denied => return .{ .fail = "session 2 event denied" },
        .dispatch_error => return .{ .fail = "session 2 dispatch error" },
        .scope_not_found => return .{ .fail = "session 2 scope not found" },
    }
}