swarmdo 1.19.0 → 1.29.0

package/v3/@swarmdo/cli/dist/src/apply/apply.js

@@ -19,7 +19,10 @@ export function parsePatch(text) {
     let hunk = null;
     const stripPrefix = (p) => p.replace(/^[ab]\//, '').replace(/\t.*$/, '').trim();
     for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
+        // CRLF tolerance (#9): a diff generated on/for CRLF files carries \r on
+        // every line; strip it so hunk content compares EOL-agnostically.
+        const raw = lines[i];
+        const line = raw.endsWith('\r') ? raw.slice(0, -1) : raw;
         if (line.startsWith('diff --git')) {
             cur = null;
             hunk = null;
@@ -54,7 +57,10 @@ export function parsePatch(text) {
                 hunk.lines.push({ type: ' ', content: '' }); // blank context line written without the leading space
             }
             else if (line.startsWith('\\')) {
-                // "" — ignore
+                // "" — attaches to the preceding hunk line,
+                // recording that that side of the diff has no trailing newline.
+                if (hunk.lines.length)
+                    hunk.lines[hunk.lines.length - 1].noEol = true;
             }
             else {
                 hunk = null; // end of hunk block
@@ -87,6 +93,16 @@ function blockMatchesAt(source, at, block) {
             return false;
     return true;
 }
+/** How many positions in `source` the `block` matches. Pure. */
+function countMatches(source, block) {
+    if (block.length === 0)
+        return 0;
+    let n = 0;
+    for (let i = 0; i + block.length <= source.length; i++)
+        if (blockMatchesAt(source, i, block))
+            n++;
+    return n;
+}
 /**
  * Find where `block` occurs in `source`, preferring the position nearest
  * `expected` (0-based). Returns -1 if not found. Deterministic: on ties the
@@ -114,11 +130,24 @@ function findBlock(source, block, expected) {
 export function applyPatch(source, patch, opts = {}) {
     const fuzz = opts.fuzz ?? 2;
     const trailingNewline = source.endsWith('\n');
+    // CRLF support (#9): match EOL-agnostically, then write inserted lines with
+    // the file's dominant EOL so CRLF sources stay CRLF. `lines` keeps each
+    // line's original bytes (untouched lines round-trip exactly); `matchLines`
+    // is the \r-stripped twin every comparison runs against. The two are spliced
+    // in lockstep so indices stay aligned.
+    const crlfCount = (source.match(/\r\n/g) ?? []).length;
+    const newlineCount = (source.match(/\n/g) ?? []).length;
+    const dominantCrlf = crlfCount > newlineCount - crlfCount;
     const lines = source.split('\n');
     if (trailingNewline)
         lines.pop(); // drop the empty element from a trailing \n
+    const stripCr = (s) => (s.endsWith('\r') ? s.slice(0, -1) : s);
+    const matchLines = lines.map(stripCr);
     let offset = 0;
     const results = [];
+    // If a hunk that reaches EOF carries an explicit no-newline marker, it — not
+    // the source — decides the output's trailing newline. undefined = no marker.
+    let eofNoEol;
     for (const hunk of patch.hunks) {
         const { oldBlock, newBlock } = hunkBlocks(hunk);
         const expected = hunk.oldStart - 1 + offset;
@@ -136,7 +165,7 @@ export function applyPatch(source, patch, opts = {}) {
                 if (lead > leadTrimmable || tail > tailTrimmable)
                     continue;
                 const trimmed = oldBlock.slice(lead, oldBlock.length - tail);
-                const at = findBlock(lines, trimmed, expected + lead);
+                const at = findBlock(matchLines, trimmed, expected + lead);
                 if (at >= 0) {
                     placed = at - lead;
                     usedFuzz = f;
@@ -150,19 +179,50 @@ export function applyPatch(source, patch, opts = {}) {
             results.push({ hunk, applied: false });
             continue;
         }
-        // Splice: remove oldBlock.length lines at `placed`, insert newBlock.
-        // (trimLead/trimTail only affected *matching*, not what we replace.)
-        void trimLead;
-        void trimTail;
-        lines.splice(placed, oldBlock.length, ...newBlock);
+        // A hunk is AMBIGUOUS if the block it matched on occurs elsewhere too — the
+        // nearest-match tiebreak may have picked the wrong duplicate. Check the
+        // matched (trimmed) block against the current lines BEFORE splicing.
+        const matchedBlock = oldBlock.slice(trimLead, oldBlock.length - trimTail);
+        const ambiguous = countMatches(matchLines, matchedBlock) > 1;
+        // Splice: remove oldBlock.length lines at `placed`, insert newBlock —
+        // raw lines get the file's dominant EOL, the match twin stays stripped.
+        const insertRaw = dominantCrlf ? newBlock.map((l) => l + '\r') : newBlock;
+        lines.splice(placed, oldBlock.length, ...insertRaw);
+        matchLines.splice(placed, oldBlock.length, ...newBlock);
         offset += newBlock.length - oldBlock.length;
-        results.push({ hunk, applied: true, at: placed, fuzzUsed: usedFuzz });
+        results.push({ hunk, applied: true, at: placed, fuzzUsed: usedFuzz, ...(ambiguous && { ambiguous: true }) });
+        // If this hunk's new content is now the tail of the file, its markers
+        // determine whether the file ends with a newline.
+        if (placed + newBlock.length === lines.length)
+            eofNoEol = newSideEndsNoEol(hunk);
     }
     let result = lines.join('\n');
-    if (trailingNewline)
+    // The patch's explicit EOF marker wins; absent one, keep the source's state.
+    const endWithNewline = eofNoEol === undefined ? trailingNewline : !eofNoEol;
+    if (endWithNewline)
         result += '\n';
+    // An inserted line that became the no-trailing-newline tail carries the
+    // dominant-EOL \r it was given for joining — a bare CR at EOF is never
+    // meaningful, so drop it.
+    else if (result.endsWith('\r'))
+        result = result.slice(0, -1);
     return { ok: results.every((r) => r.applied), result, hunks: results };
 }
+/**
+ * Whether the NEW side of `hunk` ends without a trailing newline — read from the
+ * last context/addition line's marker. Returns undefined if the hunk carries no
+ * `\ No newline` marker at all (so the source's state should be kept). Pure.
+ */
+function newSideEndsNoEol(hunk) {
+    if (!hunk.lines.some((l) => l.noEol))
+        return undefined;
+    for (let i = hunk.lines.length - 1; i >= 0; i--) {
+        const l = hunk.lines[i];
+        if (l.type === ' ' || l.type === '+')
+            return !!l.noEol;
+    }
+    return undefined;
+}
 function countLeadingContext(hunk) {
     let n = 0;
     for (const l of hunk.lines) {

package/v3/@swarmdo/cli/dist/src/changelog/changelog.js

@@ -24,18 +24,41 @@ export const SECTIONS = [
     { type: 'chore', label: 'Chores', hidden: true },
 ];
 const SUBJECT_RE = /^(\w+)(?:\(([^)]+)\))?(!)?:\s+(.+)$/;
+// git's default revert subject: `Revert "<original subject>"` (git-revert(1)).
+// The conventional `revert:` type is handled by SUBJECT_RE; this catches the
+// bare git form, which otherwise falls into the hidden `other` bucket.
+const REVERT_RE = /^Revert\s+"(.+)"$/;
+// Conventional Commits: a breaking-change footer MUST be the uppercase token
+// `BREAKING CHANGE` (or `BREAKING-CHANGE`) at the start of a footer line,
+// followed by `: `. Anchoring to a line start avoids a false positive when the
+// phrase merely appears in prose ("this is not a BREAKING CHANGE, just …").
+const BREAKING_RE = /^BREAKING[ -]CHANGE:\s/m;
 /** Parse one conventional-commit subject (+ optional body for BREAKING CHANGE). */
 export function parseCommit(hash, subject, body = '') {
-    const m = SUBJECT_RE.exec(subject.trim());
+    const trimmed = subject.trim();
+    const rev = REVERT_RE.exec(trimmed);
+    if (rev) {
+        // Recurse into the quoted original subject to lift its scope/description.
+        const inner = SUBJECT_RE.exec(rev[1].trim());
+        return {
+            hash,
+            type: 'revert',
+            scope: inner ? inner[2] ?? null : null,
+            breaking: BREAKING_RE.test(body),
+            subject: inner ? inner[4].trim() : rev[1].trim(),
+            raw: trimmed,
+        };
+    }
+    const m = SUBJECT_RE.exec(trimmed);
     if (!m) {
-        return { hash, type: null, scope: null, breaking: /BREAKING[ -]CHANGE/.test(body), subject: subject.trim(), raw: subject.trim() };
+        return { hash, type: null, scope: null, breaking: BREAKING_RE.test(body), subject: subject.trim(), raw: subject.trim() };
     }
     const [, type, scope, bang, desc] = m;
     return {
         hash,
         type: type.toLowerCase(),
         scope: scope ?? null,
-        breaking: bang === '!' || /BREAKING[ -]CHANGE/.test(body),
+        breaking: bang === '!' || BREAKING_RE.test(body),
         subject: desc.trim(),
         raw: subject.trim(),
     };

package/v3/@swarmdo/cli/dist/src/codegraph/codegraph.d.ts

@@ -31,6 +31,13 @@ export interface ImportEdge {
     resolved: string | null;
     /** 1-based line of the import */
     line: number;
+    /**
+     * True for a TypeScript type-only import/export (`import type …`,
+     * `export type … from …`). These are erased at compile time (with
+     * isolatedModules/verbatimModuleSyntax) so they create NO runtime dependency
+     * — relevant to cycle detection, where a type-only "cycle" is benign.
+     */
+    isTypeOnly?: boolean;
 }
 export interface CodeIndex {
     /** Repo-relative file → symbols declared in it. */
@@ -46,19 +53,31 @@ export declare function extractImports(source: string, file: string): Array<{
     from: string;
     spec: string;
     line: number;
+    isTypeOnly: boolean;
 }>;
 /**
- * Resolve a spec to a repo-relative file in `fileSet`, or null. Only relative
- * specs (`.`/`..`) resolve; bare specifiers (packages, aliases, `node:`) are
- * external → null. Tries the path as-is, common extensions, and `/index.*`,
- * and rewrites a `.js` spec to its `.ts` sibling (TS ESM convention).
+ * A tsconfig `paths` / workspace alias: a bare-specifier pattern mapped to a
+ * repo-relative target (baseUrl already applied), each optionally containing a
+ * single star wildcard — e.g. pattern `@swarmdo/[star]` → target
+ * `v3/@swarmdo/[star]/src`, where `[star]` captures the remaining spec.
  */
-export declare function resolveImport(fromFile: string, spec: string, fileSet: Set<string>): string | null;
-/** Build an index from already-read files. Pure. */
+export interface ImportAlias {
+    pattern: string;
+    target: string;
+}
+/**
+ * Resolve a spec to a repo-relative file in `fileSet`, or null. Relative specs
+ * (`.`/`..`) resolve against the importing file's dir. Bare specifiers resolve
+ * only if they match a tsconfig-`paths`/workspace `alias` — otherwise they're
+ * external (packages, `node:`) → null. Tries common extensions and `/index.*`,
+ * and rewrites a `.js` spec to its `.ts` sibling (TS ESM convention). Pure.
+ */
+export declare function resolveImport(fromFile: string, spec: string, fileSet: Set<string>, aliases?: ImportAlias[]): string | null;
+/** Build an index from already-read files. `aliases` resolve bare-specifier internal imports. Pure. */
 export declare function buildIndex(files: Array<{
     file: string;
     source: string;
-}>): CodeIndex;
+}>, aliases?: ImportAlias[]): CodeIndex;
 export interface QueryOptions {
     /** Substring/case-insensitive match instead of exact. */
     fuzzy?: boolean;

package/v3/@swarmdo/cli/dist/src/codegraph/codegraph.js

@@ -28,6 +28,43 @@ const MATCHERS = [
     { kind: 'enum', re: /^export\s+(?:const\s+)?enum\s+([A-Za-z_$][\w$]*)/ },
     { kind: 'const', re: /^export\s+(?:const|let|var)\s+([A-Za-z_$][\w$]*)/ },
 ];
+/**
+ * Top-level (comma-separated) simple-identifier declarator names in a
+ * const/let/var declaration list, e.g. `a = 1, b = fn(1, 2), c = 3` → [a,b,c].
+ * Commas inside parens/brackets/braces/strings don't split. Destructuring
+ * patterns (a segment starting with `{`/`[`) yield no name — kept as-is. Pure.
+ */
+function declaratorNames(decl) {
+    const names = [];
+    let depth = 0;
+    let start = 0;
+    let str = null;
+    const take = (seg) => {
+        const m = seg.trim().match(/^([A-Za-z_$][\w$]*)/);
+        if (m)
+            names.push(m[1]);
+    };
+    for (let i = 0; i < decl.length; i++) {
+        const ch = decl[i];
+        if (str) {
+            if (ch === str && decl[i - 1] !== '\\')
+                str = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === '`')
+            str = ch;
+        else if (ch === '(' || ch === '[' || ch === '{')
+            depth++;
+        else if (ch === ')' || ch === ']' || ch === '}')
+            depth--;
+        else if (ch === ',' && depth === 0) {
+            take(decl.slice(start, i));
+            start = i + 1;
+        }
+    }
+    take(decl.slice(start));
+    return names;
+}
 /** Extract exported symbols from one source file. Pure. */
 export function extractSymbols(source, file) {
     const out = [];
@@ -37,9 +74,29 @@ export function extractSymbols(source, file) {
         const trimmed = raw.trimStart();
         if (!trimmed.startsWith('export'))
             continue;
+        // `export * as ns from '…'` (ES2020) creates a real named export `ns` — a
+        // namespace binding — unlike bare `export * from '…'` which adds no local
+        // name. Index it (kind 'const', the closest value-binding kind) before the
+        // blanket `export *` skip below.
+        const nsRe = /^export\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\b/;
+        const nsm = trimmed.match(nsRe);
+        if (nsm) {
+            out.push({ name: nsm[1], kind: 'const', file, line: i + 1, signature: trimmed.slice(0, SIG_MAX).replace(/\s+$/, '') });
+            continue;
+        }
         // Skip re-export / bare forms handled elsewhere: `export {` and `export *`.
         if (/^export\s*[*{]/.test(trimmed))
             continue;
+        // const/let/var can declare MULTIPLE comma-separated bindings — index each
+        // (`export const a = 1, b = 2` → a AND b). Exclude `const enum` (handled by
+        // the enum matcher) and leave destructuring exports unindexed as before.
+        const declM = trimmed.match(/^export\s+(?:const|let|var)\s+(?!enum\b)(.*)$/);
+        if (declM) {
+            const sig = trimmed.slice(0, SIG_MAX).replace(/\s+$/, '');
+            for (const name of declaratorNames(declM[1]))
+                out.push({ name, kind: 'const', file, line: i + 1, signature: sig });
+            continue;
+        }
         for (const { kind, re } of MATCHERS) {
             const m = trimmed.match(re);
             if (!m)
@@ -77,6 +134,9 @@ export function extractImports(source, file) {
         const line = lines[i];
         if (!/\b(?:from|import|require)\b/.test(line))
             continue;
+        // A whole-import type-only form: `import type …` / `export type …`. NOT
+        // inline `import { type X }` (mixed with value imports → still a runtime edge).
+        const isTypeOnly = /^\s*(?:import|export)\s+type\b/.test(line);
         const seen = new Set();
         for (const re of IMPORT_RES) {
             re.lastIndex = 0;
@@ -86,7 +146,7 @@ export function extractImports(source, file) {
                 if (seen.has(spec))
                     continue; // same spec caught by two patterns on one line
                 seen.add(spec);
-                out.push({ from: file, spec, line: i + 1 });
+                out.push({ from: file, spec, line: i + 1, isTypeOnly });
             }
         }
     }
@@ -106,16 +166,20 @@ function joinRelative(fromFile, spec) {
     return parts.join('/');
 }
 const RESOLVE_EXTS = ['', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.mts', '.cts'];
-/**
- * Resolve a spec to a repo-relative file in `fileSet`, or null. Only relative
- * specs (`.`/`..`) resolve; bare specifiers (packages, aliases, `node:`) are
- * external → null. Tries the path as-is, common extensions, and `/index.*`,
- * and rewrites a `.js` spec to its `.ts` sibling (TS ESM convention).
- */
-export function resolveImport(fromFile, spec, fileSet) {
-    if (!spec.startsWith('.'))
+/** Substitute a spec through one alias (with `*` wildcard), or null if no match. Pure. */
+function applyAlias(pattern, target, spec) {
+    const star = pattern.indexOf('*');
+    if (star < 0)
+        return spec === pattern ? target : null;
+    const prefix = pattern.slice(0, star);
+    const suffix = pattern.slice(star + 1);
+    if (spec.length < prefix.length + suffix.length || !spec.startsWith(prefix) || !spec.endsWith(suffix))
         return null;
-    const base = joinRelative(fromFile, spec);
+    const mid = spec.slice(prefix.length, spec.length - suffix.length);
+    return target.includes('*') ? target.replace('*', mid) : target;
+}
+/** Resolve a bare repo-relative base path to a file in `fileSet` (exts + /index + .js→.ts). Pure. */
+function resolveInFileSet(base, fileSet) {
     const bases = [base];
     const jsExt = base.match(/\.(js|jsx|mjs|cjs)$/);
     if (jsExt)
@@ -132,15 +196,35 @@ export function resolveImport(fromFile, spec, fileSet) {
     }
     return null;
 }
-/** Build an index from already-read files. Pure. */
-export function buildIndex(files) {
+/**
+ * Resolve a spec to a repo-relative file in `fileSet`, or null. Relative specs
+ * (`.`/`..`) resolve against the importing file's dir. Bare specifiers resolve
+ * only if they match a tsconfig-`paths`/workspace `alias` — otherwise they're
+ * external (packages, `node:`) → null. Tries common extensions and `/index.*`,
+ * and rewrites a `.js` spec to its `.ts` sibling (TS ESM convention). Pure.
+ */
+export function resolveImport(fromFile, spec, fileSet, aliases = []) {
+    if (spec.startsWith('.'))
+        return resolveInFileSet(joinRelative(fromFile, spec), fileSet);
+    for (const a of aliases) {
+        const cand = applyAlias(a.pattern, a.target, spec);
+        if (cand == null)
+            continue;
+        const r = resolveInFileSet(cand, fileSet);
+        if (r)
+            return r;
+    }
+    return null;
+}
+/** Build an index from already-read files. `aliases` resolve bare-specifier internal imports. Pure. */
+export function buildIndex(files, aliases = []) {
     const symbols = [];
     const fileSet = new Set(files.map((f) => f.file));
     const imports = [];
     for (const { file, source } of files) {
         symbols.push(...extractSymbols(source, file));
         for (const imp of extractImports(source, file)) {
-            imports.push({ ...imp, resolved: resolveImport(imp.from, imp.spec, fileSet) });
+            imports.push({ ...imp, resolved: resolveImport(imp.from, imp.spec, fileSet, aliases) });
         }
     }
     // Stable order: file, then line.

package/v3/@swarmdo/cli/dist/src/codegraph/store.d.ts

@@ -4,11 +4,18 @@
  * Shared by the `codegraph` CLI command and the codegraph MCP tools so the
  * scan/persist behaviour can't drift between them.
  */
-import { type CodeIndex } from './codegraph.js';
+import { type CodeIndex, type ImportAlias } from './codegraph.js';
 export declare const INDEX_REL: string;
 /** Recursively collect source files under `root`, skipping vendor/build dirs and .d.ts. */
 export declare function walkSourceFiles(root: string): string[];
 export declare function indexPath(root: string): string;
+/**
+ * Read `<root>/tsconfig.json` and derive repo-relative import aliases from
+ * `compilerOptions.paths` (+ `baseUrl`). Tolerant of JSONC comments/trailing
+ * commas; returns [] on any problem (so bare-specifier imports stay external,
+ * as before). Only the first target of each path pattern is used. Pure-ish (fs read).
+ */
+export declare function parseTsconfigAliases(root: string): ImportAlias[];
 /** Scan a repo (or a subpath of it) and build the index. `root` is the repo
  * root used for relative paths; `scanRoot` (default = root) is where to walk. */
 export declare function scanRepo(root: string, scanRoot?: string): CodeIndex;

package/v3/@swarmdo/cli/dist/src/codegraph/store.js

@@ -53,6 +53,83 @@ function safeRead(abs) {
 export function indexPath(root) {
     return path.join(root, INDEX_REL);
 }
+/**
+ * Strip JSONC `//` and block comments + trailing commas, STRING-AWARE so a `/*`
+ * inside a path pattern (e.g. `"@app/*"`, ubiquitous in tsconfig paths) isn't
+ * mistaken for a comment start. Pure.
+ */
+function stripJsonc(s) {
+    let out = '';
+    let inStr = false, esc = false;
+    for (let i = 0; i < s.length; i++) {
+        const ch = s[i];
+        if (inStr) {
+            out += ch;
+            if (esc)
+                esc = false;
+            else if (ch === '\\')
+                esc = true;
+            else if (ch === '"')
+                inStr = false;
+            continue;
+        }
+        if (ch === '"') {
+            inStr = true;
+            out += ch;
+            continue;
+        }
+        if (ch === '/' && s[i + 1] === '/') {
+            while (i < s.length && s[i] !== '\n')
+                i++;
+            out += '\n';
+            continue;
+        }
+        if (ch === '/' && s[i + 1] === '*') {
+            i += 2;
+            while (i < s.length && !(s[i] === '*' && s[i + 1] === '/'))
+                i++;
+            i++;
+            continue;
+        }
+        out += ch;
+    }
+    return out.replace(/,(\s*[}\]])/g, '$1');
+}
+/**
+ * Read `<root>/tsconfig.json` and derive repo-relative import aliases from
+ * `compilerOptions.paths` (+ `baseUrl`). Tolerant of JSONC comments/trailing
+ * commas; returns [] on any problem (so bare-specifier imports stay external,
+ * as before). Only the first target of each path pattern is used. Pure-ish (fs read).
+ */
+export function parseTsconfigAliases(root) {
+    let raw;
+    try {
+        raw = fs.readFileSync(path.join(root, 'tsconfig.json'), 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const json = stripJsonc(raw);
+    let cfg;
+    try {
+        cfg = JSON.parse(json);
+    }
+    catch {
+        return [];
+    }
+    const co = cfg.compilerOptions ?? {};
+    if (!co.paths || typeof co.paths !== 'object')
+        return [];
+    const baseUrl = typeof co.baseUrl === 'string' ? co.baseUrl : '.';
+    const aliases = [];
+    for (const [pattern, targets] of Object.entries(co.paths)) {
+        const first = Array.isArray(targets) ? targets[0] : undefined;
+        if (typeof first !== 'string')
+            continue;
+        aliases.push({ pattern, target: path.join(baseUrl, first).split(path.sep).join('/') });
+    }
+    return aliases;
+}
 /** Scan a repo (or a subpath of it) and build the index. `root` is the repo
  * root used for relative paths; `scanRoot` (default = root) is where to walk. */
 export function scanRepo(root, scanRoot = root) {
@@ -60,7 +137,7 @@ export function scanRepo(root, scanRoot = root) {
     const read = files
         .map((abs) => ({ file: path.relative(root, abs), source: safeRead(abs) }))
         .filter((f) => f.source !== null);
-    return buildIndex(read);
+    return buildIndex(read, parseTsconfigAliases(root));
 }
 /** Persist the index to .swarm/codegraph.json under `root`. */
 export function saveIndex(root, index) {

package/v3/@swarmdo/cli/dist/src/commands/apply.js

@@ -32,6 +32,7 @@ async function run(ctx) {
     const root = ctx.cwd || process.cwd();
     const dryRun = ctx.flags['dry-run'] === true;
     const partial = ctx.flags.partial === true;
+    const strict = ctx.flags.strict === true;
     // The parser may deliver --fuzz as a number or a string; accept both.
     const fuzz = typeof ctx.flags.fuzz === 'number' ? ctx.flags.fuzz
         : typeof ctx.flags.fuzz === 'string' ? parseInt(ctx.flags.fuzz, 10)
@@ -61,6 +62,7 @@ async function run(ctx) {
     }
     let totalApplied = 0;
     let totalRejected = 0;
+    let totalAmbiguous = 0;
     const writes = [];
     for (const fp of patches) {
         const file = targetFile(root, fp);
@@ -85,8 +87,16 @@ async function run(ctx) {
         totalApplied += applied;
         totalRejected += rejected;
         const fuzzy = res.hunks.filter((h) => h.applied && (h.fuzzUsed ?? 0) > 0).length;
+        const ambiguous = res.hunks.filter((h) => h.applied && h.ambiguous).length;
+        totalAmbiguous += ambiguous;
         const tag = rejected === 0 ? output.dim('ok') : output.bold(`${rejected} rejected`);
-        output.writeln(`${rel}  ${applied}/${res.hunks.length} hunks${fuzzy ? output.dim(` (${fuzzy} fuzzy)`) : ''}  ${tag}`);
+        const ambTag = ambiguous ? output.error(` ⚠ ${ambiguous} ambiguous`) : '';
+        output.writeln(`${rel}  ${applied}/${res.hunks.length} hunks${fuzzy ? output.dim(` (${fuzzy} fuzzy)`) : ''}  ${tag}${ambTag}`);
+        if (ambiguous) {
+            for (const h of res.hunks.filter((x) => x.applied && x.ambiguous)) {
+                output.writeln(output.dim(`    ⚠ hunk @ line ${(h.at ?? 0) + 1}: matched a block that also appears elsewhere — verify it landed on the intended one`));
+            }
+        }
         if (rejected === 0 || partial) {
             if (res.result !== source)
                 writes.push({ file, content: res.result });
@@ -97,9 +107,11 @@ async function run(ctx) {
             fs.writeFileSync(w.file, w.content);
     }
     const verb = dryRun ? 'would apply' : 'applied';
-    output.writeln(output.dim(`${verb} ${totalApplied} hunks, ${totalRejected} rejected${dryRun ? ' (dry run)' : ''}`));
-    // Exit 1 if anything was rejected — a CI/agent can branch on it.
-    const code = totalRejected > 0 ? 1 : 0;
+    const ambSummary = totalAmbiguous ? `, ${totalAmbiguous} ambiguous` : '';
+    output.writeln(output.dim(`${verb} ${totalApplied} hunks, ${totalRejected} rejected${ambSummary}${dryRun ? ' (dry run)' : ''}`));
+    // Exit 1 if anything was rejected — a CI/agent can branch on it. With --strict,
+    // an ambiguous match (possibly landed on the wrong duplicate) also fails.
+    const code = totalRejected > 0 || (strict && totalAmbiguous > 0) ? 1 : 0;
     return { success: code === 0, exitCode: code };
 }
 export const applyCommand = {
@@ -109,6 +121,7 @@ export const applyCommand = {
         { name: 'dry-run', description: 'report what would apply/reject without writing', type: 'boolean' },
         { name: 'fuzz', description: 'max context lines to drop when matching a drifted hunk (default 2)', type: 'string' },
         { name: 'partial', description: 'write files even when some of their hunks are rejected', type: 'boolean' },
+        { name: 'strict', description: 'exit 1 if any hunk matched an ambiguous (duplicated) block, even if it applied', type: 'boolean' },
     ],
     examples: [
         { command: 'swarmdo apply changes.patch', description: 'Apply a patch file' },

package/v3/@swarmdo/cli/dist/src/commands/compact-snapshot.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `swarmdo compact-snapshot` — capture / restore a compaction-survival digest.
+ *
+ *   swarmdo compact-snapshot write   # snapshot working state (call on PreCompact)
+ *   swarmdo compact-snapshot read    # print the digest, then consume it (first
+ *                                    # prompt after compaction re-injects it)
+ *   swarmdo compact-snapshot read --keep   # print without consuming
+ *
+ * The digest (recently edited files, uncommitted changes, branch) lets an agent
+ * re-ground after context compaction instead of re-exploring. The engine is
+ * pure + tested (../compact-snapshot/compact-snapshot.ts); this wrapper does the
+ * fs read (edit ledger), git calls, and one-shot persistence.
+ */
+import type { Command } from '../types.js';
+export declare const compactSnapshotCommand: Command;
+export default compactSnapshotCommand;
+//# sourceMappingURL=compact-snapshot.d.ts.map