@lousy-agents/cli 5.15.7 → 5.17.0

package/dist/index.js

@@ -2990,7 +2990,7 @@ exports.basename = (path, { windows } = {}) => {
 
 
 },
-455(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
+889(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
 // NAMESPACE OBJECT: ../../node_modules/micromark/lib/constructs.js
 var constructs_namespaceObject = {};
 __webpack_require__.r(constructs_namespaceObject);
@@ -3063,16 +3063,24 @@ function createBoundedReadStream(opened, maxBytes) {
 }
 
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/file-identity.js
+
 function isZero(value) {
     return value === 0 || value === 0n;
 }
+function sameStatValue(left, right) {
+    return typeof left === typeof right ? left === right : BigInt(left) === BigInt(right);
+}
+function sha256Hex(data, encoding) {
+    const buffer = typeof data === "string" ? Buffer.from(data, encoding ?? "utf8") : data;
+    return (0,external_node_crypto_.createHash)("sha256").update(buffer).digest("hex");
+}
 function file_identity_sameFileIdentity(left, right, platform = process.platform) {
-    if (left.ino !== right.ino) {
+    if (!sameStatValue(left.ino, right.ino)) {
         return false;
     }
     // On Windows, path-based stat calls can report dev=0 while fd-based stat
     // reports a real volume serial; treat either-side dev=0 as "unknown device".
-    if (left.dev === right.dev) {
+    if (sameStatValue(left.dev, right.dev)) {
         return true;
     }
     return platform === "win32" && (isZero(left.dev) || isZero(right.dev));
@@ -4466,6 +4474,377 @@ async function runPinnedPathHelper(params) {
     }
 }
 
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/sidecar-lock.js
+
+
+
+
+const GLOBAL_STATE_KEY = Symbol.for("fsSafe.sidecarLockManagers");
+function getGlobalManagers() {
+    const globalWithState = globalThis;
+    if (!globalWithState[GLOBAL_STATE_KEY]) {
+        globalWithState[GLOBAL_STATE_KEY] = new Map();
+    }
+    return globalWithState[GLOBAL_STATE_KEY];
+}
+function resolveManagerState(key) {
+    const managers = getGlobalManagers();
+    let state = managers.get(key);
+    if (!state) {
+        state = { cleanupRegistered: false, held: new Map() };
+        managers.set(key, state);
+    }
+    return state;
+}
+async function readLockSnapshot(lockPath) {
+    try {
+        const stat = await promises_.lstat(lockPath);
+        const raw = await promises_.readFile(lockPath, "utf8");
+        try {
+            const parsed = JSON.parse(raw);
+            const payload = parsed && typeof parsed === "object" && !Array.isArray(parsed)
+                ? parsed
+                : null;
+            return { raw, payload, stat };
+        }
+        catch {
+            return { raw, payload: null, stat };
+        }
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return null;
+        }
+        throw err;
+    }
+}
+function snapshotMatches(current, observed) {
+    if (observed.stat && current.stat && !file_identity_sameFileIdentity(observed.stat, current.stat)) {
+        return false;
+    }
+    if (observed.raw !== undefined) {
+        return current.raw === observed.raw;
+    }
+    return observed.stat !== undefined && current.stat !== undefined;
+}
+async function removeLockIfUnchanged(lockPath, observed) {
+    const current = await readLockSnapshot(lockPath);
+    if (!current || !observed) {
+        return false;
+    }
+    if (!snapshotMatches(current, observed)) {
+        // The lock changed after we decided it was stale. Leave the fresh holder's
+        // file alone; deleting by path here would break mutual exclusion.
+        return false;
+    }
+    await promises_.rm(lockPath, { force: true }).catch(() => undefined);
+    return true;
+}
+async function lockSnapshotStillPresent(lockPath, observed) {
+    const current = await readLockSnapshot(lockPath);
+    return !!current && !!observed && snapshotMatches(current, observed);
+}
+async function removeStaleLockIfAllowed(params) {
+    if (!params.shouldRemoveStaleLock) {
+        return "not-approved";
+    }
+    if (params.snapshot.raw === undefined) {
+        return "not-approved";
+    }
+    if (!(await params.shouldRemoveStaleLock({
+        lockPath: params.lockPath,
+        normalizedTargetPath: params.normalizedTargetPath,
+        raw: params.snapshot.raw,
+        payload: params.snapshot.payload,
+    }))) {
+        return "not-approved";
+    }
+    const current = await readLockSnapshot(params.lockPath);
+    if (!current || !snapshotMatches(current, params.snapshot)) {
+        return "changed";
+    }
+    try {
+        await promises_.rm(params.lockPath, { force: true });
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return "changed";
+        }
+        return "not-approved";
+    }
+    return "removed";
+}
+function snapshotMatchesSync(lockPath, observed) {
+    try {
+        const stat = external_node_fs_.lstatSync(lockPath);
+        if (observed.stat && !file_identity_sameFileIdentity(observed.stat, stat)) {
+            return false;
+        }
+        return observed.raw === undefined || external_node_fs_.readFileSync(lockPath, "utf8") === observed.raw;
+    }
+    catch {
+        return false;
+    }
+}
+async function resolveNormalizedTargetPath(targetPath) {
+    const resolved = external_node_path_.resolve(targetPath);
+    const dir = external_node_path_.dirname(resolved);
+    await promises_.mkdir(dir, { recursive: true });
+    try {
+        return external_node_path_.join(await promises_.realpath(dir), external_node_path_.basename(resolved));
+    }
+    catch {
+        return resolved;
+    }
+}
+function computeDelayMs(retry, attempt) {
+    const minTimeout = retry.minTimeout ?? 50;
+    const maxTimeout = retry.maxTimeout ?? 1000;
+    const factor = retry.factor ?? 1;
+    const base = Math.min(maxTimeout, Math.max(minTimeout, minTimeout * factor ** attempt));
+    const jitter = retry.randomize ? 1 + Math.random() : 1;
+    return Math.min(maxTimeout, Math.round(base * jitter));
+}
+async function defaultShouldReclaim(params) {
+    const createdAt = typeof params.payload?.createdAt === "string" ? params.payload.createdAt : "";
+    const createdAtMs = Date.parse(createdAt);
+    if (Number.isFinite(createdAtMs) && params.nowMs - createdAtMs > params.staleMs) {
+        return true;
+    }
+    try {
+        const stat = await promises_.stat(params.lockPath);
+        return params.nowMs - stat.mtimeMs > params.staleMs;
+    }
+    catch {
+        return true;
+    }
+}
+function releaseAllLocksSync(state) {
+    for (const [normalizedTargetPath, held] of state.held) {
+        void held.handle.close().catch(() => undefined);
+        try {
+            if (snapshotMatchesSync(held.lockPath, held.snapshot)) {
+                external_node_fs_.rmSync(held.lockPath, { force: true });
+            }
+        }
+        catch {
+            // Best-effort process-exit cleanup.
+        }
+        state.held.delete(normalizedTargetPath);
+    }
+}
+async function releaseHeldLock(state, normalizedTargetPath, held, opts = {}) {
+    const current = state.held.get(normalizedTargetPath);
+    if (current !== held) {
+        return false;
+    }
+    if (opts.force) {
+        held.count = 0;
+    }
+    else {
+        held.count -= 1;
+        if (held.count > 0) {
+            return false;
+        }
+    }
+    if (held.releasePromise) {
+        await held.releasePromise.catch(() => undefined);
+        return true;
+    }
+    state.held.delete(normalizedTargetPath);
+    held.releasePromise = (async () => {
+        await held.handle.close().catch(() => undefined);
+        await removeLockIfUnchanged(held.lockPath, held.snapshot);
+    })();
+    try {
+        await held.releasePromise;
+        return true;
+    }
+    finally {
+        held.releasePromise = undefined;
+    }
+}
+function createSidecarLockManager(key) {
+    const state = resolveManagerState(key);
+    function ensureExitCleanupRegistered() {
+        if (state.cleanupRegistered) {
+            return;
+        }
+        state.cleanupRegistered = true;
+        process.on("exit", () => releaseAllLocksSync(state));
+    }
+    async function acquire(options) {
+        ensureExitCleanupRegistered();
+        const normalizedTargetPath = await resolveNormalizedTargetPath(options.targetPath);
+        const lockPath = options.lockPath ?? `${normalizedTargetPath}.lock`;
+        const held = state.held.get(normalizedTargetPath);
+        if (held && options.allowReentrant) {
+            held.count += 1;
+            const release = () => releaseHeldLock(state, normalizedTargetPath, held).then(() => undefined);
+            return {
+                lockPath,
+                normalizedTargetPath,
+                release,
+                [Symbol.asyncDispose]: release,
+            };
+        }
+        const startedAt = Date.now();
+        const retry = options.retry ?? {};
+        const maxRetries = options.timeoutMs === Number.POSITIVE_INFINITY ? undefined : retry.retries;
+        let attempt = 0;
+        while (true) {
+            let handle = null;
+            try {
+                handle = await promises_.open(lockPath, "wx");
+                const payload = await options.payload();
+                const raw = `${JSON.stringify(payload, null, 2)}\n`;
+                await handle.writeFile(raw, "utf8");
+                const snapshot = { raw, payload, stat: await handle.stat() };
+                const createdHeld = {
+                    count: 1,
+                    handle,
+                    lockPath,
+                    snapshot,
+                    acquiredAt: Date.now(),
+                    metadata: options.metadata ?? {},
+                };
+                state.held.set(normalizedTargetPath, createdHeld);
+                const release = () => releaseHeldLock(state, normalizedTargetPath, createdHeld).then(() => undefined);
+                return {
+                    lockPath,
+                    normalizedTargetPath,
+                    release,
+                    [Symbol.asyncDispose]: release,
+                };
+            }
+            catch (err) {
+                if (handle) {
+                    const failedSnapshot = { payload: null };
+                    try {
+                        failedSnapshot.stat = await handle.stat();
+                    }
+                    catch {
+                        // Best-effort cleanup of a failed exclusive create.
+                    }
+                    const current = state.held.get(normalizedTargetPath);
+                    if (current?.handle === handle) {
+                        state.held.delete(normalizedTargetPath);
+                    }
+                    // If payload serialization/write fails, the file may be empty or
+                    // partial JSON, so remove while our exclusive handle is still open.
+                    await promises_.rm(lockPath, { force: true }).catch(() => undefined);
+                    await handle.close().catch(() => undefined);
+                    // Windows can refuse removing an open file; retry after close but
+                    // only if the path still points at the file identity we created.
+                    await removeLockIfUnchanged(lockPath, failedSnapshot);
+                }
+                if (err.code !== "EEXIST") {
+                    throw err;
+                }
+                const nowMs = Date.now();
+                const snapshot = await readLockSnapshot(lockPath);
+                if (!snapshot) {
+                    continue;
+                }
+                const shouldReclaim = options.shouldReclaim ?? defaultShouldReclaim;
+                if (await shouldReclaim({
+                    lockPath,
+                    normalizedTargetPath,
+                    payload: snapshot?.payload ?? null,
+                    staleMs: options.staleMs,
+                    nowMs,
+                    heldByThisProcess: state.held.has(normalizedTargetPath),
+                })) {
+                    if (!(await lockSnapshotStillPresent(lockPath, snapshot))) {
+                        continue;
+                    }
+                    const staleRecovery = options.staleRecovery ?? "fail-closed";
+                    if (staleRecovery === "remove-if-unchanged") {
+                        const removal = await removeStaleLockIfAllowed({
+                            lockPath,
+                            normalizedTargetPath,
+                            snapshot,
+                            shouldRemoveStaleLock: options.shouldRemoveStaleLock,
+                        });
+                        if (removal === "removed" || removal === "changed") {
+                            continue;
+                        }
+                    }
+                    throw Object.assign(new Error(`file lock stale for ${normalizedTargetPath}`), {
+                        code: "file_lock_stale",
+                        lockPath,
+                        normalizedTargetPath,
+                    });
+                }
+                const elapsed = Date.now() - startedAt;
+                if ((options.timeoutMs !== undefined &&
+                    options.timeoutMs !== Number.POSITIVE_INFINITY &&
+                    elapsed >= options.timeoutMs) ||
+                    (maxRetries !== undefined && attempt >= maxRetries)) {
+                    throw Object.assign(new Error(`file lock timeout for ${normalizedTargetPath}`), {
+                        code: "file_lock_timeout",
+                        lockPath,
+                        normalizedTargetPath,
+                    });
+                }
+                const remaining = options.timeoutMs === undefined || options.timeoutMs === Number.POSITIVE_INFINITY
+                    ? Number.POSITIVE_INFINITY
+                    : Math.max(0, options.timeoutMs - elapsed);
+                const delay = Math.min(computeDelayMs(retry, attempt), remaining);
+                attempt += 1;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+    }
+    async function withLock(options, fn) {
+        const lock = await acquire(options);
+        try {
+            return await fn();
+        }
+        finally {
+            await lock.release();
+        }
+    }
+    async function drain() {
+        for (const [normalizedTargetPath, held] of Array.from(state.held.entries())) {
+            await releaseHeldLock(state, normalizedTargetPath, held, { force: true }).catch(() => undefined);
+        }
+    }
+    function reset() {
+        releaseAllLocksSync(state);
+    }
+    function heldEntries() {
+        return Array.from(state.held.entries()).map(([normalizedTargetPath, held]) => ({
+            normalizedTargetPath,
+            lockPath: held.lockPath,
+            acquiredAt: held.acquiredAt,
+            metadata: held.metadata,
+            forceRelease: () => releaseHeldLock(state, normalizedTargetPath, held, { force: true }),
+        }));
+    }
+    return { acquire, withLock, drain, reset, heldEntries };
+}
+async function withSidecarLock(targetPath, options, fn) {
+    const manager = createSidecarLockManager(options.managerKey ?? `fs-safe.sidecar-lock:${targetPath}`);
+    const { managerKey: _managerKey, ...acquireOptions } = options;
+    return await manager.withLock({ ...acquireOptions, targetPath }, fn);
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/test-hooks.js
+let test_hooks_fsSafeTestHooks;
+function allowFsSafeTestHooks() {
+    return  false || process.env.VITEST === "true";
+}
+function getFsSafeTestHooks() {
+    return test_hooks_fsSafeTestHooks;
+}
+function __setFsSafeTestHooksForTest(hooks) {
+    if (hooks && !allowFsSafeTestHooks()) {
+        throw new Error("__setFsSafeTestHooksForTest is only available in tests");
+    }
+    test_hooks_fsSafeTestHooks = hooks;
+}
+
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/pinned-write.js
 
 
@@ -4479,6 +4858,8 @@ async function runPinnedPathHelper(params) {
 
 
 
+
+
 function pinned_write_byteLength(input, encoding) {
     return typeof input === "string"
         ? Buffer.byteLength(input, encoding ?? "utf8")
@@ -4536,6 +4917,12 @@ async function runPinnedWriteHelper(params) {
     validatePinnedOperationPayload({
         relativeParentPath: params.relativeParentPath,
     });
+    // The Python helper deliberately enforces the strict post-rename inode
+    // contract. The explicit compatibility policy therefore uses the guarded
+    // Node fallback, where content verification can replace that one check.
+    if (params.onRenameIdentityMismatch === "verify-content") {
+        return await runPinnedWriteFallback(params);
+    }
     if (getFsSafePythonConfig().mode === "off") {
         return await runPinnedWriteFallback(params);
     }
@@ -4550,8 +4937,11 @@ async function runPinnedWriteHelper(params) {
             throw error;
         }
     }
+    const input = params.input.kind === "stream"
+        ? { kind: "buffer", data: Buffer.from(await inputToBase64(params.input, params.maxBytes), "base64") }
+        : params.input;
     const payload = {
-        base64: await inputToBase64(params.input, params.maxBytes),
+        base64: await inputToBase64(input, params.maxBytes),
         basename: params.basename,
         maxBytes: params.maxBytes ?? -1,
         mkdir: params.mkdir,
@@ -4569,11 +4959,32 @@ async function runPinnedWriteHelper(params) {
     }
     catch (error) {
         if (canFallbackFromPythonError(error)) {
-            return await runPinnedWriteFallback(params);
+            return await runPinnedWriteFallback({ ...params, input });
         }
         throw error;
     }
 }
+async function runPinnedWriteWithRenamePolicy(params) {
+    const { targetPath, renameIdentity, ...writeParams } = params;
+    if (renameIdentity !== "verify-content-with-lock") {
+        return await runPinnedWriteHelper(writeParams);
+    }
+    const relativeTargetPath = writeParams.relativeParentPath
+        ? `${writeParams.relativeParentPath}/${writeParams.basename}`
+        : writeParams.basename;
+    const lockPath = external_node_path_.join(writeParams.rootPath, `.fs-safe-write-${sha256Hex(relativeTargetPath)}.lock`);
+    return await withSidecarLock(writeParams.rootPath, {
+        managerKey: `fs-safe.write:${targetPath}`,
+        lockPath,
+        staleMs: 30_000,
+        timeoutMs: 5_000,
+        payload: () => ({ pid: process.pid, createdAt: new Date().toISOString() }),
+        retry: { retries: 5, minTimeout: 100, maxTimeout: 2_000, factor: 2 },
+    }, async () => await runPinnedWriteHelper({
+        ...writeParams,
+        onRenameIdentityMismatch: "verify-content",
+    }));
+}
 async function runPinnedCopyHelper(params) {
     assertSafeBasename(params.basename);
     validatePinnedOperationPayload({
@@ -4629,7 +5040,10 @@ async function runPinnedWriteFallback(params) {
             else {
                 await writeStreamToHandle(params.input.stream, handle, params.maxBytes);
             }
+            await handle.sync();
             const stat = await handle.stat();
+            await handle.close().catch(() => undefined);
+            await syncDirectoryBestEffort(parentPath);
             created = false;
             return { dev: stat.dev, ino: stat.ino };
         }
@@ -4677,11 +5091,49 @@ async function runPinnedWriteFallback(params) {
         await withAsyncDirectoryGuards([parentGuard], async () => {
             await promises_.rename(tempPath, targetPath);
             renamed = true;
+            await getFsSafeTestHooks()?.afterPinnedWriteFallbackRename?.(targetPath);
             await syncDirectoryBestEffort(parentPath);
             targetStat = await promises_.lstat(targetPath);
-            if (targetStat.isSymbolicLink() || !file_identity_sameFileIdentity(targetStat, expectedTempStat)) {
+            if (targetStat.isSymbolicLink()) {
                 throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
             }
+            if (!file_identity_sameFileIdentity(targetStat, expectedTempStat)) {
+                // On filesystems like rclone FUSE, rename(2) can give the destination a
+                // different inode from the source temp fd even with zero concurrency. The
+                // caller must ensure mutual exclusion before passing "verify-content";
+                // fall back to a content hash for this rename-boundary check only.
+                if (params.onRenameIdentityMismatch !== "verify-content") {
+                    throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
+                }
+                if (params.input.kind !== "buffer") {
+                    throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
+                }
+                const expectedHash = sha256Hex(params.input.data, params.input.encoding);
+                const readFlags = external_node_fs_.constants.O_RDONLY |
+                    (process.platform !== "win32" && "O_NOFOLLOW" in external_node_fs_.constants
+                        ? external_node_fs_.constants.O_NOFOLLOW
+                        : 0);
+                const readHandle = await promises_.open(targetPath, readFlags);
+                let actualHash;
+                let readHandleStat;
+                try {
+                    // Capture fd-based identity before reading — this is stable across all
+                    // subsequent lookups (on FUSE and locally), unlike the lstat-based
+                    // targetStat that triggered this fallback.
+                    readHandleStat = await readHandle.stat();
+                    actualHash = sha256Hex(await readHandle.readFile());
+                }
+                finally {
+                    await readHandle.close().catch(() => undefined);
+                }
+                if (actualHash !== expectedHash) {
+                    throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
+                }
+                // Replace the unreliable lstat-based targetStat with the fd-based stat so
+                // the returned identity is consistent with what subsequent verifications
+                // (e.g. verifyAtomicWriteResult) will obtain by opening the same file.
+                targetStat = readHandleStat;
+            }
         });
     }
     catch (error) {
@@ -5777,21 +6229,6 @@ function normalizePinnedPathError(error) {
     });
 }
 
-;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/test-hooks.js
-let test_hooks_fsSafeTestHooks;
-function allowFsSafeTestHooks() {
-    return  false || process.env.VITEST === "true";
-}
-function getFsSafeTestHooks() {
-    return test_hooks_fsSafeTestHooks;
-}
-function __setFsSafeTestHooksForTest(hooks) {
-    if (hooks && !allowFsSafeTestHooks()) {
-        throw new Error("__setFsSafeTestHooksForTest is only available in tests");
-    }
-    test_hooks_fsSafeTestHooks = hooks;
-}
-
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/json-stringify.js
 function stringifyJsonDocument(value, replacer, space) {
     const text = JSON.stringify(value, replacer, space);
@@ -6127,6 +6564,7 @@ class RootHandle {
             data,
             mkdir: this.defaults.mkdir,
             mode: this.defaults.mode,
+            renameIdentity: this.defaults.renameIdentity,
             ...options,
             denyMutations: mergeDenyMutationPolicies(this.defaults.denyMutations, options.denyMutations),
         });
@@ -6561,21 +6999,23 @@ async function writeFileInRoot(root, params) {
 async function commitPinnedWriteInRoot(root, pinned, params) {
     let identity;
     try {
-        identity = await runPinnedWriteHelper({
+        identity = await runPinnedWriteWithRenamePolicy({
             rootPath: pinned.rootReal,
             relativeParentPath: pinned.relativeParentPath,
             basename: pinned.basename,
+            targetPath: pinned.targetPath,
+            renameIdentity: params.renameIdentity,
             mkdir: params.mkdir !== false,
             mode: params.mode ?? pinned.mode,
             overwrite: params.overwrite,
-            input: {
-                kind: "buffer",
-                data: params.data,
-                encoding: params.encoding,
-            },
+            input: { kind: "buffer", data: params.data, encoding: params.encoding },
         });
     }
     catch (error) {
+        const errorCode = error?.code;
+        if (errorCode === "file_lock_stale" || errorCode === "file_lock_timeout") {
+            throw error;
+        }
         if (params.overwrite === false && isAlreadyExistsError(error)) {
             throw new errors_FsSafeError("already-exists", "file already exists", {
                 cause: error instanceof Error ? error : undefined,
@@ -10720,7 +11160,7 @@ function handleIntersectionResults(result, left, right) {
     result.value = merged.data;
     return result;
 }
-const $ZodTuple = /*@__PURE__*/ (/* unused pure expression or super */ null && (core.$constructor("$ZodTuple", (inst, def) => {
+const $ZodTuple = /*@__PURE__*/ $constructor("$ZodTuple", (inst, def) => {
     $ZodType.init(inst, def);
     const items = def.items;
     inst._zod.parse = (payload, ctx) => {
@@ -10796,7 +11236,7 @@ const $ZodTuple = /*@__PURE__*/ (/* unused pure expression or super */ null && (
         }
         return handleTupleResults(itemResults, payload, items, input, optoutStart);
     };
-})));
+});
 function getTupleOptStart(items, key) {
     for (let i = items.length - 1; i >= 0; i--) {
         if (items[i]._zod[key] !== "optional")
@@ -10806,7 +11246,7 @@ function getTupleOptStart(items, key) {
 }
 function handleTupleResult(result, final, index) {
     if (result.issues.length) {
-        final.issues.push(...util.prefixIssues(index, result.issues));
+        final.issues.push(...prefixIssues(index, result.issues));
     }
     final.value[index] = result.value;
 }
@@ -10822,7 +11262,7 @@ function handleTupleResults(itemResults, final, items, input, optoutStart) {
                 final.value.length = i;
                 break;
             }
-            final.issues.push(...util.prefixIssues(i, r.issues));
+            final.issues.push(...prefixIssues(i, r.issues));
         }
         final.value[i] = r.value;
     }
@@ -13606,12 +14046,12 @@ const tupleProcessor = (schema, ctx, _json, params) => {
     json.type = "array";
     const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
     const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
-    const prefixItems = def.items.map((x, i) => process(x, ctx, {
+    const prefixItems = def.items.map((x, i) => to_json_schema_process(x, ctx, {
         ...params,
         path: [...params.path, prefixPath, i],
     }));
     const rest = def.rest
-        ? process(def.rest, ctx, {
+        ? to_json_schema_process(def.rest, ctx, {
             ...params,
             path: [...params.path, restPath, ...(ctx.target === "openapi-3.0" ? [def.items.length] : [])],
         })
@@ -14817,24 +15257,24 @@ function intersection(left, right) {
         right: right,
     });
 }
-const ZodTuple = /*@__PURE__*/ (/* unused pure expression or super */ null && (core.$constructor("ZodTuple", (inst, def) => {
-    core.$ZodTuple.init(inst, def);
+const ZodTuple = /*@__PURE__*/ $constructor("ZodTuple", (inst, def) => {
+    $ZodTuple.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json, params) => processors.tupleProcessor(inst, ctx, json, params);
+    inst._zod.processJSONSchema = (ctx, json, params) => tupleProcessor(inst, ctx, json, params);
     inst.rest = (rest) => inst.clone({
         ...inst._zod.def,
         rest: rest,
     });
-})));
+});
 function tuple(items, _paramsOrRest, _params) {
-    const hasRest = _paramsOrRest instanceof core.$ZodType;
+    const hasRest = _paramsOrRest instanceof $ZodType;
     const params = hasRest ? _params : _paramsOrRest;
     const rest = hasRest ? _paramsOrRest : null;
     return new ZodTuple({
         type: "tuple",
         items: items,
         rest,
-        ...util.normalizeParams(params),
+        ...normalizeParams(params),
     });
 }
 const ZodRecord = /*@__PURE__*/ $constructor("ZodRecord", (inst, def) => {
@@ -14844,7 +15284,7 @@ const ZodRecord = /*@__PURE__*/ $constructor("ZodRecord", (inst, def) => {
     inst.keyType = def.keyType;
     inst.valueType = def.valueType;
 });
-function record(keyType, valueType, params) {
+function schemas_record(keyType, valueType, params) {
     // v3-compat: z.record(valueType, params?) — defaults keyType to z.string()
     if (!valueType || !valueType._zod) {
         return new ZodRecord({
@@ -15335,7 +15775,7 @@ const stringbool = (...args) => core._stringbool({
 }, ...args);
 function schemas_json(params) {
     const jsonSchema = lazy(() => {
-        return union([schemas_string(params), schemas_number(), schemas_boolean(), schemas_null(), schemas_array(jsonSchema), record(schemas_string(), jsonSchema)]);
+        return union([schemas_string(params), schemas_number(), schemas_boolean(), schemas_null(), schemas_array(jsonSchema), schemas_record(schemas_string(), jsonSchema)]);
     });
     return jsonSchema;
 }
@@ -25617,7 +26057,7 @@ const dist_src_Octokit = Octokit.plugin(requestLog, legacyRestEndpointMethods, p
 const execFileAsync = (0,external_node_util_.promisify)(external_node_child_process_.execFile);
 const RulesetRuleSchema = schemas_object({
     type: schemas_string(),
-    parameters: record(schemas_string(), unknown()).optional()
+    parameters: schemas_record(schemas_string(), unknown()).optional()
 });
 const RulesetSchema = schemas_object({
     id: schemas_number(),
@@ -26053,7 +26493,7 @@ const MAX_NPMRC_BYTES = 64 * 1024;
 // 1 MB — covers even the largest real-world manifests
 const MAX_PACKAGE_JSON_BYTES = 1024 * 1024;
 const PackageJsonSchema = schemas_object({
-    scripts: record(schemas_string(), schemas_string()).optional()
+    scripts: schemas_record(schemas_string(), schemas_string()).optional()
 });
 /**
  * File system implementation of script discovery gateway
@@ -26187,7 +26627,7 @@ const PackageJsonSchema = schemas_object({
 /** Maximum lock file size: 256 KB */ const MAX_LOCK_FILE_BYTES = 262_144;
 /** Relative path to the skills lock file. */ const SKILLS_LOCK_PATH = "skills-lock.json";
 /** Zod schema for skills-lock.json structure */ const SkillsLockSchema = schemas_object({
-    skills: record(schemas_string(), unknown()).optional()
+    skills: schemas_record(schemas_string(), unknown()).optional()
 });
 /**
  * Reads the skills-lock.json file and returns the set of locked skill names.
@@ -27900,6 +28340,1584 @@ async function checkAndPromptAgentShell(npmrcGateway, targetDir, prompt, environ
     }
 }
 
+;// CONCATENATED MODULE: ../doctor/src/formatters/human-renderer.ts
+const SEVERITY_ORDER = [
+    "critical",
+    "high",
+    "medium",
+    "low",
+    "info"
+];
+const CATEGORY_ORDER = [
+    "missing-required",
+    "malformed-reference",
+    "wrong-direction",
+    "drift",
+    "governance",
+    "composition-style"
+];
+function sortFindings(findings) {
+    return [
+        ...findings
+    ].sort((a, b)=>{
+        const severityDiff = SEVERITY_ORDER.indexOf(a.severity) - SEVERITY_ORDER.indexOf(b.severity);
+        if (severityDiff !== 0) return severityDiff;
+        return CATEGORY_ORDER.indexOf(a.category) - CATEGORY_ORDER.indexOf(b.category);
+    });
+}
+function renderHuman(summary, findings, logger, snapshotRef) {
+    if (snapshotRef) {
+        logger.info(`Evidence snapshot: ${snapshotRef}`);
+    }
+    logger.info(`Archetype: ${summary.archetype}`);
+    logger.info(`  ${summary.archetypeDescription}`);
+    logger.info(`  Dominance score: ${(summary.dominanceScore * 100).toFixed(0)}%`);
+    logger.info(`  Total records: ${summary.totalRecords}`);
+    if (summary.harnessBreakdown.length > 0) {
+        logger.info("  Harness breakdown:");
+        for (const { harness, count } of summary.harnessBreakdown){
+            logger.info(`    ${harness}: ${count}`);
+        }
+    }
+    if (summary.crossHarnessEdges > 0) {
+        logger.info(`  Cross-harness edges: ${summary.crossHarnessEdges}`);
+    }
+    if (findings.length === 0) {
+        logger.success("No findings.");
+        return;
+    }
+    logger.info(`\nFindings (${findings.length}):`);
+    const sorted = sortFindings(findings);
+    for (const finding of sorted){
+        const severityTag = `[${finding.severity.toUpperCase()}]`;
+        const classTag = `[${finding.classification}]`;
+        const assumedTag = finding.assumedIntent ? " [assumed intent]" : "";
+        logger.info(`  ${severityTag}${classTag} ${finding.criterionId}: ${finding.description}${assumedTag}`);
+        if (finding.evidenceCitation) {
+            logger.info(`    Evidence: node ${finding.evidenceCitation.nodeId} (${finding.evidenceCitation.sourceFile})`);
+        }
+    }
+}
+function hasBlockingFindings(findings) {
+    return findings.some((f)=>(f.severity === "critical" || f.severity === "high") && f.classification === "defect");
+}
+
+;// CONCATENATED MODULE: ../doctor/src/lib/cross-harness-edges.ts
+function resolveEdgeTargets(edge) {
+    return Array.isArray(edge.direction.to) ? edge.direction.to : [
+        edge.direction.to
+    ];
+}
+function buildHarnessByPath(records) {
+    const harnessByPath = new Map();
+    for (const record of records){
+        harnessByPath.set(record.path, record.harness);
+    }
+    return harnessByPath;
+}
+function isCrossHarnessTarget(edge, targetPath, sourceHarness, harnessByPath) {
+    if (edge.malformed || edge.type === "glob-binding") return false;
+    const targetHarness = harnessByPath.get(targetPath);
+    return targetHarness !== undefined && targetHarness !== sourceHarness;
+}
+function countCrossHarnessEdges(records) {
+    const harnessByPath = buildHarnessByPath(records);
+    let count = 0;
+    for (const record of records){
+        for (const edge of record.edges){
+            for (const target of resolveEdgeTargets(edge)){
+                if (isCrossHarnessTarget(edge, target, record.harness, harnessByPath)) {
+                    count++;
+                }
+            }
+        }
+    }
+    return count;
+}
+
+;// CONCATENATED MODULE: ../doctor/src/formatters/json-formatter.ts
+
+
+const HarnessNameSchema = schemas_enum([
+    "claude",
+    "copilot",
+    "codex",
+    "antigravity",
+    "hermes",
+    "crush",
+    "pi",
+    "shared"
+]);
+const ConstructTypeSchema = schemas_enum([
+    "instruction",
+    "skill",
+    "agent",
+    "subagent",
+    "mcp-server",
+    "plugin",
+    "hook"
+]);
+const EdgeTypeSchema = schemas_enum([
+    "hard-import",
+    "soft-reference",
+    "glob-binding"
+]);
+const ArchetypeSchema = schemas_enum([
+    "pure",
+    "intentional-hybrid",
+    "canonical-contract",
+    "accidental-sprawl",
+    "none",
+    "ambiguous"
+]);
+const CitationHandleSchema = schemas_object({
+    nodeId: schemas_string(),
+    sourceFile: schemas_string(),
+    lineRange: tuple([
+        schemas_number(),
+        schemas_number()
+    ]).optional(),
+    snapshotRef: schemas_string().optional()
+});
+const FindingSchema = schemas_object({
+    id: schemas_string(),
+    criterionId: schemas_string(),
+    targetId: schemas_string(),
+    severity: schemas_enum([
+        "critical",
+        "high",
+        "medium",
+        "low",
+        "info"
+    ]),
+    category: schemas_enum([
+        "missing-required",
+        "malformed-reference",
+        "wrong-direction",
+        "drift",
+        "governance",
+        "composition-style"
+    ]),
+    classification: schemas_enum([
+        "defect",
+        "advisory",
+        "info"
+    ]),
+    intentGated: schemas_boolean(),
+    assumedIntent: schemas_boolean(),
+    description: schemas_string(),
+    evidenceCitation: CitationHandleSchema.optional(),
+    snapshotRef: schemas_string().optional()
+});
+const ReportInventoryItemSchema = schemas_object({
+    id: schemas_string(),
+    path: schemas_string(),
+    harness: HarnessNameSchema,
+    constructType: ConstructTypeSchema,
+    loadMechanism: schemas_enum([
+        "referenced",
+        "convention-loaded"
+    ]),
+    serverName: schemas_string().optional(),
+    transport: schemas_string().optional()
+});
+const ReportEdgeSchema = schemas_object({
+    from: schemas_string(),
+    to: schemas_string(),
+    type: EdgeTypeSchema,
+    malformed: schemas_boolean(),
+    reason: schemas_enum([
+        "missing-target",
+        "path-traversal"
+    ]).optional(),
+    crossHarness: schemas_boolean()
+});
+const ReportJsonSchema = schemas_object({
+    archetype: ArchetypeSchema,
+    dominanceScore: schemas_number(),
+    totalRecords: schemas_number(),
+    harnessBreakdown: schemas_array(schemas_object({
+        harness: schemas_string(),
+        count: schemas_number()
+    })),
+    crossHarnessEdges: schemas_number(),
+    inventory: schemas_array(ReportInventoryItemSchema),
+    edges: schemas_array(ReportEdgeSchema),
+    findings: schemas_array(FindingSchema),
+    snapshotRef: schemas_string().optional()
+});
+function toInventoryItems(records) {
+    return records.map((record)=>({
+            id: record.id,
+            path: record.path,
+            harness: record.harness,
+            constructType: record.constructType,
+            loadMechanism: record.loadMechanism,
+            ...record.serverName !== undefined ? {
+                serverName: record.serverName
+            } : {},
+            ...record.transport !== undefined ? {
+                transport: record.transport
+            } : {}
+        })).sort((a, b)=>a.path.localeCompare(b.path) || a.id.localeCompare(b.id));
+}
+function toReportEdges(records) {
+    const harnessByPath = buildHarnessByPath(records);
+    const result = [];
+    for (const record of records){
+        for (const edge of record.edges){
+            for (const target of resolveEdgeTargets(edge)){
+                result.push({
+                    from: edge.direction.from,
+                    to: target,
+                    type: edge.type,
+                    malformed: edge.malformed,
+                    ...edge.reason !== undefined ? {
+                        reason: edge.reason
+                    } : {},
+                    crossHarness: isCrossHarnessTarget(edge, target, record.harness, harnessByPath)
+                });
+            }
+        }
+    }
+    return result;
+}
+function toJson(summary, findings, records, snapshotRef) {
+    const edges = toReportEdges(records);
+    const report = {
+        archetype: summary.archetype,
+        dominanceScore: summary.dominanceScore,
+        totalRecords: summary.totalRecords,
+        harnessBreakdown: summary.harnessBreakdown,
+        crossHarnessEdges: edges.filter((edge)=>edge.crossHarness).length,
+        inventory: toInventoryItems(records),
+        edges,
+        findings,
+        ...snapshotRef !== undefined ? {
+            snapshotRef
+        } : {}
+    };
+    return ReportJsonSchema.parse(report);
+}
+
+;// CONCATENATED MODULE: ../doctor/src/formatters/summary-formatter.ts
+
+const ARCHETYPE_DESCRIPTIONS = {
+    pure: "Single-harness configuration. One AI coding assistant dominates the repository.",
+    "intentional-hybrid": "Multi-harness configuration with cross-harness references. Harnesses deliberately share context.",
+    "canonical-contract": "Shared AGENTS.md contract. All harnesses read from a single canonical instruction file.",
+    "accidental-sprawl": "Multiple harnesses configured without cross-referencing. May indicate legacy or uncoordinated setup.",
+    none: "No agentic configuration detected.",
+    ambiguous: "Configuration does not fit a single archetype cleanly."
+};
+function formatSummary(records, classification) {
+    const counts = new Map();
+    for (const r of records){
+        counts.set(r.harness, (counts.get(r.harness) ?? 0) + 1);
+    }
+    const harnessBreakdown = Array.from(counts.entries()).map(([harness, count])=>({
+            harness,
+            count
+        })).sort((a, b)=>a.harness.localeCompare(b.harness));
+    const crossHarnessEdges = countCrossHarnessEdges(records);
+    return {
+        archetype: classification.archetype,
+        archetypeDescription: ARCHETYPE_DESCRIPTIONS[classification.archetype],
+        dominanceScore: classification.dominanceScore,
+        totalRecords: records.length,
+        harnessBreakdown,
+        crossHarnessEdges
+    };
+}
+
+;// CONCATENATED MODULE: ../doctor/src/gateways/intent-artifact.ts
+
+
+
+
+const MAX_INTENT_BYTES = 65_536;
+const ARTIFACT_FILENAME = "intent.json";
+const ARTIFACT_DIR = ".agentic-doctor";
+const DeclaredIntentSchema = schemas_object({
+    targetHarnesses: schemas_array(schemas_enum([
+        "claude",
+        "copilot",
+        "codex",
+        "antigravity",
+        "hermes",
+        "crush",
+        "pi",
+        "shared"
+    ])),
+    desiredCapabilities: schemas_array(schemas_string()),
+    confirmedAnswers: schemas_record(schemas_string(), unknown()),
+    intentSource: schemas_enum([
+        "interactive",
+        "ci-assumed",
+        "pre-committed"
+    ]),
+    snapshotRef: schemas_string().optional()
+});
+async function readIntentArtifact(repoRoot) {
+    const artifactRelPath = `${ARTIFACT_DIR}/${ARTIFACT_FILENAME}`;
+    const artifactPath = (0,external_node_path_.resolve)(repoRoot, ARTIFACT_DIR, ARTIFACT_FILENAME);
+    let raw;
+    try {
+        raw = await file_system_utils_readTextWithinRoot(repoRoot, artifactRelPath, MAX_INTENT_BYTES);
+    } catch  {
+        return {
+            found: false
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    } catch  {
+        return {
+            found: false
+        };
+    }
+    const result = DeclaredIntentSchema.safeParse(parsed);
+    if (!result.success) {
+        return {
+            found: false
+        };
+    }
+    return {
+        found: true,
+        artifact: result.data,
+        path: artifactPath
+    };
+}
+async function writeIntentArtifact(repoRoot, artifact) {
+    const artifactPath = await resolveSafePath(repoRoot, `${ARTIFACT_DIR}/${ARTIFACT_FILENAME}`);
+    await mkdir(dirname(artifactPath), {
+        recursive: true
+    });
+    await writeFile(artifactPath, JSON.stringify(artifact, null, 2), "utf-8");
+    return artifactPath;
+}
+function buildDefaultIntent(harnesses) {
+    return {
+        targetHarnesses: harnesses.filter((h)=>h !== "shared"),
+        desiredCapabilities: [],
+        confirmedAnswers: {},
+        intentSource: "ci-assumed"
+    };
+}
+
+;// CONCATENATED MODULE: ../doctor/src/entities/harness-footprints.ts
+const HARNESS_NAMES = [
+    "claude",
+    "copilot",
+    "codex",
+    "antigravity",
+    "hermes",
+    "crush",
+    "pi"
+];
+const HARNESS_FOOTPRINTS = {
+    claude: {
+        name: "claude",
+        status: "verified",
+        readsAgentsMd: false,
+        walkBoundary: "git-root",
+        conventionFiles: [
+            "CLAUDE.md"
+        ],
+        conventionDirs: [
+            ".claude/"
+        ],
+        primaryIndicators: [
+            "CLAUDE.md",
+            ".claude/"
+        ],
+        crossRefMechanisms: [
+            {
+                edgeType: "hard-import",
+                description: "Claude @path/to/file syntax at line start inlines the referenced file"
+            },
+            {
+                edgeType: "soft-reference",
+                description: "Frontmatter see:/references:/requires: keys or markdown links to sibling instruction files"
+            }
+        ]
+    },
+    copilot: {
+        name: "copilot",
+        status: "verified",
+        readsAgentsMd: false,
+        walkBoundary: "project",
+        conventionFiles: [
+            ".github/copilot-instructions.md"
+        ],
+        conventionDirs: [
+            ".github/instructions/"
+        ],
+        primaryIndicators: [
+            ".github/copilot-instructions.md",
+            ".github/instructions/"
+        ],
+        crossRefMechanisms: [
+            {
+                edgeType: "glob-binding",
+                description: "Copilot applyTo frontmatter field scopes an instruction to matching source files"
+            },
+            {
+                edgeType: "soft-reference",
+                description: "Frontmatter see:/references:/requires: keys or markdown links to sibling instruction files"
+            }
+        ]
+    },
+    codex: {
+        name: "codex",
+        status: "verified",
+        readsAgentsMd: true,
+        walkBoundary: "git-root",
+        conventionFiles: [
+            "AGENTS.md",
+            "AGENTS.override.md"
+        ],
+        conventionDirs: [
+            ".codex/",
+            ".agents/skills/",
+            ".codex-plugin/"
+        ],
+        primaryIndicators: [
+            "AGENTS.override.md",
+            ".codex/",
+            ".agents/skills/",
+            ".codex-plugin/"
+        ],
+        crossRefMechanisms: [
+            {
+                edgeType: "soft-reference",
+                description: "Frontmatter see:/references:/requires: keys or markdown links to sibling instruction files"
+            }
+        ]
+    },
+    antigravity: {
+        name: "antigravity",
+        status: "needs-verification",
+        readsAgentsMd: false,
+        walkBoundary: null,
+        conventionFiles: [
+            "GEMINI.md"
+        ],
+        conventionDirs: [
+            ".gemini/"
+        ],
+        primaryIndicators: [
+            "GEMINI.md",
+            ".gemini/"
+        ],
+        crossRefMechanisms: [
+            {
+                edgeType: "soft-reference",
+                description: "Frontmatter see:/references:/requires: keys or markdown links to sibling instruction files"
+            }
+        ]
+    },
+    hermes: {
+        name: "hermes",
+        status: "verified",
+        readsAgentsMd: true,
+        walkBoundary: "git-root",
+        conventionFiles: [
+            ".hermes.md",
+            "HERMES.md",
+            "AGENTS.md",
+            "agents.md",
+            "CLAUDE.md",
+            "claude.md",
+            ".cursorrules",
+            "SOUL.md"
+        ],
+        conventionDirs: [],
+        primaryIndicators: [
+            ".hermes.md",
+            "HERMES.md",
+            "SOUL.md"
+        ],
+        crossRefMechanisms: [
+            {
+                edgeType: "soft-reference",
+                description: "Frontmatter see:/references:/requires: keys or markdown links to sibling instruction files"
+            }
+        ]
+    },
+    crush: {
+        name: "crush",
+        status: "verified",
+        readsAgentsMd: true,
+        walkBoundary: null,
+        conventionFiles: [
+            "AGENTS.md",
+            "crush.json"
+        ],
+        conventionDirs: [
+            ".crush/",
+            ".agents/skills/"
+        ],
+        primaryIndicators: [
+            "crush.json",
+            ".crush/"
+        ],
+        crossRefMechanisms: [
+            {
+                edgeType: "soft-reference",
+                description: "Frontmatter see:/references:/requires: keys or markdown links to sibling instruction files"
+            }
+        ]
+    },
+    pi: {
+        name: "pi",
+        status: "verified",
+        readsAgentsMd: true,
+        walkBoundary: "filesystem-root",
+        conventionFiles: [
+            "AGENTS.md",
+            "AGENTS.MD",
+            "CLAUDE.md",
+            "CLAUDE.MD"
+        ],
+        conventionDirs: [
+            ".pi/",
+            ".pi/skills/",
+            ".pi/prompts/"
+        ],
+        primaryIndicators: [
+            ".pi/",
+            ".pi/skills/",
+            ".pi/prompts/"
+        ],
+        crossRefMechanisms: [
+            {
+                edgeType: "soft-reference",
+                description: "Frontmatter see:/references:/requires: keys or markdown links to sibling instruction files"
+            }
+        ]
+    },
+    shared: {
+        name: "shared",
+        status: "verified",
+        readsAgentsMd: true,
+        walkBoundary: null,
+        conventionFiles: [
+            "AGENTS.md",
+            "AGENTS.MD",
+            "agents.md"
+        ],
+        conventionDirs: [],
+        primaryIndicators: [
+            "AGENTS.md",
+            "AGENTS.MD",
+            "agents.md"
+        ],
+        crossRefMechanisms: []
+    }
+};
+function getFootprint(harness) {
+    return HARNESS_FOOTPRINTS[harness];
+}
+function matchesPrimaryIndicator(repoRelativePath, indicators) {
+    const normalized = repoRelativePath.replace(/\\/g, "/");
+    return indicators.some((indicator)=>{
+        if (indicator.endsWith("/")) {
+            return normalized === indicator.slice(0, -1) || normalized.startsWith(indicator);
+        }
+        return normalized === indicator;
+    });
+}
+
+;// CONCATENATED MODULE: ../doctor/src/lib/edge-parser.ts
+
+const HARD_IMPORT_GLOBAL_RE = /^@([^\s@][^\s]*)/gm;
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---/;
+const MARKDOWN_LINK_RE = /\[(?:[^\]]*)\]\(([^)]+)\)/g;
+const SOFT_REF_FRONTMATTER_KEYS = [
+    "see",
+    "references",
+    "requires"
+];
+function edge_parser_parseFrontmatter(content) {
+    const match = FRONTMATTER_RE.exec(content);
+    if (!match) return null;
+    try {
+        const parsed = (0,dist/* .parse */.qg)(match[1]);
+        return typeof parsed === "object" && parsed !== null ? parsed : null;
+    } catch  {
+        return null;
+    }
+}
+function contentWithoutFrontmatter(content) {
+    return content.replace(FRONTMATTER_RE, "");
+}
+function toStringArray(value) {
+    if (typeof value === "string") return [
+        value
+    ];
+    if (Array.isArray(value)) return value.filter((v)=>typeof v === "string");
+    return [];
+}
+function isInstructionFilePath(path) {
+    return path.endsWith(".md") || path.endsWith(".instructions.md") || path.endsWith(".mdc");
+}
+function parseRawEdges(content) {
+    const edges = [];
+    const fm = edge_parser_parseFrontmatter(content);
+    if (fm) {
+        if (fm.applyTo) {
+            for (const glob of toStringArray(fm.applyTo)){
+                edges.push({
+                    type: "glob-binding",
+                    rawTarget: glob
+                });
+            }
+        }
+        for (const key of SOFT_REF_FRONTMATTER_KEYS){
+            const value = fm[key];
+            if (value) {
+                for (const ref of toStringArray(value)){
+                    if (isInstructionFilePath(ref)) {
+                        edges.push({
+                            type: "soft-reference",
+                            rawTarget: ref
+                        });
+                    }
+                }
+            }
+        }
+    }
+    const body = fm ? contentWithoutFrontmatter(content) : content;
+    for (const match of body.matchAll(HARD_IMPORT_GLOBAL_RE)){
+        const target = match[1];
+        if (target.includes("/")) {
+            edges.push({
+                type: "hard-import",
+                rawTarget: target
+            });
+        }
+    }
+    for (const match of body.matchAll(MARKDOWN_LINK_RE)){
+        const href = match[1];
+        if (!href.startsWith("http://") && !href.startsWith("https://") && isInstructionFilePath(href)) {
+            edges.push({
+                type: "soft-reference",
+                rawTarget: href
+            });
+        }
+    }
+    return edges;
+}
+
+;// CONCATENATED MODULE: ../doctor/src/gateways/mcp-config.ts
+
+
+const MAX_MCP_CONFIG_BYTES = 1_048_576;
+const MCP_CONFIG_SOURCES = [
+    {
+        relPath: ".mcp.json",
+        harness: "shared"
+    },
+    {
+        relPath: ".vscode/mcp.json",
+        harness: "copilot"
+    }
+];
+const McpServerEntrySchema = schemas_object({
+    type: schemas_string().optional(),
+    transport: schemas_string().optional()
+}).passthrough();
+const McpConfigSchema = schemas_object({
+    mcpServers: schemas_record(schemas_string(), McpServerEntrySchema).optional()
+}).passthrough();
+async function readMcpServersFromSource(repoRoot, source) {
+    let content;
+    try {
+        content = await file_system_utils_readTextWithinRoot(repoRoot, source.relPath, MAX_MCP_CONFIG_BYTES);
+    } catch  {
+        return [];
+    }
+    let raw;
+    try {
+        raw = JSON.parse(content);
+    } catch  {
+        return [];
+    }
+    const result = McpConfigSchema.safeParse(raw);
+    if (!result.success || result.data.mcpServers === undefined) {
+        return [];
+    }
+    return Object.entries(result.data.mcpServers).map(([serverName, entry])=>({
+            serverName,
+            harness: source.harness,
+            path: source.relPath,
+            ...entry.transport !== undefined ? {
+                transport: entry.transport
+            } : entry.type !== undefined ? {
+                transport: entry.type
+            } : {}
+        }));
+}
+async function enumerateMcpServers(repoRoot) {
+    const records = [];
+    for (const source of MCP_CONFIG_SOURCES){
+        records.push(...await readMcpServersFromSource(repoRoot, source));
+    }
+    return records;
+}
+
+;// CONCATENATED MODULE: ../doctor/src/gateways/scanner.ts
+
+
+
+
+
+const MAX_FILE_BYTES = 1_048_576;
+const SCANNABLE_EXTENSIONS = new Set([
+    ".md",
+    ".mdc",
+    ".json",
+    ".yaml",
+    ".yml",
+    ".toml"
+]);
+// Extensionless files that are known harness convention artifacts
+const SCANNABLE_EXTENSIONLESS = new Set([
+    ".cursorrules"
+]);
+const ALL_HARNESS_NAMES = [
+    ...HARNESS_NAMES,
+    "shared"
+];
+function isScannableFile(name) {
+    if (SCANNABLE_EXTENSIONLESS.has(name)) return true;
+    const dot = name.lastIndexOf(".");
+    if (dot === -1) return false;
+    return SCANNABLE_EXTENSIONS.has(name.slice(dot));
+}
+function isMarkdownFile(name) {
+    return name.endsWith(".md") || name.endsWith(".mdc");
+}
+function determineConstructType(relPath) {
+    if (relPath.startsWith(".agents/skills/") || relPath.startsWith(".pi/skills/") || relPath.startsWith(".pi/prompts/")) {
+        return "skill";
+    }
+    if (relPath.startsWith(".codex-plugin/")) {
+        return "plugin";
+    }
+    if (relPath.startsWith(".claude/hooks/")) {
+        return "hook";
+    }
+    if (relPath.startsWith(".claude/agents/")) {
+        return "subagent";
+    }
+    if (relPath.startsWith(".claude/commands/")) {
+        return "agent";
+    }
+    return "instruction";
+}
+function determineHarness(repoRelativePath) {
+    const matching = ALL_HARNESS_NAMES.filter((harness)=>matchesPrimaryIndicator(repoRelativePath, HARNESS_FOOTPRINTS[harness].primaryIndicators));
+    if (matching.length === 0) return null;
+    if (matching.length >= 2) return "shared";
+    return matching[0];
+}
+function resolveEdge(rawTarget, type, sourceAbsPath, repoRoot, existingAbsPaths) {
+    const from = (0,external_node_path_.relative)(repoRoot, sourceAbsPath).replace(/\\/g, "/");
+    if (type === "glob-binding") {
+        return {
+            type,
+            direction: {
+                from,
+                to: rawTarget
+            },
+            target: rawTarget,
+            malformed: false
+        };
+    }
+    const sourceDir = (0,external_node_path_.dirname)(sourceAbsPath);
+    const resolvedAbs = (0,external_node_path_.resolve)(sourceDir, rawTarget);
+    const absoluteRoot = (0,external_node_path_.resolve)(repoRoot);
+    const isWithinRoot = resolvedAbs === absoluteRoot || resolvedAbs.startsWith(`${absoluteRoot}${external_node_path_.sep}`);
+    if (!isWithinRoot) {
+        return {
+            type,
+            direction: {
+                from,
+                to: rawTarget
+            },
+            target: rawTarget,
+            malformed: true,
+            reason: "path-traversal"
+        };
+    }
+    const relativeTarget = (0,external_node_path_.relative)(absoluteRoot, resolvedAbs).replace(/\\/g, "/");
+    if (!existingAbsPaths.has(resolvedAbs)) {
+        return {
+            type,
+            direction: {
+                from,
+                to: relativeTarget
+            },
+            target: relativeTarget,
+            malformed: true,
+            reason: "missing-target"
+        };
+    }
+    return {
+        type,
+        direction: {
+            from,
+            to: relativeTarget
+        },
+        target: relativeTarget,
+        malformed: false
+    };
+}
+async function collectFiles(repoRoot, relDir, collected, depth = 0) {
+    if (depth > 10) return;
+    let entries;
+    try {
+        entries = await file_system_utils_listDirectoryWithinRoot(repoRoot, relDir);
+    } catch  {
+        return;
+    }
+    entries.sort((a, b)=>a.name.localeCompare(b.name));
+    for (const entry of entries){
+        const entryRel = relDir ? `${relDir}/${entry.name}` : entry.name;
+        const entryAbs = (0,external_node_path_.resolve)(repoRoot, entryRel);
+        if (entry.isDirectory()) {
+            if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") {
+                continue;
+            }
+            await collectFiles(repoRoot, entryRel, collected, depth + 1);
+        } else if (entry.isFile() && isScannableFile(entry.name)) {
+            collected.push({
+                absPath: entryAbs,
+                relPath: entryRel
+            });
+        }
+    }
+}
+async function scanRepository(repoRoot) {
+    const absRoot = (0,external_node_path_.resolve)(repoRoot);
+    const allFiles = [];
+    await collectFiles(absRoot, "", allFiles);
+    const existingAbsPaths = new Set(allFiles.map((f)=>f.absPath));
+    const rawRecords = [];
+    for (const { absPath, relPath } of allFiles){
+        const harness = determineHarness(relPath);
+        if (harness === null) continue;
+        let content = null;
+        if (isMarkdownFile(relPath)) {
+            try {
+                content = await file_system_utils_readTextWithinRoot(absRoot, relPath, MAX_FILE_BYTES);
+            } catch  {
+                content = null;
+            }
+        }
+        rawRecords.push({
+            absPath,
+            relPath,
+            harness,
+            content
+        });
+    }
+    const records = rawRecords.map(({ absPath, relPath, harness, content })=>{
+        const edges = [];
+        if (content !== null) {
+            const rawEdges = parseRawEdges(content);
+            for (const raw of rawEdges){
+                edges.push(resolveEdge(raw.rawTarget, raw.type, absPath, absRoot, existingAbsPaths));
+            }
+        }
+        const id = harness === "shared" ? `shared:${relPath}` : `${harness}:${relPath}`;
+        return {
+            id,
+            path: relPath,
+            harness,
+            constructType: determineConstructType(relPath),
+            loadMechanism: "convention-loaded",
+            edges
+        };
+    });
+    const referencedPaths = new Set();
+    for (const record of records){
+        for (const edge of record.edges){
+            if (!edge.malformed && edge.type !== "glob-binding" && typeof edge.direction.to === "string") {
+                referencedPaths.add(edge.direction.to);
+            }
+        }
+    }
+    for (const record of records){
+        if (referencedPaths.has(record.path)) {
+            record.loadMechanism = "referenced";
+        }
+    }
+    const mcpServers = await enumerateMcpServers(absRoot);
+    for (const server of mcpServers){
+        records.push({
+            id: `mcp-server:${server.path}#${server.serverName}`,
+            path: server.path,
+            harness: server.harness,
+            constructType: "mcp-server",
+            loadMechanism: "convention-loaded",
+            edges: [],
+            serverName: server.serverName,
+            ...server.transport !== undefined ? {
+                transport: server.transport
+            } : {}
+        });
+    }
+    return records;
+}
+
+;// CONCATENATED MODULE: ../doctor/src/gateways/wisdom-client.ts
+
+
+const MAX_GRAPH_BYTES = 10_485_760;
+class WisdomUnavailableError extends Error {
+    constructor(reason){
+        super(`Wisdom graph unavailable: ${reason}`);
+        this.name = "WisdomUnavailableError";
+    }
+}
+const WisdomNodeSchema = schemas_object({
+    id: schemas_string(),
+    label: schemas_string().optional(),
+    description: schemas_string().optional(),
+    sourceFile: schemas_string().optional(),
+    lineStart: schemas_number().int().min(1).optional().catch(undefined),
+    lineEnd: schemas_number().int().min(1).optional().catch(undefined)
+}).passthrough();
+const WisdomGraphSchema = schemas_object({
+    nodes: schemas_array(WisdomNodeSchema),
+    edges: schemas_array(unknown()).default([]),
+    snapshotRef: schemas_string().optional()
+});
+function createWisdomClient(wisdomDir) {
+    async function getGraph() {
+        let raw;
+        try {
+            raw = await file_system_utils_readTextWithinRoot(wisdomDir, "graphify-out/graph.json", MAX_GRAPH_BYTES);
+        } catch  {
+            throw new WisdomUnavailableError("graph.json not found in wisdom directory — ensure the wisdom submodule is initialized");
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        } catch  {
+            throw new WisdomUnavailableError("graph.json is not valid JSON");
+        }
+        try {
+            return WisdomGraphSchema.parse(parsed);
+        } catch  {
+            throw new WisdomUnavailableError("graph.json does not match expected schema (nodes must be an array with id strings)");
+        }
+    }
+    async function findNodeById(nodeId) {
+        const graph = await getGraph();
+        return graph.nodes.find((n)=>n.id === nodeId) ?? null;
+    }
+    return {
+        getGraph,
+        findNodeById
+    };
+}
+
+;// CONCATENATED MODULE: ../doctor/src/use-cases/harness-profile.ts
+const PURE_DOMINANCE_THRESHOLD = 0.8;
+function buildHarnessProfiles(records) {
+    if (records.length === 0) return [];
+    const data = new Map();
+    for (const record of records){
+        const existing = data.get(record.harness) ?? {
+            records: 0,
+            edges: 0
+        };
+        data.set(record.harness, {
+            records: existing.records + 1,
+            edges: existing.edges + record.edges.length
+        });
+    }
+    const totalWeight = records.reduce((acc, r)=>acc + 1 + r.edges.length, 0);
+    return Array.from(data.entries()).map(([harness, { records: recordCount, edges: edgeCount }])=>({
+            harness,
+            recordCount,
+            edgeCount,
+            share: totalWeight > 0 ? (recordCount + edgeCount) / totalWeight : 0
+        }));
+}
+
+;// CONCATENATED MODULE: ../doctor/src/use-cases/classify-archetype.ts
+
+
+function hasCrossHarnessEdges(records) {
+    const harnessByPath = new Map();
+    for (const record of records){
+        harnessByPath.set(record.path, record.harness);
+    }
+    for (const record of records){
+        for (const edge of record.edges){
+            if (edge.malformed || edge.type === "glob-binding" || typeof edge.direction.to !== "string") {
+                continue;
+            }
+            const targetHarness = harnessByPath.get(edge.direction.to);
+            if (targetHarness && targetHarness !== record.harness) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function classifyArchetype(records) {
+    if (records.length === 0) {
+        return {
+            archetype: "none",
+            dominanceScore: 0,
+            ambiguities: []
+        };
+    }
+    const profiles = buildHarnessProfiles(records);
+    const distinctHarnesses = new Set(records.map((r)=>r.harness));
+    if (distinctHarnesses.size === 1 && distinctHarnesses.has("shared")) {
+        return {
+            archetype: "canonical-contract",
+            dominanceScore: 1,
+            ambiguities: []
+        };
+    }
+    const nonSharedHarnesses = [
+        ...distinctHarnesses
+    ].filter((h)=>h !== "shared");
+    const needsVerificationHarnesses = nonSharedHarnesses.filter((h)=>HARNESS_FOOTPRINTS[h].status === "needs-verification");
+    const ambiguities = needsVerificationHarnesses.map((h)=>`harness '${h}' detection patterns are not fully verified`);
+    // If all non-shared harnesses need verification, the archetype is ambiguous
+    if (nonSharedHarnesses.length > 0 && needsVerificationHarnesses.length === nonSharedHarnesses.length) {
+        const topProfile = profiles.reduce((a, b)=>a.share > b.share ? a : b);
+        return {
+            archetype: "ambiguous",
+            dominanceScore: topProfile.share,
+            ambiguities
+        };
+    }
+    // pure: single dominant harness with no cross-harness edges
+    if (nonSharedHarnesses.length === 1) {
+        const dominant = profiles.find((p)=>p.harness === nonSharedHarnesses[0]);
+        const score = dominant?.share ?? 1;
+        if (score >= (/* inlined export .PURE_DOMINANCE_THRESHOLD */0.8) && !hasCrossHarnessEdges(records)) {
+            return {
+                archetype: "pure",
+                dominanceScore: score,
+                ambiguities
+            };
+        }
+    }
+    const crossHarness = hasCrossHarnessEdges(records);
+    const topProfile = profiles.reduce((a, b)=>a.share > b.share ? a : b);
+    if (crossHarness) {
+        return {
+            archetype: "intentional-hybrid",
+            dominanceScore: topProfile.share,
+            ambiguities
+        };
+    }
+    // ambiguous when needs-verification harnesses are present alongside verified ones
+    if (ambiguities.length > 0) {
+        return {
+            archetype: "ambiguous",
+            dominanceScore: topProfile.share,
+            ambiguities
+        };
+    }
+    return {
+        archetype: "accidental-sprawl",
+        dominanceScore: topProfile.share,
+        ambiguities
+    };
+}
+
+;// CONCATENATED MODULE: ../doctor/src/use-cases/criteria.ts
+const CRITERIA = [
+    {
+        id: "missing-copilot-instructions",
+        appliesToHarness: "copilot",
+        severity: "critical",
+        classification: "defect",
+        category: "missing-required",
+        description: "GitHub Copilot requires .github/copilot-instructions.md to load workspace instructions. Without it, Copilot operates without any project-specific context.",
+        capability: "copilot-workspace-instructions",
+        checkMethod: "inventory.fileExists",
+        checkArgs: {
+            harness: "copilot",
+            paths: [
+                ".github/copilot-instructions.md"
+            ]
+        }
+    },
+    {
+        id: "missing-intent-artifact",
+        appliesToHarness: "all",
+        severity: "medium",
+        classification: "defect",
+        category: "governance",
+        description: "No declared intent artifact found at .agentic-doctor/intent.json. Without declared intent, the doctor cannot evaluate capability preconditions.",
+        checkMethod: "inventory.constructPresent",
+        checkArgs: {
+            harness: "claude",
+            constructType: "instruction"
+        }
+    },
+    {
+        id: "malformed-claude-import",
+        appliesToHarness: "claude",
+        severity: "high",
+        classification: "defect",
+        category: "malformed-reference",
+        description: "A Claude @import reference points to a file that does not exist or escapes the repository root.",
+        checkMethod: "inventory.edgePresent",
+        checkArgs: {
+            fromHarness: "claude",
+            toHarness: "claude",
+            edgeType: "hard-import"
+        }
+    },
+    {
+        id: "cross-harness-drift",
+        appliesToHarness: "all",
+        appliesToArchetype: "accidental-sprawl",
+        severity: "high",
+        classification: "advisory",
+        category: "drift",
+        description: "Multiple AI harnesses are configured but share no cross-harness references. This may indicate accidental configuration sprawl rather than intentional multi-harness setup.",
+        checkMethod: "inventory.archetypeIs",
+        checkArgs: {}
+    },
+    {
+        id: "wrong-direction-copilot-imports-claude",
+        appliesToHarness: "copilot",
+        severity: "medium",
+        classification: "advisory",
+        category: "wrong-direction",
+        description: "A Copilot instruction file references a Claude instruction file. Copilot does not process @import directives, so this reference has no effect and may indicate copy-paste drift.",
+        checkMethod: "inventory.edgeDirectionExists",
+        checkArgs: {
+            fromHarness: "copilot",
+            toHarness: "claude"
+        }
+    },
+    {
+        id: "missing-claude-md",
+        appliesToHarness: "claude",
+        severity: "high",
+        classification: "defect",
+        category: "missing-required",
+        description: "Claude Code requires CLAUDE.md or .claude/ directory to load project instructions.",
+        checkMethod: "inventory.fileExists",
+        checkArgs: {
+            harness: "claude",
+            paths: [
+                "CLAUDE.md",
+                ".claude/"
+            ]
+        }
+    },
+    {
+        id: "missing-agents-md",
+        appliesToHarness: "codex",
+        severity: "high",
+        classification: "defect",
+        category: "missing-required",
+        description: "Codex/OpenAI Codex requires AGENTS.md to load project instructions.",
+        checkMethod: "inventory.fileExists",
+        checkArgs: {
+            harness: "codex",
+            paths: [
+                "AGENTS.md",
+                "AGENTS.override.md"
+            ]
+        }
+    },
+    {
+        id: "missing-hermes-config",
+        appliesToHarness: "hermes",
+        severity: "medium",
+        classification: "advisory",
+        category: "missing-required",
+        description: "Hermes does not have a primary configuration file (.hermes.md or HERMES.md).",
+        checkMethod: "inventory.fileExists",
+        checkArgs: {
+            harness: "hermes",
+            paths: [
+                ".hermes.md",
+                "HERMES.md"
+            ]
+        }
+    },
+    {
+        id: "missing-crush-config",
+        appliesToHarness: "crush",
+        severity: "medium",
+        classification: "advisory",
+        category: "missing-required",
+        description: "Crush does not have a crush.json configuration file.",
+        checkMethod: "inventory.fileExists",
+        checkArgs: {
+            harness: "crush",
+            paths: [
+                "crush.json"
+            ]
+        }
+    }
+];
+
+;// CONCATENATED MODULE: ../doctor/src/use-cases/detect-ambiguities.ts
+function detectAmbiguities(records, classification) {
+    const questions = [];
+    if (classification.archetype === "accidental-sprawl") {
+        const harnesses = [
+            ...new Set(records.map((r)=>r.harness))
+        ].filter((h)=>h !== "shared");
+        if (harnesses.length > 1) {
+            questions.push({
+                id: "intended-multi-harness",
+                question: `Multiple AI harnesses are configured (${harnesses.join(", ")}). Is this intentional?`,
+                hint: "Answer 'yes' if you want multiple harnesses to work together. Answer 'no' if this is legacy configuration."
+            });
+        }
+    }
+    if (classification.archetype === "intentional-hybrid") {
+        const pathToHarness = new Map(records.map((r)=>[
+                r.path,
+                r.harness
+            ]));
+        const hasCrossHarnessImports = records.some((r)=>r.edges.some((e)=>!e.malformed && e.type === "hard-import" && typeof e.direction.to === "string" && pathToHarness.has(e.direction.to) && pathToHarness.get(e.direction.to) !== r.harness));
+        if (hasCrossHarnessImports) {
+            questions.push({
+                id: "hard-import-intentional",
+                question: "Claude hard-imports (@path) are referencing instruction files from other harnesses. Is this intentional?",
+                hint: "Hard imports cause Claude to inline the file contents at runtime."
+            });
+        }
+    }
+    return questions;
+}
+
+;// CONCATENATED MODULE: ../doctor/src/use-cases/evaluate-engine.ts
+function makeId(criterionId, targetId) {
+    return `${criterionId}:${targetId}`;
+}
+function checkFileExists(criterion, args, ctx) {
+    const { harness, paths } = args;
+    const anyMatch = ctx.records.some((r)=>paths.some((p)=>r.path === p || r.path.startsWith(p.endsWith("/") ? p : `${p}/`)));
+    if (!anyMatch) {
+        return [
+            {
+                id: makeId(criterion.id, `${harness}:all`),
+                criterionId: criterion.id,
+                targetId: `${harness}:all`,
+                severity: criterion.severity,
+                category: criterion.category,
+                classification: criterion.classification,
+                intentGated: false,
+                assumedIntent: false,
+                description: criterion.description
+            }
+        ];
+    }
+    return [];
+}
+function checkConstructPresent(criterion, ctx) {
+    const hasRecords = ctx.records.length > 0;
+    const hasIntent = ctx.intent !== null;
+    if (hasRecords && !hasIntent) {
+        return [
+            {
+                id: makeId(criterion.id, "all:intent"),
+                criterionId: criterion.id,
+                targetId: "all:intent",
+                severity: criterion.severity,
+                category: criterion.category,
+                classification: criterion.classification,
+                intentGated: false,
+                assumedIntent: true,
+                description: criterion.description
+            }
+        ];
+    }
+    return [];
+}
+function checkEdgePresent(criterion, args, ctx) {
+    const fromRecords = ctx.records.filter((r)=>r.harness === args.fromHarness);
+    const hasMalformedEdges = fromRecords.some((r)=>r.edges.some((e)=>e.malformed && (args.edgeType === undefined || e.type === args.edgeType)));
+    if (hasMalformedEdges) {
+        return [
+            {
+                id: makeId(criterion.id, `${args.fromHarness}:malformed`),
+                criterionId: criterion.id,
+                targetId: `${args.fromHarness}:malformed`,
+                severity: criterion.severity,
+                category: criterion.category,
+                classification: criterion.classification,
+                intentGated: false,
+                assumedIntent: false,
+                description: criterion.description
+            }
+        ];
+    }
+    return [];
+}
+function checkEdgeDirection(criterion, args, ctx) {
+    const fromRecords = ctx.records.filter((r)=>r.harness === args.fromHarness);
+    const toRecords = ctx.records.filter((r)=>r.harness === args.toHarness);
+    const toPaths = new Set(toRecords.map((r)=>r.path));
+    const hasDirectedEdge = fromRecords.some((r)=>r.edges.some((e)=>!e.malformed && (args.edgeType === undefined || e.type === args.edgeType) && typeof e.direction.to === "string" && toPaths.has(e.direction.to)));
+    if (!hasDirectedEdge) {
+        return [
+            {
+                id: makeId(criterion.id, `${args.fromHarness}:${args.toHarness}`),
+                criterionId: criterion.id,
+                targetId: `${args.fromHarness}:${args.toHarness}`,
+                severity: criterion.severity,
+                category: criterion.category,
+                classification: criterion.classification,
+                intentGated: false,
+                assumedIntent: false,
+                description: criterion.description
+            }
+        ];
+    }
+    return [];
+}
+function checkArchetypeIs(criterion, ctx) {
+    return [
+        {
+            id: makeId(criterion.id, `all:${ctx.classification.archetype}`),
+            criterionId: criterion.id,
+            targetId: `all:${ctx.classification.archetype}`,
+            severity: criterion.severity,
+            category: criterion.category,
+            classification: criterion.classification,
+            intentGated: false,
+            assumedIntent: false,
+            description: criterion.description
+        }
+    ];
+}
+function checkEdgeDirectionExists(criterion, args, ctx) {
+    const fromRecords = ctx.records.filter((r)=>r.harness === args.fromHarness);
+    const toRecords = ctx.records.filter((r)=>r.harness === args.toHarness);
+    const toPaths = new Set(toRecords.map((r)=>r.path));
+    const hasEdge = fromRecords.some((r)=>r.edges.some((e)=>!e.malformed && (args.edgeType === undefined || e.type === args.edgeType) && typeof e.direction.to === "string" && toPaths.has(e.direction.to)));
+    if (hasEdge) {
+        return [
+            {
+                id: makeId(criterion.id, `${args.fromHarness}:${args.toHarness}`),
+                criterionId: criterion.id,
+                targetId: `${args.fromHarness}:${args.toHarness}`,
+                severity: criterion.severity,
+                category: criterion.category,
+                classification: criterion.classification,
+                intentGated: false,
+                assumedIntent: false,
+                description: criterion.description
+            }
+        ];
+    }
+    return [];
+}
+function checkCapabilityDeclared(criterion, ctx) {
+    if (!criterion.capability || ctx.intent === null) return [];
+    const isDeclared = ctx.intent.desiredCapabilities.includes(criterion.capability);
+    if (!isDeclared) {
+        return [
+            {
+                id: makeId(criterion.id, `all:${criterion.capability}`),
+                criterionId: criterion.id,
+                targetId: `all:${criterion.capability}`,
+                severity: criterion.severity,
+                category: criterion.category,
+                classification: criterion.classification,
+                intentGated: true,
+                assumedIntent: false,
+                description: criterion.description
+            }
+        ];
+    }
+    return [];
+}
+function evaluate(criteria, ctx) {
+    const findings = [];
+    for (const criterion of criteria){
+        if (criterion.appliesToArchetype && criterion.appliesToArchetype !== "all" && ctx.classification.archetype !== criterion.appliesToArchetype) {
+            continue;
+        }
+        const harnesses = new Set(ctx.records.map((r)=>r.harness));
+        if (criterion.appliesToHarness !== "all" && !harnesses.has(criterion.appliesToHarness)) {
+            continue;
+        }
+        switch(criterion.checkMethod){
+            case "inventory.fileExists":
+                {
+                    findings.push(...checkFileExists(criterion, criterion.checkArgs, ctx));
+                    break;
+                }
+            case "inventory.constructPresent":
+                {
+                    findings.push(...checkConstructPresent(criterion, ctx));
+                    break;
+                }
+            case "inventory.edgePresent":
+                {
+                    findings.push(...checkEdgePresent(criterion, criterion.checkArgs, ctx));
+                    break;
+                }
+            case "inventory.edgeDirection":
+                {
+                    findings.push(...checkEdgeDirection(criterion, criterion.checkArgs, ctx));
+                    break;
+                }
+            case "inventory.archetypeIs":
+                {
+                    findings.push(...checkArchetypeIs(criterion, ctx));
+                    break;
+                }
+            case "inventory.edgeDirectionExists":
+                {
+                    findings.push(...checkEdgeDirectionExists(criterion, criterion.checkArgs, ctx));
+                    break;
+                }
+            case "intent.capabilityDeclared":
+                {
+                    findings.push(...checkCapabilityDeclared(criterion, ctx));
+                    break;
+                }
+            default:
+                break;
+        }
+    }
+    return findings;
+}
+
+;// CONCATENATED MODULE: ../doctor/src/index.ts
+
+
+
+
+
+
+
+
+
+
+
+;// CONCATENATED MODULE: ./src/commands/doctor.ts
+
+
+
+
+const doctorCommand = defineCommand({
+    meta: {
+        name: "doctor",
+        description: "Diagnose agentic configuration across harnesses: inventory, classify, and evaluate preconditions"
+    },
+    args: {
+        summary: {
+            type: "boolean",
+            description: "Show archetype classification only — skip evaluation",
+            default: false
+        },
+        format: {
+            type: "string",
+            description: "Output format: human (default) or json",
+            default: "human"
+        },
+        ci: {
+            type: "boolean",
+            description: "Force non-interactive mode",
+            default: false
+        }
+    },
+    async run ({ args }) {
+        const logger = dist_createConsola();
+        const repoPath = (0,external_node_path_.resolve)(process.cwd());
+        const format = args.format === "json" ? "json" : "human";
+        const records = await scanRepository(repoPath);
+        const classification = classifyArchetype(records);
+        const summary = formatSummary(records, classification);
+        // Load wisdom graph for snapshotRef (gracefully degrade if unavailable)
+        const wisdomDir = (0,external_node_path_.resolve)(repoPath, "wisdom");
+        let snapshotRef;
+        try {
+            const wisdomClient = createWisdomClient(wisdomDir);
+            const graph = await wisdomClient.getGraph();
+            snapshotRef = graph.snapshotRef;
+        } catch (err) {
+            if (!(err instanceof WisdomUnavailableError)) throw err;
+            logger.debug("Wisdom graph unavailable — snapshotRef will be omitted");
+        }
+        if (args.summary) {
+            if (format === "json") {
+                process.stdout.write(`${JSON.stringify({
+                    archetype: summary.archetype,
+                    dominanceScore: summary.dominanceScore,
+                    totalRecords: summary.totalRecords,
+                    harnessBreakdown: summary.harnessBreakdown,
+                    crossHarnessEdges: summary.crossHarnessEdges,
+                    inventory: toInventoryItems(records)
+                }, null, 2)}\n`);
+            } else {
+                renderHuman(summary, [], logger, snapshotRef);
+            }
+            return;
+        }
+        if (classification.archetype === "none") {
+            if (format === "json") {
+                process.stdout.write(`${JSON.stringify(toJson(summary, [], records, snapshotRef), null, 2)}\n`);
+            } else {
+                logger.info("No agentic constructs found in the repository.");
+            }
+            return;
+        }
+        const intentResult = await readIntentArtifact(repoPath);
+        let intent = intentResult.found ? intentResult.artifact : null;
+        // Interactive elicitation when no intent artifact and running in a TTY
+        const isInteractive = !args.ci && process.stdin.isTTY === true;
+        if (intent === null && isInteractive) {
+            const questions = detectAmbiguities(records, classification);
+            for (const q of questions){
+                logger.info(`\n${q.hint}`);
+                const answer = await logger.prompt(q.question, {
+                    type: "confirm",
+                    initial: false
+                });
+                if (answer) {
+                    logger.info("  Noted.");
+                }
+            }
+            // After interactive prompts, re-read in case user pre-created the artifact
+            const retried = await readIntentArtifact(repoPath);
+            if (retried.found) intent = retried.artifact;
+        }
+        const findings = evaluate(CRITERIA, {
+            records,
+            classification,
+            intent
+        });
+        if (format === "json") {
+            const report = toJson(summary, findings, records, snapshotRef);
+            process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+        } else {
+            renderHuman(summary, findings, logger, snapshotRef);
+        }
+        if (hasBlockingFindings(findings)) {
+            process.exitCode = 1;
+        }
+    }
+});
+
 ;// CONCATENATED MODULE: ../core/src/use-cases/init-copilot-setup-workflow.ts
 /**
  * Use case for initializing a Copilot Setup Steps workflow in a new project.
@@ -48660,7 +50678,7 @@ const remark = unified().use(remarkParse).use(remarkStringify).freeze()
  */ 
 
 
-/** Zod schema for a rule config map: rule IDs validated with regex to prevent prototype pollution */ const RuleConfigMapSchema = record(schemas_string().regex(/^[a-z]+\/[a-z]+(?:-[a-z]+)*$/), schemas_enum([
+/** Zod schema for a rule config map: rule IDs validated with regex to prevent prototype pollution */ const RuleConfigMapSchema = schemas_record(schemas_string().regex(/^[a-z]+\/[a-z]+(?:-[a-z]+)*$/), schemas_enum([
     "error",
     "warn",
     "off"
@@ -49500,7 +51518,7 @@ const MAX_HOOKS_PER_EVENT = 100;
     powershell: schemas_string().min(1, "Hook PowerShell command must not be empty").optional(),
     cwd: schemas_string().optional(),
     timeoutSec: schemas_number().positive().optional(),
-    env: record(schemas_string().regex(ENV_KEY_PATTERN, "Hook env key must be a valid identifier (no prototype-polluting keys)"), schemas_string()).optional()
+    env: schemas_record(schemas_string().regex(ENV_KEY_PATTERN, "Hook env key must be a valid identifier (no prototype-polluting keys)"), schemas_string()).optional()
 }).strict().refine((data)=>Boolean(data.bash) || Boolean(data.powershell), {
     message: "At least one of 'bash' or 'powershell' must be provided and non-empty"
 });
@@ -49688,7 +51706,7 @@ const AgentSkillFrontmatterSchema = schemas_object({
     }),
     license: schemas_string().optional(),
     compatibility: schemas_string().max(500, "Compatibility must be 500 characters or fewer").optional(),
-    metadata: record(schemas_string(), schemas_string()).optional(),
+    metadata: schemas_record(schemas_string(), schemas_string()).optional(),
     "allowed-tools": schemas_string().optional(),
     "argument-hint": schemas_string().optional()
 });
@@ -50713,6 +52731,7 @@ const skillArgs = {
 
 
 
+
 // Gateways
 const lessonFileGateway = createLessonFileGateway();
 const initHooksConfigGateway = createInitHooksConfigGateway();
@@ -50738,7 +52757,8 @@ const src_main = defineCommand({
         "copilot-setup": copilotSetupCommand,
         context: contextCmd,
         "init-hooks": initHooksCmd,
-        capture: captureCommand
+        capture: captureCommand,
+        doctor: doctorCommand
     }
 });
 runMain(src_main);
@@ -59601,4 +61621,4 @@ if (installedChunkData !== 0) { // 0 means "already installed".'
 // module factories are used so entry inlining is disabled
 // startup
 // Load entry module and return exports
-var __webpack_exports__ = __webpack_require__(455);
+var __webpack_exports__ = __webpack_require__(889);