@@ -58,11 +58,6 @@ public DirectorySource(string directory, Options? opts = null)
         Opts = opts ?? new Options();
     }
 
-    /// <summary>
-    /// Enumerate the matched files as <see cref="FileSource"/> instances, sorted
-    /// by full path (ordinal). The sort happens on the full path so that nested
-    /// directory traversal is also deterministic.
-    /// </summary>
     /// <summary>
     /// How two resolved directory paths are compared when deciding "is this an
     /// ancestor I have already walked".
@@ -81,6 +76,11 @@ public DirectorySource(string directory, Options? opts = null)
     private static readonly StringComparer PathComparer =
         OperatingSystem.IsLinux() ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;
 
+    /// <summary>
+    /// Enumerate the matched files as <see cref="FileSource"/> instances, sorted
+    /// by full path (ordinal). The sort happens on the full path so that nested
+    /// directory traversal is also deterministic.
+    /// </summary>
     public IEnumerable<FileSource> Expand()
     {
         IEnumerable<string> files = Collect(Directory, new HashSet<string>(PathComparer))
@@ -193,17 +193,15 @@ private static string RealPath(string path)
             current = Path.Combine(current, segment);
             try
             {
-                // returnFinalTarget walks a chain of links in one call; the bound is the
-                // OS's own, and a link cycle here surfaces as an IOException we fall back on.
-                var target = System.IO.Directory.ResolveLinkTarget(current, returnFinalTarget: true)
-                             ?? System.IO.File.ResolveLinkTarget(current, returnFinalTarget: true);
-                if (target is not null)
-                {
-                    var t = target.FullName;
-                    current = Path.IsPathRooted(t)
-                        ? Path.GetFullPath(t)
-                        : Path.GetFullPath(Path.Combine(Path.GetDirectoryName(current) ?? root, t));
-                }
+                // returnFinalTarget walks a chain of links (relative or absolute
+                // targets, either) in one call and hands back an already
+                // fully-qualified target. Every path this loop resolves is a
+                // directory — Collect only ever calls RealPath on one it has
+                // already confirmed exists — so Directory.ResolveLinkTarget alone
+                // is authoritative; a link cycle here surfaces as an IOException
+                // we fall back on.
+                var target = System.IO.Directory.ResolveLinkTarget(current, returnFinalTarget: true);
+                if (target is not null) current = target.FullName;
             }
             catch (IOException) { /* unresolvable — keep the lexical form for this segment */ }
             catch (UnauthorizedAccessException) { /* ditto */ }
 
@@ -218,6 +218,23 @@ async function stackForAgentContext(opts: InitOptions, prior: Manifest | undefin
   return resolveStack(opts.cwd, overrides);
 }
 
+/** Writes `contents` to `path` (relative to `cwd`), unless `dryRun` — in which case
+ *  the write is skipped entirely and the caller still records what WOULD have
+ *  landed. Factors the mkdir+writeFile pair shared by every write site below. */
+async function writeUnlessDryRun(cwd: string, dryRun: boolean, path: string, contents: string): Promise<void> {
+  if (dryRun) return;
+  const abs = join(cwd, path);
+  await mkdir(dirname(abs), { recursive: true });
+  await writeFile(abs, contents, "utf8");
+}
+
+/** "would be VERBED" during a dry run, plain VERBED otherwise — the one tense
+ *  marker every reported write shares, so each call site states only its own
+ *  past participle instead of writing out both tenses of the whole sentence. */
+function verbed(dryRun: boolean, pastParticiple: string): string {
+  return dryRun ? `would be ${pastParticiple}` : pastParticiple;
+}
+
 async function writeAgentContext(opts: InitOptions, result: InitResult): Promise<void> {
   warnIfMonorepoSubdir(opts, result);
   const prior = await readManifest(opts.cwd);
@@ -255,34 +272,23 @@ async function writeAgentContext(opts: InitOptions, result: InitResult): Promise
   const dryRun = opts.printOnly === true;
 
   for (const w of writes) {
-    if (!dryRun) {
-      const abs = join(opts.cwd, w.path);
-      await mkdir(dirname(abs), { recursive: true });
-      await writeFile(abs, w.contents, "utf8");
-    }
+    await writeUnlessDryRun(opts.cwd, dryRun, w.path, w.contents);
     result.created.push(w.path);
   }
   for (const c of conflicts) {
-    if (!dryRun) {
-      const abs = join(opts.cwd, c.newPath);
-      await mkdir(dirname(abs), { recursive: true });
-      await writeFile(abs, c.contents, "utf8");
-    }
+    await writeUnlessDryRun(opts.cwd, dryRun, c.newPath, c.contents);
     result.created.push(c.newPath);
     // Past tense only when it actually happened — a dry run that reports "written
     // to <path>.new" is claiming an edit-preserving side effect the user can go
     // look for and will not find.
     result.warnings.push(
-      dryRun
-        ? `${c.path} appears hand-edited; refreshed version would be written to ${c.newPath}`
-        : `${c.path} appears hand-edited; refreshed version written to ${c.newPath}`,
+      `${c.path} appears hand-edited; refreshed version ${verbed(dryRun, "written")} to ${c.newPath}`,
     );
   }
-  if (!dryRun) {
-    const manifestAbs = join(opts.cwd, AGENT_CONTEXT_MANIFEST_PATH);
-    await mkdir(dirname(manifestAbs), { recursive: true });
-    await writeFile(manifestAbs, JSON.stringify(decision.manifest, null, 2) + "\n", "utf8");
-  }
+  await writeUnlessDryRun(
+    opts.cwd, dryRun, AGENT_CONTEXT_MANIFEST_PATH,
+    JSON.stringify(decision.manifest, null, 2) + "\n",
+  );
   result.created.push(AGENT_CONTEXT_MANIFEST_PATH);
 
   for (const orphan of decision.removed) {
@@ -301,28 +307,20 @@ async function wireRootMemory(cwd: string, result: InitResult, dryRun = false):
 
   // If neither root memory file exists, create CLAUDE.md (Claude Code's canonical) with the import.
   if (!claudeExists && !agentsExists) {
-    if (!dryRun) await writeFile(claudePath, `# Project memory\n\n${ROOT_IMPORT_LINE}\n`, "utf8");
-    result.created.push(
-      dryRun
-        ? "CLAUDE.md (would be created with MetaObjects @import)"
-        : "CLAUDE.md (created with MetaObjects @import)",
-    );
+    await writeUnlessDryRun(cwd, dryRun, "CLAUDE.md", `# Project memory\n\n${ROOT_IMPORT_LINE}\n`);
+    result.created.push(`CLAUDE.md (${verbed(dryRun, "created")} with MetaObjects @import)`);
     return;
   }
   // Otherwise append the import to whichever exist (idempotent — never double-add).
   for (const [path, exists] of [[claudePath, claudeExists], [agentsPath, agentsExists]] as const) {
     if (!exists) continue;
     const body = await readFile(path, "utf8");
     if (body.includes(ROOT_IMPORT_LINE)) continue;
-    if (!dryRun) await writeFile(path, `${body.replace(/\n*$/, "\n")}\n${ROOT_IMPORT_LINE}\n`, "utf8");
+    const target = path.endsWith("AGENTS.md") ? "AGENTS.md" : "CLAUDE.md";
+    await writeUnlessDryRun(cwd, dryRun, target, `${body.replace(/\n*$/, "\n")}\n${ROOT_IMPORT_LINE}\n`);
     // Past tense only when it actually happened — this one mutates a file the user
     // owns, so a dry run reporting it as done is the most misleading of the three.
-    const target = path.endsWith("AGENTS.md") ? "AGENTS.md" : "CLAUDE.md";
-    result.warnings.push(
-      dryRun
-        ? `would wire ${ROOT_IMPORT_LINE} into ${target} so the MetaObjects context loads`
-        : `wired ${ROOT_IMPORT_LINE} into ${target} so the MetaObjects context loads`,
-    );
+    result.warnings.push(`${verbed(dryRun, "wired")} ${ROOT_IMPORT_LINE} into ${target} so the MetaObjects context loads`);
   }
 }