@dougharness/cli 1.0.1 → 1.1.0

package/node_modules/@dougharness/flow/lib/decisions.mjs

@@ -15,7 +15,7 @@ import { unifiedDiff, writeProposals, countLines, insertBulletUnderHeading, remo
 const DECISIONS_RELDIR = "docs/decisions";
 const RULES_RELDIR = ".claude/rules";
 const CLAUDE_MD_RELPATH = "CLAUDE.md";
-const GATES_SCRIPTS_RELDIR = "plugins/doug-gates/scripts";
+const HOOK_SCRIPTS_RELDIR = ".doug/hooks/scripts";
 
 // Scans docs/decisions/NNNN-*.md and returns the next zero-padded number ("0001" when the directory is empty
 // or missing). A file that does not match the NNNN-*.md shape (a stray README, say) is ignored rather than
@@ -185,7 +185,7 @@ function validateRemoveEntry(entry, oldLines, dir) {
   if (!nonEmptyString(entry.source)) return { ok: false, reason: "each remove entry needs a non-empty string \"source\"" };
   if (!nonEmptyString(entry.enforcedBy)) return { ok: false, reason: "each remove entry needs a non-empty string \"enforcedBy\"" };
   if (entry.enforcedBy.endsWith(".mjs")) {
-    const relHook = `${GATES_SCRIPTS_RELDIR}/${entry.enforcedBy}`;
+    const relHook = `${HOOK_SCRIPTS_RELDIR}/${entry.enforcedBy}`;
     if (!existsSync(join(dir, relHook))) return { ok: false, reason: `enforcedBy names a hook that does not exist: ${relHook}` };
   }
   return { ok: true };

package/node_modules/@dougharness/flow/lib/embeddings.mjs

@@ -13,6 +13,21 @@ const DEFAULT_TIMEOUT_MS = 2000;
 const OLLAMA_BASE_URL = "http://localhost:11434";
 const DEFAULT_MODEL = "embeddinggemma";
 
+// Provider presets (card embedding-providers-unsloth): memory.embeddings.preset fills only the fields the
+// config leaves unset. sendsDims: whether the request carries `dimensions`; requiresKey: an unset key env var
+// is refused without calling the server; modelsList: "v1" lists models with GET /v1/models.
+const PRESETS = {
+  ollama: { provider: "openai-compatible", baseUrl: OLLAMA_BASE_URL, apiKeyEnv: undefined, sendsDims: true, requiresKey: false, modelsList: null },
+  unsloth: { provider: "openai-compatible", baseUrl: "http://127.0.0.1:8888", apiKeyEnv: "UNSLOTH_API_KEY", sendsDims: false, requiresKey: true, modelsList: "v1" },
+  openai: { provider: "openai-compatible", baseUrl: "https://api.openai.com", apiKeyEnv: "OPENAI_API_KEY", sendsDims: true, requiresKey: true, modelsList: "v1" },
+  voyage: { provider: "voyage", baseUrl: "https://api.voyageai.com", apiKeyEnv: "VOYAGE_API_KEY", sendsDims: true, requiresKey: true, modelsList: null },
+  custom: { provider: undefined, baseUrl: undefined, apiKeyEnv: undefined, sendsDims: true, requiresKey: false, modelsList: null },
+};
+
+function presetOf(e) {
+  return e && typeof e.preset === "string" && Object.hasOwn(PRESETS, e.preset) ? PRESETS[e.preset] : null;
+}
+
 function isValidEmbeddingsConfig(e) {
   return !!(
     e &&
@@ -44,13 +59,30 @@ export function readMemoryConfig(dir) {
   const memory = raw && typeof raw === "object" ? raw.memory : undefined;
   const e = memory && typeof memory === "object" ? memory.embeddings : undefined;
   if (e === null || e === undefined) return { embeddings: null };
-  if (!isValidEmbeddingsConfig(e)) {
+  const resolved = applyPreset(e);
+  if (!isValidEmbeddingsConfig(resolved)) {
     process.stderr.write(`[doug] ${CONFIG_RELPATH} memory.embeddings is not a valid shape; treating as unset (keyword-only)\n`);
     return { embeddings: null };
   }
+  if (e.preset !== undefined) return {
+      embeddings: { preset: e.preset, provider: resolved.provider, baseUrl: resolved.baseUrl, model: resolved.model, dims: resolved.dims, apiKeyEnv: resolved.apiKeyEnv },
+    };
   return { embeddings: { provider: e.provider, baseUrl: e.baseUrl, model: e.model, dims: e.dims, apiKeyEnv: e.apiKeyEnv } };
 }
 
+// A preset fills provider, baseUrl and apiKeyEnv only where the config leaves them unset. A config with no
+// `preset` key is returned as is.
+function applyPreset(e) {
+  if (!e || typeof e !== "object" || e.preset === undefined) return e;
+  const p = presetOf(e);
+  if (!p) return null;
+  const out = { ...e };
+  for (const k of ["provider", "baseUrl", "apiKeyEnv"]) {
+    if (out[k] === undefined && p[k] !== undefined) out[k] = p[k];
+  }
+  return out;
+}
+
 function isValidIndexConfig(idx) {
   return !!(
     idx &&
@@ -131,10 +163,10 @@ function l2normalize(vec) {
 // pairs and a dozen known-unrelated pairs, embedded together, must separate by a stated margin or the
 // configured embedder is not doing semantic work. Failing loudly here catches that before reembed commits to
 // it.
-// This path lies outside plugins/doug-flow, at the repo root — so it is outside a Doug plugin's own `files`
-// list. A standalone-published copy of this plugin (installed on its own, without the rest of this repo
-// checked out alongside it) will not have it; pass `--pairs <file>` in that case.
-export const DEFAULT_SANITY_PAIRS = join(dirname(fileURLToPath(import.meta.url)), "../../../evals/memory/pairs.json");
+// This path lives inside plugins/doug-flow/lib, under this plugin's own `files` list in package.json, so a
+// standalone-published copy of this plugin (installed on its own, without the rest of this repo checked out
+// alongside it) still has it.
+export const DEFAULT_SANITY_PAIRS = join(dirname(fileURLToPath(import.meta.url)), "data/pairs.json");
 
 function meanOf(nums) {
   return nums.reduce((a, b) => a + b, 0) / nums.length;
@@ -230,10 +262,28 @@ export async function checkEmbeddingSanity(provider, pairs) {
   };
 }
 
-// Task prefixes the provider layer must add; the server never adds them. Only the two models named in the
-// research note carry a prefix; every other model gets none.
+// Task prefixes the provider layer must add; the server never adds them. Only the models below carry a
+// prefix; every other model gets none. mxbai and qwen3 prefix queries only, documents get "".
 function prefixFor(model, inputType) {
-  const m = String(model || "");
+  // Match on the lowercased basename after the last "/", so HF-style names (org/name) and Ollama names agree.
+  let m = String(model || "").split(/[/\\]/).pop().toLowerCase();
+  // LM Studio-style "text-embedding-<name>" ids: match on <name> when it is a prefixed family (not OpenAI's text-embedding-3-*).
+  if (m.startsWith("text-embedding-")) {
+    const rest = m.slice("text-embedding-".length);
+    if (["mxbai-embed-large", "qwen3-embedding", "embeddinggemma", "nomic"].some((f) => rest.startsWith(f))) m = rest;
+  }
+  // https://huggingface.co/mixedbread-ai/mxbai-embed-large-v1 README ("add the prompt for query (not for
+  // documents)"); https://ollama.com/library/mxbai-embed-large
+  if (m.startsWith("mxbai-embed-large")) {
+    return inputType === "query" ? "Represent this sentence for searching relevant passages: " : "";
+  }
+  // https://huggingface.co/Qwen/Qwen3-Embedding-0.6B/raw/main/config_sentence_transformers.json (query prompt;
+  // "document": ""). No space after "Query:".
+  if (m.startsWith("qwen3-embedding")) {
+    return inputType === "query"
+      ? "Instruct: Given a web search query, retrieve relevant passages that answer the query\nQuery:"
+      : "";
+  }
   if (m.startsWith("embeddinggemma")) {
     return inputType === "query" ? "task: search result | query: " : "title: none | text: ";
   }
@@ -247,34 +297,73 @@ function isAbortLike(err) {
   return err && (err.name === "AbortError" || err.name === "TimeoutError");
 }
 
-async function readBodySnippet(res) {
+// The key never reaches a reason: a server that echoes the Authorization header back in an error body gets
+// every occurrence of the key replaced.
+async function readBodySnippet(res, key) {
   try {
-    return (await res.text()).slice(0, 200);
+    let text = await res.text();
+    if (key) text = text.split(key).join("[redacted]");
+    return text.slice(0, 200);
   } catch {
     return "";
   }
 }
 
-async function embedOpenAICompatible(e, texts, inputType, { fetchImpl, timeoutMs }) {
+// A provider whose baseUrl host is localhost, 127.0.0.1 or ::1 never requires a key (card local-provider-no-key):
+// the key is sent only when its env var is set, and a 401/403 says the server wants one. An unparseable URL is not local.
+function isLocalUrl(baseUrl) {
+  try {
+    const h = new URL(baseUrl).hostname;
+    return h === "localhost" || h === "127.0.0.1" || h === "[::1]" || h === "::1";
+  } catch {
+    return false;
+  }
+}
+
+function localKeyReason(e) {
+  const preset = presetOf(e);
+  const name = e.apiKeyEnv || (preset && preset.apiKeyEnv) || "OPENAI_API_KEY";
+  return process.env[name] ? `server rejected the key in ${name}` : `server requires a key: set ${name}`;
+}
+
+// `state` is the provider instance's memory: { omitDims } turns true once a server has rejected `dimensions`.
+async function embedOpenAICompatible(e, texts, inputType, { fetchImpl, timeoutMs }, state = { omitDims: false }) {
+  const preset = presetOf(e);
+  const local = isLocalUrl(e.baseUrl);
+  if (preset && preset.requiresKey && !local) {
+    const name = e.apiKeyEnv || "OPENAI_API_KEY";
+    if (!process.env[name]) return { ok: false, reason: `missing API key: set ${name}` };
+  }
   const prefix = prefixFor(e.model, inputType);
   const input = texts.map((t) => prefix + t);
   const url = `${e.baseUrl.replace(/\/$/, "")}/v1/embeddings`;
   const headers = { "content-type": "application/json" };
-  const key = process.env[e.apiKeyEnv || "OPENAI_API_KEY"];
+  const key = process.env[e.apiKeyEnv || (local && preset && preset.apiKeyEnv) || "OPENAI_API_KEY"];
   if (key) headers.authorization = `Bearer ${key}`;
-  let res;
-  try {
-    res = await fetchImpl(url, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({ model: e.model, input, dimensions: e.dims }),
-      signal: AbortSignal.timeout(timeoutMs),
-    });
-  } catch (err) {
-    return { ok: false, reason: isAbortLike(err) ? "timeout" : `request failed: ${err.message}` };
+  const send = async (withDims) => {
+    const payload = withDims ? { model: e.model, input, dimensions: e.dims } : { model: e.model, input };
+    try {
+      return await fetchImpl(url, { method: "POST", headers, body: JSON.stringify(payload), signal: AbortSignal.timeout(timeoutMs) });
+    } catch (err) {
+      return { failure: { ok: false, reason: isAbortLike(err) ? "timeout" : `request failed: ${err.message}` } };
+    }
+  };
+  const sendsDims = !(preset && !preset.sendsDims) && !state.omitDims;
+  let res = await send(sendsDims);
+  if (res.failure) return res.failure;
+  let body = null;
+  if (!res.ok) {
+    body = await readBodySnippet(res, key);
+    // A server that rejects `dimensions` (400 naming it): retry this batch once without it, remember that.
+    if (sendsDims && res.status === 400 && /dimensions/i.test(body)) {
+      state.omitDims = true;
+      res = await send(false);
+      if (res.failure) return res.failure;
+      body = res.ok ? null : await readBodySnippet(res, key);
+    }
   }
   if (!res.ok) {
-    const body = await readBodySnippet(res);
+    if (local && (res.status === 401 || res.status === 403)) return { ok: false, reason: localKeyReason(e) };
     return { ok: false, reason: `HTTP ${res.status}${body ? `: ${body}` : ""}` };
   }
   let json;
@@ -322,7 +411,7 @@ async function embedVoyage(e, texts, inputType, { fetchImpl, timeoutMs }) {
     return { ok: false, reason: isAbortLike(err) ? "timeout" : `request failed: ${err.message}` };
   }
   if (!res.ok) {
-    const body = await readBodySnippet(res);
+    const body = await readBodySnippet(res, key);
     return { ok: false, reason: `HTTP ${res.status}${body ? `: ${body}` : ""}` };
   }
   let json;
@@ -368,10 +457,11 @@ export function createProvider(cfg, opts = {}) {
   if (!e) return null;
   const fetchImpl = opts.fetch || globalThis.fetch;
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const state = { omitDims: false };
   const sendBatch =
     e.provider === "voyage"
       ? (texts, inputType) => embedVoyage(e, texts, inputType, { fetchImpl, timeoutMs })
-      : (texts, inputType) => embedOpenAICompatible(e, texts, inputType, { fetchImpl, timeoutMs });
+      : (texts, inputType) => embedOpenAICompatible(e, texts, inputType, { fetchImpl, timeoutMs }, state);
   return {
     name: e.provider,
     model: e.model,
@@ -412,6 +502,53 @@ function isOllamaPresetUrl(baseUrl) {
   }
 }
 
+// Whether a /v1/models entry is the configured model: the id equals it, or the id's last "/" segment equals or
+// starts with it, case-insensitively.
+function v1ModelMatches(entry, wantModel) {
+  const id = entry && typeof entry.id === "string" ? entry.id.toLowerCase() : "";
+  const want = String(wantModel).toLowerCase();
+  if (!id) return false;
+  if (id === want) return true;
+  const last = id.split("/").pop();
+  return last === want || last.startsWith(want);
+}
+
+// The unsloth/openai presets: GET <base>/v1/models with the Bearer key. Never throws; the key is never put in
+// a reason.
+async function probeV1Models(e, root, wantModel, { fetchImpl, timeoutMs }) {
+  const kind = e.preset;
+  const envName = e.apiKeyEnv || (presetOf(e) && presetOf(e).apiKeyEnv) || "OPENAI_API_KEY";
+  const base = { reachable: false, kind, version: null, models: null, modelPresent: false, modelLoaded: null, embedOk: null };
+  const key = process.env[envName];
+  const local = isLocalUrl(root);
+  if (!key && !local) return { ...base, reason: `missing API key: set ${envName}` };
+  let res;
+  try {
+    res = await fetchImpl(`${root}/v1/models`, { headers: key ? { authorization: `Bearer ${key}` } : {}, signal: AbortSignal.timeout(timeoutMs) });
+  } catch (err) {
+    return { ...base, reason: isAbortLike(err) ? "timeout" : `request failed: ${err.message}` };
+  }
+  if (local && (res.status === 401 || res.status === 403)) return { ...base, reason: localKeyReason(e) };
+  if (res.status === 401) return { ...base, reason: `HTTP 401: key rejected or missing; set ${envName}` };
+  if (!res.ok) return { ...base, reason: `HTTP ${res.status}` };
+  let json;
+  try {
+    json = await res.json();
+  } catch (err) {
+    return { ...base, reason: `invalid JSON response: ${err.message}` };
+  }
+  const entries = Array.isArray(json && json.data) ? json.data : [];
+  const match = entries.find((m) => v1ModelMatches(m, wantModel));
+  return {
+    ...base,
+    reachable: true,
+    models: entries.map((m) => m && m.id).filter((id) => typeof id === "string"),
+    modelPresent: !!match,
+    modelLoaded: match && typeof match.loaded === "boolean" ? match.loaded : null,
+    reason: null,
+  };
+}
+
 // Probes a configured provider, or a local Ollama when nothing is configured. GET /api/version (then /api/tags)
 // is tried first; only when it succeeds is this reported as kind "ollama" with a model list. When /api/version
 // fails — a working llama-server, vLLM, LM Studio, or hosted key never serves it — this falls back to one
@@ -419,15 +556,24 @@ function isOllamaPresetUrl(baseUrl) {
 // reachable non-Ollama provider must never be told to go install Ollama. The one exception: an openai-compatible
 // provider configured at the Ollama preset host:port (localhost/127.0.0.1:11434) that is NOT reachable even via
 // the embed fallback is still reported as kind "ollama" — that combination means a down local Ollama, the one
-// case doctor exists to catch, not a different, genuinely unreachable server. Never throws; every branch has a
+// case doctor exists to catch, not a different, genuinely unreachable server. With nothing configured the probe
+// targets DOUG_OLLAMA_BASE_URL when set and non-empty (read at call time), else localhost:11434; a configured
+// baseUrl always wins. Never throws; every branch has a
 // 2s timeout.
 export async function probeProvider(cfg, opts = {}) {
   const fetchImpl = opts.fetch || globalThis.fetch;
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const e = cfg && cfg.embeddings;
-  const baseUrl = e && e.baseUrl ? e.baseUrl : OLLAMA_BASE_URL;
+  const baseUrl = e && e.baseUrl ? e.baseUrl : process.env.DOUG_OLLAMA_BASE_URL || OLLAMA_BASE_URL;
   const wantModel = e && e.model ? e.model : DEFAULT_MODEL;
   const root = baseUrl.replace(/\/$/, "");
+  const preset = presetOf(e);
+  if (preset && preset.modelsList === "v1") return probeV1Models(e, root, wantModel, { fetchImpl, timeoutMs });
+  if (preset && e.provider === "voyage") {
+    // No models endpoint is documented for Voyage: one embed probe, never the Ollama /api/version path.
+    const result = await createProvider(cfg, { fetch: fetchImpl, timeoutMs }).embed(["probe"]);
+    return { reachable: result.ok, kind: "voyage", version: null, models: null, modelPresent: null, embedOk: result.ok, reason: result.ok ? null : result.reason };
+  }
   const isPresetHost = (!e || e.provider === "openai-compatible") && isOllamaPresetUrl(baseUrl);
 
   let version = null;
@@ -486,6 +632,13 @@ const INSTALL_COMMANDS = {
 const PRESET_SNIPPET =
   '"memory": { "embeddings": { "provider": "openai-compatible", "baseUrl": "http://localhost:11434", "model": "embeddinggemma", "dims": 512 } }';
 
+const PRESET_SNIPPETS = [
+  ["ollama", '"memory": { "embeddings": { "preset": "ollama", "model": "embeddinggemma", "dims": 512 } }'],
+  ["unsloth", '"memory": { "embeddings": { "preset": "unsloth", "model": "embeddinggemma", "dims": 512 } }  (a key is only needed if the server enforces auth: UNSLOTH_API_KEY)'],
+  ["openai", '"memory": { "embeddings": { "preset": "openai", "model": "text-embedding-3-small", "dims": 512 } }  (set OPENAI_API_KEY)'],
+  ["voyage", '"memory": { "embeddings": { "preset": "voyage", "model": "voyage-4", "dims": 512 } }  (set VOYAGE_API_KEY)'],
+];
+
 function installCommandFor(platform) {
   return INSTALL_COMMANDS[platform] || INSTALL_COMMANDS.linux;
 }
@@ -515,10 +668,19 @@ export function doctorReport(cfg, probe, platform = process.platform) {
     }
     lines.push("Enable it by adding to .doug/config.json:");
     lines.push(`  ${PRESET_SNIPPET}`);
+    lines.push("Or pick a provider preset (one snippet per preset):");
+    for (const [name, snippet] of PRESET_SNIPPETS) lines.push(`  ${name}: ${snippet}`);
     return lines.join("\n");
   }
 
   lines.push(`memory.embeddings is configured: ${embeddings.provider} ${embeddings.model}/${embeddings.dims} at ${embeddings.baseUrl}.`);
+  if (presetOf(embeddings) && PRESETS[embeddings.preset].modelsList === "v1") {
+    if (!probe.reachable) lines.push(`Not reachable: ${probe.reason || "unknown error"}.`);
+    else if (probe.modelPresent === false) lines.push(`Reachable but ${embeddings.model} is not listed by ${embeddings.baseUrl}/v1/models.`);
+    else if (probe.modelLoaded === false) lines.push(`${embeddings.model} is listed but not loaded; load it on the server.`);
+    else lines.push(`Reachable; would use ${embeddings.model}/${embeddings.dims}.`);
+    return lines.join("\n");
+  }
   if (!probe.reachable) {
     lines.push(`Not reachable: ${probe.reason || "unknown error"}.`);
     // Only an Ollama-shaped miss (or nothing detected at all) gets install instructions — a real, reachable

package/node_modules/@dougharness/flow/lib/land.mjs

@@ -85,6 +85,39 @@ function run(command, cwd, timeoutMs) {
   return { command, ok: !timedOut && r.status === 0, status: r.status, timedOut: !!timedOut, durationMs: Date.now() - started, outputTail: tail((r.stdout || "") + "\n" + (r.stderr || "")) };
 }
 
+// card verified-tree-record: run plan.verify through the project's vendored verify.mjs (--json), which computes the
+// branch worktree's tree, credits a verified-tree record of it, or runs the commands and records the result for
+// the MAIN checkout (--record-dir). Returns the entries land records under `verify` (command, ok, status, timedOut,
+// durationMs, outputTail, plus credited: "verified-tree" when credited), stopping at the first failure like
+// today's loop, or null when the output cannot be read (the caller then runs the loop unchanged).
+function verifyViaVendored(script, dir, work, commands, timeoutMs) {
+  try {
+    const args = [script, "--json", "--by", "land", "--cwd", work, "--record-dir", dir, "--timeout-ms", String(timeoutMs), ...commands.flatMap((c) => ["--command", c])];
+    const r = spawnSync(process.execPath, args, { cwd: work, encoding: "utf8", timeout: timeoutMs * commands.length + 60000, maxBuffer: 64 * 1024 * 1024, env: commandEnv() });
+    let out = null;
+    try {
+      out = JSON.parse(String(r.stdout || "").trim().split("\n").pop());
+    } catch {
+      out = null;
+    }
+    if (!out || !Array.isArray(out.results) || out.results.length === 0) {
+      const why = r.error && r.error.code === "ETIMEDOUT" ? "timed out" : "gave no readable result";
+      return { error: `the vendored verify.mjs ${why}; land does not re-run the commands` };
+    }
+    return out.results.map((x) => ({
+      command: x.command,
+      ok: x.ok === true,
+      status: x.status,
+      timedOut: !!x.timedOut,
+      durationMs: x.durationMs,
+      outputTail: x.outputTail || "",
+      ...(out.credited ? { credited: out.credited } : {}),
+    }));
+  } catch (err) {
+    return { error: `the vendored verify.mjs could not run: ${err && err.message}` };
+  }
+}
+
 // Returns { ok: true, base, branch, mergeCommit, verify } or { ok: false, reason, verify? }. Never throws on a refusal.
 export function landPlan(dir, plan, { timeoutMs = 600000, now = () => new Date(), deleteBranches = false } = {}) {
   if (!plan) return { ok: false, reason: "no plan" };
@@ -131,20 +164,46 @@ export function landPlan(dir, plan, { timeoutMs = 600000, now = () => new Date()
   const verify = [];
   const acceptance = [];
   try {
-    const commands = [...(plan.install ? [plan.install] : []), ...(plan.verify || [])];
-    for (const command of commands) {
-      const r = run(command, work, timeoutMs);
+    // card verified-tree-record: install always runs through run(). plan.verify goes through the vendored
+    // verify.mjs when the project has one (it credits a verified-tree record of the branch's tree and writes one
+    // for the main checkout after a green run); otherwise, or when it cannot be read, today's loop runs.
+    const failVerify = (r) => {
+      const why = r.timedOut ? `timed out after ${timeoutMs} ms` : `exit ${r.status}`;
+      return { ok: false, reason: `verify failed on ${branch}: \`${r.command}\` (${why})\n${r.outputTail}`, verify, acceptance: [] };
+    };
+    if (plan.install) {
+      const r = run(plan.install, work, timeoutMs);
       verify.push(r);
-      if (!r.ok) {
-        const why = r.timedOut ? `timed out after ${timeoutMs} ms` : `exit ${r.status}`;
-        return { ok: false, reason: `verify failed on ${branch}: \`${command}\` (${why})\n${r.outputTail}`, verify, acceptance: [] };
+      if (!r.ok) return failVerify(r);
+    }
+    const verifyList = plan.verify || [];
+    const vendored = join(dir, ".doug/hooks/scripts/verify.mjs");
+    let viaVerify = null;
+    if (verifyList.length && existsSync(vendored)) viaVerify = verifyViaVendored(vendored, dir, work, verifyList, timeoutMs);
+    if (viaVerify && viaVerify.error) {
+      return { ok: false, reason: `verify failed on ${branch}: ${viaVerify.error}`, verify, acceptance: [] };
+    }
+    if (viaVerify) {
+      for (const r of viaVerify) {
+        verify.push(r);
+        if (!r.ok) return failVerify(r);
+      }
+    } else {
+      for (const command of verifyList) {
+        const r = run(command, work, timeoutMs);
+        verify.push(r);
+        if (!r.ok) return failVerify(r);
       }
     }
 
     const acceptanceCommands = acceptanceEntries(plan.acceptance).filter((a) => a.command);
     for (const a of acceptanceCommands) {
-      const r = run(a.command, work, timeoutMs);
-      const entry = { text: a.text, command: a.command, ok: r.ok, status: r.status, timedOut: r.timedOut, durationMs: r.durationMs, outputTail: r.outputTail };
+      // Card flow-suite-dedupe: a command identical to a plan.verify command already ran (green, or land returned above); reuse its result.
+      const same = verify.slice(plan.install ? 1 : 0).find((v) => String(v.command).trim() === String(a.command).trim());
+      const r = same ? null : run(a.command, work, timeoutMs);
+      const entry = same
+        ? { text: a.text, command: a.command, ok: same.ok, status: same.status, timedOut: false, durationMs: 0, outputTail: "", reused: "verify" }
+        : { text: a.text, command: a.command, ok: r.ok, status: r.status, timedOut: r.timedOut, durationMs: r.durationMs, outputTail: r.outputTail };
       acceptance.push(entry);
       if (!entry.ok) {
         const why = entry.timedOut ? `timed out after ${timeoutMs} ms` : `exit ${entry.status}`;
@@ -211,8 +270,8 @@ export function landPlan(dir, plan, { timeoutMs = 600000, now = () => new Date()
     baseWas: baseTip.slice(0, 7),
     branchTip: branchTip.slice(0, 7),
     mergeCommit,
-    verify: verify.map((v) => ({ command: v.command, ok: v.ok, durationMs: v.durationMs })),
-    acceptance: acceptance.map((a) => ({ text: a.text, command: a.command, ok: a.ok, durationMs: a.durationMs })),
+    verify: verify.map((v) => ({ command: v.command, ok: v.ok, durationMs: v.durationMs, ...(v.credited ? { credited: v.credited } : {}) })),
+    acceptance: acceptance.map((a) => ({ text: a.text, command: a.command, ok: a.ok, durationMs: a.durationMs, ...(a.reused ? { reused: a.reused } : {}) })),
   };
   savePlan(dir, { ...plan, landed });
   return { ok: true, base, branch, mergeCommit, verify, acceptance, worktrees, branches: branchesResult };

package/node_modules/@dougharness/flow/lib/learn.mjs

@@ -14,12 +14,69 @@ import { listOutcomes, listLessons, jaccard, reflectTokens, REFLECT_DUPLICATE_JA
 
 // --- collectSignals ----------------------------------------------------------------------------------------
 
+// card op-learn-gate-shape: a hand row's gate text is free-form per project ("typecheck 0; unit 639 passed" for
+// Doug itself, "pytest 0" or "ruff 0; pytest 2" for a pytest project, "npm test 1" for an npm one, ...), so
+// reading it as a failure unless it starts with Doug's own literal "typecheck 0" misclassified every other
+// project's green gate as a failure. readGate reads each top-level ";"/","-separated clause instead: a
+// ";" or "," inside a clause's own parenthesised note (e.g. "pytest 0 (41 passed, 2 skipped)") never splits
+// that clause, since the note is free text and may itself carry commas. Within a clause: a `<n> passed`
+// count is neutral, a clause naming a fail/error word is a failure, and a clause ending in an exit code (an
+// optional parenthesised note allowed) is a pass or a failure by that code - independent of Doug's own shape.
+const PASSED_COUNT_RE = /^.*\S\s+\d+\s+passed$/i;
+const FAIL_WORD_RE = /\b(fail|fails|failed|failure|failures|error|errors)\b/i;
+const EXIT_CLAUSE_RE = /^(.*\S)\s+(\d+)(\s*\([^)]*\))?$/;
+
+// Splits on a top-level ";" or "," only - one inside parentheses (depth tracked, not just "the last paren")
+// stays part of its clause, so a parenthesised note's own comma (a pass/skip breakdown) never fractures the
+// clause it belongs to.
+function splitGateClauses(gate) {
+  const clauses = [];
+  let depth = 0;
+  let current = "";
+  for (const ch of gate) {
+    if (ch === "(") depth += 1;
+    else if (ch === ")") depth = Math.max(0, depth - 1);
+    if ((ch === ";" || ch === ",") && depth === 0) {
+      clauses.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  clauses.push(current);
+  return clauses.map((c) => c.trim()).filter((c) => c.length > 0);
+}
+
+// Pure: reads one hand-track gate string into "pass" or "fail" (see the rules in the comment above). Exported
+// for both isGateFailure below and run-report/doug-hand's own use of the same reading.
+export function readGate(gate) {
+  if (typeof gate !== "string" || !gate.trim()) return "fail";
+  const clauses = splitGateClauses(gate);
+  let hasFailingClause = false;
+  let hasPassingExitClause = false;
+  for (const clause of clauses) {
+    if (PASSED_COUNT_RE.test(clause)) continue; // a) a pass count - neutral
+    if (FAIL_WORD_RE.test(clause)) {
+      hasFailingClause = true; // b) a fail/error word - failing, checked before c)
+      continue;
+    }
+    const m = EXIT_CLAUSE_RE.exec(clause);
+    if (m) {
+      if (Number(m[2]) !== 0) hasFailingClause = true; // c) a non-zero exit clause - failing
+      else hasPassingExitClause = true; // c) a zero exit clause - passing
+      continue;
+    }
+    // d) anything else - neutral
+  }
+  return !hasFailingClause && hasPassingExitClause ? "pass" : "fail";
+}
+
 // A hand row's own gate text is the only record of pass/fail on that track (no independent verifier runs on
 // it); a flow row's `verified` column is that record on the flow track. See memory.mjs's OUTCOMES_COLUMNS_SQL
 // comment for why the two tracks are never averaged together.
 function isGateFailure(row) {
   if (row.track === "flow") return row.verified === 0;
-  if (row.track === "hand") return !(typeof row.gate === "string" && row.gate.startsWith("typecheck 0"));
+  if (row.track === "hand") return readGate(row.gate) === "fail";
   return false;
 }
 
@@ -417,13 +474,13 @@ const DEMOTE_RULES = [
 ];
 
 // Review MINOR 7: a `tighten` target is the real path readOwnSkills() (scripts/learn.mjs) read the skill's
-// description from (`skill.file`), not a hardcoded `plugins/doug-flow/skills/<name>/SKILL.md` - a caller may
+// description from (`skill.file`), not a hardcoded `skills/<name>/SKILL.md` - a caller may
 // point `learn.mjs` at a checkout laid out differently, or at a skill outside this repository entirely. Made
 // relative to `dir` when the file is really inside it (the common case: readable, and matches how every other
 // proposal's `target` reads), else reported absolute rather than a misleading relative path. Falls back to the
-// historical hardcoded shape only for a caller (or an older test fixture) that supplies no `file` at all.
+// plugin-relative `skills/<name>/SKILL.md` shape only for a caller (or an older test fixture) that supplies no `file` at all.
 function tightenTarget(dir, skill) {
-  if (!skill.file) return `plugins/doug-flow/skills/${skill.name}/SKILL.md`;
+  if (!skill.file) return `skills/${skill.name}/SKILL.md`;
   const resolved = resolve(skill.file);
   if (dir) {
     const base = resolve(dir);

package/node_modules/@dougharness/flow/lib/memory-import.mjs

@@ -6,7 +6,7 @@ import { basename, join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { createHash } from "node:crypto";
 import { projectSlug } from "./cost.mjs";
-import { addLesson, getLesson, listLessons, supersedeLesson } from "./memory.mjs";
+import { addLesson, getLesson, listLessons, supersedeLesson, unstaleLesson } from "./memory.mjs";
 
 export function autoMemoryDir(projectDir, claudeDir = join(homedir(), ".claude")) {
   return join(claudeDir, "projects", projectSlug(projectDir), "memory");
@@ -77,10 +77,11 @@ export function parseFrontmatter(text) {
 
 export function importAutoMemory(m, opts = {}) {
   const { projectDir, claudeDir, now } = opts;
-  void now; // accepted for interface consistency; every timestamp here is measured (data.modified or file mtime)
+  // `now` (defaults to the current time) is only the retirement timestamp written to a stale row; every other
+  // timestamp here is measured (data.modified or file mtime).
   const dir = autoMemoryDir(projectDir, claudeDir);
   if (!existsSync(dir)) {
-    return { dir, found: false, added: 0, updated: 0, unchanged: 0, skipped: 0, files: [] };
+    return { dir, found: false, added: 0, updated: 0, unchanged: 0, skipped: 0, retired: 0, files: [] };
   }
   const names = readdirSync(dir, { withFileTypes: true })
     .filter((e) => e.isFile() && e.name.endsWith(".md") && e.name !== "MEMORY.md")
@@ -105,6 +106,7 @@ export function importAutoMemory(m, opts = {}) {
     const id = createHash("sha256").update(`auto-memory\n${name}\n${text}`).digest("hex").slice(0, 16);
     const existing = getLesson(m, id);
     if (existing) {
+      if (existing.stale) unstaleLesson(m, id);
       unchanged++;
       files.push({ file: name, id, action: "unchanged" });
       continue;
@@ -141,5 +143,21 @@ export function importAutoMemory(m, opts = {}) {
       files.push({ file: name, id, action: "added" });
     }
   }
-  return { dir, found: true, added, updated, unchanged, skipped, files };
+  // Retire (mark stale) every live row this importer wrote (source_agent "auto-memory") whose file is no longer
+  // under the directory: a rewritten file supersedes its prior row above, but a deleted file left no trace here
+  // to react to. Keyed on basename, the same key the per-file loop above uses to find a prior row, so a row
+  // whose citation dir differs from this run's dir but whose basename is still present is not retired (card
+  // memory-import-retires-deleted).
+  const nameSet = new Set(names);
+  const retiredAt = (now ? new Date(now) : new Date()).toISOString();
+  let retired = 0;
+  for (const lesson of listLessons(m)) {
+    if (lesson.source_agent !== "auto-memory") continue;
+    if (lesson.stale) continue;
+    if (nameSet.has(basename(lesson.citation))) continue;
+    m.prepare("UPDATE lessons SET stale = ? WHERE id = ?").run(retiredAt, lesson.id);
+    retired++;
+    files.push({ file: basename(lesson.citation), id: lesson.id, action: "retired" });
+  }
+  return { dir, found: true, added, updated, unchanged, skipped, retired, files };
 }