looply-cli 0.0.0-stage → 0.2.0

package/dist/session-checkpoint-runtime.js

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATE_SUBDIR = exports.DEFAULT_CHECKPOINT_LIMITS = void 0;
+exports.measureWorkspace = measureWorkspace;
+exports.writeCheckpoint = writeCheckpoint;
+exports.reportCheckpoint = reportCheckpoint;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const core_1 = require("@looply/core");
+const trusted_git_1 = require("./trusted-git");
+/**
+ * CAPTURING WHAT A SESSION LOOPLY COULD NOT ADOPT HAS ACTUALLY DONE.
+ *
+ * `session-checkpoint.ts` decides; this reads the tree and writes the export.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 A MANIFEST IS NOT AN EXPORT, AND THE CHARTER ASKS FOR AN EXPORT.
+ *
+ * A record saying "src/a.ts is modified" is a list of names. The thing a person
+ * needs in order to start a managed run from this work is the WORK: the diff of
+ * what changed and the contents of what is new. Writing only the names would be
+ * the offer-with-nothing-behind-it again, one level in.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 AN ABSOLUTE GIT PATH, NEVER THE BARE NAME. The cwd here is the workspace of
+ * a session this build REFUSED to adopt — the least trusted directory in the
+ * whole product — and on Windows the cwd is searched before PATH. A bare `git`
+ * would let that tree choose the program that reads it. This is the same defect
+ * a guard caught in the watcher, in a place where it would have been worse.
+ *
+ * ⚠️ AND THE CAPTURE IS BOUNDED. A session writes these files and is still
+ * writing them; an unbounded copy is this process doing unbounded work on the
+ * word of something it does not control. Hitting a bound is NAMED in the
+ * manifest, never silently truncated.
+ */
+/**
+ * 🔴 THE FIRST LINK ON THE WAY TO A PATH, OR NULL.
+ *
+ * ⚠️ AND IT CHECKS EVERY ANCESTOR, NOT THE FILE. `git ls-files --others`
+ * WALKS THROUGH A JUNCTION: with a junction at `src/link`, it reports
+ * `src/link/secret.txt` — a path whose final component lstats as an ordinary
+ * file. A check on that component alone sees nothing wrong and copies a file
+ * from outside the workspace into an export labelled as this session's work.
+ *
+ * Measured, not assumed: `ls-files --others` on a checkout with a directory
+ * junction returned exactly that path, and `lstat` of the junction itself
+ * returned `isSymbolicLink() === true` — which is why the answer is to walk
+ * the prefixes rather than to trust the leaf.
+ */
+function linkOnTheWayTo(workspace, rel) {
+    // git reports forward slashes on every platform, so this splits on one.
+    const parts = rel.split('/').filter((p) => p !== '');
+    let at = (0, node_path_1.resolve)(workspace);
+    for (let i = 0; i < parts.length; i += 1) {
+        at = (0, node_path_1.join)(at, parts[i]);
+        try {
+            /**
+             * ⚠️ THE INDEX, NOT `indexOf`. A path can repeat a component
+             * (`src/x/src/y.ts`), and `indexOf` would name the FIRST occurrence -
+             * reporting a link at a place there is none while the real one goes
+             * unnamed.
+             */
+            if ((0, node_fs_1.lstatSync)(at).isSymbolicLink())
+                return parts.slice(0, i + 1).join('/');
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+exports.DEFAULT_CHECKPOINT_LIMITS = {
+    maxDiffBytes: 4 * 1024 * 1024,
+    maxUntrackedFiles: 500,
+    maxFileBytes: 4 * 1024 * 1024,
+};
+function git(workspace, args) {
+    const bin = (0, trusted_git_1.gitBinary)();
+    if (bin === null)
+        return null;
+    try {
+        return (0, node_child_process_1.execFileSync)(bin, [...(0, trusted_git_1.trustedGitArgs)(), ...args], {
+            cwd: workspace,
+            env: (0, trusted_git_1.trustedGitEnv)(process.env, workspace),
+            encoding: 'utf8',
+            maxBuffer: 64 * 1024 * 1024,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * What this machine can establish about the workspace.
+ *
+ * ⚠️ EVERY FAILURE IS `null`, NEVER AN EMPTY LIST. `checkpointVerdict` answers
+ * `unmeasurable` for a null and would produce a clean-looking checkpoint from an
+ * empty one — which is the single most consequential thing this file could get
+ * wrong, so the distinction is made here rather than left to a caller.
+ */
+/**
+ * 🔴 LOOPLY'S OWN STATE DIRECTORY IS NOT THE SESSION'S WORK, AND A LIVE RUN
+ * PROVED WHY IT MATTERS.
+ *
+ * The checkpoint store lives at `<workspace>/.looply/state/checkpoints`, and
+ * `git ls-files --others` lists everything under it. So the FIRST checkpoint
+ * copied the session's work; the SECOND copied the session's work AND the first
+ * checkpoint; a third would have copied both. Measured: 5 untracked files became
+ * 12 on the second run. Each capture contained every capture before it.
+ *
+ * ⚠️ AND IT WAS ALSO MISLABELLED. `.looply/state/sessions.jsonl` is looply's
+ * own ledger, and it landed in a directory labelled "this session's untracked
+ * work" — a product's bookkeeping presented as somebody else's output.
+ *
+ * ⚠️ ONLY `state` IS EXCLUDED, NOT ALL OF `.looply`. A session that created
+ * `.looply/config.yaml` really did create it, and dropping that would be a guess
+ * about what counts as work. `state` is this product's runtime bookkeeping by
+ * construction, which is not a guess.
+ */
+exports.STATE_SUBDIR = '.looply/state';
+function measureWorkspace(workspace, liveness, heldBy, stateSubdir = exports.STATE_SUBDIR) {
+    const revision = git(workspace, ['rev-parse', 'HEAD'])?.trim() ?? null;
+    /**
+     * ⚠️ `diff HEAD --name-only` AND NOT `diff --name-only`. The second omits
+     * anything already staged, and a session that ran `git add` would produce a
+     * checkpoint reporting its work as absent.
+     */
+    const dirtyOut = git(workspace, ['diff', 'HEAD', '--name-only']);
+    const untrackedOut = git(workspace, ['ls-files', '--others', '--exclude-standard']);
+    const lines = (text) => text === null ? null : text.split(/\r?\n/).filter((l) => l.trim() !== '');
+    const allUntracked = lines(untrackedOut);
+    const prefix = stateSubdir.replace(/\/+$/, '');
+    const mine = (p) => p === prefix || p.startsWith(prefix + '/');
+    const excluded = allUntracked === null ? [] : allUntracked.filter(mine);
+    return {
+        liveness,
+        revision,
+        dirty: lines(dirtyOut),
+        untracked: allUntracked === null ? null : allUntracked.filter((p) => !mine(p)),
+        heldBy,
+        excluded,
+    };
+}
+const atomicWrite = (path, body) => {
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(path), { recursive: true });
+    const tmp = `${path}.partial`;
+    const fd = (0, node_fs_1.openSync)(tmp, 'w');
+    try {
+        (0, node_fs_1.writeSync)(fd, body);
+    }
+    finally {
+        (0, node_fs_1.closeSync)(fd);
+    }
+    (0, node_fs_1.renameSync)(tmp, path);
+};
+/**
+ * Write the checkpoint: a manifest, the diff, and the untracked files.
+ *
+ * 🔴 THE MANIFEST IS WRITTEN LAST. Everything it names must already exist, or a
+ * crash mid-capture leaves a manifest describing an export that is not there —
+ * and a manifest is exactly what a later reader will trust.
+ */
+function writeCheckpoint(root, checkpoint, limits = exports.DEFAULT_CHECKPOINT_LIMITS) {
+    const dir = (0, node_path_1.join)(root, 'checkpoints', `${checkpoint.sessionId}-${checkpoint.takenAt.replace(/[:.]/g, '-')}`);
+    (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    const incomplete = [];
+    /* ── the diff of everything tracked, staged or not ─────────────────── */
+    let diffPath = null;
+    const diff = git(checkpoint.workspace, ['diff', 'HEAD']);
+    if (diff === null) {
+        incomplete.push('the diff could not be produced, so the tracked changes are named but not captured');
+    }
+    else if (diff.length > limits.maxDiffBytes) {
+        diffPath = (0, node_path_1.join)(dir, 'changes.patch');
+        atomicWrite(diffPath, diff.slice(0, limits.maxDiffBytes));
+        incomplete.push(`the diff is ${diff.length} bytes and was cut at ${limits.maxDiffBytes} — it is NOT a complete patch`);
+    }
+    else {
+        diffPath = (0, node_path_1.join)(dir, 'changes.patch');
+        atomicWrite(diffPath, diff);
+    }
+    /* ── the untracked files, which no diff contains ───────────────────── */
+    let copied = 0;
+    for (const rel of checkpoint.untracked) {
+        if (copied >= limits.maxUntrackedFiles) {
+            incomplete.push(`${checkpoint.untracked.length - copied} untracked file(s) were not copied — ${limits.maxUntrackedFiles} is the limit`);
+            break;
+        }
+        /**
+         * 🔴 THE LINK CHECK IS ON THE WHOLE PATH, NOT THE LEAF, AND A TEST
+         * FOUND OUT WHY. `git ls-files --others` walks THROUGH a junction: with one
+         * at `src/link` it reports `src/link/secret.txt`, whose final component is
+         * an ordinary file. Checking that component alone saw nothing wrong and
+         * copied a file from outside the workspace into an export labelled as this
+         * session's work.
+         */
+        const link = linkOnTheWayTo(checkpoint.workspace, rel);
+        if (link !== null) {
+            incomplete.push(`${rel} is reached through the link ${link} and was not followed — what it points at is not this session's work`);
+            continue;
+        }
+        const from = (0, node_path_1.resolve)(checkpoint.workspace, rel);
+        let st;
+        try {
+            st = (0, node_fs_1.lstatSync)(from);
+        }
+        catch {
+            incomplete.push(`${rel} vanished between being listed and being read`);
+            continue;
+        }
+        if (st.isSymbolicLink()) {
+            incomplete.push(`${rel} is a link and was not followed — what it points at is not this session's work`);
+            continue;
+        }
+        if (!st.isFile())
+            continue;
+        if (st.size > limits.maxFileBytes) {
+            incomplete.push(`${rel} is ${st.size} bytes, past the ${limits.maxFileBytes}-byte limit — not copied`);
+            continue;
+        }
+        const to = (0, node_path_1.join)(dir, 'untracked', rel);
+        try {
+            (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(to), { recursive: true });
+            (0, node_fs_1.copyFileSync)(from, to);
+            copied += 1;
+        }
+        catch (e) {
+            incomplete.push(`${rel} could not be copied: ${e.message}`);
+        }
+    }
+    const manifest = (0, node_path_1.join)(dir, 'CHECKPOINT.json');
+    atomicWrite(manifest, `${JSON.stringify({
+        ...checkpoint,
+        export: {
+            diff: diffPath === null ? null : 'changes.patch',
+            untrackedCopied: copied,
+            untrackedListed: checkpoint.untracked.length,
+        },
+        /**
+         * 🔴 THE INCOMPLETENESS TRAVELS WITH THE THING. A reader who has to
+         * compare two lists to notice a truncated patch will not notice it.
+         */
+        incomplete,
+        certifies: 'nothing. This records what was found in the workspace and when. It does not say the work is ' +
+            'correct, reviewed, complete or safe, and it does not adopt the session.',
+    }, null, 2)}\n`);
+    return { dir, manifest, diff: diffPath, copied, incomplete };
+}
+/** The lines a person reads, with what the export actually contains. */
+function reportCheckpoint(written, checkpoint, out, excluded = []) {
+    for (const line of (0, core_1.describeCheckpoint)(checkpoint))
+        out(line);
+    /**
+     * ⚠️ SAID, NOT SILENT. Leaving files out of a capture is exactly the kind
+     * of thing that has to be visible: a reader counting files would otherwise
+     * find fewer than `git status` shows and have no way to know why.
+     */
+    if (excluded.length > 0) {
+        out(`  ${excluded.length} file(s) under ${exports.STATE_SUBDIR} left out — looply's own bookkeeping, not this session's work`);
+    }
+    out(`  written to ${written.dir}`);
+    out(`  ${written.diff === null ? 'no patch' : 'changes.patch'}, ${written.copied} untracked file(s) copied`);
+    for (const gap of written.incomplete)
+        out(`  incomplete: ${gap}`);
+}
+//# sourceMappingURL=session-checkpoint-runtime.js.map

package/dist/session-checkpoint-runtime.js.map

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

package/dist/session-control-transport.d.ts

@@ -0,0 +1,106 @@
+import { type ControlVerdict, type SessionControlGrant } from '@looply/core';
+import { type AdapterPaths } from './session-adapter-runtime';
+import type { ServerSessionGrant } from './server-client';
+/**
+ * THE WIRE THAT TURNS F-14 ON.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHAT WAS SITTING UNCONNECTED. The fold, the grant table, the routes, the SDK
+ * reader, the adapter's two directories and the bounded watcher were all in
+ * place, and `sessions --offer` still printed *"this machine could not ask the
+ * server"* — because nothing in the CLI had ever asked it anything about a
+ * grant. `server.url` and `server.machine_token_file` were parsed by
+ * `config.ts` and read by NOBODY: a configuration block with no consumer, which
+ * is this codebase's most-named defect wearing different clothes.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 THE TWO HALVES COME FROM DIFFERENT PLACES ON PURPOSE.
+ *
+ *   the grant            the SERVER's, because authority is not this machine's
+ *                        to mint and a local file cannot hold it
+ *   the acknowledgement  the SESSION's own channel, because provenance is the
+ *                        one thing a server cannot observe about a process on
+ *                        somebody else's machine
+ *
+ * Collapsing either into the other is the failure this whole feature is about.
+ * A grant read from a local file is a machine authorizing itself; an
+ * acknowledgement taken from the server alone is whoever last POSTed one.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 `null` IS NOT `refused`, AND EVERY CALLER HERE HAS TO HANDLE BOTH.
+ *
+ * Unpaired, unregistered, unreachable — none of those is a decision anybody
+ * made about this session, and folding them into a refusal would put a
+ * plausible sentence on the screen where an absence of information belongs.
+ */
+export interface ControlTransportDeps {
+    /** This machine's identity, or null when it has not paired. */
+    machine(): {
+        readonly machineId: string;
+        readonly projectId: string;
+    } | null;
+    /** Grants for the project, or a throw. A throw is `null`, never a refusal. */
+    grants(projectId: string): Promise<readonly ServerSessionGrant[]>;
+    /** Record the acknowledgement on the server so its record matches this one. */
+    recordAck(projectId: string, grantId: string, ack: {
+        handshakeNonce: string;
+        sessionId: string;
+        workspace: string;
+        repositoryId: string;
+        scope: readonly string[];
+        via: 'adapter' | 'operator';
+    }): Promise<void>;
+    /** Where this session's inbox and outbox live. */
+    paths(sessionId: string): AdapterPaths;
+    supportedAdapters(): readonly string[];
+    now(): string;
+    /** Said out loud, because every one of these lines is a reason for observe-only. */
+    note(line: string): void;
+}
+/**
+ * One coherent answer about control, from ONE read of the grants.
+ *
+ * 🔴 THE VERDICT, THE SCOPE AND THE EXPIRY ALL COME FROM THE SAME GRANT.
+ * Fetching them separately opens a window in which they describe different
+ * grants — a verb checked against a scope that was superseded between two
+ * calls — so `directionContextFor` and `serverControlFor` are both this one
+ * function, narrowed.
+ */
+export interface ControlSnapshot {
+    readonly verdict: ControlVerdict;
+    readonly scope: readonly string[];
+    readonly expiresAt: string;
+}
+export declare function controlSnapshotFor(deps: ControlTransportDeps): (sessionId: string) => Promise<ControlSnapshot | null>;
+/**
+ * F40: THE OFFER REACHES THE SESSION, AND SO DOES THE REVOCATION.
+ *
+ * 🔴 MEASURED BEFORE LIVE-3: `offerFor` and `revocationFor` were called by tests and by nothing else, so
+ * every earlier proof had its test script put the handshake in the inbox — the script was the messenger,
+ * and the product could not establish control on its own. Delivered here, on the one read that already
+ * holds the live grant, into the session's inbox and NOWHERE ELSE: the note names the grant and its scope,
+ * never the nonce.
+ *
+ * ⚠️ ONCE PER GRANT. An offer already in the inbox is the same offer; a handshake acknowledged or spent
+ * is not offered again; an expired grant is not offered at all. A revocation is told once, so a
+ * cooperating session stops on its own — direction is refused by `mayDirect` either way.
+ */
+export declare function deliverControlNotice(paths: AdapterPaths, grant: SessionControlGrant, at: string, note: (line: string) => void): void;
+/**
+ * What the server and the session's own channel say about directing this
+ * session — the verdict alone, for callers that need nothing else.
+ */
+export declare function serverControlFor(deps: ControlTransportDeps): (sessionId: string) => Promise<ControlVerdict | null>;
+/**
+ * The same read, shaped for `mayDirect`.
+ *
+ * ⚠️ `null` HERE MEANS NOTHING WAS ESTABLISHED, and `mayDirect` turns that
+ * into `unmeasurable` rather than into an ending. An unreachable server is not
+ * a person withdrawing permission.
+ */
+export declare function directionContextFor(deps: ControlTransportDeps): (sessionId: string) => Promise<{
+    control: ControlVerdict;
+    scope: readonly string[];
+    expiresAt: string;
+} | null>;
+//# sourceMappingURL=session-control-transport.d.ts.map

package/dist/session-control-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-control-transport.d.ts","sourceRoot":"","sources":["../src/session-control-transport.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,cAAc,EAEnB,KAAK,mBAAmB,EACzB,MAAM,cAAc,CAAC;AACtB,OAAO,EAA6E,KAAK,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzI,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,MAAM,WAAW,oBAAoB;IACnC,+DAA+D;IAC/D,OAAO,IAAI;QAAE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAC7E,8EAA8E;IAC9E,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,kBAAkB,EAAE,CAAC,CAAC;IAClE,+EAA+E;IAC/E,SAAS,CACP,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,GAAG,EAAE;QACH,cAAc,EAAE,MAAM,CAAC;QACvB,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;QAClB,YAAY,EAAE,MAAM,CAAC;QACrB,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;QACzB,GAAG,EAAE,SAAS,GAAG,UAAU,CAAC;KAC7B,GACA,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,kDAAkD;IAClD,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,CAAC;IACvC,iBAAiB,IAAI,SAAS,MAAM,EAAE,CAAC;IACvC,GAAG,IAAI,MAAM,CAAC;IACd,oFAAoF;IACpF,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAuCD;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,oBAAoB,GAAG,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAgIrH;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,mBAAmB,EAC1B,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAC3B,IAAI,CAkBN;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,oBAAoB,GAAG,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAGlH;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,oBAAoB,GACzB,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;IAAE,OAAO,EAAE,cAAc,CAAC;IAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAMjH"}

package/dist/session-control-transport.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.controlSnapshotFor = controlSnapshotFor;
+exports.deliverControlNotice = deliverControlNotice;
+exports.serverControlFor = serverControlFor;
+exports.directionContextFor = directionContextFor;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const core_1 = require("@looply/core");
+const session_adapter_runtime_1 = require("./session-adapter-runtime");
+/**
+ * ⚠️ THE HIGHEST GENERATION WINS, AND EARLIER ONES ARE NOT CONSIDERED. A
+ * session that has been granted control twice has one live grant and a history;
+ * evaluating the history would let a spent generation answer for the current
+ * one, which is the shape `session-control.ts` calls "reviving a spent
+ * identity".
+ */
+function liveGrantFor(grants, sessionId) {
+    const mine = grants.filter((g) => g.sessionId === sessionId);
+    if (mine.length === 0)
+        return null;
+    return mine.reduce((best, g) => (g.generation > best.generation ? g : best));
+}
+/**
+ * ⚠️ `machineId` IS SUPPLIED BY THIS MACHINE, NEVER READ OFF THE WIRE. It is
+ * what `controlVerdict` compares the grant against, and a value the server
+ * chose would let the server tell a machine which machine it is.
+ */
+function asGrant(row, machineId) {
+    return {
+        id: row.id,
+        issuedBy: row.issuedBy,
+        machineId,
+        projectId: row.projectId,
+        repositoryId: row.repositoryId,
+        workspace: row.workspace,
+        sessionId: row.sessionId,
+        scope: row.scope,
+        handshakeNonce: row.handshakeNonce,
+        issuedAt: row.issuedAt,
+        expiresAt: row.expiresAt,
+        version: row.version,
+        state: row.state,
+        generation: row.generation,
+    };
+}
+function controlSnapshotFor(deps) {
+    return async (sessionId) => {
+        const identity = deps.machine();
+        if (identity === null) {
+            deps.note('this machine is not paired with a server, so nothing about control was established');
+            return null;
+        }
+        let rows;
+        try {
+            rows = await deps.grants(identity.projectId);
+        }
+        catch (e) {
+            deps.note(`the server could not be asked about control grants: ${e.message}`);
+            return null;
+        }
+        const row = liveGrantFor(rows, sessionId);
+        if (row === null) {
+            /**
+             * ⚠️ A REFUSAL STILL CARRIES A SCOPE AND AN EXPIRY, and they are empty
+             * and already-past on purpose: a caller that read them without looking at
+             * the verdict would find a grant that permits nothing and lapsed at the
+             * moment it asked. Failing closed in the shape as well as in the branch.
+             */
+            return {
+                verdict: { kind: 'refused', because: `no control grant has ever been issued for ${sessionId}` },
+                scope: [],
+                expiresAt: deps.now(),
+            };
+        }
+        const grant = asGrant(row, identity.machineId);
+        const at = deps.now();
+        const paths = deps.paths(sessionId);
+        /**
+         * 🔴 THE ACKNOWLEDGEMENT COMES FROM THE SESSION'S OWN OUTBOX, RULED BY THE
+         * FOLD. Nothing here decides whether a message is admissible; `ruleOnOutbox`
+         * does, inside `collectOutbox`, which is why the replay and identity rules
+         * are testable without a server.
+         */
+        const collected = (0, session_adapter_runtime_1.collectOutbox)(paths, { grant, supportedAdapters: deps.supportedAdapters(), at });
+        if (!collected.present) {
+            // F40: a session that has never answered is exactly the one that needs the offer.
+            deliverControlNotice(paths, grant, at, deps.note);
+            return {
+                verdict: { kind: 'refused', because: `${sessionId} has no outbox, so it has not acknowledged through its adapter` },
+                scope: grant.scope,
+                expiresAt: grant.expiresAt,
+            };
+        }
+        for (const blind of collected.unreadable)
+            deps.note(`outbox: ${blind}`);
+        let ack = null;
+        for (const { file, ruling } of collected.rulings) {
+            if (ruling.kind === 'accept') {
+                /**
+                 * 🔴 SPENT BEFORE ANYTHING ACTS ON IT. A crash between acting and
+                 * recording leaves a replayable handshake — the one thing the nonce
+                 * exists to prevent, reachable by pulling a plug at the right moment.
+                 * The cost of the other order is that a lost acknowledgement needs a
+                 * re-issued grant, which is an inconvenience with a person in the loop.
+                 */
+                (0, session_adapter_runtime_1.markSpent)(paths, ruling.ack.handshakeNonce, at, `acknowledged ${ruling.ack.grantId} from ${file}`, ruling.ack);
+                (0, session_adapter_runtime_1.archive)(paths, file);
+                /**
+                 * 🔴 AND IF THE SERVER CANNOT BE TOLD, NOTHING WAS ESTABLISHED. The
+                 * handshake is already spent, so this acknowledgement cannot be
+                 * presented again and the grant has to be re-issued — a real cost, paid
+                 * deliberately. Returning `controlled` on a local decision the server
+                 * has no record of would be two systems disagreeing about who may
+                 * direct a session, with neither able to see the other's answer.
+                 */
+                try {
+                    await deps.recordAck(identity.projectId, ruling.ack.grantId, {
+                        handshakeNonce: ruling.ack.handshakeNonce,
+                        sessionId: ruling.ack.sessionId,
+                        workspace: ruling.ack.workspace,
+                        repositoryId: ruling.ack.repositoryId,
+                        scope: ruling.ack.scope,
+                        via: ruling.ack.via,
+                    });
+                }
+                catch (e) {
+                    deps.note(`the session acknowledged, and the server could not be told: ${e.message}. ` +
+                        'That handshake is spent; a new grant is needed.');
+                    return null;
+                }
+                ack = ruling.ack;
+                break;
+            }
+            /**
+             * ⚠️ EVERY OTHER RULING IS SAID, NOT SWALLOWED. A declined grant, a
+             * replayed handshake and an unparseable file all leave the session at
+             * observe-only, and which one happened is the whole difference between
+             * "it said no", "somebody tried something" and "its adapter is broken".
+             */
+            if (ruling.kind === 'declined')
+                deps.note(`${file}: the session declined — ${ruling.because}`);
+            else if (ruling.kind === 'refused')
+                deps.note(`${file}: not accepted — ${ruling.because}`);
+            else
+                deps.note(`${file}: nothing established — ${ruling.because}`);
+        }
+        /**
+         * 🔴 AN ACKNOWLEDGEMENT ALREADY VALIDATED FOR THIS HANDSHAKE STILL COUNTS.
+         *
+         * A live run found this the hard way: `--offer` consumed the outbox message
+         * and archived it, and the next command answered "the session has not
+         * acknowledged this grant". Control lasted exactly one read. The
+         * acknowledgement is looked up by the LIVE grant's nonce, so a new grant
+         * still needs a new one — and the grant itself is re-read from the server
+         * every time, so revocation and expiry are unaffected.
+         */
+        if (ack === null)
+            ack = (0, session_adapter_runtime_1.validatedAck)(paths, grant.handshakeNonce);
+        // F40: unanswered, it is offered; revoked, the session is told (see `deliverControlNotice`).
+        if (ack === null || grant.state === 'revoked')
+            deliverControlNotice(paths, grant, at, deps.note);
+        return {
+            verdict: (0, core_1.controlVerdict)({
+                grant,
+                ack,
+                at,
+                asking: { machineId: identity.machineId, projectId: identity.projectId },
+            }),
+            scope: grant.scope,
+            expiresAt: grant.expiresAt,
+        };
+    };
+}
+/**
+ * F40: THE OFFER REACHES THE SESSION, AND SO DOES THE REVOCATION.
+ *
+ * 🔴 MEASURED BEFORE LIVE-3: `offerFor` and `revocationFor` were called by tests and by nothing else, so
+ * every earlier proof had its test script put the handshake in the inbox — the script was the messenger,
+ * and the product could not establish control on its own. Delivered here, on the one read that already
+ * holds the live grant, into the session's inbox and NOWHERE ELSE: the note names the grant and its scope,
+ * never the nonce.
+ *
+ * ⚠️ ONCE PER GRANT. An offer already in the inbox is the same offer; a handshake acknowledged or spent
+ * is not offered again; an expired grant is not offered at all. A revocation is told once, so a
+ * cooperating session stops on its own — direction is refused by `mayDirect` either way.
+ */
+function deliverControlNotice(paths, grant, at, note) {
+    if (grant.state === 'authorized') {
+        if (Date.parse(grant.expiresAt) <= Date.parse(at))
+            return;
+        if ((0, session_adapter_runtime_1.validatedAck)(paths, grant.handshakeNonce) !== null)
+            return;
+        if ((0, session_adapter_runtime_1.spentHandshakes)(paths).includes(grant.handshakeNonce))
+            return;
+        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(paths.inbox, `control-offered-${grant.id}.json`)))
+            return;
+        (0, session_adapter_runtime_1.deliver)(paths, (0, core_1.offerFor)(grant, at));
+        note(`offered control of ${grant.sessionId} through its inbox — grant ${grant.id}, scope ${grant.scope.join(', ')}, ` +
+            `until ${grant.expiresAt}; it has not acknowledged yet`);
+        return;
+    }
+    if (grant.state === 'revoked') {
+        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(paths.inbox, `control-revoked-${grant.id}.json`)))
+            return;
+        (0, session_adapter_runtime_1.deliver)(paths, (0, core_1.revocationFor)(grant, at, 'the owner revoked this grant'));
+        note(`told ${grant.sessionId} through its inbox that grant ${grant.id} was revoked`);
+    }
+}
+/**
+ * What the server and the session's own channel say about directing this
+ * session — the verdict alone, for callers that need nothing else.
+ */
+function serverControlFor(deps) {
+    const snapshot = controlSnapshotFor(deps);
+    return async (sessionId) => (await snapshot(sessionId))?.verdict ?? null;
+}
+/**
+ * The same read, shaped for `mayDirect`.
+ *
+ * ⚠️ `null` HERE MEANS NOTHING WAS ESTABLISHED, and `mayDirect` turns that
+ * into `unmeasurable` rather than into an ending. An unreachable server is not
+ * a person withdrawing permission.
+ */
+function directionContextFor(deps) {
+    const snapshot = controlSnapshotFor(deps);
+    return async (sessionId) => {
+        const snap = await snapshot(sessionId);
+        return snap === null ? null : { control: snap.verdict, scope: snap.scope, expiresAt: snap.expiresAt };
+    };
+}
+//# sourceMappingURL=session-control-transport.js.map

package/dist/session-control-transport.js.map

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