@descryy/mcp 0.1.0

package/dist/tools/propagation.d.ts

@@ -0,0 +1,74 @@
+/**
+ * `propagation` — "if I change this field, where does it come out?"
+ *
+ * §11.9's data-flow query. The honest answer depends entirely on resolution and
+ * the tool says so on every call rather than only when it goes wrong.
+ *
+ * **Field-level propagation requires R3.** §11A.6 is explicit: propagation
+ * compares *shapes*, not names, and shapes are what a type checker buys. Below
+ * R3 this query still returns something useful — the paths data *can* travel —
+ * but "where the `currency` field ends up" and "which functions this value can
+ * reach" are different claims, and only the second is provable at R2. The query
+ * layer already computes the floor and writes the note; this tool's job is to
+ * make sure a caller cannot receive the answer without it, and to refuse to
+ * dress a path-level answer up as a field-level one in its headline.
+ *
+ * ## The empty answer is several different answers
+ *
+ * The resolution guard above was the only guard here, and it protects the
+ * *quality* of a non-empty answer. It says nothing about an empty one.
+ *
+ * **`PROPAGATES_TO` has no producer.** No adapter emits it, and it is the first
+ * of the four edge types this walk follows — five of §11.5's six hops are that
+ * type. So on a real graph this tool returned `reached: []` and a headline
+ * reading *"X can reach 0 node(s)"*: a user asks what propagates and is told
+ * nothing propagates. That is §20.2's fourth category collapsing into its
+ * second, in the user-facing surface rather than in an instrument, and it is
+ * the same defect `hidden-dependency.ts` carries `analysed` for.
+ *
+ * So an empty walk is now attributed rather than reported. The tool probes the
+ * edges incident to the start node and reports which of the requested types it
+ * found. **It deliberately does not claim which cause applies** — a local probe
+ * cannot separate *no producer emits this edge type* from *this node has none
+ * of them*, and guessing between them would be the same overreach one level
+ * down. It names the candidates and says it cannot choose.
+ */
+import { type BriefNode, type NodeCandidates, type ToolDefinition } from "./kit.ts";
+/** A node the data can reach, with how far along the walk it sits. */
+export interface ReachedNode extends BriefNode {
+    readonly depth: number;
+    readonly score: number;
+}
+export interface PropagationReport {
+    readonly from: BriefNode;
+    /** Capped by `limit`; `reachedTotal` is the uncapped count. */
+    readonly reached: readonly ReachedNode[];
+    readonly reachedTotal: number;
+    /**
+     * True only at R3 and above.
+     *
+     * False means the answer is *where data can flow*, not *which field arrives
+     * where* — the second compares shapes and shapes need a type checker.
+     */
+    readonly fieldLevel: boolean;
+    /**
+     * False when no edge of any walked type touches the start node.
+     *
+     * **An empty `reached` with `analysed: false` means the walk did not run**,
+     * not that nothing propagates. `PROPAGATES_TO` has no producer today, so
+     * this is the common case rather than the exotic one.
+     */
+    readonly analysed: boolean;
+    readonly edgeTypesWalked: readonly string[];
+    /** The subset of `edgeTypesWalked` actually found on an edge touching this node. */
+    readonly edgeTypesPresent: readonly string[];
+}
+/**
+ * One call, two shapes — narrow on `"from" in data`.
+ *
+ * `NodeCandidates` arrives when the symbol did not resolve to exactly one
+ * node, and nothing was walked.
+ */
+export type PropagationData = PropagationReport | NodeCandidates;
+export declare const propagationTool: ToolDefinition;
+//# sourceMappingURL=propagation.d.ts.map

package/dist/tools/propagation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"propagation.d.ts","sourceRoot":"","sources":["../../src/tools/propagation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAIH,OAAO,EAOL,KAAK,SAAS,EACd,KAAK,cAAc,EAEnB,KAAK,cAAc,EACpB,MAAM,UAAU,CAAC;AAGlB,sEAAsE;AACtE,MAAM,WAAW,WAAY,SAAQ,SAAS;IAC5C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,+DAA+D;IAC/D,QAAQ,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;IACzC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5C,oFAAoF;IACpF,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9C;AAED;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,iBAAiB,GAAG,cAAc,CAAC;AAsKjE,eAAO,MAAM,eAAe,EAAE,cAY7B,CAAC"}

package/dist/tools/propagation.js

@@ -0,0 +1,194 @@
+/**
+ * `propagation` — "if I change this field, where does it come out?"
+ *
+ * §11.9's data-flow query. The honest answer depends entirely on resolution and
+ * the tool says so on every call rather than only when it goes wrong.
+ *
+ * **Field-level propagation requires R3.** §11A.6 is explicit: propagation
+ * compares *shapes*, not names, and shapes are what a type checker buys. Below
+ * R3 this query still returns something useful — the paths data *can* travel —
+ * but "where the `currency` field ends up" and "which functions this value can
+ * reach" are different claims, and only the second is provable at R2. The query
+ * layer already computes the floor and writes the note; this tool's job is to
+ * make sure a caller cannot receive the answer without it, and to refuse to
+ * dress a path-level answer up as a field-level one in its headline.
+ *
+ * ## The empty answer is several different answers
+ *
+ * The resolution guard above was the only guard here, and it protects the
+ * *quality* of a non-empty answer. It says nothing about an empty one.
+ *
+ * **`PROPAGATES_TO` has no producer.** No adapter emits it, and it is the first
+ * of the four edge types this walk follows — five of §11.5's six hops are that
+ * type. So on a real graph this tool returned `reached: []` and a headline
+ * reading *"X can reach 0 node(s)"*: a user asks what propagates and is told
+ * nothing propagates. That is §20.2's fourth category collapsing into its
+ * second, in the user-facing surface rather than in an instrument, and it is
+ * the same defect `hidden-dependency.ts` carries `analysed` for.
+ *
+ * So an empty walk is now attributed rather than reported. The tool probes the
+ * edges incident to the start node and reports which of the requested types it
+ * found. **It deliberately does not claim which cause applies** — a local probe
+ * cannot separate *no producer emits this edge type* from *this node has none
+ * of them*, and guessing between them would be the same overreach one level
+ * down. It names the candidates and says it cannot choose.
+ */
+import { dataFlowFrom, DATA_FLOW_EDGE_TYPES } from "@descryy/core";
+import { answer, briefNode, optionalInteger, optionalString, optionalStringArray, ToolInputError, } from "./kit.js";
+import { resolveOneNode } from "./lookup.js";
+const SCHEMA = {
+    type: "object",
+    properties: {
+        nodeId: { type: "string", description: "Graph node id to start from." },
+        symbol: {
+            type: "string",
+            description: "Symbol name to start from, when you do not have a node id. Ambiguity is reported rather " +
+                "than guessed at — narrow it with \"file\".",
+        },
+        file: {
+            type: "string",
+            description: "Repository-relative path, to disambiguate \"symbol\" or to start from a file.",
+        },
+        edgeTypes: {
+            type: "array",
+            items: { type: "string" },
+            description: "Restrict the walk. Defaults to PROPAGATES_TO, READS, WRITES and RETURNS — the four that " +
+                "carry data rather than control.",
+        },
+        maxDepth: { type: "integer", minimum: 1, description: "Hop limit. Default unbounded." },
+        limit: {
+            type: "integer",
+            minimum: 1,
+            description: "Cap on nodes in the reply. Default 25 (MK-9 — the same walk-cost reduction impact.ts " +
+                "applies, for the same reason). A capped reply always discloses shown/total; raise this " +
+                "explicitly when the full set is needed.",
+        },
+    },
+    additionalProperties: false,
+};
+async function run(args, ctx) {
+    const nodeId = optionalString(args, "nodeId");
+    const symbol = optionalString(args, "symbol");
+    const file = optionalString(args, "file");
+    const edgeTypes = optionalStringArray(args, "edgeTypes");
+    const maxDepth = optionalInteger(args, "maxDepth", 1);
+    const limit = optionalInteger(args, "limit", 1) ?? 25;
+    if (nodeId === undefined && symbol === undefined && file === undefined) {
+        throw new ToolInputError('give one of "nodeId", "symbol" or "file"');
+    }
+    const found = resolveOneNode(ctx.session, { nodeId, symbol, file });
+    if (found.node === null) {
+        const base = ctx.session.provider().baseStamp();
+        return answer({
+            headline: found.headline,
+            state: "refused",
+            nameLevel: true,
+            resolutionFloor: 0,
+            commitSha: base.commitSha,
+            graphBuiltAt: base.graphBuiltAt,
+            irSchemaVersion: base.irSchemaVersion,
+            notes: found.notes,
+            data: { candidates: found.candidates.map(briefNode) },
+        });
+    }
+    ctx.progress(`Following data out of ${found.node.name}`);
+    const flow = dataFlowFrom(ctx.session.provider(), found.node.id, {
+        ...(maxDepth === undefined ? {} : { maxDepth }),
+        ...(edgeTypes === undefined ? {} : { types: edgeTypes }),
+    });
+    const reached = flow.data.filter((entry) => entry.node.id !== found.node?.id);
+    const shown = reached.slice(0, limit);
+    const notes = [...found.notes, ...flow.notes];
+    if (shown.length < reached.length) {
+        notes.push(`${reached.length - shown.length} further node(s) are on the path but not listed — the reply ` +
+            `is capped at ${limit}.`);
+    }
+    // Which of the walked edge types exist at all around the start node. This is
+    // the baseline precondition: with none of them present the walk had nothing
+    // to follow, and "reaches 0 nodes" is a statement about the graph's contents
+    // rather than about this symbol.
+    const walked = edgeTypes ?? DATA_FLOW_EDGE_TYPES;
+    const present = new Set();
+    for (const edge of [
+        ...ctx.session.provider().outgoing(found.node.id),
+        ...ctx.session.provider().incoming(found.node.id),
+    ]) {
+        if (walked.includes(edge.type))
+            present.add(edge.type);
+    }
+    const absent = walked.filter((type) => !present.has(type));
+    const analysed = present.size > 0;
+    if (absent.length > 0) {
+        notes.push(`No ${absent.join(", ")} edge touches this node, so ${absent.length === 1 ? "that type" : "those types"} ` +
+            "contributed nothing to this answer.");
+    }
+    if (!analysed) {
+        notes.push(`None of the requested edge types (${walked.join(", ")}) appear on any edge touching this node, ` +
+            "so the walk had nothing to follow. That is not a finding that no data leaves this symbol: " +
+            "no producer emitting these edge types at all, a graph built without the source that would " +
+            "carry them, and a symbol that genuinely propagates nothing are three different situations. " +
+            "This probe is local to one node and cannot tell them apart — it reports that the walk did " +
+            "not run rather than choosing between them.");
+    }
+    const fieldLevel = flow.stamp.resolutionFloor >= 3;
+    return {
+        result: {
+            ...flow,
+            data: {
+                from: briefNode(found.node),
+                reached: shown.map((entry) => ({
+                    ...briefNode(entry.node),
+                    depth: entry.depth,
+                    score: Number(entry.score.toFixed(4)),
+                })),
+                reachedTotal: reached.length,
+                fieldLevel,
+                /**
+                 * False when no edge of any walked type touches the start node.
+                 *
+                 * **An empty `reached` with `analysed: false` means the walk did not
+                 * run, not that nothing propagates.** Mirrors `HiddenDependencyReport`.
+                 */
+                analysed,
+                edgeTypesWalked: walked,
+                edgeTypesPresent: [...present].sort(),
+            },
+            notes,
+        },
+        ...(analysed ? (reached.length === 0 ? { state: "empty" } : {}) : { state: "refused" }),
+        // Never name-level, at any resolution.
+        //
+        // §11A.5's R2 carve-out — class A for "name-level facts only" — is for
+        // single assertions about existence: a missing environment variable, a
+        // migration head. This tool's claim is that *data* travels a route, and data
+        // is a shape concern by nature: a `PROPAGATES_TO` edge derived without a
+        // type checker is a weaker fact than the resolved reference underneath it.
+        // So R3 and R4 reach A on their own merits and R2 is capped at B, which is
+        // the conservative reading and the one "when in doubt, understate" picks.
+        nameLevel: false,
+        // The headline is the sentence a user acts on, so the not-analysable case
+        // gets its own rather than reusing "reaches 0 node(s)" with a note beneath
+        // it. A count of zero in the headline reads as a measurement whatever the
+        // notes say.
+        headline: !analysed
+            ? `Data flow out of ${found.node.name} was not analysed: the graph holds no ` +
+                `${walked.join("/")} edge touching it. This is not a finding that nothing propagates.`
+            : fieldLevel
+                ? `Data from ${found.node.name} reaches ${reached.length} node(s), at field level.`
+                : `${found.node.name} can reach ${reached.length} node(s). This is where data *can* flow, ` +
+                    "not which field arrives where — that needs R3.",
+    };
+}
+export const propagationTool = {
+    name: "propagation",
+    class: "read",
+    tier: "evidence",
+    version: "1.0.0",
+    title: "Where does this data end up?",
+    description: "Follow a value from a symbol or field through the graph along the edges that carry data. " +
+        "Field-level answers require a type checker (R3); below that the answer is path-level and " +
+        "labelled as such rather than overstated.",
+    inputSchema: SCHEMA,
+    run,
+};
+//# sourceMappingURL=propagation.js.map

package/dist/tools/propagation.js.map

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

package/dist/tools/questions.d.ts

@@ -0,0 +1,80 @@
+/**
+ * `questions` — TIER-A-2's last mile: a human sees an open question and can
+ * answer it, in this conversation.
+ *
+ * Everything upstream of this tool already existed and was inert together:
+ * a refusal carries `attrs.blockedBy` + `attrs.refusalClass` (DEC-242) → the
+ * grouper collapses rows sharing both into one question (DEC-243) → a
+ * confirmed answer is stored and capped at reliability class B regardless of
+ * anything else (DEC-223). Nothing before this tool could show a question to
+ * a person or accept an answer back. This is that door — the same role
+ * `link_workspace` plays for the workspace-pairing declaration, except this
+ * one both reads and writes, because "what's still open" and "record an
+ * answer" are one conversation, not two round trips.
+ *
+ * ## One tool, not two — and not folded into `link_workspace`
+ *
+ * DEC-243 named two shapes and built neither: a dedicated tool, or extending
+ * `link_workspace`'s write pattern to accept a `ConfirmedFact`. Rejected the
+ * second explicitly: `session.ts`'s own `writeConfirmedFact` already exists
+ * as "a second, narrow writer... so a future field gets a third writer, not
+ * a branch in this one" — the identical reasoning applies one layer up.
+ * `link_workspace` is about workspace pairing; bolting an unrelated write
+ * concern onto it would be the tool-layer version of the shape drift DEC's
+ * own `MODEL.fields`/`DTO.fields` incident already cost this project once
+ * (§3.1). A dedicated tool that both lists and answers is one coherent
+ * concern — "the question queue" — read and write together because a caller
+ * asking "what's still open" immediately after recording an answer should
+ * see the queue that answer just shrank, not have to call twice.
+ *
+ * ## Answering re-computes locally rather than re-reading the file
+ *
+ * `session.config.confirmedFacts` is loaded once at session start and is
+ * `readonly` — writing via `writeConfirmedFact` does not update it in
+ * memory. Rather than reload `.descry/config.json` from disk mid-call, the
+ * just-written fact is merged into a local copy for this response only, the
+ * same way `writeConfirmedFact`'s own `replaced` return value already tells
+ * a caller what was overwritten without a second read.
+ */
+import type { RefusalDropCounts, RefusalQuestion } from "@descryy/core";
+import type { ConfirmedFact } from "@descryy/ir";
+import { type ToolDefinition } from "./kit.ts";
+/**
+ * Both halves of one conversation: the queue, and the answer that just shrank it.
+ *
+ * Read and write together because a caller asking "what's still open"
+ * immediately after recording an answer should see the queue that answer
+ * changed, not have to call twice.
+ */
+export interface QuestionsData {
+    /**
+     * The `ConfirmedFact` written by this call, or null when none was given.
+     *
+     * A human assertion, not a graph fact: when it is later used to mint an
+     * edge, that edge is capped at reliability class B by DEC-223 regardless of
+     * anything else about it.
+     */
+    readonly recorded: ConfirmedFact | null;
+    /**
+     * Rows a human could actually resolve, grouped by `blockedBy`.
+     *
+     * DEC-242's `value-unknown` class only. A reader-capability gap or a
+     * per-call value never appears here, because no sentence answers those.
+     */
+    readonly questions: readonly RefusalQuestion[];
+    /** Every refusal-ledger row, classified or not. The outer denominator. */
+    readonly totalRefusalRows: number;
+    /**
+     * Of those, how many carry `attrs.blockedBy`/`refusalClass` at all.
+     *
+     * The gap between this and `totalRefusalRows` is rows no adapter classified:
+     * never askable, and **not the same population** as "still open".
+     */
+    readonly classifiedRows: number;
+    /** Rows a stored confirmed fact already answers, so they are not listed as questions. */
+    readonly alreadyAnswered: number;
+    /** Rows dropped by refusal class, per DEC-242's own rule. */
+    readonly dropped: RefusalDropCounts;
+}
+export declare const questionsTool: ToolDefinition;
+//# sourceMappingURL=questions.d.ts.map

package/dist/tools/questions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"questions.d.ts","sourceRoot":"","sources":["../../src/tools/questions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD,OAAO,EAA4E,KAAK,cAAc,EAAE,MAAM,UAAU,CAAC;AAGzH;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI,CAAC;IACxC;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS,eAAe,EAAE,CAAC;IAC/C,0EAA0E;IAC1E,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC;;;;;OAKG;IACH,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,yFAAyF;IACzF,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,6DAA6D;IAC7D,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;CACrC;AAmLD,eAAO,MAAM,aAAa,EAAE,cAiB3B,CAAC"}

package/dist/tools/questions.js

@@ -0,0 +1,213 @@
+/**
+ * `questions` — TIER-A-2's last mile: a human sees an open question and can
+ * answer it, in this conversation.
+ *
+ * Everything upstream of this tool already existed and was inert together:
+ * a refusal carries `attrs.blockedBy` + `attrs.refusalClass` (DEC-242) → the
+ * grouper collapses rows sharing both into one question (DEC-243) → a
+ * confirmed answer is stored and capped at reliability class B regardless of
+ * anything else (DEC-223). Nothing before this tool could show a question to
+ * a person or accept an answer back. This is that door — the same role
+ * `link_workspace` plays for the workspace-pairing declaration, except this
+ * one both reads and writes, because "what's still open" and "record an
+ * answer" are one conversation, not two round trips.
+ *
+ * ## One tool, not two — and not folded into `link_workspace`
+ *
+ * DEC-243 named two shapes and built neither: a dedicated tool, or extending
+ * `link_workspace`'s write pattern to accept a `ConfirmedFact`. Rejected the
+ * second explicitly: `session.ts`'s own `writeConfirmedFact` already exists
+ * as "a second, narrow writer... so a future field gets a third writer, not
+ * a branch in this one" — the identical reasoning applies one layer up.
+ * `link_workspace` is about workspace pairing; bolting an unrelated write
+ * concern onto it would be the tool-layer version of the shape drift DEC's
+ * own `MODEL.fields`/`DTO.fields` incident already cost this project once
+ * (§3.1). A dedicated tool that both lists and answers is one coherent
+ * concern — "the question queue" — read and write together because a caller
+ * asking "what's still open" immediately after recording an answer should
+ * see the queue that answer just shrank, not have to call twice.
+ *
+ * ## Answering re-computes locally rather than re-reading the file
+ *
+ * `session.config.confirmedFacts` is loaded once at session start and is
+ * `readonly` — writing via `writeConfirmedFact` does not update it in
+ * memory. Rather than reload `.descry/config.json` from disk mid-call, the
+ * just-written fact is merged into a local copy for this response only, the
+ * same way `writeConfirmedFact`'s own `replaced` return value already tells
+ * a caller what was overwritten without a second read.
+ */
+import { applyConfirmedFacts, counts, groupRefusalsIntoQuestions } from "@descryy/core";
+import { writeConfirmedFact } from "../session.js";
+import { answer, optionalString, requiredString, ToolInputError } from "./kit.js";
+const SCHEMA = {
+    type: "object",
+    properties: {
+        answer: {
+            type: "object",
+            description: "Record a confirmed value for one question, keyed on the exact blockedBy string a question " +
+                "reports. Omit to only list what is still open.",
+            properties: {
+                blockedBy: {
+                    type: "string",
+                    description: "Must equal a question's own \"blockedBy\" field, byte for byte — no fuzzy match.",
+                },
+                value: { type: "string", description: "The confirmed literal value." },
+                environment: {
+                    type: "string",
+                    description: "Optional. Omit for an unscoped answer (the common case) — never infer one from the value " +
+                        "itself (a hostname naming \"staging\" is not evidence the caller may read). A second answer " +
+                        "with a different environment for the same blockedBy is a second fact, not a replacement.",
+                },
+                confirmedBy: {
+                    type: "string",
+                    description: "Free text — who or what is asserting this. Defaults to \"user\".",
+                },
+            },
+            required: ["blockedBy", "value"],
+            additionalProperties: false,
+        },
+    },
+    additionalProperties: false,
+};
+async function run(args, ctx) {
+    const { session } = ctx;
+    const notes = [];
+    let facts = session.config.confirmedFacts;
+    let recorded = null;
+    const answerArg = args["answer"];
+    if (answerArg !== undefined) {
+        if (typeof answerArg !== "object" || answerArg === null) {
+            throw new ToolInputError('"answer" must be an object');
+        }
+        const a = answerArg;
+        const blockedBy = requiredString(a, "blockedBy");
+        const value = requiredString(a, "value");
+        const environment = optionalString(a, "environment");
+        const confirmedBy = optionalString(a, "confirmedBy") ?? "user";
+        // "Against what" (see ConfirmedFact.confirmedAtCommit) — the repo's own
+        // commit at the moment this answer is given, so a later mint can tell
+        // whether the code has moved since a human said this value was correct.
+        // Best-effort: a repo path with no git history (a fixture, a non-git
+        // checkout) simply cannot supply one, and that is exactly the "unknown"
+        // case `confirmedAtCommit` is designed to carry as an absence rather than
+        // a guess — never let this recording fail because the disclosure couldn't.
+        const confirmedAtCommit = await session
+            .root()
+            .then((r) => r.commitSha)
+            .catch(() => undefined);
+        recorded = {
+            repo: session.config.repo,
+            blockedBy,
+            value,
+            ...(environment === undefined ? {} : { environment }),
+            confirmedBy,
+            confirmedAt: new Date().toISOString(),
+            ...(confirmedAtCommit === undefined ? {} : { confirmedAtCommit }),
+        };
+        ctx.progress(`Recording an answer for ${blockedBy}${environment === undefined ? "" : ` (${environment})`}`);
+        const written = await writeConfirmedFact(session.repoPath, recorded);
+        const sameKey = (f) => f.repo === recorded?.repo && f.blockedBy === recorded.blockedBy && f.environment === recorded.environment;
+        facts = [...facts.filter((f) => !sameKey(f)), recorded];
+        notes.push(written.replaced === null
+            ? `Recorded a new answer for "${blockedBy}"${environment === undefined ? "" : ` in "${environment}"`}.`
+            : `Replaced the previous answer for "${blockedBy}"` +
+                `${environment === undefined ? "" : ` in "${environment}"`} (was "${written.replaced.value}", ` +
+                `confirmed ${written.replaced.confirmedAt}).`);
+    }
+    ctx.progress("Reading the refusal ledger");
+    const provider = session.provider();
+    const { refs, truncated } = provider.unresolvedRefs();
+    const total = counts(session.store().driver).unresolvedRefs;
+    const { answered, stillOpen } = applyConfirmedFacts(refs, facts, session.config.repo);
+    const grouped = groupRefusalsIntoQuestions(session.config.repo, stillOpen);
+    if (truncated) {
+        notes.push("The classified-refusal read was capped and some rows were not examined — this list may be " +
+            "incomplete. Re-run with a narrower scope, or treat this as a lower bound.");
+    }
+    if (total > refs.length) {
+        notes.push(`${total - refs.length} of ${total} refusal-ledger row(s) carry no classification at all yet ` +
+            "(no adapter has set attrs.blockedBy/refusalClass for them) — never askable, not counted " +
+            "above, and not the same population as \"still open\".");
+    }
+    if (answered.length > 0) {
+        notes.push(`${answered.length} previously-open row(s) are already answered by a stored confirmed fact and ` +
+            "are not listed as questions.");
+    }
+    for (const [cls, count] of Object.entries(grouped.dropped)) {
+        if (cls === "value-unknown")
+            continue; // never dropped under its own class name
+        notes.push(`${count} row(s) are "${cls}" — DEC-242's own rule: not askable, never surfaced here.`);
+    }
+    const headline = grouped.questions.length === 0
+        ? recorded !== null
+            ? `Answer recorded. No open questions remain in ${session.config.repo}.`
+            : `No open questions in ${session.config.repo}. ${refs.length} classified refusal row(s) examined.`
+        : `${grouped.questions.length} open question(s) in ${session.config.repo}, covering ` +
+            `${grouped.questions.reduce((n, q) => n + q.sites.length, 0)} call site(s).`;
+    return answer({
+        headline,
+        // Existence of a question is a name-level fact — the expression is
+        // present in source or it is not, the same class as a missing
+        // environment variable. Whether it has been *answered* is a separate
+        // axis this tool never conflates with resolution. `UnresolvedRef` itself
+        // carries no resolution level (refusals are not edges and were never
+        // scored, per DEC-223's own matching function), so R0 is the honest
+        // floor rather than a borrowed number — the same choice `link_workspace`
+        // makes for the same reason: this is not a claim resting on graph edges.
+        nameLevel: true,
+        resolutionFloor: 0,
+        commitSha: provider.baseStamp().commitSha,
+        graphBuiltAt: provider.baseStamp().graphBuiltAt,
+        irSchemaVersion: provider.baseStamp().irSchemaVersion,
+        // Empty only for a pure read that found nothing open — the classified
+        // population is real (`classifiedRows`). Recording an answer that happens
+        // to empty the queue is a successful write, not an empty search.
+        ...(recorded === null && grouped.questions.length === 0 ? { state: "empty" } : {}),
+        notes,
+        data: {
+            recorded,
+            questions: grouped.questions,
+            totalRefusalRows: total,
+            classifiedRows: refs.length,
+            alreadyAnswered: answered.length,
+            dropped: grouped.dropped,
+        },
+    });
+}
+/**
+ * §7's handshake gate. `undefined` means this call has nothing to confirm —
+ * a pure read of the open-question queue (no `answer` given) must stay
+ * answerable on the first call, or this tool could not answer the first
+ * question ever asked of it. Only a call that would actually write a
+ * `ConfirmedFact` describes itself, so `resolveActionDispatch` mints a token
+ * for that call alone.
+ */
+function describeAction(args) {
+    const a = args["answer"];
+    if (typeof a !== "object" || a === null)
+        return undefined;
+    const { blockedBy, value, environment } = a;
+    if (typeof blockedBy !== "string" || typeof value !== "string")
+        return undefined;
+    return (`record a ConfirmedFact: "${blockedBy}" = "${value}"` +
+        (typeof environment === "string" ? ` (environment: ${environment})` : "") +
+        " — capped at reliability class B (DEC-223) once used.");
+}
+export const questionsTool = {
+    name: "questions",
+    class: "action",
+    tier: "evidence",
+    version: "1.0.0",
+    title: "See and answer open refusal-ledger questions",
+    description: "List every refusal-ledger row a human could actually resolve (DEC-242's \"value-unknown\" " +
+        "class only — a reader-capability gap or a per-call value is never surfaced here, because no " +
+        "sentence answers those). Pass \"answer\" to record a confirmed value for one question, keyed " +
+        "on its exact \"blockedBy\" string within this repository; the answer is capped at reliability " +
+        "class B when later used, regardless of anything else about the edge it resolves (DEC-223). " +
+        "Recording an answer takes a two-call confirmation: the first call with \"answer\" performs " +
+        "nothing and returns a token; call again with \"confirmToken\" to actually record it.",
+    inputSchema: SCHEMA,
+    run,
+    describeAction,
+};
+//# sourceMappingURL=questions.js.map

package/dist/tools/questions.js.map

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