dorfl 0.0.0 → 0.1.0

package/dist/cwd-section.js

@@ -0,0 +1,209 @@
+import { run, runAsync, localMainDivergence } from './git.js';
+import { isParticipatingRepo } from './detect.js';
+import { scanRepoPaths } from './scan.js';
+import { arbiterStatus } from './arbiter.js';
+import { listMirrors } from './registry.js';
+import { encodeRepoKey, mirrorPath } from './repo-mirror.js';
+import { heldTaskSlugsStrict, listItemLockEntries } from './item-lock.js';
+/** True iff the working repo has a git remote with name `remote`. The held-lock
+ * read targets the COORDINATION arbiter (default `origin`); we only attempt it
+ * when that remote actually exists, so a repo with no coordination remote keeps
+ * the empty held set rather than failing on a `git remote get-url` miss. */
+function remoteExists(cwd, remote, env) {
+    return run('git', ['remote', 'get-url', remote], cwd, { env }).status === 0;
+}
+/**
+ * The FETCH-FREE pre-check that decides whether a DEFAULT `scan`/`status` should
+ * pay for the cwd section at all. It does NO network I/O: it reads whether the cwd
+ * participates (local `readdirSync`) and resolves the cwd's arbiter URL via the
+ * fetch-free {@link arbiterStatus} (a local `git remote get-url`), then asks the
+ * fetch-free {@link resolveRegistration} (local {@link listMirrors} key match)
+ * whether that URL is already a registered mirror.
+ *
+ * The CLI gates on this BEFORE calling {@link resolveCwdSection}: a participating
+ * cwd that is ALSO registered is skipped (the registry already covers it, and the
+ * cwd read would only re-fetch the same arbiter), while a participating cwd with
+ * NO mirror is resolved + shown standalone so a mirror-less repo you are standing
+ * in is never invisible. `--here` bypasses this gate (it ALWAYS resolves the cwd,
+ * and only the cwd).
+ */
+export function cwdSectionDisposition(input) {
+    if (!isParticipatingRepo(input.cwd)) {
+        return { participating: false, alsoRegistered: false };
+    }
+    // Fetch-free: arbiterStatus reads the local remote config only (no fetch).
+    const status = arbiterStatus({
+        cwd: input.cwd,
+        remote: input.arbiterRemote,
+        env: input.env,
+    });
+    const { alsoRegistered } = resolveRegistration({
+        arbiterUrl: status.url,
+        config: input.config,
+        env: input.env,
+    });
+    return { participating: true, alsoRegistered };
+}
+/**
+ * Resolve the cwd-local section for `scan`/`status`. Returns
+ * `{participating: false}` when the cwd is NOT a participating repo (the callers
+ * then render only the registry view, unchanged). When participating it:
+ *
+ *   1. FETCHES the cwd repo's arbiter first (warn + fall back to last-known on
+ *      failure — never errors), then computes the divergence vs `<arbiter>/main`;
+ *   2. reads the COORDINATION arbiter's HELD-LOCK set (the remote where
+ *      `refs/dorfl/lock/*` live, default `origin`; fail-closed: throws when that
+ *      remote exists but is unreachable) to SUBTRACT in-flight items from the pool;
+ *   3. reads the cwd's `work/` lifecycle from the LOCAL WORKING TREE
+ *      (`scanRepoPaths([cwd])`) with that held set subtracted;
+ *   4. de-dups against the registry (is the cwd's arbiter URL a registered
+ *      mirror?).
+ *
+ * It MUTATES nothing but the arbiter fetch (a read refresh, same as the registry
+ * fetch-first); it never claims/moves/integrates.
+ */
+export async function resolveCwdSection(options) {
+    const { cwd, config, warn, env } = options;
+    if (!isParticipatingRepo(cwd)) {
+        return { path: cwd, participating: false };
+    }
+    // 1. The cwd repo's arbiter + fetch-first divergence. We resolve the arbiter
+    //    via the SAME `arbiterStatus` the dashboard's arbiter section uses; if it
+    //    is configured we fetch it BEFORE diffing (the local tree is the least
+    //    authoritative view) — warn + fall back to last-known on failure. Resolved
+    //    FIRST (before the pool read) so the held-lock subtraction below reads that
+    //    same arbiter's lock refs.
+    const arbiter = await resolveCwdArbiter({
+        cwd,
+        remote: options.arbiterRemote,
+        warn,
+        env,
+    });
+    // 2. The held-lock set to SUBTRACT from the cwd pool (the SELECTION fix). The
+    //    lock refs live on the COORDINATION arbiter (`refs/dorfl/lock/*`) — the SAME
+    //    remote `claim`/`do` use, default `origin` — NOT the `arbiter`-named
+    //    DIVERGENCE remote resolved above (this repo has no `arbiter` remote; its
+    //    arbiter IS `origin`). So we read the held set from the coordination remote
+    //    and FAIL CLOSED on a read fault (`heldTaskSlugsStrict` throws): an offline /
+    //    unreachable arbiter makes the eligible pool UNKNOWN, and we must NOT emit a
+    //    confident-but-wrong pool (which CI would enumerate into doomed claim legs).
+    //    A repo with NO coordination remote configured has nothing to subtract and
+    //    nothing to fail against — it keeps the empty set.
+    const lockRemote = options.lockArbiterRemote ?? 'origin';
+    const hasLockRemote = remoteExists(cwd, lockRemote, env);
+    const heldSlugs = hasLockRemote
+        ? await heldTaskSlugsStrict(cwd, lockRemote, env)
+        : new Set();
+    // 3. The cwd's `work/` lifecycle from the LOCAL WORKING TREE (not a mirror ref),
+    //    with the arbiter-read held set SUBTRACTED so in-flight (lock-held) items are
+    //    not reported eligible. Thread the per-machine override so the cwd section's
+    //    eligibility matches what `do`/`advance` autopick will actually select.
+    const localReport = scanRepoPaths([cwd], config, heldSlugs, options.override);
+    const repo = localReport.repos[0];
+    // 3b. The PER-ITEM LOCK in-flight SURFACE for the cwd (prd
+    //     `ledger-status-per-item-lock-refs` US #8). The subtraction above removes a
+    //     held slug from the eligible `items[]` pool; on its OWN that leaves a
+    //     held/stuck cwd item in a BLIND SPOT — gone from every bucket with nothing
+    //     explaining why (the regression this fixes). The registry/mirror `scan`
+    //     attaches `lockHeld` to each `RepoReport` so a held item still shows up
+    //     in-progress/stuck; the cwd `RepoReport` from `scanRepoPaths` did not. So we
+    //     read the SAME held lock entries (action × state + reason/questions) via the
+    //     SAME `listItemLockEntries` primitive the mirror path uses (NOT a second
+    //     reader) and attach them, making `.cwd.repo.lockHeld` symmetric with
+    //     `.repos[].lockHeld`.
+    //
+    //     This is a SURFACE only, and it is INTENTIONALLY graceful (best-effort,
+    //     empty on any fault — exactly as `listItemLockEntries` is on the mirror
+    //     side): a read fault degrades to "no in-flight locks shown", it must NOT
+    //     fail the section. The SELECTION subtraction above stays STRICT
+    //     (`heldTaskSlugsStrict`, fail-closed) — the two reads have deliberately
+    //     different fault models (selection fails closed; the surface degrades).
+    //     Read from the SAME coordination remote the subtraction used. A repo with no
+    //     coordination remote has no lock refs to read — empty surface.
+    if (repo !== undefined && hasLockRemote) {
+        const lockHeld = await listItemLockEntries(cwd, lockRemote, env);
+        if (lockHeld.length > 0) {
+            repo.lockHeld = lockHeld;
+        }
+    }
+    // 4. De-dup: is the cwd's arbiter URL a registered hub mirror? Compare the
+    //    cwd's mirror KEY (from its arbiter URL) against the registry's keys.
+    const { alsoRegistered, registeredMirrorPath } = resolveRegistration({
+        arbiterUrl: arbiter?.url,
+        config,
+        env,
+    });
+    return {
+        path: cwd,
+        participating: true,
+        repo,
+        totalItems: localReport.totalItems,
+        totalEligible: localReport.totalEligible,
+        alsoRegistered,
+        ...(registeredMirrorPath !== undefined ? { registeredMirrorPath } : {}),
+        ...(arbiter !== undefined ? { arbiter } : {}),
+    };
+}
+/**
+ * Resolve the cwd repo's arbiter + divergence. Reuses `arbiterStatus` to find
+ * the arbiter remote/URL, FETCHES its `main` first (warn + fall back to
+ * last-known on failure — NEVER errors, ADR §5/§6), then reads the divergence of
+ * local `main` vs `<arbiter>/main` in both directions. Returns `undefined` when
+ * no arbiter remote is configured (no divergence line to show).
+ */
+async function resolveCwdArbiter(input) {
+    const { cwd, env } = input;
+    const status = arbiterStatus({ cwd, remote: input.remote, env });
+    if (!status.configured) {
+        return undefined;
+    }
+    const remote = status.remote;
+    // Fetch-first ALSO for the cwd (the maintainer's explicit ask): refresh the
+    // arbiter's `main` before diffing, reusing scan-status-fetch-first's
+    // fetch+warn+fallback. A failed fetch is NOT fatal — warn + last-known.
+    let fetched = false;
+    const fetch = await runAsync('git', ['fetch', '--quiet', remote], cwd, { env });
+    if (fetch.status === 0) {
+        fetched = true;
+    }
+    else {
+        input.warn?.(`could not fetch the cwd repo's arbiter '${remote}'; ` +
+            'computing local divergence from last-known (offline). ' +
+            fetch.stderr.trim());
+    }
+    const { ahead, behind } = await localMainDivergence(cwd, remote, env);
+    return {
+        remote,
+        configured: true,
+        url: status.url,
+        fetched,
+        ahead,
+        behind,
+    };
+}
+/**
+ * De-dup helper: is the cwd repo (identified by its arbiter URL) ALSO registered
+ * in the registry? The registry keys a mirror off its arbiter URL via
+ * `encodeRepoKey`/`mirrorPath`, so we encode the cwd's arbiter URL the same way
+ * and look for a matching registered mirror (by key, robust to the lossy URL).
+ * Returns whether it is registered + the matching mirror path (so the registry
+ * view can drop that row). With no arbiter URL there is nothing to match.
+ */
+function resolveRegistration(input) {
+    const { arbiterUrl, config, env } = input;
+    if (arbiterUrl === undefined || arbiterUrl.trim() === '') {
+        return { alsoRegistered: false };
+    }
+    const cwdKey = encodeRepoKey(arbiterUrl);
+    const cwdMirrorPath = mirrorPath(config.workspacesDir, arbiterUrl);
+    for (const mirror of listMirrors({
+        workspacesDir: config.workspacesDir,
+        env,
+    })) {
+        if (mirror.key === cwdKey || mirror.path === cwdMirrorPath) {
+            return { alsoRegistered: true, registeredMirrorPath: mirror.path };
+        }
+    }
+    return { alsoRegistered: false };
+}
+//# sourceMappingURL=cwd-section.js.map

package/dist/cwd-section.js.map

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

package/dist/decision-engine.d.ts

@@ -0,0 +1,170 @@
+/**
+ * **The SHARED decision engine** (prd
+ * `agentic-question-resolution-retire-disposition-vocabulary` US #9, decision 3 +
+ * 13/14; task `decision-engine-shared-decide-seam`): the GENERALISED
+ * `decide(input, allowedOutcomes) → verdict` core every question-resolution
+ * decision is built on. It is the same `prompt → VERDICT → dispatch` shape
+ * `intake` already has, lifted into ONE outcome-AGNOSTIC engine so intake and the
+ * advance-apply rung share the machinery WITHOUT being forced to identical
+ * verdicts or inputs.
+ *
+ * Two things are parameters, NOT hard-coded into the engine:
+ *
+ * - **the INPUT-ADAPTER** ({@link DecisionDecider}'s `TInput`): each caller's
+ *   front door reads a DIFFERENT thing (intake reads an issue + its comment
+ *   thread; advance-apply reads an answered sidecar + its source item). The engine
+ *   never knows that shape — it threads the caller's `input` opaquely to the
+ *   injected decider, so the adapter boundary sits OUTSIDE the engine (decision 3:
+ *   "the INPUT adapter differs per front door and is NOT forced to be shared").
+ * - **the ALLOWED-OUTCOME SET** ({@link decide}'s `allowedOutcomes`): each caller
+ *   passes the SUBSET of {@link DecisionOutcome} it permits — advance-apply allows
+ *   `{task | prd | adr | delete | ask}`, intake keeps its own `{task | prd | ask |
+ *   bounce}` (intake is NOT refactored onto this engine here — decision 13). The
+ *   engine never hard-codes which outcomes a caller permits; it only VALIDATES the
+ *   returned verdict against the set and rejects (loudly) one outside it
+ *   (decision 14: "the engine stays outcome-AGNOSTIC", so `adr` can be added to a
+ *   caller later WITHOUT re-architecting).
+ *
+ * This module is the PURE engine + its types ONLY — no fs, no git, no seam ops, no
+ * wiring into `sidecar.ts` / `apply-persist.ts` / `intake.ts`. The keystone apply
+ * task (`agentic-apply-retire-disposition-vocabulary`) consumes it next; intake
+ * adopting `adr` is a separate decision (the engine being agnostic means it CAN
+ * be added later).
+ */
+/**
+ * The SUPERSET of outcomes the engine knows — a "verdict" is what an agent
+ * decides to DO with an input (the analogue of intake's {@link IntakeOutcome}):
+ *
+ * - **task** — mint a self-contained task from the input.
+ * - **spec** — mint a spec from the input.
+ * - **adr** — mint an adr from the input (NO caller wires this yet; the keystone's
+ *   allowed set will, and `agentic-apply-mint-adr-route` adds the route — decision
+ *   14 keeps the engine agnostic so this is added without re-architecting).
+ * - **delete** — delete the SOURCE the input is about (a direct, git-recoverable
+ *   removal — decision 12).
+ * - **ask** — ask the operator a follow-up (re-pause; the conversation
+ *   accumulates — decision 5).
+ *
+ * No caller is forced to allow ALL of these: each passes its own SUBSET to
+ * {@link decide}. The engine is agnostic to which subset a caller permits.
+ */
+export type DecisionOutcome = 'task' | 'spec' | 'adr' | 'delete' | 'ask';
+/**
+ * The VERDICT the decider returns — the chosen {@link DecisionOutcome} plus the
+ * DRAFTED content for that outcome (the analogue of {@link IntakeVerdict}). Every
+ * content field is OPTIONAL on the shape: a given verdict only fills the channels
+ * its outcome consumes (a `task` fills the task channels, an `ask` fills
+ * `question`, a `delete` may carry only a `reason`). The dispatching CALLER
+ * decides which channels it requires for each outcome it allows — the engine only
+ * guards the `outcome` discriminator against the allowed set, never the content
+ * (it stays outcome-agnostic).
+ */
+export interface DecisionVerdict {
+    /** Which outcome the decider chose for the input. */
+    outcome: DecisionOutcome;
+    /** The drafted task's content-derived slug (`task` outcome). */
+    taskSlug?: string;
+    /** The drafted task's `title:` (`task` outcome). */
+    taskTitle?: string;
+    /**
+     * The drafted task BODY (`task` outcome) — the markdown AFTER the frontmatter.
+     * The dispatching caller writes the frontmatter; the agent never writes
+     * git-visible files (the in-band boundary intake already follows).
+     */
+    taskBody?: string;
+    /** The drafted spec's content-derived slug (`spec` outcome). */
+    specSlug?: string;
+    /** The drafted spec's `title:` (`spec` outcome). */
+    specTitle?: string;
+    /** The drafted spec BODY (`spec` outcome) — the markdown AFTER the frontmatter. */
+    specBody?: string;
+    /** The drafted adr's content-derived slug (`adr` outcome). */
+    adrSlug?: string;
+    /** The drafted adr's `title:` (`adr` outcome). */
+    adrTitle?: string;
+    /** The drafted adr BODY (`adr` outcome) — the markdown AFTER the frontmatter. */
+    adrBody?: string;
+    /**
+     * The reason the source should be deleted (`delete` outcome) — the caller
+     * carries it into the revertible deletion's commit message (decision 12: the
+     * delete is git-recoverable, the reason in the commit message).
+     */
+    deleteReason?: string;
+    /**
+     * The drafted follow-up question(s) (`ask` outcome) — the caller appends them
+     * to the conversation and re-pauses (decision 5: reuse the existing
+     * append/re-pause loop).
+     */
+    question?: string;
+}
+/**
+ * The DECISION step: given the caller's `input` (whatever its input-adapter
+ * shaped), return a {@link DecisionVerdict}. This is the INJECTED, STUBBABLE seam
+ * — exactly like intake's `IntakeDecider`: production wires a harness/agent; tests
+ * inject a CANNED verdict (no model, no network). The engine is generic over
+ * `TInput` so the adapter boundary sits in the CALLER, never in the engine.
+ */
+export type DecisionDecider<TInput> = (input: TInput) => Promise<DecisionVerdict>;
+/**
+ * Thrown when a returned verdict's `outcome` is OUTSIDE the caller's
+ * `allowedOutcomes`. The engine NEVER silently coerces an out-of-set verdict — a
+ * caller that does not allow `adr` can never receive an `adr` verdict; it gets
+ * this loud rejection instead (the allowed-outcome guard).
+ */
+export declare class DisallowedOutcomeError extends Error {
+    /** The outcome the decider returned that was not permitted. */
+    readonly outcome: DecisionOutcome;
+    /** The set the caller allowed (the SUBSET it passed to {@link decide}). */
+    readonly allowed: readonly DecisionOutcome[];
+    constructor(outcome: DecisionOutcome, allowed: readonly DecisionOutcome[]);
+}
+/**
+ * Thrown when `allowedOutcomes` itself is EMPTY — a caller that allows no outcome
+ * can never receive a valid verdict, so this is a programming error caught up
+ * front rather than surfaced as a confusing per-verdict rejection.
+ */
+export declare class EmptyAllowedOutcomesError extends Error {
+    constructor();
+}
+/**
+ * **The engine core.** Run the injected `decide`r over the caller's `input`, then
+ * VALIDATE the returned verdict's `outcome` against `allowedOutcomes` — the
+ * caller's permitted SUBSET of {@link DecisionOutcome}. Returns the verdict
+ * verbatim when it is in the set; throws {@link DisallowedOutcomeError} (loudly)
+ * when it is not. Throws {@link EmptyAllowedOutcomesError} when the set is empty.
+ *
+ * The engine is outcome-AGNOSTIC: it hard-codes NO caller's outcomes and inspects
+ * ONLY the `outcome` discriminator (never the per-outcome content channels — those
+ * are the dispatching caller's concern). The INPUT-ADAPTER boundary sits in the
+ * caller: `input` is threaded opaquely to the decider, so the engine never knows
+ * its shape.
+ *
+ * @param input the caller's adapter-shaped input (issue thread, answered sidecar
+ *   + source item, …) — opaque to the engine.
+ * @param decide the INJECTED decision seam (tests pass a canned verdict; prod a
+ *   harness-backed one).
+ * @param allowedOutcomes the caller's permitted subset (an array or any
+ *   iterable). Order is preserved in the rejection message.
+ */
+export declare function decide<TInput>(input: TInput, decide: DecisionDecider<TInput>, allowedOutcomes: Iterable<DecisionOutcome>): Promise<DecisionVerdict>;
+/**
+ * Parse a decider's emitted VERDICT out of its (possibly prose-wrapped / fenced)
+ * textual output into a {@link DecisionVerdict} — the PRODUCTION-WIRE helper a
+ * harness-backed {@link DecisionDecider} uses to recover the verdict an agent
+ * emitted, modeled 1:1 on intake's `parseIntakeVerdict`. It pulls the first JSON
+ * object carrying an `"outcome"` field via the SHARED {@link extractJsonObjectSpan}
+ * (the same extractor every prompt→verdict→dispatch seam in this package uses —
+ * NOT a forked copy), `JSON.parse`s it, and validates the shape:
+ * `outcome ∈ {task,spec,adr,delete,ask}`.
+ *
+ * This validates the verdict is a WELL-FORMED member of the SUPERSET; the
+ * caller-specific allowed-outcome guard ({@link decide}) then rejects one outside
+ * the caller's SUBSET. The two checks are distinct: shape here, policy there.
+ *
+ * THROWS a clear error on: no JSON object present, invalid JSON, or an `outcome`
+ * not in the superset. A harness-backed decider lets the throw propagate so the
+ * caller maps it onto its own agent-failed path (a malformed verdict degrades
+ * honestly, never a crash and never a silent dispatch).
+ */
+export declare function parseDecisionVerdict(output: string): DecisionVerdict;
+//# sourceMappingURL=decision-engine.d.ts.map

package/dist/decision-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decision-engine.d.ts","sourceRoot":"","sources":["../src/decision-engine.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH;;;;;;;;;;;;;;;;GAgBG;AAKH,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,KAAK,CAAC;AAEzE;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe;IAC/B,qDAAqD;IACrD,OAAO,EAAE,eAAe,CAAC;IACzB,gEAAgE;IAChE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oDAAoD;IACpD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gEAAgE;IAChE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oDAAoD;IACpD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mFAAmF;IACnF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,8DAA8D;IAC9D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kDAAkD;IAClD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iFAAiF;IACjF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,CAAC,MAAM,IAAI,CACrC,KAAK,EAAE,MAAM,KACT,OAAO,CAAC,eAAe,CAAC,CAAC;AAE9B;;;;;GAKG;AACH,qBAAa,sBAAuB,SAAQ,KAAK;IAChD,+DAA+D;IAC/D,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,CAAC;gBACjC,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,SAAS,eAAe,EAAE;CAUzE;AAED;;;;GAIG;AACH,qBAAa,yBAA0B,SAAQ,KAAK;;CAQnD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,MAAM,CAAC,MAAM,EAClC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,eAAe,CAAC,MAAM,CAAC,EAC/B,eAAe,EAAE,QAAQ,CAAC,eAAe,CAAC,GACxC,OAAO,CAAC,eAAe,CAAC,CAW1B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CA0DpE"}

package/dist/decision-engine.js

@@ -0,0 +1,136 @@
+import { extractJsonObjectSpan } from './verdict-json.js';
+/**
+ * Thrown when a returned verdict's `outcome` is OUTSIDE the caller's
+ * `allowedOutcomes`. The engine NEVER silently coerces an out-of-set verdict — a
+ * caller that does not allow `adr` can never receive an `adr` verdict; it gets
+ * this loud rejection instead (the allowed-outcome guard).
+ */
+export class DisallowedOutcomeError extends Error {
+    /** The outcome the decider returned that was not permitted. */
+    outcome;
+    /** The set the caller allowed (the SUBSET it passed to {@link decide}). */
+    allowed;
+    constructor(outcome, allowed) {
+        super(`decision verdict 'outcome' ${JSON.stringify(outcome)} is not in the ` +
+            `caller's allowed set {${allowed.join(' | ')}}; the engine rejects an ` +
+            `out-of-set verdict rather than coercing it.`);
+        this.name = 'DisallowedOutcomeError';
+        this.outcome = outcome;
+        this.allowed = allowed;
+    }
+}
+/**
+ * Thrown when `allowedOutcomes` itself is EMPTY — a caller that allows no outcome
+ * can never receive a valid verdict, so this is a programming error caught up
+ * front rather than surfaced as a confusing per-verdict rejection.
+ */
+export class EmptyAllowedOutcomesError extends Error {
+    constructor() {
+        super('decide() was called with an EMPTY allowedOutcomes set; a caller must ' +
+            'allow at least one outcome.');
+        this.name = 'EmptyAllowedOutcomesError';
+    }
+}
+/**
+ * **The engine core.** Run the injected `decide`r over the caller's `input`, then
+ * VALIDATE the returned verdict's `outcome` against `allowedOutcomes` — the
+ * caller's permitted SUBSET of {@link DecisionOutcome}. Returns the verdict
+ * verbatim when it is in the set; throws {@link DisallowedOutcomeError} (loudly)
+ * when it is not. Throws {@link EmptyAllowedOutcomesError} when the set is empty.
+ *
+ * The engine is outcome-AGNOSTIC: it hard-codes NO caller's outcomes and inspects
+ * ONLY the `outcome` discriminator (never the per-outcome content channels — those
+ * are the dispatching caller's concern). The INPUT-ADAPTER boundary sits in the
+ * caller: `input` is threaded opaquely to the decider, so the engine never knows
+ * its shape.
+ *
+ * @param input the caller's adapter-shaped input (issue thread, answered sidecar
+ *   + source item, …) — opaque to the engine.
+ * @param decide the INJECTED decision seam (tests pass a canned verdict; prod a
+ *   harness-backed one).
+ * @param allowedOutcomes the caller's permitted subset (an array or any
+ *   iterable). Order is preserved in the rejection message.
+ */
+export async function decide(input, decide, allowedOutcomes) {
+    const allowed = [...allowedOutcomes];
+    if (allowed.length === 0) {
+        throw new EmptyAllowedOutcomesError();
+    }
+    const allowedSet = new Set(allowed);
+    const verdict = await decide(input);
+    if (!allowedSet.has(verdict.outcome)) {
+        throw new DisallowedOutcomeError(verdict.outcome, allowed);
+    }
+    return verdict;
+}
+/**
+ * Parse a decider's emitted VERDICT out of its (possibly prose-wrapped / fenced)
+ * textual output into a {@link DecisionVerdict} — the PRODUCTION-WIRE helper a
+ * harness-backed {@link DecisionDecider} uses to recover the verdict an agent
+ * emitted, modeled 1:1 on intake's `parseIntakeVerdict`. It pulls the first JSON
+ * object carrying an `"outcome"` field via the SHARED {@link extractJsonObjectSpan}
+ * (the same extractor every prompt→verdict→dispatch seam in this package uses —
+ * NOT a forked copy), `JSON.parse`s it, and validates the shape:
+ * `outcome ∈ {task,spec,adr,delete,ask}`.
+ *
+ * This validates the verdict is a WELL-FORMED member of the SUPERSET; the
+ * caller-specific allowed-outcome guard ({@link decide}) then rejects one outside
+ * the caller's SUBSET. The two checks are distinct: shape here, policy there.
+ *
+ * THROWS a clear error on: no JSON object present, invalid JSON, or an `outcome`
+ * not in the superset. A harness-backed decider lets the throw propagate so the
+ * caller maps it onto its own agent-failed path (a malformed verdict degrades
+ * honestly, never a crash and never a silent dispatch).
+ */
+export function parseDecisionVerdict(output) {
+    const span = extractJsonObjectSpan(output, 'outcome');
+    if (span === undefined) {
+        throw new Error('decision agent produced no parseable {outcome, …} verdict.');
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(output.slice(span.start, span.end));
+    }
+    catch (err) {
+        throw new Error(`decision verdict was not valid JSON: ${err.message}`);
+    }
+    if (typeof parsed !== 'object' || parsed === null) {
+        throw new Error('decision verdict was not an object.');
+    }
+    const obj = parsed;
+    const outcome = obj.outcome;
+    if (outcome !== 'task' &&
+        outcome !== 'spec' &&
+        outcome !== 'adr' &&
+        outcome !== 'delete' &&
+        outcome !== 'ask') {
+        throw new Error(`decision verdict 'outcome' was not one of task|spec|adr|delete|ask (got ` +
+            `${JSON.stringify(outcome)}).`);
+    }
+    // Map the per-outcome fields onto the verdict shape, keeping ONLY the strings
+    // the dispatcher consumes (a missing optional stays absent). Every field is
+    // optional on the type, so each outcome's content is carried verbatim when
+    // present — the engine never demands a channel (it stays outcome-agnostic).
+    const str = (v) => typeof v === 'string' ? v : undefined;
+    return {
+        outcome,
+        ...(str(obj.taskSlug) !== undefined ? { taskSlug: str(obj.taskSlug) } : {}),
+        ...(str(obj.taskTitle) !== undefined
+            ? { taskTitle: str(obj.taskTitle) }
+            : {}),
+        ...(str(obj.taskBody) !== undefined ? { taskBody: str(obj.taskBody) } : {}),
+        ...(str(obj.specSlug) !== undefined ? { specSlug: str(obj.specSlug) } : {}),
+        ...(str(obj.specTitle) !== undefined
+            ? { specTitle: str(obj.specTitle) }
+            : {}),
+        ...(str(obj.specBody) !== undefined ? { specBody: str(obj.specBody) } : {}),
+        ...(str(obj.adrSlug) !== undefined ? { adrSlug: str(obj.adrSlug) } : {}),
+        ...(str(obj.adrTitle) !== undefined ? { adrTitle: str(obj.adrTitle) } : {}),
+        ...(str(obj.adrBody) !== undefined ? { adrBody: str(obj.adrBody) } : {}),
+        ...(str(obj.deleteReason) !== undefined
+            ? { deleteReason: str(obj.deleteReason) }
+            : {}),
+        ...(str(obj.question) !== undefined ? { question: str(obj.question) } : {}),
+    };
+}
+//# sourceMappingURL=decision-engine.js.map

package/dist/decision-engine.js.map

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

package/dist/detect.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A repo participates iff any of its lifecycle-bearing `work/` pools
+ * ({@link PARTICIPATING_POOLS}) contains at least one `.md` file. This is the
+ * predicate `remote find` (ADR §1) filters on AND the fetch-free gate
+ * `scan`/`status` use before resolving the (expensive) cwd section.
+ */
+export declare function isParticipatingRepo(repoPath: string): boolean;
+/**
+ * Find every `work/`-participating repo under `folder` (recursively), pruning
+ * `node_modules`/dotdirs and not descending into a participating repo. The
+ * returned list is deduplicated and sorted (deterministic). This is the
+ * discovery primitive behind `remote find <folder>` (ADR §1): the caller filters
+ * on {@link isParticipatingRepo} and toggle-adds the chosen ones via `remote
+ * add`. A non-existent / non-directory `folder` yields `[]` (never throws).
+ */
+export declare function findParticipatingRepos(folder: string): string[];
+//# sourceMappingURL=detect.d.ts.map

package/dist/detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../src/detect.ts"],"names":[],"mappings":"AAyCA;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE7D;AAoDD;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAc/D"}