@opum-ai/lore 0.1.0 → 0.1.1

package/src/commands/query.ts

@@ -1,312 +0,0 @@
-/**
- * commands/query.ts — `lore query ["<text>"] [--type <T>] [--tag <t>]… [--status <S>] [--field k=v]… [--limit <n>]`.
- *
- * The thin, read-only layer behind the bundle's full-text search (cli-surface
- * §query; LORE-33). Commander supplies a verified indexed {@link BundleGraph}
- * with automatic reference fallback; direct core callers retain the reference
- * loader. The optional search text and frontmatter filters then go to the pure
- * {@link query} engine, which keeps concepts matching every filter, ranks them
- * by BM25 relevance, and returns the top `--limit` hits with a bounded-output
- * signal. **No vectors, RAG, or chunking** (ADR-0018): the lexical index remains
- * deterministic and in memory.
- *
- * Output follows the uniform CLI modes: the `{schemaVersion, kind: "query.results",
- * data}` envelope under the global `--json`, otherwise a ranked listing — one
- * `<id>  [<type>]  (<score>)  — <snippet>` line per hit followed by the §3 truncation
- * footer when the `--limit` cap dropped matches. There is no command-specific JSON
- * flag; machine consumers use the same `--json` they use everywhere. The pretty and
- * plain renderers are identical (the listing is structural — no severities to color),
- * so they share one renderer.
- *
- * Validation lives here (the ranking/filtering stays pure in `core/query.ts`): an
- * unknown flag, a repeated `--type`/`--status`/`--limit`, a value-less value flag, a
- * non-integer/too-large/non-positive `--limit`, a malformed `--field` (no `=` or an
- * empty key), or a second positional is a `usage` error (exit 2). `query` never looks
- * an id up, so there is no `not_found` path — zero hits is a normal exit 0.
- */
-
-import { join } from "node:path";
-import type { BacklogAdapter } from "../adapters/backlog";
-import { loadBundle } from "../core/bundle";
-import { loadProfile } from "../core/profile";
-import { type FieldFilter, type QueryResult, query } from "../core/query";
-import { loadRetrievalGraph, type RetrievalGraphLoader } from "../core/retrieval";
-import { DOCS_DIR } from "../core/scaffold";
-import type { WorkspaceRetrievalContext, WorkspaceRetrievalSelection } from "../core/workspace-retrieval";
-import { EXIT_OK, LoreError, singleLine, stripAnsiAndControls, WarningCollector, type Writer } from "../errors";
-import { emit, type OutputContext, type Renderable, renderTruncationLine, truncation } from "../output";
-import { optionValues, parseCommandArgs, singleOptionValue, workspaceSelection } from "./args";
-
-/** Options for {@link runQuery}; `root` and the streams are injectable for tests. */
-export interface QueryCommandOptions {
-  /** The repo root the `docs/` bundle resolves against. */
-  root: string;
-  /** The resolved output mode/color (from `output.ts`). */
-  output: OutputContext;
-  /** The command's normalized positional + flag tokens from Commander. */
-  args: readonly string[];
-  /** stdout sink; defaults to `process.stdout`. */
-  stdout?: Writer;
-  /** stderr sink for advisory warnings; defaults to `process.stderr`. */
-  stderr?: Writer;
-  /** Backlog snapshot seam used only by indexed projection freshness/builds. */
-  adapter?: BacklogAdapter;
-  /** Indexed/reference selector injected by the Commander handler or conformance tests. */
-  retrieval?: RetrievalGraphLoader;
-}
-
-/** The parsed form of `lore query`'s arguments. */
-interface QueryArgs {
-  /** The free-text search (the optional positional); `undefined` means filters-only. */
-  text?: string;
-  /** `--type` (at most once). */
-  type?: string;
-  /** `--status` (at most once). */
-  status?: string;
-  /** `--limit` (at most once); `undefined` falls back to the engine default. */
-  limit?: number;
-  /** `--tag` values, in order (repeatable). */
-  tags: string[];
-  /** `--field key=value` filters, in order (repeatable). */
-  fields: FieldFilter[];
-  readonly workspace?: WorkspaceRetrievalSelection;
-}
-
-/** The narrow-it hint on the §3 truncation line (AC#2) — the actionable ways to bound a broad result. */
-const NARROW_HINT = "narrow with --type/--tag/--status/--field, or raise --limit";
-
-/**
- * Run `lore query`: parse the arguments, load the bundle, search it, emit the
- * `query.results`, and return `0`. A bad flag/positional throws a `usage`
- * {@link LoreError} (exit `2`); there is no not-found path (zero hits is a normal `0`).
- */
-export function runQuery(options: QueryCommandOptions): number | Promise<number> {
-  const parsed = parseQueryArgs(options.args);
-  const advisories = new WarningCollector();
-  const retrieval = options.retrieval ?? (parsed.workspace !== undefined ? loadRetrievalGraph : undefined);
-  if (retrieval !== undefined) {
-    return retrieval({
-      root: options.root,
-      warnings: advisories,
-      adapter: options.adapter,
-      ...(parsed.workspace !== undefined ? { workspace: parsed.workspace } : {}),
-    }).then(async (loaded) => {
-      try {
-        const indexedResult = await loaded.indexed?.query({
-          text: parsed.text,
-          type: parsed.type,
-          tags: parsed.tags,
-          status: parsed.status,
-          fields: parsed.fields,
-          limit: parsed.limit,
-        });
-        return finishQuery(options, parsed, loaded.graph, advisories, indexedResult, loaded.workspace);
-      } finally {
-        await loaded.dispose?.();
-      }
-    });
-  }
-  const profile = loadProfile({ root: options.root });
-  const graph = loadBundle(join(options.root, DOCS_DIR), { warnings: advisories, profile });
-  return finishQuery(options, parsed, graph, advisories);
-}
-
-function finishQuery(
-  options: QueryCommandOptions,
-  parsed: QueryArgs,
-  graph: ReturnType<typeof loadBundle>,
-  advisories: WarningCollector,
-  indexedResult?: QueryResult,
-  workspace?: WorkspaceRetrievalContext,
-): number {
-  advisories.flush({ color: options.output.color, stderr: options.stderr });
-
-  const data =
-    indexedResult ??
-    query(graph, {
-      text: parsed.text,
-      type: parsed.type,
-      tags: parsed.tags,
-      status: parsed.status,
-      fields: parsed.fields,
-      limit: parsed.limit,
-    });
-  const scoped: QueryResult =
-    workspace === undefined
-      ? data
-      : {
-          ...data,
-          hits: data.hits.map((hit) => ({ ...hit, provenance: workspace.provenanceById.get(hit.id) })),
-          workspace: workspace.scope,
-        };
-  emit(queryRenderable(scoped), options.output, options.stdout);
-  return EXIT_OK;
-}
-
-// ── Argument parsing ───────────────────────────────────────────────────────────
-
-/**
- * Parse `query`'s tokens into the optional text positional and the value flags
- * (`--type`/`--status`/`--limit` at most once each; `--tag`/`--field` repeatable),
- * also accepting the `--flag=value` form. Commander has already resolved Lore's
- * global flags, so a `--`-prefixed token here is a command flag: an unrecognized one
- * is a `usage` error, as is a repeated single-value flag, a value-less value flag, a
- * non-integer/out-of-range `--limit`, a malformed `--field`, or a second positional.
- * A `--` ends option parsing.
- */
-function parseQueryArgs(args: readonly string[]): QueryArgs {
-  const parsed = parseCommandArgs(args, "query");
-  const workspace = workspaceSelection(parsed);
-  const positionals = parsed.positionals;
-  const trimmed = (name: string): string | undefined => {
-    const value = singleOptionValue(parsed, name);
-    if (value === undefined) return undefined;
-    const result = value.trim();
-    if (result === "") throw usage(`--${name} needs a value`, `pass a value, e.g. \`--${name} orders\``);
-    return result;
-  };
-  const type = trimmed("type");
-  const status = trimmed("status");
-  const rawLimit = singleOptionValue(parsed, "limit");
-  if (rawLimit === "") throw usage("--limit needs a value", "pass a value, e.g. `--limit orders`");
-  const limit = rawLimit === undefined ? undefined : parseCount("--limit", rawLimit);
-  const tags = optionValues(parsed, "tag").map((value) => {
-    const tag = value.trim();
-    if (tag === "") throw usage("--tag needs a value", "pass a value, e.g. `--tag orders`");
-    return tag;
-  });
-  const fields = optionValues(parsed, "field").map(parseFieldFilter);
-  if (positionals.length > 1) {
-    throw usage(
-      `unexpected argument "${positionals[1]}"`,
-      'pass one quoted search string, e.g. `lore query "soft delete retention"`',
-    );
-  }
-  return { text: positionals[0], type, status, limit, tags, fields, workspace };
-}
-
-/**
- * Parse a `--field` argument into a `key=value` {@link FieldFilter}. Splits on the
- * **first** `=` (so a value may itself contain `=`); both sides are **trimmed** (the
- * comparison folds case and ignores surrounding space, so a padded `status= Done` must
- * not silently miss). A missing `=`, an empty key, or an **empty value** is a `usage`
- * error — the latter matching the empty-value guard {@link readValue} enforces for every
- * other flag, so `--field status=` is rejected rather than matching only a literally
- * empty field.
- */
-function parseFieldFilter(raw: string): FieldFilter {
-  const eq = raw.indexOf("=");
-  if (eq === -1) {
-    throw usage(`invalid --field "${raw}"`, "use key=value, e.g. `--field status=in-progress`");
-  }
-  const key = raw.slice(0, eq).trim();
-  if (key === "") {
-    throw usage(`invalid --field "${raw}"`, "the field name before = must not be empty");
-  }
-  const value = raw.slice(eq + 1).trim();
-  if (value === "") {
-    throw usage(`invalid --field "${raw}"`, "the value after = must not be empty");
-  }
-  return { key, value };
-}
-
-/**
- * Parse `--limit`'s value as a positive integer. Rejects a non-digit run (`Number()`
- * would coerce `"1.5"`/`"0x2"`/`" 2 "`/`"1e3"`), `0` (a zero cap returns nothing
- * useful), and a precision-losing `> 2^53` run — mirroring the count guard `lore
- * graph`/`context` use so the commands accept counts identically.
- */
-function parseCount(flag: string, value: string): number {
-  if (!/^\d+$/.test(value)) {
-    throw usage(`invalid ${flag} "${value}"`, `pass an integer ≥ 1, e.g. \`${flag} 20\``);
-  }
-  const count = Number.parseInt(value, 10);
-  if (!Number.isSafeInteger(count)) {
-    throw usage(`${flag} "${value}" is too large`, "pass a smaller integer");
-  }
-  if (count < 1) {
-    throw usage(`invalid ${flag} "${value}"`, `pass an integer ≥ 1, e.g. \`${flag} 20\``);
-  }
-  return count;
-}
-
-/**
- * Read a value flag's argument: its inline `--flag=value` form when present, else the
- * **next** token. A missing/empty value — or a next token that is itself an option
- * (`--type --tag`) — is a `usage` error rather than a silently swallowed flag
- * (mirroring `lore graph`/`context`'s value-flag guard).
- */
-// ── Output ─────────────────────────────────────────────────────────────────────
-
-/**
- * The per-result rendering bundle for `query` (output.ts dispatches on the mode).
- * `--json` always carries the structured {@link QueryResult}; the pretty/plain text is
- * the ranked listing. The two text modes render identically (the data is structural —
- * no severities to color), so pretty and plain share one renderer.
- */
-function queryRenderable(data: QueryResult): Renderable<QueryResult> {
-  return { kind: "query.results", data, pretty: renderText, plain: renderText };
-}
-
-/**
- * A human/pipe-stable ranked listing: a `query "<text>": <n> matches` header (or
- * `query (filters): …` when filters drove the result), one `<id>  [<type>]
- * (<score>)  — <snippet>` line per hit (the `(<score>)` shown only under a text query;
- * the `— <snippet>` dropped when the concept has neither summary nor title), and the
- * trailing §3 truncation footer when the `--limit` cap dropped matches. ANSI-free and
- * deterministic: the query text and every hit's `id`/`type`/`snippet` are sanitized
- * ({@link sanitizeField}) before interpolation, so a crafted concept file (an id, a
- * `type`/`summary` frontmatter scalar) or the raw `--query` argument cannot smuggle an
- * ANSI escape sequence or other control byte into the rendered line (LORE-118).
- */
-function renderText(data: QueryResult): string {
-  const queryText = data.query !== undefined ? sanitizeField(data.query) : undefined;
-  const head = queryText !== undefined ? `query "${queryText}"` : "query (filters)";
-  const lines = [
-    ...(data.workspace !== undefined
-      ? [`workspace: ${sanitizeField(data.workspace.workspaceId)} (${data.workspace.repositories.length} repositories)`]
-      : []),
-    `${head}: ${data.total} ${data.total === 1 ? "match" : "matches"}`,
-  ];
-  for (const hit of data.hits) {
-    const score = queryText !== undefined ? `  (${formatScore(hit.score)})` : "";
-    const id = sanitizeField(hit.id);
-    const type = sanitizeField(hit.type);
-    const snippet = hit.snippet !== undefined ? `  — ${sanitizeField(hit.snippet)}` : "";
-    lines.push(`  ${id}  [${type}]${score}${snippet}`);
-  }
-  const footer = renderTruncationLine(truncation(data.total, data.shown, NARROW_HINT));
-  if (footer !== "") {
-    lines.push(footer);
-  }
-  return lines.join("\n");
-}
-
-/**
- * Sanitize a field before it is interpolated into the plain/pretty listing: collapse
- * it to one line ({@link singleLine}) and strip ANSI escape sequences plus residual C0/C1
- * control bytes ({@link stripAnsiAndControls}) — every source here (a concept `id`, its
- * `type`/`summary` frontmatter, or the raw `--query` text) can carry attacker-influenced
- * bytes (a crafted bundle file, or the CLI argument itself), and without this a CSI
- * sequence could rewrite terminal state or forge output (LORE-118).
- */
-function sanitizeField(text: string): string {
-  return stripAnsiAndControls(singleLine(text));
-}
-
-/**
- * Format a BM25 score for the text listing: two decimals normally, but a **positive**
- * score that would round to `0.00` (a real hit whose relevance is tiny — e.g. a
- * near-ubiquitous term in a large bundle) falls back to two significant figures, so a
- * returned hit is never displayed as the `0.00` that reads like "should have been
- * dropped". Exported for direct unit coverage of both branches.
- */
-export function formatScore(score: number): string {
-  const fixed = score.toFixed(2);
-  return score > 0 && Number(fixed) === 0 ? score.toPrecision(2) : fixed;
-}
-
-/** A `usage` {@link LoreError} (exit `2`) with an actionable hint. */
-function usage(message: string, hint: string): LoreError {
-  return new LoreError("usage", message, hint);
-}

package/src/commands/reconcile-shared.ts

@@ -1,280 +0,0 @@
-/**
- * reconcile-shared.ts — resolve every `tasks:`-linked concept's live Backlog data and compute its
- * reconciled status + managed-block rows, shared by `lore sync` (LORE-26, writes the result) and
- * `lore check` (LORE-27, diffs it against disk and never writes — ADR-0007).
- *
- * Both commands need the *identical* gather: skip reserved-stem concepts (`index`/`log`, regenerated
- * wholesale elsewhere), read and validate the project's status flow/overrides **before** spending any
- * Backlog subprocess round-trip (so a broken `.lore/config.toml` is reported immediately rather than
- * masked behind N task resolutions — sync's own fail-fast property, LORE-26 round 4), resolve every
- * distinct linked task id once, and run `core/reconcile.ts`'s `reconcileStatus` per concept. Only what
- * happens with the result differs, so that part stays with each command.
- */
-
-import { posix } from "node:path";
-import { type BacklogAdapter, type BacklogTaskDetail, readStatusFlow } from "../adapters/backlog";
-import { loadConfig } from "../config";
-import { toRefList } from "../core/bundle";
-import type { Concept } from "../core/concept";
-import type { ManagedTaskRow } from "../core/managed-block";
-import { type ReconciledStatus, reconcileStatus, validateReconcileInputs } from "../core/reconcile";
-import { RESERVED_STEMS } from "../core/scaffold";
-import { LoreError } from "../errors";
-// `mapWithConcurrency`/`TASK_DETAILS_CONCURRENCY` moved to the neutral `./concurrency` module
-// (LORE-233) so `link.ts` can share them too without a `link -> reconcile-shared -> link` import
-// cycle (this file already imports `dedupeTaskIds`/`defaultAdapter`/`verifiedViewTask` FROM
-// `link.ts`). Re-exported here so `check.ts` and `reconcile-shared.test.ts`, which import both
-// from this module, keep working unchanged.
-import { mapWithConcurrency, TASK_DETAILS_CONCURRENCY } from "./concurrency";
-import { dedupeTaskIds, defaultAdapter, verifiedViewTask } from "./link";
-
-export { mapWithConcurrency, TASK_DETAILS_CONCURRENCY };
-
-/** The outcome of resolving one task id: its live detail, or the error resolving it hit. */
-export type TaskResolution =
-  | { readonly ok: true; readonly detail: BacklogTaskDetail }
-  | { readonly ok: false; readonly error: unknown };
-
-/** One concept's resolved reconciliation: its recomputed status and live managed-block rows. */
-export interface ReconcileTarget {
-  /** The concept as loaded (unmodified) — its `frontmatter.status` is the pre-reconciliation value. */
-  readonly concept: Concept;
-  /** The rolled-up status (`core/reconcile.ts`), or `null` when the concept links no tasks (never true here). */
-  readonly newStatus: ReconciledStatus | null;
-  /** The linked tasks' live data, in the concept's own `tasks:` order, ready for `regenerateTaskBlock`. */
-  readonly rows: ManagedTaskRow[];
-}
-
-/** One concept eligible for reconciliation: not a reserved stem, and linking at least one task. */
-export interface EligibleConcept {
-  readonly concept: Concept;
-  /** Its `tasks:` frontmatter, deduplicated (case-insensitively) but otherwise in authored order. */
-  readonly linked: string[];
-}
-
-/**
- * Filter `concepts` to those eligible for reconciliation: not a reserved stem (`index`/`log` —
- * regenerated wholesale elsewhere, so a reconciled write here would only be silently discarded,
- * mirroring `link`/`rename`/`supersede`'s shared `assertNotReservedStem` policy) and linking at
- * least one task. Pure and synchronous — callers use it to decide *whether* reconciliation is
- * needed at all (e.g. `lore check` deciding sync-vs-async) without paying for any Backlog IO.
- *
- * Deliberately type-agnostic: a `tasks:` list is reconciled on ANY concept type, not only
- * `Story`/`Spec` — `lore link` (LORE-24) never restricts which type it targets, and this predates
- * LORE-27 entirely (`tasks:` on a `Reference`/`ADR`/etc. is an OKF §9-tolerated unknown-key warning,
- * never an error). Narrowing eligibility to specific types here would make `check` (which shares
- * this exact function) more restrictive than `sync` — the disagreement-with-`sync` failure mode
- * this module's callers otherwise take pains to avoid — not fix a LORE-27-introduced gap.
- */
-export function linkedConcepts(concepts: Iterable<Concept>): EligibleConcept[] {
-  const eligible: EligibleConcept[] = [];
-  for (const concept of concepts) {
-    if (RESERVED_STEMS.has(posix.basename(concept.id))) {
-      continue;
-    }
-    const linked = dedupeTaskIds(toRefList(concept.frontmatter.tasks));
-    if (linked.length > 0) {
-      eligible.push({ concept, linked });
-    }
-  }
-  return eligible;
-}
-
-/** The project's reconciliation config: its ordered status flow and `[reconcile.overrides]`. */
-export interface ReconcileConfig {
-  readonly flow: readonly string[];
-  readonly overrides: Readonly<Record<string, string>>;
-}
-
-/**
- * Read (but do not validate) `backlog/config.yml`'s status flow and `.lore/config.toml`'s
- * `[reconcile.overrides]` — pure IO, no semantic check, no Backlog subprocess round-trip. Split out
- * from {@link resolveReconcileConfig} so a caller with its OWN precedence to preserve (`lore sync`,
- * against `.lore/profile.toml`) can interleave the syntactic reads, the semantic validation, and
- * whatever else it needs in the exact order its own contract requires, rather than this module
- * silently deciding that order.
- */
-export function readReconcileConfig(root: string): ReconcileConfig {
-  const flow = readStatusFlow(root);
-  const config = loadConfig({ root });
-  return { flow, overrides: config.reconcile.overrides };
-}
-
-/**
- * {@link readReconcileConfig} plus its semantic validation — the fast, local, IO-only half of
- * reconciliation, with no Backlog subprocess round-trip. This is what {@link gatherReconciliation}
- * uses by default; a caller that already resolved (and validated) its own config up front (`lore
- * sync`, see {@link readReconcileConfig}'s doc comment) passes it straight to `gatherReconciliation`
- * instead, so the files are never read/validated twice in the same command run.
- *
- * @throws LoreError `validation` if the status flow has fewer than two entries, a duplicate entry,
- *   or an override's target is not a valid rollup status.
- */
-export function resolveReconcileConfig(root: string): ReconcileConfig {
-  const resolved = readReconcileConfig(root);
-  validateReconcileInputs(resolved.flow, resolved.overrides);
-  return resolved;
-}
-
-/**
- * Resolve every `tasks:`-linked, non-reserved-stem concept in `concepts` to a {@link ReconcileTarget}.
- * Returns `[]` (constructing no adapter at all, mirroring `rename.ts`'s precedent) when nothing in
- * `concepts` links a task — so a bundle with no Story/Spec coupling never shells out to Backlog.
- *
- * @param root the repo root `backlog/config.yml` / `.lore/config.toml` / the Backlog adapter resolve
- *   against — independent of whichever docs bundle root `concepts` was loaded from.
- * @param concepts the concepts to consider (already loaded/scoped by the caller).
- * @param adapterOverride test seam; defaults to {@link defaultAdapter}.
- * @param configOverride an already-resolved-and-validated {@link ReconcileConfig} (`lore sync` passes
- *   its own, having already called {@link resolveReconcileConfig} itself for ordering reasons); when
- *   omitted, resolved (and validated) here.
- * @param detailsOverride an already-resolved {@link TaskResolution} map, keyed by lowercase task id,
- *   covering (at least) every id `concepts` links — `lore check`'s multi-root drift pass (LORE-50)
- *   resolves the union of every bundle root's linked ids exactly once and passes the shared result
- *   to each root's own `gatherReconciliation` call, rather than each root re-fetching the same id.
- *   When omitted, every id is resolved fresh via `adapterOverride`/`defaultAdapter`, as before.
- * @param configErrorOverride a config-validation failure another caller already hit resolving the
- *   SAME config this call would otherwise read fresh (LORE-50: `lore check`'s multi-root pass
- *   resolves the config once, up front, for every bundle root that has any eligible concept). When
- *   set (and `configOverride` is not), thrown immediately in place of re-reading/re-validating —
- *   preserving the exact fail-fast point a fresh {@link resolveReconcileConfig} call would have hit
- *   for THIS call's own eligible concepts, without a second disk read. Ignored when `eligible` is
- *   empty (mirrors `resolveReconcileConfig` never running for a concept list with nothing to
- *   reconcile) or when `configOverride` is given (a caller with a genuinely resolved config, like
- *   `lore sync`, never also carries a cached failure).
- * @throws LoreError `validation` if the status flow/overrides are malformed (before any task
- *   resolution); `not_found` (exit 3) naming the first linked task id that no longer exists, OR
- *   whose resolved detail's `id` does not case-insensitively match the requested id.
- */
-export async function gatherReconciliation(
-  root: string,
-  concepts: Iterable<Concept>,
-  adapterOverride?: BacklogAdapter,
-  configOverride?: ReconcileConfig,
-  detailsOverride?: ReadonlyMap<string, TaskResolution>,
-  configErrorOverride?: unknown,
-): Promise<ReconcileTarget[]> {
-  const eligible = linkedConcepts(concepts);
-  if (eligible.length === 0) {
-    return [];
-  }
-
-  if (configOverride === undefined && configErrorOverride !== undefined) {
-    throw configErrorOverride;
-  }
-  const { flow, overrides } = configOverride ?? resolveReconcileConfig(root);
-
-  const allTaskIds = dedupeTaskIds(eligible.flatMap((e) => e.linked));
-  const details = detailsOverride
-    ? pickResolved(detailsOverride, allTaskIds)
-    : await resolveAllTasks(adapterOverride ?? defaultAdapter(root), allTaskIds);
-
-  return eligible.map(({ concept, linked }) => {
-    const detailList = linked.map((id) => details.get(id.toLowerCase()) as BacklogTaskDetail);
-    const newStatus = reconcileStatus(
-      detailList.map((d) => d.status),
-      flow,
-      overrides,
-    );
-    const rows: ManagedTaskRow[] = detailList.map((d) => ({
-      id: d.id,
-      title: d.title,
-      status: d.status,
-      file: d.file,
-    }));
-    return { concept, newStatus, rows };
-  });
-}
-
-/**
- * Resolve every task id to a {@link TaskResolution}, keyed by lowercase id — a not-found, an
- * identity-mismatched, or a rejected `viewTask` all become an `ok: false` entry rather than a
- * thrown error, so a caller resolving ids shared across several independent groups (bundle roots,
- * in `lore check`'s multi-root drift pass) can fetch each distinct id exactly once and let EACH
- * group decide for itself whether ids IT needs failed, instead of one failing id aborting every
- * group's resolution. Reads run concurrently, bounded to {@link TASK_DETAILS_CONCURRENCY} in
- * flight at once (via {@link mapWithConcurrency}); this never throws.
- *
- * Every resolved detail's own `id` is checked (case-insensitively) against the requested `taskId`
- * via `link.ts`'s shared {@link verifiedViewTask} — a mismatch is treated exactly like a not-found
- * rather than stored as `ok: true` (it throws a `LoreError`, caught below and stored verbatim, same
- * as any other `viewTask` rejection). Nothing downstream (`gatherReconciliation`'s
- * `details.get(id.toLowerCase())` lookup keys purely on the REQUESTED id) would otherwise notice an
- * adapter handing back the wrong task's detail, and a mismatch here would silently attribute
- * another task's title/status to this concept's managed `tasks:` block. This is the ONE place the
- * check lives — `verifiedViewTask` — shared with `link.ts`'s own `viewTask` consumers and
- * `tasks.ts`'s `resolveRollup` (LORE-125), so the comparison/`LoreError` never drifts between sites.
- */
-export async function resolveTaskDetails(
-  adapter: BacklogAdapter,
-  taskIds: readonly string[],
-): Promise<Map<string, TaskResolution>> {
-  const resolved = new Map<string, TaskResolution>();
-  await mapWithConcurrency(taskIds, TASK_DETAILS_CONCURRENCY, async (taskId) => {
-    try {
-      const detail = await verifiedViewTask(adapter, taskId);
-      if (detail === null) {
-        resolved.set(taskId.toLowerCase(), {
-          ok: false,
-          error: new LoreError(
-            "not_found",
-            `task "${taskId}" does not exist`,
-            "a linked concept's tasks: list must reference only live Backlog tasks — check the id, or unlink it",
-            { taskId },
-          ),
-        });
-      } else {
-        resolved.set(taskId.toLowerCase(), { ok: true, detail });
-      }
-    } catch (cause) {
-      resolved.set(taskId.toLowerCase(), {
-        ok: false,
-        error: cause instanceof Error ? cause : new Error(String(cause)),
-      });
-    }
-  });
-  return resolved;
-}
-
-/**
- * Resolve every task id to its live {@link BacklogTaskDetail}, keyed by lowercase id. Every id is
- * validated to exist BEFORE any concept's status/managed-block is computed — mirrors
- * `commands/link.ts`'s up-front validation exactly, including running the reads concurrently
- * (`allSettled`) but reporting the first not-found/failure in argument order.
- *
- * @throws LoreError `not_found` (exit 3) naming the first missing task id, in `taskIds` order.
- */
-async function resolveAllTasks(
-  adapter: BacklogAdapter,
-  taskIds: readonly string[],
-): Promise<Map<string, BacklogTaskDetail>> {
-  const resolved = await resolveTaskDetails(adapter, taskIds);
-  return pickResolved(resolved, taskIds);
-}
-
-/**
- * Extract `taskIds` from an already-resolved {@link TaskResolution} map, throwing the FIRST (in
- * `taskIds` order) unresolved id's own error — the same contract {@link resolveAllTasks} always
- * had, now shared by a caller (`lore check`, LORE-50) that resolved the map once, up front, for a
- * UNION of ids spanning more than this one `taskIds` list. An id genuinely absent from `resolved`
- * (the caller's union omitted one `gatherReconciliation` call actually needs — never expected in
- * practice, since every caller derives its union from the same eligible concepts) fails loud rather
- * than silently treating it as resolved.
- */
-function pickResolved(
-  resolved: ReadonlyMap<string, TaskResolution>,
-  taskIds: readonly string[],
-): Map<string, BacklogTaskDetail> {
-  const details = new Map<string, BacklogTaskDetail>();
-  for (const taskId of taskIds) {
-    const r = resolved.get(taskId.toLowerCase());
-    if (r === undefined) {
-      throw new Error(`internal: task "${taskId}" was never resolved`);
-    }
-    if (!r.ok) {
-      throw r.error;
-    }
-    details.set(taskId.toLowerCase(), r.detail);
-  }
-  return details;
-}