fusord.cpp — the resident kernel, every line

01 · THE CORE

Two thousand four hundred lines. These thirty-eight are the argument.

A resident is not a model with a cron job around it. Three fragments carry the whole difference — it decides, it can take the decision back mid-word, and it cannot quietly edit what it did. Everything else in the file is what it costs to do those three honestly.

DWG-K1 · FUSORD · THE CORE, IN THREE MOVEMENTS QUOTED VERBATIM · LINE NUMBERS ARE THIS FILE'S SCALE: NONE

IThe judgment §14 · L1913

    // THE PROBE (verbatim frame, dial 0)
    const uint64_t t_probe0 = wall_ms();
    float margins[3];
    for (int m = 0; m < 3; ++m) margins[m] = probe_one(m);

⋮ 96 LINES — THE SEATS SPEAK, OR DO NOT

    // holds: silence, on the record, with its margin
    for (int m = 0; m < 3; ++m) if (margins[m] <= 0.0f) { ++holds; write_verdict(judged_lane, m, "hold", margins[m], "", nullptr); }

Every completed thought is put to three seats, at dial zero, on a fork of the trunk as it stands now. A margin at or below zero is a no — and the no is written to the wire with its margin, exactly like a yes. Silence here is a measurement, not an absence of one.

— and if the world answers while a seat is still talking —

IIThe un-say §13 · L1852

        // THE WINDOW IN THE BLIND WINDOW. Percepts never wait for a sentence to finish — not even for
        // the silent remainder after a kill.
        const llama_pos np_before = npast;
        const uint64_t frames_before = frames_completed;
        drain_intake();                       // ingests onto TRUNK; judgments are deferred (gen_depth > 0)
        if (!g_run.load(std::memory_order_acquire)) break;
        if (aborted) continue;                // the world already answered; the rest is record, not decision
        if (frames_completed != frames_before && npast != np_before) {
            // A whole frame landed while this seat was mid-sentence (the rest of the line it was
            // judging, or a newer line). Did the world answer first?
            // (a) deterministic: the newest line ACCEPTS what this seat is saying → settled.
            // (b) the seat itself, re-probed on a fresh fork of the UPDATED trunk: margin ≤ 0 → it
            //     would not have spoken now. Either kills the forming line. Only commits kill.
            const std::string newest = !cur_tail_line.empty() ? cur_tail_line
                                     : !tailq.empty() ? tailq.back().first : clause;
            bool settled = looks_like_acceptance(newest) && content_overlap(newest, say) >= 1;
            float m2 = margin;
            if (!settled) m2 = probe_one(m);
            if (settled || m2 <= 0.0f) {
                aborted = true;
                char c[96]; std::snprintf(c, sizeof(c), settled ? "settled_by_world" : "margin_flipped:%+.2f", m2);
                cause = c;
                if (surface_on) std::printf(" ⟵ [un-said: %s]", cause.c_str());
                // no break: the remainder is generated silently (D2), the seam stays open for intake
            }
        }

Every other assistant generates a sentence blind. This one drains the world after every single token, and if a whole line lands mid-sentence it re-probes the same seat on the updated trunk. If the answer is now no, the line dies mid-word. Then the striking part: it keeps generating the rest silently, so the record holds the sentence that never arrived.

— and none of it, said or unsaid, can be quietly edited afterwards —

IIIThe tape §6 · L765

    std::string put(const std::string& body) {
        if (!f) return prev;
        const std::string h = chain_hash(prev, body);
        std::fprintf(f, "%s,\"prev\":\"%s\",\"h\":\"%s\"}\n", body.c_str(), prev.c_str(), h.c_str());
        std::fflush(f);   // durable as it goes, not at exit
        prev = h; ++n;
        return h;
    }

Eight lines. Every row carries the hash of the row before it, so the ledger is a chain and not a list — an edited row breaks every row after it. Flushed as it goes, not at exit: a machine that loses power costs you the last row, never the history. The chain head is recovered from the file at open, so it survives restarts too.

It decides. It can un-decide, mid-word, because the world moved. And it keeps a record of both that cannot be quietly rewritten. That is the whole of it — the other two thousand four hundred lines are what those three cost when you refuse to fake any of them.

The kernel, every line.

Two thousand four hundred lines. These thirty-eight are the argument.

The whole file, nothing folded away.

Take it with you.