@ask-llm/plugin 0.17.0 → 0.19.0

package/scripts/lib/broker.mjs

@@ -0,0 +1,327 @@
+// Source of truth: broker.mts. The sibling .mjs is generated by `yarn workspace @ask-llm/plugin build:hooks`; never edit it.
+// Unavailable or incompatible app-server brokers fall back to per-edit Codex.
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { createRpcClient } from "./broker-rpc.mjs";
+import { connectWebSocket } from "./broker-transport.mjs";
+import { parseFrontmatter } from "./frontmatter.mjs";
+// State file under <markerDir>/.codex-pair/state/ (ADR-092).
+export const BROKER_STATE_FILE = "broker.json";
+export const BROKER_HEALTH_TIMEOUT_MS = 2000;
+export const BROKER_SOCKET_PREFIX = "codex-pair-broker";
+// Pin the app-server protocol version so incompatible upgrades fail the handshake.
+export const BROKER_PROTOCOL_VERSION = "v2";
+export const JSONRPC_METHODS = Object.freeze({
+    INITIALIZE: "initialize",
+    THREAD_START: "thread/start",
+    TURN_START: "turn/start",
+    TURN_INTERRUPT: "turn/interrupt",
+    MODEL_LIST: "model/list", // used for health probe (cheap, no side effects)
+});
+// turn/completed carries the final agent message and structured verdict.
+export const JSONRPC_NOTIFICATIONS = Object.freeze({
+    TURN_COMPLETED: "turn/completed",
+    TURN_STARTED: "turn/started",
+    ITEM_AGENT_MESSAGE_DELTA: "item/agentMessage/delta", // streaming text
+    THREAD_TOKEN_USAGE_UPDATED: "thread/tokenUsage/updated", // cost tracking
+});
+// Strict structured output requires every property; nullable fields remain optional in meaning.
+export function buildVerdictSchema() {
+    return {
+        type: "object",
+        required: ["verdict", "findings"],
+        additionalProperties: false,
+        properties: {
+            verdict: {
+                type: "string",
+                enum: ["clean", "concerns"],
+                description: "Closed-set verdict (parser.mjs:parseConcernsJson contract).",
+            },
+            findings: {
+                type: "array",
+                description: "Use an empty array when verdict is clean.",
+                items: {
+                    type: "object",
+                    required: ["severity", "body", "title", "file", "line_start", "recommendation"],
+                    additionalProperties: false,
+                    properties: {
+                        severity: {
+                            type: "string",
+                            enum: ["high", "medium", "low"],
+                            description: "ADR-077 severity ladder. 'medium' (canonical) — 'med' is a legacy alias.",
+                        },
+                        body: {
+                            type: "string",
+                            description: "The concern itself — what's wrong + why it matters + how to fix.",
+                        },
+                        title: {
+                            type: ["string", "null"],
+                            description: "Optional short title rendered ahead of the file:line line.",
+                        },
+                        file: {
+                            type: ["string", "null"],
+                            description: "File path (optional). Prepended to the rendered concern.",
+                        },
+                        line_start: {
+                            type: ["integer", "null"],
+                            description: "Line number (optional). Multi-review M3 hotfix: parser.mjs reads `line_start`, not `line`. Rendered as ':<n>' suffix on file.",
+                        },
+                        recommendation: {
+                            type: ["string", "null"],
+                            description: "Optional fix suggestion. Appended on a new line after body.",
+                        },
+                    },
+                },
+            },
+        },
+    };
+}
+// Read the session broker descriptor; callers validate it before use.
+export function readBrokerState(markerDir) {
+    return lifecycleReadBrokerDescriptor(markerDir);
+}
+export function resolveBrokerPreference(markerDir, env = process.env) {
+    if (env.ASK_CODEX_BROKER !== "1")
+        return false;
+    try {
+        const marker = readFileSync(join(markerDir, ".codex-pair", "context.md"), "utf8");
+        return parseFrontmatter(marker).frontmatter.broker !== false;
+    }
+    catch {
+        return false;
+    }
+}
+export function isBrokerDescriptorEligible(state) {
+    if (!isIsolatedBrokerHome(state.isolatedHome))
+        return false;
+    if (!hasCurrentBrokerAuth(state.isolatedHome))
+        return false;
+    if (state.protocolVersion !== BROKER_PROTOCOL_VERSION)
+        return false;
+    if (!lifecycleIsPidAlive(state.pid))
+        return false;
+    return true;
+}
+export function isBrokerEnabled(markerDir) {
+    if (!resolveBrokerPreference(markerDir))
+        return false;
+    const state = lifecycleReadBrokerDescriptor(markerDir);
+    return state !== null && isBrokerDescriptorEligible(state);
+}
+export function brokerStatePath(markerDir, stateDir) {
+    return join(markerDir, stateDir, BROKER_STATE_FILE);
+}
+// Re-exported so hooks import one broker surface; the lifecycle module imports this module's constants.
+export { clearStaleBrokerState } from "./broker-lifecycle.mjs";
+import { hasCurrentBrokerAuth, isIsolatedBrokerHome, isPidAlive as lifecycleIsPidAlive, readBrokerDescriptorSync as lifecycleReadBrokerDescriptor, } from "./broker-lifecycle.mjs";
+// Caller owns the returned connection; any failure rejects so the hook falls back to direct review.
+export async function initializeBroker(transportUrl, clientInfo, options = {}) {
+    const { handshakeTimeoutMs = 5000, initializeTimeoutMs = 5000 } = options;
+    const connection = await (options.connectWebSocket ?? connectWebSocket)(transportUrl, { handshakeTimeoutMs });
+    const rpc = (options.createRpcClient ?? createRpcClient)(connection, { defaultTimeoutMs: initializeTimeoutMs });
+    try {
+        const initializeResult = await rpc.request(JSONRPC_METHODS.INITIALIZE, { clientInfo }, { timeoutMs: initializeTimeoutMs });
+        rpc.notify("initialized", {});
+        return { connection, rpc, initializeResult };
+    }
+    catch (err) {
+        try {
+            connection.close(1011, "initialize failed");
+        }
+        catch {
+            // already torn down
+        }
+        throw err;
+    }
+}
+// Initializes a fresh connection and completes `model/list`; any failure means unhealthy, never a throw.
+export async function probeBrokerHealth(state) {
+    if (!state || typeof state.transportUrl !== "string")
+        return false;
+    let connection;
+    let rpc;
+    try {
+        connection = await connectWebSocket(state.transportUrl, {
+            handshakeTimeoutMs: BROKER_HEALTH_TIMEOUT_MS,
+        });
+        rpc = createRpcClient(connection, { defaultTimeoutMs: BROKER_HEALTH_TIMEOUT_MS });
+        // Initialize each probe connection before model/list.
+        await rpc.request(JSONRPC_METHODS.INITIALIZE, { clientInfo: { name: "codex-pair-health-probe", title: "codex-pair health probe", version: "0.0.0" } }, { timeoutMs: BROKER_HEALTH_TIMEOUT_MS });
+        rpc.notify("initialized", {});
+        await rpc.request(JSONRPC_METHODS.MODEL_LIST, undefined, {
+            timeoutMs: BROKER_HEALTH_TIMEOUT_MS,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        if (connection && !connection.destroyed) {
+            try {
+                connection.close(1000, "probe done");
+            }
+            catch {
+                // best-effort
+            }
+        }
+    }
+}
+// Transport and protocol failures fall back; numeric model errors keep their meaning.
+async function brokerRequest(rpc, method, params, timeoutMs, brokerPhase) {
+    try {
+        return await rpc.request(method, params, { timeoutMs });
+    }
+    catch (caught) {
+        const err = caught;
+        const protocolRejection = [-32600, -32601, -32602].includes(err?.code);
+        if (err && typeof err === "object" && (typeof err.code !== "number" || protocolRejection) && !err.brokerFailure) {
+            err.verdict = "error";
+            err.brokerFailure = true;
+            err.brokerPhase = protocolRejection ? "protocol" : brokerPhase;
+        }
+        throw err;
+    }
+}
+export async function submitReview(args) {
+    const { rpc, connection, cwd, baseInstructions, prompt, model, timeoutMs = 60_000, abortSignal } = args;
+    const effort = args.effort ?? "medium";
+    if (!rpc)
+        throw new Error("submitReview: rpc client required");
+    if (!connection)
+        throw new Error("submitReview: connection required");
+    if (typeof prompt !== "string" || prompt.length === 0) {
+        throw new Error("submitReview: prompt required");
+    }
+    const deadline = Date.now() + timeoutMs;
+    const remaining = () => Math.max(0, deadline - Date.now());
+    // Hook reviews use ephemeral read-only threads with no interactive approvals.
+    const threadResp = await brokerRequest(rpc, JSONRPC_METHODS.THREAD_START, {
+        ephemeral: true,
+        cwd,
+        baseInstructions,
+        model,
+        approvalPolicy: "never",
+        sandbox: "read-only",
+    }, remaining(), "thread_start");
+    const threadId = threadResp?.thread?.id;
+    if (typeof threadId !== "string") {
+        // Thread-start failure means the broker protocol is unusable.
+        const err = new Error("submitReview: thread/start returned no thread.id");
+        err.verdict = "error";
+        err.brokerFailure = true;
+        err.brokerPhase = "thread_start";
+        throw err;
+    }
+    // Register completion before turn/start to avoid missing a fast terminal event.
+    const completionPromise = rpc.waitFor(JSONRPC_NOTIFICATIONS.TURN_COMPLETED, (n) => n.params?.threadId === threadId, remaining());
+    completionPromise.catch(() => { });
+    let completion;
+    try {
+        // Constrain output to the parser-compatible verdict shape.
+        const turnResp = await brokerRequest(rpc, JSONRPC_METHODS.TURN_START, {
+            threadId,
+            input: [{ type: "text", text: prompt }],
+            outputSchema: buildVerdictSchema(),
+            effort,
+            // Belt-and-suspenders: also pin turn-level sandbox + deny network.
+            sandboxPolicy: { type: "readOnly", networkAccess: false },
+        }, remaining(), "turn_start");
+        const turnId = turnResp?.turn?.id;
+        if (typeof turnId !== "string") {
+            // Turn-start failure means the broker protocol is unusable.
+            const err = new Error("submitReview: turn/start returned no turn.id");
+            err.verdict = "error";
+            err.brokerFailure = true;
+            err.brokerPhase = "turn_start";
+            throw err;
+        }
+        // 4. Wire cancellation. abortSignal abort → turn/interrupt + reject.
+        let abortHandler = null;
+        let interruptSent = false;
+        // Track completion so a late abort cannot interrupt a finished turn.
+        let completed = false;
+        const abortPromise = abortSignal
+            ? new Promise((_, reject) => {
+                abortHandler = () => {
+                    // A completed turn must ignore late aborts.
+                    if (completed)
+                        return;
+                    interruptSent = true;
+                    // Reject abort promptly; interrupt is best-effort.
+                    rpc.request(JSONRPC_METHODS.TURN_INTERRUPT, { threadId, turnId }, { timeoutMs: 2000 }).catch(() => { });
+                    // Use the verdict field consumed by verdictFromError.
+                    const err = new Error("submitReview: aborted");
+                    err.verdict = "error";
+                    err.aborted = true; // structured marker for callers who care
+                    reject(err);
+                };
+                if (abortSignal.aborted)
+                    abortHandler();
+                else
+                    abortSignal.addEventListener("abort", abortHandler);
+            })
+            : null;
+        // 5. Race the completion against the abort.
+        try {
+            completion = abortPromise ? await Promise.race([completionPromise, abortPromise]) : await completionPromise;
+            completed = true;
+        }
+        catch (caught) {
+            const err = caught;
+            // Timeout interrupts the server turn; use the RPC timeout marker.
+            if (!interruptSent && err && err.timeout === true) {
+                rpc.request(JSONRPC_METHODS.TURN_INTERRUPT, { threadId, turnId }, { timeoutMs: 2000 }).catch(() => { });
+                const wrapped = new Error("submitReview: turn timed out");
+                wrapped.verdict = "timeout";
+                wrapped.timeout = true;
+                wrapped.brokerFailure = true;
+                wrapped.brokerPhase = "turn_completion";
+                throw wrapped;
+            }
+            if (err && typeof err === "object" && !err.aborted) {
+                err.brokerFailure = true;
+                err.brokerPhase = "turn_completion";
+            }
+            throw err;
+        }
+        finally {
+            if (abortHandler && abortSignal) {
+                abortSignal.removeEventListener("abort", abortHandler);
+            }
+        }
+    }
+    finally {
+        completionPromise.cancel?.();
+    }
+    // Use the last agentMessage because a turn may emit multiple messages.
+    const turn = completion?.params?.turn;
+    if (!turn || !Array.isArray(turn.items)) {
+        // M4: protocol-layer failure → brokerFailure → hook falls back.
+        const err = new Error("submitReview: turn/completed missing turn.items");
+        err.verdict = "parse_failed";
+        err.brokerFailure = true;
+        err.brokerPhase = "protocol";
+        throw err;
+    }
+    if (turn.status === "failed" || turn.status === "interrupted") {
+        const err = new Error(`submitReview: turn ${turn.status}${turn.error?.message ? ` — ${turn.error.message}` : ""}`);
+        err.verdict = "error";
+        if (turn.status === "failed" &&
+            /invalid_json_schema|unsupported method|method not found|invalid params/i.test(turn.error?.message ?? "")) {
+            err.brokerFailure = true;
+            err.brokerPhase = "protocol";
+        }
+        throw err;
+    }
+    const finalMessage = turn.items.findLast?.((i) => i?.type === "agentMessage");
+    if (!finalMessage || typeof finalMessage.text !== "string") {
+        // Missing agentMessage is a protocol failure that permits direct fallback.
+        const err = new Error("submitReview: turn/completed has no agentMessage item");
+        err.verdict = "parse_failed";
+        err.brokerFailure = true;
+        err.brokerPhase = "protocol";
+        throw err;
+    }
+    return finalMessage.text;
+}

package/scripts/lib/debounce-state.mjs

@@ -0,0 +1,206 @@
+// Per-file edit-debounce state (design 2026-06-03, closes #96 Bug 2 / Idea 1).
+//
+// Two per-file stores under <markerDir>/.codex-pair/state/:
+//   debounce/<sha256(file)[0:16]>.json — edit record { file, generation, burstStartedAt, reviewedGen, sessionId }
+//   pending/<sha256(file)[0:16]>.json  — settled verdict { file, message } awaiting surface
+//
+// Atomic writes use tmp+rename (ADR-086/091). Reads tolerate missing/malformed
+// (return null / []). Every write is best-effort — debounce state failures must
+// never break the hook (ADR-077).
+
+import { createHash } from "node:crypto";
+import { mkdirSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { stateRoot } from "./state.mjs";
+
+export const DEBOUNCE_DIR = "debounce";
+export const PENDING_DIR = "pending";
+export const REVIEWING_DIR = "reviewing";
+export const DEFAULT_DEBOUNCE_MS = 15_000;
+export const DEFAULT_DEBOUNCE_MAX_MS = 60_000;
+// Sweep records/pending older than maxMs + this buffer (junk from crashes).
+export const DEBOUNCE_STALE_BUFFER_MS = 300_000;
+
+export const debounceRoot = (markerDir) => join(stateRoot(markerDir), DEBOUNCE_DIR);
+export const pendingRoot = (markerDir) => join(stateRoot(markerDir), PENDING_DIR);
+export const reviewingRoot = (markerDir) => join(stateRoot(markerDir), REVIEWING_DIR);
+
+function fileHash(file) {
+  return createHash("sha256").update(String(file)).digest("hex").slice(0, 16);
+}
+export const debounceRecordPath = (markerDir, file) => join(debounceRoot(markerDir), `${fileHash(file)}.json`);
+export const pendingPath = (markerDir, file) => join(pendingRoot(markerDir), `${fileHash(file)}.json`);
+
+function writeAtomicSync(p, value) {
+  try {
+    mkdirSync(dirname(p), { recursive: true });
+    const tmp = `${p}.tmp.${process.pid}`;
+    writeFileSync(tmp, JSON.stringify(value));
+    renameSync(tmp, p);
+  } catch {
+    // best-effort (ADR-077)
+  }
+}
+
+// Record one edit. Increments generation; preserves burstStartedAt while a
+// burst is unconsumed (reviewedGen < generation), resets it for a fresh burst.
+export function bumpEditRecord(markerDir, file, { sessionId, now }) {
+  let prev = null;
+  try {
+    prev = JSON.parse(readFileSync(debounceRecordPath(markerDir, file), "utf8"));
+  } catch {
+    prev = null;
+  }
+  const generation = (prev?.generation ?? 0) + 1;
+  const burstInProgress = prev && prev.reviewedGen < prev.generation;
+  const burstStartedAt = burstInProgress ? prev.burstStartedAt : now;
+  const record = { file, generation, burstStartedAt, reviewedGen: prev?.reviewedGen ?? 0, sessionId };
+  writeAtomicSync(debounceRecordPath(markerDir, file), record);
+  return record;
+}
+
+export function readEditRecord(markerDir, file) {
+  try {
+    return JSON.parse(readFileSync(debounceRecordPath(markerDir, file), "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+// Pure decision: should the worker born for `myGeneration` review now?
+export function decideReview({ record, myGeneration, now, maxMs }) {
+  if (!record) return { review: false, reason: "record-missing" };
+  if (record.reviewedGen >= myGeneration) return { review: false, reason: "already-reviewed" };
+  if (record.generation === myGeneration) return { review: true, reason: "settled" };
+  if (now - record.burstStartedAt >= maxMs) return { review: true, reason: "max-cap" };
+  return { review: false, reason: "superseded" };
+}
+
+// Advance reviewedGen so the next edit starts a fresh burst. Best-effort.
+// Note: a cap-triggered worker (generation N < the current latest M) advances
+// reviewedGen to N, not M — so the latest-gen worker still reviews the SETTLED
+// state once editing stops. A long continuous burst therefore yields a mid-burst
+// cap review (state at N) plus a final settled review (state at M): two reviews
+// of two DIFFERENT states, which is intended. The per-file inflight lock bounds
+// the worst case to one in-flight Codex call at a time (extra wakers coalesce).
+export function markReviewed(markerDir, file, generation) {
+  const p = debounceRecordPath(markerDir, file);
+  let rec;
+  try {
+    rec = JSON.parse(readFileSync(p, "utf8"));
+  } catch {
+    return;
+  }
+  if (rec.reviewedGen < generation) {
+    rec.reviewedGen = generation;
+    writeAtomicSync(p, rec);
+  }
+}
+
+export function writePending(markerDir, file, message) {
+  writeAtomicSync(pendingPath(markerDir, file), { file, message });
+}
+
+// Worker handoff marker (2026-07-02 seamless-pairing design, dogfood finding).
+// The worker advances reviewedGen BEFORE the forced-sync hook acquires the
+// per-file inflight lock, so a Stop-gate check in that gap would see neither
+// "settling" nor "reviewing" and let the turn end mid-review. The worker holds
+// this marker across the whole handoff (markReviewing → spawn → clearReviewing)
+// so the gate always has an observable signal. Best-effort like all debounce
+// state; a leaked marker ages out via the gate's freshness window + TTL sweep.
+export const reviewingPath = (markerDir, file) => join(reviewingRoot(markerDir), `${fileHash(file)}.json`);
+
+export function markReviewing(markerDir, file) {
+  writeAtomicSync(reviewingPath(markerDir, file), { file, at: Date.now() });
+}
+
+export function clearReviewing(markerDir, file) {
+  try {
+    unlinkSync(reviewingPath(markerDir, file));
+  } catch {
+    // already gone
+  }
+}
+
+// Read + clear every pending verdict (surfaced exactly once). Returns messages.
+export function drainPending(markerDir) {
+  const root = pendingRoot(markerDir);
+  const messages = [];
+  let names;
+  try {
+    names = readdirSync(root);
+  } catch {
+    return messages;
+  }
+  for (const name of names) {
+    if (!name.endsWith(".json")) continue;
+    const full = join(root, name);
+    try {
+      const { message } = JSON.parse(readFileSync(full, "utf8"));
+      if (typeof message === "string" && message.length > 0) messages.push(message);
+    } catch {
+      // skip malformed
+    }
+    try {
+      unlinkSync(full);
+    } catch {
+      // already gone
+    }
+  }
+  return messages;
+}
+
+// Bound how many drained verdicts are surfaced inline. drainPending still
+// clears ALL pending files; only the surfaced text is capped, so a burst that
+// touches many files can't inject an unbounded blob into Claude's context —
+// the overflow stays in the log. Trailer points there.
+export const MAX_SURFACE_VERDICTS = 8;
+export function joinPendingForSurface(messages) {
+  if (messages.length <= MAX_SURFACE_VERDICTS) return messages.join("\n\n");
+  const extra = messages.length - MAX_SURFACE_VERDICTS;
+  return `${messages
+    .slice(0, MAX_SURFACE_VERDICTS)
+    .join("\n\n")}\n\n[codex-pair] +${extra} more verdict(s) drained — see .codex-pair/log.jsonl`;
+}
+
+// SessionEnd cancel: drop all debounce + pending state so orphaned sleepers
+// self-cancel (decideReview → record-missing) and no stale verdict leaks into
+// a later session.
+export function clearAllDebounceState(markerDir) {
+  for (const root of [debounceRoot(markerDir), pendingRoot(markerDir), reviewingRoot(markerDir)]) {
+    let names;
+    try {
+      names = readdirSync(root);
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      try {
+        unlinkSync(join(root, name));
+      } catch {
+        // best-effort
+      }
+    }
+  }
+}
+
+// Probabilistic TTL sweep (mirrors ADR-097). Best-effort; never throws.
+export function sweepStaleDebounce(markerDir, maxMs) {
+  const cutoff = Date.now() - (maxMs + DEBOUNCE_STALE_BUFFER_MS);
+  for (const root of [debounceRoot(markerDir), pendingRoot(markerDir), reviewingRoot(markerDir)]) {
+    let names;
+    try {
+      names = readdirSync(root);
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      const full = join(root, name);
+      try {
+        if (statSync(full).mtimeMs < cutoff) unlinkSync(full);
+      } catch {
+        // skip
+      }
+    }
+  }
+}

package/scripts/lib/frontmatter.mjs

@@ -0,0 +1,57 @@
+// Source of truth: frontmatter.mts. The sibling .mjs is generated by `yarn workspace @ask-llm/plugin build:hooks`; never edit it.
+export function parseFrontmatter(content) {
+    if (typeof content !== "string" || content.length === 0) {
+        return { frontmatter: {}, body: "", malformed: false };
+    }
+    const firstNewline = content.indexOf("\n");
+    if (firstNewline === -1)
+        return { frontmatter: {}, body: content, malformed: false };
+    const opener = content.slice(0, firstNewline).replace(/\r$/, "");
+    if (opener !== "---")
+        return { frontmatter: {}, body: content, malformed: false };
+    const rest = content.slice(firstNewline + 1);
+    const closerMatch = rest.match(/^---\s*$/m);
+    if (!closerMatch || typeof closerMatch.index !== "number") {
+        return { frontmatter: {}, body: content, malformed: true };
+    }
+    const fmText = rest.slice(0, closerMatch.index);
+    let body = rest.slice(closerMatch.index + closerMatch[0].length);
+    if (body.startsWith("\r"))
+        body = body.slice(1);
+    if (body.startsWith("\n"))
+        body = body.slice(1);
+    const frontmatter = {};
+    for (const rawLine of fmText.split("\n")) {
+        const line = rawLine.replace(/\r$/, "");
+        const trimmed = line.trim();
+        if (trimmed.length === 0 || trimmed.startsWith("#"))
+            continue;
+        const colon = line.indexOf(":");
+        if (colon === -1)
+            continue;
+        const key = line.slice(0, colon).trim();
+        if (key.length === 0)
+            continue;
+        let valueRaw = line.slice(colon + 1);
+        // Strip inline comment, but only when `#` follows whitespace.
+        const inlineComment = valueRaw.match(/\s+#.*$/);
+        if (inlineComment && typeof inlineComment.index === "number") {
+            valueRaw = valueRaw.slice(0, inlineComment.index);
+        }
+        let value = valueRaw.trim();
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        if (value === "true")
+            frontmatter[key] = true;
+        else if (value === "false")
+            frontmatter[key] = false;
+        else if (/^-?\d+$/.test(value))
+            frontmatter[key] = Number(value);
+        else if (/^-?\d+\.\d+$/.test(value))
+            frontmatter[key] = Number(value);
+        else
+            frontmatter[key] = value;
+    }
+    return { frontmatter, body, malformed: false };
+}