akm-cli 0.9.0-beta.50 → 0.9.0-beta.52

package/dist/commands/improve/preparation.js

@@ -572,7 +572,7 @@ async function runSessionExtractPass(args) {
  * LLM schema repair, and returns the still-failing ref set + the repair records.
  */
 async function runValidationAndRepairPass(args) {
-    const { postCleanupRefs, options, startMs, budgetMs } = args;
+    const { postCleanupRefs, options, startMs, budgetMs, primaryStashDir } = args;
     const validationFailures = [];
     for (const candidate of postCleanupRefs) {
         try {
@@ -617,7 +617,14 @@ async function runValidationAndRepairPass(args) {
                 startMs,
                 budgetMs,
                 llmConfig: llmCfg,
-                stashDir: options.stashDir,
+                // #591/#379 regression: options.stashDir is the raw, unresolved CLI
+                // flag (only set when --stash-dir is passed explicitly — never true
+                // for the scheduled tasks). primaryStashDir is the already-resolved
+                // source path and is what runSchemaRepairPass's `stashDir` param
+                // documents itself as needing ("proposal-queue writes"). Passing
+                // options.stashDir here made every schema-repair attempt throw
+                // `runSchemaRepairPass requires stashDir` on every cron invocation.
+                stashDir: primaryStashDir,
                 findFilePath: findAssetFilePath,
                 isLessonCandidateFn: isLessonCandidate,
             });
@@ -737,6 +744,7 @@ export async function runImprovePreparationStage(args) {
         options,
         startMs,
         budgetMs,
+        primaryStashDir,
     });
     // Phase 0.5 — structural hygiene pass
     let lintSummary;

package/dist/commands/improve/recombine.js

@@ -51,7 +51,7 @@ import { warn } from "../../core/warn.js";
 import { closeDatabase, getAllEntries, getEntitiesByEntryIds, openExistingDatabase, } from "../../indexer/db/db.js";
 import { resolveImproveProcessRunnerFromProfile, runnerIsLlm } from "../../integrations/agent/runner.js";
 import { chatCompletion } from "../../llm/client.js";
-import { validateProposalFrontmatter } from "../proposal/validators/proposal-quality-validators.js";
+import { isValidDescription, isValidWhenToUse, validateProposalFrontmatter, } from "../proposal/validators/proposal-quality-validators.js";
 import { archiveProposal, createProposal, isProposalSkipped, listProposals } from "../proposal/validators/proposals.js";
 import { isConsolidationEligibleMemoryName, isSessionCaptureMemoryName } from "./consolidate.js";
 const RECOMBINE_SYSTEM_PROMPT = recombineSystemPrompt;
@@ -438,6 +438,20 @@ export function deriveRecombineLessonRef(cluster) {
     const hash = createHash("sha256").update(memberKey, "utf8").digest("hex").slice(0, 8);
     return `lesson:recombined/${slug || "cluster"}-${hash}`;
 }
+function validatePromotedLessonFrontmatter(ref, frontmatter) {
+    const descCheck = isValidDescription(frontmatter.description, ref);
+    if (!descCheck.ok)
+        return { ok: false, reason: descCheck.reason };
+    const whenToUseCheck = isValidWhenToUse(frontmatter.when_to_use, ref);
+    if (!whenToUseCheck.ok)
+        return { ok: false, reason: whenToUseCheck.reason };
+    if (typeof frontmatter.description === "string" &&
+        typeof frontmatter.when_to_use === "string" &&
+        frontmatter.description.trim().toLowerCase() === frontmatter.when_to_use.trim().toLowerCase()) {
+        return { ok: false, reason: "description and when_to_use are identical" };
+    }
+    return { ok: true };
+}
 /**
  * The membership fingerprint of a cluster: its member entryKeys sorted and
  * joined. Single source of truth shared by {@link deriveRecombineLessonRef}'s
@@ -652,9 +666,18 @@ export async function akmRecombine(opts) {
                 : undefined;
             const lessonRef = matchedRow?.hypothesis_ref ?? derivedRef;
             const sourceRefs = cluster.members.map((m) => `memory:${m.entry.name}`);
+            const priorRow = stateDb ? getRecombineHypothesis(stateDb, lessonRef) : undefined;
+            const alreadyPromoted = priorRow?.promoted_at != null;
+            const nextCount = stateDb == null
+                ? 0
+                : priorRow == null
+                    ? 1
+                    : priorRow.last_run === sourceRun
+                        ? priorRow.consecutive_count
+                        : priorRow.consecutive_count + 1;
             // Quality gate (always-run): the frontmatter description must be present
-            // and non-truncated. This runs BEFORE createProposal on BOTH the
-            // hypothesis and the promotion paths — never bypassed.
+            // and non-truncated. Promotion adds the full lesson frontmatter check so
+            // `when_to_use` never bypasses validation on the promote=true path.
             const fmCheck = validateProposalFrontmatter({ description: generalization.description });
             if (!fmCheck.ok) {
                 appendEvent({
@@ -670,29 +693,43 @@ export async function akmRecombine(opts) {
                 }, opts.ctx);
                 continue;
             }
+            const promote = stateDb != null && !alreadyPromoted && nextCount >= confirmThreshold;
+            if (promote) {
+                const lessonFmCheck = validatePromotedLessonFrontmatter(lessonRef, {
+                    description: generalization.description,
+                    when_to_use: generalization.when_to_use,
+                });
+                if (!lessonFmCheck.ok) {
+                    appendEvent({
+                        eventType: "recombine_invoked",
+                        ref: lessonRef,
+                        metadata: {
+                            signal: cluster.signature,
+                            memberCount: cluster.members.length,
+                            outcome: "quality_rejected",
+                            reason: lessonFmCheck.reason,
+                            sourceRun,
+                        },
+                    }, opts.ctx);
+                    continue;
+                }
+            }
             // A defensible generalization was produced this run — record it so it is
             // NOT decayed by the unseen sweep below.
             seenThisRun.add(lessonRef);
-            // #625/#633 — record the re-induction and read the prior promotion state.
-            // `lessonRef` is the matched row's ref (overlap match) or the freshly
-            // derived member-set ref (first/non-overlapping induction). The induction
-            // refreshes the row's `member_key` to the current membership so the
-            // overlap window slides with the drifting cluster.
-            const nowIso = new Date().toISOString();
-            const priorRow = stateDb ? getRecombineHypothesis(stateDb, lessonRef) : undefined;
-            const alreadyPromoted = priorRow?.promoted_at != null;
+            // #625/#633 — record the re-induction only AFTER the quality gate passed.
+            // Quality-rejected outputs must not advance the confirmation streak.
             const count = stateDb
                 ? recordRecombineInduction(stateDb, {
                     hypothesisRef: lessonRef,
                     signature: cluster.signature,
                     memberKey,
-                    seenAt: nowIso,
+                    seenAt: new Date().toISOString(),
                     run: sourceRun,
                 })
                 : 0;
             // Promote to a `type: lesson` proposal when the confirmation streak
             // reaches the threshold AND the hypothesis has not already been promoted.
-            const promote = stateDb != null && !alreadyPromoted && count >= confirmThreshold;
             const proposalType = promote ? "lesson" : "hypothesis";
             const frontmatter = {
                 type: proposalType,
@@ -716,7 +753,7 @@ export async function akmRecombine(opts) {
                 ref: lessonRef,
                 source: "recombine",
                 sourceRun,
-                payload: { content, frontmatter: { description: generalization.description } },
+                payload: { content, frontmatter },
                 eligibilitySource,
                 // The promotion is a distinct asset (lesson) for the same ref; force
                 // past the duplicate-pending guard (the stale hypothesis was just
@@ -738,7 +775,7 @@ export async function akmRecombine(opts) {
                 continue;
             }
             if (promote && stateDb) {
-                markRecombineHypothesisPromoted(stateDb, lessonRef, nowIso);
+                markRecombineHypothesisPromoted(stateDb, lessonRef, new Date().toISOString());
                 lessonsPromoted += 1;
                 appendEvent({
                     eventType: "recombine_invoked",

package/dist/commands/lint/env-key-rules.js

@@ -96,6 +96,10 @@ export const DANGEROUS_VAULT_KEY_PATTERNS = [
         pattern: /^BASH_FUNC_/,
         reason: "Shellshock-class bash function injection (CVE-2014-6271)",
     },
+    {
+        pattern: /^GIT_CONFIG_/,
+        reason: "Git config injection through environment override variables",
+    },
 ];
 /**
  * Returns `true` if the given key name is dangerous — either by literal match

package/dist/commands/read/knowledge.js

@@ -16,7 +16,7 @@ import { isHttpUrl, isWithin, tryReadStdinText } from "../../core/common.js";
 import { loadConfig } from "../../core/config/config.js";
 import { UsageError } from "../../core/errors.js";
 import { commitWriteTargetBoundary, formatRefForMessage, resolveWriteTarget, writeAssetToSource, } from "../../core/write-source.js";
-import { fetchWebsiteMarkdownSnapshot } from "../../sources/website-ingest.js";
+import { fetchWebsiteMarkdownSnapshot, shouldAllowPrivateWebsiteUrlForTests } from "../../sources/website-ingest.js";
 const MAX_CAPTURED_ASSET_SLUG_LENGTH = 64;
 // ── Asset-name normalisation ─────────────────────────────────────────────────
 /**
@@ -104,7 +104,10 @@ export function readKnowledgeContent(source) {
 export async function readKnowledgeInput(source, options) {
     if (!isHttpUrl(source))
         return readKnowledgeContent(source);
-    const snapshot = await fetchWebsiteMarkdownSnapshot(source, { stashDir: options?.stashDir });
+    const snapshot = await fetchWebsiteMarkdownSnapshot(source, {
+        stashDir: options?.stashDir,
+        allowPrivateHosts: options?.allowPrivateHosts ?? shouldAllowPrivateWebsiteUrlForTests(source),
+    });
     return { content: snapshot.content, preferredName: snapshot.preferredName };
 }
 // ── Asset writing ────────────────────────────────────────────────────────────

package/dist/commands/read/search-cli.js

@@ -85,10 +85,6 @@ export const searchCommand = defineJsonCommand({
         const belief = parseBeliefFilterMode(typeof args.belief === "string" ? args.belief : undefined);
         const noProjectContext = getHyphenatedBoolean(args, "no-project-context");
         const includeSessions = getHyphenatedBoolean(args, "include-sessions");
-        // --no-project-context sets env so searchDatabase picks it up without
-        // threading the flag through the entire call stack.
-        if (noProjectContext)
-            process.env.AKM_DISABLE_PROJECT_CONTEXT = "1";
         const result = await akmSearch({
             query,
             type,
@@ -98,6 +94,8 @@ export const searchCommand = defineJsonCommand({
             includeProposed,
             belief,
             includeSessions,
+            disableProjectContext: noProjectContext,
+            disableScopedUtility: noProjectContext,
             eventSource: resolveEventSource(),
         });
         output("search", result);

package/dist/commands/read/search.js

@@ -109,6 +109,8 @@ export async function akmSearch(input) {
             // would leak hits from sources the caller did not request.
             restrictToSources: namedSourceName !== undefined,
             includeExcludedTypes: input.includeSessions === true,
+            disableProjectContext: input.disableProjectContext === true,
+            disableScopedUtility: input.disableScopedUtility === true,
         });
     const registryResult = source === "stash" ? undefined : await searchRegistry(query, { limit, registries: config.registries });
     if (source === "stash") {
@@ -123,8 +125,9 @@ export async function akmSearch(input) {
             warnings: localResult?.warnings?.length ? localResult.warnings : undefined,
             timing: { totalMs: Date.now() - t0, rankMs: localResult?.rankMs, embedMs: localResult?.embedMs },
         };
-        if (!input.skipLogging)
-            logSearchEvent(query, response, localResult?.mode ?? "keyword", input.eventSource);
+        if (!input.skipLogging) {
+            logSearchEvent(query, response, localResult?.mode ?? "keyword", input.eventSource, input.disableScopedUtility === true);
+        }
         return response;
     }
     const registryHits = (registryResult?.hits ?? []).map((hit) => {
@@ -159,7 +162,7 @@ export async function akmSearch(input) {
             timing: { totalMs: Date.now() - t0 },
         };
         if (!input.skipLogging)
-            logSearchEvent(query, response, undefined, input.eventSource);
+            logSearchEvent(query, response, undefined, input.eventSource, input.disableScopedUtility === true);
         return response;
     }
     // source === "both"
@@ -177,7 +180,7 @@ export async function akmSearch(input) {
         timing: { totalMs: Date.now() - t0 },
     };
     if (!input.skipLogging)
-        logSearchEvent(query, response, undefined, input.eventSource);
+        logSearchEvent(query, response, undefined, input.eventSource, input.disableScopedUtility === true);
     return response;
 }
 /**
@@ -212,7 +215,7 @@ function resolveEntryIds(db, hits) {
  * Per-entry events are recorded only for stash hits because registry hits
  * have no local entry_id to reference.
  */
-function logSearchEvent(query, response, mode = "keyword", eventSource = "user") {
+function logSearchEvent(query, response, mode = "keyword", eventSource = "user", disableScopedUtility = false) {
     // Emit a structured event to events.jsonl so workflow-trace consumers
     // detect akm search invocations without relying on stdout scraping.
     const stashHits = response.hits.filter((h) => h.type !== "registry");
@@ -242,7 +245,7 @@ function logSearchEvent(query, response, mode = "keyword", eventSource = "user")
                 let scopeKey;
                 try {
                     const stashPath = response.stashDir;
-                    const disabled = process.env.AKM_DISABLE_SCOPED_UTILITY === "1" || (stashPath && isTransientStashPath(stashPath));
+                    const disabled = disableScopedUtility || (stashPath && isTransientStashPath(stashPath));
                     scopeKey = disabled ? undefined : getCurrentWorkflowScopeKey();
                 }
                 catch {

package/dist/commands/read/show.js

@@ -18,6 +18,7 @@
  */
 import fs from "node:fs";
 import path from "node:path";
+import { findCittyTopLevelCommandIndex } from "../../cli/parse-args.js";
 import { parseAssetRef } from "../../core/asset/asset-ref.js";
 import { parseFrontmatter } from "../../core/asset/frontmatter.js";
 import { META_DIR, parseMetaRef, resolveMetaFilePath } from "../../core/asset/stash-meta.js";
@@ -523,6 +524,14 @@ function buildSummaryResponse(full, assetPath) {
 }
 // ── argv normalisation ───────────────────────────────────────────────────────
 const SHOW_VIEW_MODES = new Set(["toc", "frontmatter", "full", "section", "lines"]);
+const SHOW_ARGV_TOP_LEVEL_ARGS = {
+    format: { type: "string" },
+    output: { type: "string" },
+    detail: { type: "string" },
+    shape: { type: "string" },
+    quiet: { type: "boolean", alias: "q" },
+    verbose: { type: "boolean" },
+};
 /**
  * Normalize argv so positional view-mode arguments after the asset ref
  * are rewritten into internal flags that citty can parse.
@@ -536,15 +545,20 @@ const SHOW_VIEW_MODES = new Set(["toc", "frontmatter", "full", "section", "lines
  * Returns a new array; the input is never modified.
  */
 export function normalizeShowArgv(argv) {
-    // argv[0]=bun argv[1]=script argv[2]=subcommand argv[3]=ref argv[4..]=rest
-    if (argv[2] !== "show")
+    const rawArgs = argv.slice(2);
+    const commandIndex = findCittyTopLevelCommandIndex(rawArgs, SHOW_ARGV_TOP_LEVEL_ARGS);
+    if (commandIndex < 0 || rawArgs[commandIndex] !== "show")
         return argv;
-    if (argv.includes("--view") || argv.includes("--heading") || argv.includes("--start") || argv.includes("--end")) {
+    const commandArgs = rawArgs.slice(commandIndex + 1);
+    if (commandArgs.includes("--view") ||
+        commandArgs.includes("--heading") ||
+        commandArgs.includes("--start") ||
+        commandArgs.includes("--end")) {
         throw new UsageError('Legacy show flags are no longer supported. Use positional syntax like `akm show knowledge:guide toc` or `akm show knowledge:guide section "Auth"`.');
     }
     // Separate global flags from positional/show-specific args
-    const prefix = argv.slice(0, 3); // [bun, script, show]
-    const rest = argv.slice(3);
+    const prefix = [...argv.slice(0, 2), ...rawArgs.slice(0, commandIndex + 1)];
+    const rest = commandArgs;
     const globalFlags = [];
     const showArgs = [];
     for (let i = 0; i < rest.length; i++) {

package/dist/commands/sources/init.js

@@ -37,7 +37,7 @@ import { copyStashSkeleton, scaffoldStashMeta } from "./stash-skeleton.js";
 function assertInitSandbox(stashDir, dirExplicitlyProvided) {
     if (!dirExplicitlyProvided)
         return; // Only guard explicit --dir, not default HOME resolution.
-    const isUnderTest = process.env.BUN_TEST === "1" || process.env.NODE_ENV === "test";
+    const isUnderTest = isUnderTestRunner();
     if (!isUnderTest)
         return;
     if (process.env.AKM_FORCE_INIT_TMP_STASH === "1")
@@ -52,6 +52,9 @@ function assertInitSandbox(stashDir, dirExplicitlyProvided) {
         return;
     throw new ConfigError(`refusing to persist --dir stashDir to a temporary path while under test runner; set AKM_FORCE_INIT_TMP_STASH=1 if you really mean it (stashDir=${stashDir})`, "INIT_TMP_STASH_REFUSED");
 }
+function isUnderTestRunner() {
+    return process.env.BUN_TEST === "1" || process.env.NODE_ENV === "test";
+}
 export async function akmInit(options) {
     const dirExplicitlyProvided = options?.dir != null;
     const setDefault = options?.setDefault === true;
@@ -114,13 +117,15 @@ export async function akmInit(options) {
     }
     // Ensure ripgrep is available (install to cache/bin if needed)
     let ripgrep;
-    try {
-        const binDir = getBinDir();
-        const rgResult = ensureRg(binDir);
-        ripgrep = rgResult;
-    }
-    catch {
-        // Non-fatal: ripgrep is optional, search works without it
+    if (!isUnderTestRunner()) {
+        try {
+            const binDir = getBinDir();
+            const rgResult = ensureRg(binDir);
+            ripgrep = rgResult;
+        }
+        catch {
+            // Non-fatal: ripgrep is optional, search works without it
+        }
     }
     return { stashDir, created, configPath, defaultStashUpdated, previousStashDir, ripgrep };
 }

package/dist/commands/sources/installed-stashes.js

@@ -17,7 +17,7 @@ import { removeLockEntry, upsertLockEntry } from "../../integrations/lockfile.js
 import { parseRegistryRef } from "../../registry/resolve.js";
 import { parseGitRepoUrl, syncMirroredRepo } from "../../sources/providers/git.js";
 import { syncFromRef } from "../../sources/providers/sync-from-ref.js";
-import { ensureWebsiteMirror } from "../../sources/website-ingest.js";
+import { ensureWebsiteMirror, shouldAllowPrivateWebsiteUrlForTests } from "../../sources/website-ingest.js";
 import { listWikis, resolveWikisRoot } from "../../wiki/wiki.js";
 import { removeInstalledRegistryEntry, upsertInstalledRegistryEntry } from "./source-add.js";
 import { removeStash } from "./source-manage.js";
@@ -194,7 +194,11 @@ async function updateGitSource(stashDir, target, all, gitSource) {
 /** Re-crawl a website source and return an UpdateResponse. */
 async function updateWebsiteSource(stashDir, target, all, websiteSource) {
     // TODO: full incremental re-crawl with delta tracking (#19)
-    await ensureWebsiteMirror(websiteSource, { requireStashDir: true, force: true });
+    await ensureWebsiteMirror(websiteSource, {
+        requireStashDir: true,
+        force: true,
+        ...(shouldAllowPrivateWebsiteUrlForTests(websiteSource.url ?? "") ? { allowPrivateHosts: true } : {}),
+    });
     return buildUpdateResponse(stashDir, target, all, []);
 }
 /** Sync a single installed registry entry and return the processed record. */

package/dist/commands/sources/schema-repair.js

@@ -20,7 +20,7 @@ import { parseFrontmatter } from "../../core/asset/frontmatter.js";
 import { authoringRulesForType } from "../../core/authoring-rules.js";
 import { appendEvent, readEvents } from "../../core/events.js";
 import { resolveStandardsContext } from "../../core/standards/resolve-standards-context.js";
-import { info, warn } from "../../core/warn.js";
+import { info } from "../../core/warn.js";
 import { resolveAssetPath } from "../../indexer/walk/path-resolver.js";
 import { chatCompletion, parseEmbeddedJsonResponse } from "../../llm/client.js";
 import { createProposal, isProposalSkipped } from "../proposal/validators/proposals.js";
@@ -46,6 +46,9 @@ export async function runSchemaRepairPass(failures, options) {
     const repairs = [];
     const repairedRefs = new Set();
     const { startMs, budgetMs, llmConfig, stashDir, findFilePath = defaultFindFilePath, isLessonCandidateFn = defaultIsLessonCandidate, chatFn = chatCompletion, } = options;
+    if (!stashDir) {
+        throw new Error("runSchemaRepairPass requires stashDir so repairs route through the proposal queue");
+    }
     for (const failure of failures) {
         if (Date.now() - startMs >= budgetMs)
             break;
@@ -97,9 +100,9 @@ export async function runSchemaRepairPass(failures, options) {
             info(`[improve] schema-repair ${failure.ref} (${fieldList})`);
             const bodyPreview = (fm.content ?? raw).slice(0, 2000);
             // Standards "rulebook" for this target — wiki schema (wiki page) or stash
-            // convention/meta facts (non-wiki asset); empty when neither fires or no
-            // stash dir is available. `resolveStandardsContext` dispatches on the ref.
-            const standardsContext = stashDir ? resolveStandardsContext(failure.ref, stashDir) : "";
+            // convention/meta facts (non-wiki asset). `resolveStandardsContext`
+            // dispatches on the ref.
+            const standardsContext = resolveStandardsContext(failure.ref, stashDir);
             const standardsSection = standardsContext.trim()
                 ? `\n\nStandards to follow (the rulebook for this target):\n${standardsContext.trim()}`
                 : "";
@@ -139,50 +142,33 @@ export async function runSchemaRepairPass(failures, options) {
             // them human-reviewable before they affect search ranking and curate hints.
             // mem0 open gaps (arXiv:2504.19413) — any LLM write to a memory field
             // should be human-reviewable.
-            if (stashDir) {
-                const proposalResult = createProposal(stashDir, {
-                    ref: failure.ref,
-                    source: "schema-repair",
-                    payload: {
-                        content: newContent,
-                        ...(Object.keys(newFm).length > 0 ? { frontmatter: newFm } : {}),
-                    },
-                });
-                if (isProposalSkipped(proposalResult)) {
-                    info(`[improve] schema-repair proposal skipped for ${failure.ref}: ${proposalResult.message}`);
-                    repairs.push({ ref: failure.ref, reason: failure.reason, outcome: "skipped" });
-                    continue;
-                }
-                info(`[improve] schema-repair queued: ${failure.ref} (proposal id: ${proposalResult.id})`);
-                appendEvent({
-                    eventType: "schema_repair_invoked",
-                    ref: failure.ref,
-                    metadata: { outcome: "queued", reason: failure.reason, proposalId: proposalResult.id },
-                });
-                repairs.push({
-                    ref: failure.ref,
-                    reason: failure.reason,
-                    outcome: "queued",
-                    proposalId: proposalResult.id,
-                });
-                // Mark as repaired so the caller removes it from the validation-failure set.
-                repairedRefs.add(failure.ref);
-            }
-            else {
-                // Fallback: no stash dir available — write directly (legacy path).
-                // This should not occur in production; stashDir is always provided by
-                // `runSchemaRepairPass` callers in improve.ts.
-                warn(`[improve] schema-repair: no stashDir available for ${failure.ref}, falling back to direct write`);
-                fs.writeFileSync(filePath, newContent, "utf8");
-                info(`[improve] schema-repair written: ${failure.ref}`);
-                appendEvent({
-                    eventType: "schema_repair_invoked",
-                    ref: failure.ref,
-                    metadata: { outcome: "written", reason: failure.reason },
-                });
-                repairs.push({ ref: failure.ref, reason: failure.reason, outcome: "written" });
-                repairedRefs.add(failure.ref);
+            const proposalResult = createProposal(stashDir, {
+                ref: failure.ref,
+                source: "schema-repair",
+                payload: {
+                    content: newContent,
+                    ...(Object.keys(newFm).length > 0 ? { frontmatter: newFm } : {}),
+                },
+            });
+            if (isProposalSkipped(proposalResult)) {
+                info(`[improve] schema-repair proposal skipped for ${failure.ref}: ${proposalResult.message}`);
+                repairs.push({ ref: failure.ref, reason: failure.reason, outcome: "skipped" });
+                continue;
             }
+            info(`[improve] schema-repair queued: ${failure.ref} (proposal id: ${proposalResult.id})`);
+            appendEvent({
+                eventType: "schema_repair_invoked",
+                ref: failure.ref,
+                metadata: { outcome: "queued", reason: failure.reason, proposalId: proposalResult.id },
+            });
+            repairs.push({
+                ref: failure.ref,
+                reason: failure.reason,
+                outcome: "queued",
+                proposalId: proposalResult.id,
+            });
+            // Mark as repaired so the caller removes it from the validation-failure set.
+            repairedRefs.add(failure.ref);
         }
         catch (e) {
             appendEvent({

package/dist/commands/sources/source-add.js

@@ -11,7 +11,7 @@ import { upsertLockEntry } from "../../integrations/lockfile.js";
 import { parseRegistryRef } from "../../registry/resolve.js";
 import { detectStashRoot } from "../../sources/providers/provider-utils.js";
 import { syncFromRef } from "../../sources/providers/sync-from-ref.js";
-import { ensureWebsiteMirror, validateWebsiteInputUrl } from "../../sources/website-ingest.js";
+import { ensureWebsiteMirror, shouldAllowPrivateWebsiteUrlForTests, validateWebsiteInputUrl, } from "../../sources/website-ingest.js";
 import { ensureWikiNameAvailable, validateWikiName } from "../../wiki/wiki.js";
 const VALID_OVERRIDE_TYPES = new Set(["wiki"]);
 export async function akmAdd(input) {
@@ -126,7 +126,8 @@ async function addLocalSource(ref, sourcePath, stashDir, wikiName, explicitName)
     };
 }
 async function addWebsiteSource(ref, stashDir, name, options, wikiName) {
-    const normalizedUrl = validateWebsiteInputUrl(ref);
+    const allowPrivateHosts = shouldAllowPrivateWebsiteUrlForTests(ref);
+    const normalizedUrl = validateWebsiteInputUrl(ref, { allowPrivateHosts });
     const config = loadUserConfig();
     const sources = [...getSources(config)];
     let entry = sources.find((stash) => stash.type === "website" && stash.url === normalizedUrl);
@@ -154,7 +155,10 @@ async function addWebsiteSource(ref, stashDir, name, options, wikiName) {
         if (changed)
             saveConfig({ ...config, sources });
     }
-    const cachePaths = await ensureWebsiteMirror(entry, { requireStashDir: true });
+    const cachePaths = await ensureWebsiteMirror(entry, {
+        requireStashDir: true,
+        ...(allowPrivateHosts ? { allowPrivateHosts: true } : {}),
+    });
     const index = await akmIndex({ stashDir });
     const updatedConfig = loadConfig();
     return {

package/dist/commands/tasks/tasks.js

@@ -16,6 +16,7 @@ import { isWithin, resolveStashDir } from "../../core/common.js";
 import { loadConfig } from "../../core/config/config.js";
 import { ConfigError, NotFoundError, UsageError } from "../../core/errors.js";
 import { getTaskHistoryDir, getTaskLogDir } from "../../core/paths.js";
+import { commitWriteTargetBoundary, deleteAssetFromSource, resolveWriteTarget, writeAssetToSource, } from "../../core/write-source.js";
 import { listAgentProfileNames } from "../../integrations/agent/index.js";
 import { resolveAssetPath } from "../../sources/resolve.js";
 import { backendNameForPlatform, selectBackend } from "../../tasks/backends/index.js";
@@ -38,7 +39,8 @@ export async function akmTasksAdd(input) {
     // Validate the schedule for the active backend before writing anything.
     const backend = backendNameForPlatform();
     parseSchedule(input.schedule, backend);
-    const stashDir = resolveStashDir();
+    const target = resolveTaskWriteTarget();
+    const stashDir = target.source.path;
     const typeRoot = path.join(stashDir, "tasks");
     fs.mkdirSync(typeRoot, { recursive: true });
     const assetPath = resolveAssetPathFromName("task", typeRoot, id);
@@ -64,7 +66,8 @@ export async function akmTasksAdd(input) {
     });
     const task = parseTaskDocument({ yaml, filePath: assetPath, id });
     await validateTaskDocument(task, { backend, stashDir });
-    fs.writeFileSync(assetPath, yaml.endsWith("\n") ? yaml : `${yaml}\n`, "utf8");
+    const ref = taskAssetRef(id);
+    await writeAssetToSource(target.source, target.config, ref, yaml);
     // Install in the OS scheduler. If install fails after the file was written,
     // delete the file so the on-disk state never claims a task is registered
     // when it isn't.
@@ -74,13 +77,14 @@ export async function akmTasksAdd(input) {
     }
     catch (err) {
         try {
-            fs.rmSync(assetPath, { force: true });
+            await deleteAssetFromSource(target.source, target.config, ref);
         }
         catch {
             /* ignore */
         }
         throw err;
     }
+    commitWriteTargetBoundary(target, `Update task:${id}`);
     return {
         id,
         ref: `task:${id}`,
@@ -192,30 +196,47 @@ export async function akmTasksShow(id) {
 }
 export async function akmTasksRemove(id) {
     const normalised = normaliseTaskId(id);
-    const stashDir = resolveStashDir();
+    const target = resolveTaskWriteTarget();
+    const stashDir = target.source.path;
     const typeRoot = path.join(stashDir, "tasks");
     if (fs.existsSync(typeRoot))
         warnLegacyMdTaskFiles(typeRoot);
-    const filePath = await resolveAssetPath(stashDir, "task", normalised);
+    await resolveAssetPath(stashDir, "task", normalised);
+    const ref = taskAssetRef(normalised);
     const sched = selectBackend();
+    let uninstallError;
+    let deleteError;
     try {
         await sched.uninstall(normalised);
     }
-    finally {
-        fs.rmSync(filePath, { force: true });
+    catch (err) {
+        uninstallError = err;
+    }
+    try {
+        await deleteAssetFromSource(target.source, target.config, ref);
     }
+    catch (err) {
+        deleteError = err;
+    }
+    if (uninstallError !== undefined)
+        throw uninstallError;
+    if (deleteError !== undefined)
+        throw deleteError;
+    commitWriteTargetBoundary(target, `Remove task:${normalised}`);
     return { id: normalised, removed: true, backend: sched.name };
 }
 export async function akmTasksSetEnabled(id, enabled) {
     const normalised = normaliseTaskId(id);
-    const stashDir = resolveStashDir();
+    const target = resolveTaskWriteTarget();
+    const stashDir = target.source.path;
     const typeRoot = path.join(stashDir, "tasks");
     if (fs.existsSync(typeRoot))
         warnLegacyMdTaskFiles(typeRoot);
     const filePath = await resolveAssetPath(stashDir, "task", normalised);
     const yaml = fs.readFileSync(filePath, "utf8");
     const updated = setEnabledInYaml(yaml, enabled);
-    fs.writeFileSync(filePath, updated, "utf8");
+    const ref = taskAssetRef(normalised);
+    await writeAssetToSource(target.source, target.config, ref, updated);
     const sched = selectBackend();
     try {
         // Reinstall from the (just-updated) definition rather than only toggling
@@ -229,9 +250,10 @@ export async function akmTasksSetEnabled(id, enabled) {
     catch (err) {
         // Roll the file back so the YAML source-of-truth and the OS
         // scheduler don't diverge silently when the backend call fails.
-        fs.writeFileSync(filePath, yaml, "utf8");
+        await writeAssetToSource(target.source, target.config, ref, yaml);
         throw err;
     }
+    commitWriteTargetBoundary(target, `Update task:${normalised}`);
     return { id: normalised, enabled, backend: sched.name };
 }
 export async function akmTasksRun(id) {
@@ -392,6 +414,12 @@ function normaliseTaskId(raw) {
     }
     return id;
 }
+function taskAssetRef(id) {
+    return { type: "task", name: id };
+}
+function resolveTaskWriteTarget() {
+    return resolveWriteTarget(loadConfig());
+}
 function renderTaskYaml(input) {
     const obj = { schedule: input.schedule };
     if (input.workflow) {