@knpkv/confluence-to-markdown 0.6.0 → 0.7.0

package/src/LocalFileSystem.ts

@@ -3,11 +3,11 @@
  *
  * @module
  */
-import * as FileSystem from "@effect/platform/FileSystem"
-import * as Path from "@effect/platform/Path"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
+import * as FileSystem from "effect/FileSystem"
 import * as Layer from "effect/Layer"
+import * as Path from "effect/Path"
 import type { ContentHash } from "./Brand.js"
 import type { FrontMatterError } from "./ConfluenceError.js"
 import { FileSystemError } from "./ConfluenceError.js"
@@ -59,9 +59,7 @@ export interface PageTreeNode {
  *
  * @category FileSystem
  */
-export class LocalFileSystem extends Context.Tag(
-  "@knpkv/confluence-to-markdown/LocalFileSystem"
-)<
+export class LocalFileSystem extends Context.Service<
   LocalFileSystem,
   {
     /**
@@ -135,7 +133,7 @@ export class LocalFileSystem extends Context.Tag(
       content: string
     ) => Effect.Effect<void, FileSystemError>
   }
->() {}
+>()("@knpkv/confluence-to-markdown/LocalFileSystem") {}
 
 /**
  * Layer that provides LocalFileSystem.
@@ -180,7 +178,7 @@ export const layer: Layer.Layer<LocalFileSystem, never, FileSystem.FileSystem |
       Effect.gen(function*() {
         const dir = pathService.dirname(filePath)
         yield* fs.makeDirectory(dir, { recursive: true }).pipe(
-          Effect.catchAll(() => Effect.void)
+          Effect.mapError((cause) => new FileSystemError({ operation: "mkdir", path: dir, cause }))
         )
 
         const serialized = serializeMarkdown(frontMatter, content)
@@ -257,7 +255,7 @@ export const layer: Layer.Layer<LocalFileSystem, never, FileSystem.FileSystem |
       Effect.gen(function*() {
         const dir = pathService.dirname(filePath)
         yield* fs.makeDirectory(dir, { recursive: true }).pipe(
-          Effect.catchAll(() => Effect.void)
+          Effect.mapError((cause) => new FileSystemError({ operation: "mkdir", path: dir, cause }))
         )
 
         // Atomic write: write to temp file, then rename
@@ -289,7 +287,7 @@ export const layer: Layer.Layer<LocalFileSystem, never, FileSystem.FileSystem |
       Effect.gen(function*() {
         const dir = pathService.dirname(filePath)
         yield* fs.makeDirectory(dir, { recursive: true }).pipe(
-          Effect.catchAll(() => Effect.void)
+          Effect.mapError((cause) => new FileSystemError({ operation: "mkdir", path: dir, cause }))
         )
 
         const serialized = serializeNewPageMarkdown(frontMatter, content)

package/src/MarkdownConverter.ts

@@ -39,9 +39,7 @@ import { ConversionError } from "./ConfluenceError.js"
  *
  * @category Conversion
  */
-export class MarkdownConverter extends Context.Tag(
-  "@knpkv/confluence-to-markdown/MarkdownConverter"
-)<
+export class MarkdownConverter extends Context.Service<
   MarkdownConverter,
   {
     /**
@@ -59,7 +57,7 @@ export class MarkdownConverter extends Context.Tag(
      */
     readonly markdownToAdf: (markdown: string) => Effect.Effect<string, ConversionError>
   }
->() {}
+>()("@knpkv/confluence-to-markdown/MarkdownConverter") {}
 
 const warningSummary = (w: WalkerWarning): string => {
   switch (w._tag) {

package/src/Schemas.ts

@@ -3,6 +3,7 @@
  *
  * @module
  */
+import * as Effect from "effect/Effect"
 import * as Schema from "effect/Schema"
 import { ContentHashSchema, PageIdSchema, SpaceKeySchema } from "./Brand.js"
 
@@ -27,18 +28,18 @@ export const ConfluenceConfigFileSchema = Schema.Struct({
   rootPageId: PageIdSchema,
   /** Confluence Cloud base URL */
   baseUrl: Schema.String.pipe(
-    Schema.pattern(/^https:\/\/[a-z0-9-]+\.atlassian\.net$/)
+    Schema.check(Schema.isPattern(/^https:\/\/[a-z0-9-]+\.atlassian\.net$/))
   ),
   /** Optional space key */
   spaceKey: Schema.optional(SpaceKeySchema),
   /** Local docs path (default: .confluence/docs) */
-  docsPath: Schema.optionalWith(Schema.String, { default: () => ".confluence/docs" }),
+  docsPath: Schema.String.pipe(Schema.withDecodingDefaultTypeKey(Effect.succeed(".confluence/docs"))),
   /** Glob patterns to exclude from sync */
-  excludePatterns: Schema.optionalWith(Schema.Array(Schema.String), { default: () => [] }),
+  excludePatterns: Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultTypeKey(Effect.succeed([]))),
   /** Save original Confluence HTML alongside markdown (default: false) */
-  saveSource: Schema.optionalWith(Schema.Boolean, { default: () => false }),
+  saveSource: Schema.Boolean.pipe(Schema.withDecodingDefaultTypeKey(Effect.succeed(false))),
   /** Glob patterns for files to track in git */
-  trackedPaths: Schema.optionalWith(Schema.Array(Schema.String), { default: () => ["**/*.md"] })
+  trackedPaths: Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultTypeKey(Effect.succeed(["**/*.md"])))
 })
 
 /**
@@ -71,9 +72,9 @@ export const PageFrontMatterSchema = Schema.Struct({
   /** Confluence page ID */
   pageId: PageIdSchema,
   /** Page version number */
-  version: Schema.Number.pipe(Schema.int(), Schema.positive()),
+  version: Schema.Int.pipe(Schema.check(Schema.isGreaterThan(0))),
   /** Page title */
-  title: Schema.String.pipe(Schema.nonEmptyString()),
+  title: Schema.NonEmptyString,
   /** Last updated timestamp (ISO8601) */
   updated: Schema.DateFromString,
   /** Parent page ID (optional) */
@@ -104,7 +105,7 @@ export type PageFrontMatter = Schema.Schema.Type<typeof PageFrontMatterSchema>
  */
 export const NewPageFrontMatterSchema = Schema.Struct({
   /** Page title */
-  title: Schema.String.pipe(Schema.nonEmptyString()),
+  title: Schema.NonEmptyString,
   /** Parent page ID (optional, determined by directory structure) */
   parentId: Schema.optional(PageIdSchema)
 })
@@ -125,9 +126,9 @@ export const SyncStateSchema = Schema.Struct({
   /** Last sync timestamp */
   lastSync: Schema.DateFromString,
   /** Map of page ID to sync info */
-  pages: Schema.Record({
-    key: Schema.String,
-    value: Schema.Struct({
+  pages: Schema.Record(
+    Schema.String,
+    Schema.Struct({
       /** Local file path */
       localPath: Schema.String,
       /** Last synced version */
@@ -135,7 +136,7 @@ export const SyncStateSchema = Schema.Struct({
       /** Content hash at last sync */
       contentHash: ContentHashSchema
     })
-  })
+  )
 })
 
 /**

package/src/SyncEngine.ts

@@ -3,10 +3,15 @@
  *
  * @module
  */
-import * as Path from "@effect/platform/Path"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
+import * as FileSystem from "effect/FileSystem"
 import * as Layer from "effect/Layer"
+import * as Path from "effect/Path"
+import type * as PlatformError from "effect/PlatformError"
+import * as Result from "effect/Result"
+import * as Schema from "effect/Schema"
+import type * as Terminal from "effect/Terminal"
 import { PageId } from "./Brand.js"
 import { ConfluenceClient } from "./ConfluenceClient.js"
 import { ConfluenceConfig } from "./ConfluenceConfig.js"
@@ -14,6 +19,14 @@ import type { ApiError, ConversionError, FrontMatterError, RateLimitError } from
 import { FileSystemError, StructureError } from "./ConfluenceError.js"
 import type { GitServiceError } from "./GitService.js"
 import { GitService } from "./GitService.js"
+import type { AdfMetadataSidecar } from "./internal/adfMetadata.js"
+import {
+  AdfMetadataSidecarSchema,
+  collectAdfMetadataHrefs,
+  externalizeAdfMetadata,
+  hydrateAdfMetadata
+} from "./internal/adfMetadata.js"
+import { parseMarkdown } from "./internal/frontmatter.js"
 import { computeHash, HashServiceLive } from "./internal/hashUtils.js"
 import { UserCache } from "./internal/userCache.js"
 import { LocalFileSystem } from "./LocalFileSystem.js"
@@ -40,7 +53,11 @@ export type SyncStatus =
 /**
  * Progress callback for version replay.
  */
-export type ProgressCallback = (current: number, total: number, message: string) => void
+export type ProgressCallback = (
+  current: number,
+  total: number,
+  message: string
+) => Effect.Effect<void, PlatformError.PlatformError, Terminal.Terminal>
 
 /**
  * Options for pull operation.
@@ -138,15 +155,15 @@ const hashBody = (markdown: string) => computeHash(markdown.trim()).pipe(Effect.
  *
  * @category Sync
  */
-export class SyncEngine extends Context.Tag(
-  "@knpkv/confluence-to-markdown/SyncEngine"
-)<
+export class SyncEngine extends Context.Service<
   SyncEngine,
   {
     /**
      * Pull pages from Confluence to local markdown.
      */
-    readonly pull: (options: PullOptions) => Effect.Effect<PullResult, SyncError>
+    readonly pull: (
+      options: PullOptions
+    ) => Effect.Effect<PullResult, SyncError | PlatformError.PlatformError, Terminal.Terminal>
 
     /**
      * Push local markdown changes to Confluence.
@@ -158,7 +175,7 @@ export class SyncEngine extends Context.Tag(
      */
     readonly status: () => Effect.Effect<StatusResult, SyncError>
   }
->() {}
+>()("@knpkv/confluence-to-markdown/SyncEngine") {}
 
 /**
  * Layer that provides SyncEngine.
@@ -168,7 +185,14 @@ export class SyncEngine extends Context.Tag(
 export const layer: Layer.Layer<
   SyncEngine,
   never,
-  ConfluenceClient | ConfluenceConfig | MarkdownConverter | LocalFileSystem | Path.Path | GitService | UserCache
+  | ConfluenceClient
+  | ConfluenceConfig
+  | MarkdownConverter
+  | LocalFileSystem
+  | Path.Path
+  | GitService
+  | UserCache
+  | FileSystem.FileSystem
 > = Layer.effect(
   SyncEngine,
   Effect.gen(function*() {
@@ -177,10 +201,69 @@ export const layer: Layer.Layer<
     const converter = yield* MarkdownConverter
     const localFs = yield* LocalFileSystem
     const pathService = yield* Path.Path
+    const fs = yield* FileSystem.FileSystem
     const git = yield* GitService
     const userCache = yield* UserCache
 
-    const docsPath = pathService.join(process.cwd(), config.docsPath)
+    const cwd = pathService.resolve(".")
+    const docsPath = pathService.join(cwd, config.docsPath)
+
+    const adfMetadataPath = (filePath: string, pageId?: string): string =>
+      pageId
+        ? pathService.join(pathService.dirname(filePath), `${pageId}.adf.json`)
+        : filePath.replace(/\.md$/, ".adf.json")
+
+    const adfMetadataHref = (filePath: string, pageId?: string): string =>
+      `./${pathService.basename(adfMetadataPath(filePath, pageId))}`
+
+    const prepareMarkdownForFile = (filePath: string, markdown: string, pageId?: string) =>
+      externalizeAdfMetadata(markdown, adfMetadataHref(filePath, pageId))
+
+    const writePreparedMarkdownWithAdfMetadata = (
+      filePath: string,
+      frontMatter: PageFrontMatter,
+      prepared: ReturnType<typeof externalizeAdfMetadata>
+    ): Effect.Effect<void, FileSystemError> =>
+      Effect.gen(function*() {
+        yield* localFs.writeMarkdownFile(filePath, frontMatter, prepared.markdown)
+        const sidecarPath = adfMetadataPath(filePath, frontMatter.pageId)
+        if (prepared.sidecar !== null) {
+          yield* localFs.writeFile(
+            sidecarPath,
+            JSON.stringify(prepared.sidecar, null, 2) + "\n"
+          )
+        } else if (yield* localFs.exists(sidecarPath)) {
+          yield* localFs.deleteFile(sidecarPath)
+        }
+      })
+
+    const readAdfMetadataSidecar = (sidecarPath: string): Effect.Effect<AdfMetadataSidecar | null, FileSystemError> =>
+      Effect.gen(function*() {
+        const exists = yield* localFs.exists(sidecarPath)
+        if (!exists) return null
+        const raw = yield* fs.readFileString(sidecarPath).pipe(
+          Effect.mapError((cause) => new FileSystemError({ operation: "read", path: sidecarPath, cause }))
+        )
+        const parsed = yield* Effect.try({
+          try: () => JSON.parse(raw) as unknown,
+          catch: (cause) => new FileSystemError({ operation: "read", path: sidecarPath, cause })
+        })
+        return yield* Schema.decodeUnknownEffect(AdfMetadataSidecarSchema)(parsed).pipe(
+          Effect.mapError((cause) => new FileSystemError({ operation: "read", path: sidecarPath, cause }))
+        )
+      })
+
+    const hydrateMarkdownForFile = (filePath: string, markdown: string): Effect.Effect<string, FileSystemError> =>
+      Effect.gen(function*() {
+        const sidecars = new Map<string, AdfMetadataSidecar>()
+        const dir = pathService.dirname(filePath)
+        for (const href of collectAdfMetadataHrefs(markdown)) {
+          const sidecarPath = pathService.resolve(dir, href)
+          const sidecar = yield* readAdfMetadataSidecar(sidecarPath)
+          if (sidecar !== null) sidecars.set(href, sidecar)
+        }
+        return hydrateAdfMetadata(markdown, sidecars)
+      })
 
     /**
      * Build a map of relative path (without .md) to pageId for resolving parents.
@@ -340,22 +423,29 @@ export const layer: Layer.Layer<
      */
     const getUser = (accountId: string): Effect.Effect<AtlassianUser | undefined, ApiError | RateLimitError> =>
       userCache.getOrFetch(accountId, client.getUser).pipe(
-        Effect.catchAll(() => Effect.succeed(undefined))
+        Effect.catchCause(() => Effect.succeed(undefined))
       )
 
     /**
      * Convert version content to markdown and front-matter.
      */
     const versionToMarkdown = (
+      filePath: string,
       pageId: PageId,
       version: PageVersionContent,
       title: string,
       parentId?: string,
       position?: number
-    ): Effect.Effect<{ markdown: string; frontMatter: PageFrontMatter }, SyncError> =>
+    ): Effect.Effect<{
+      markdown: string
+      frontMatter: PageFrontMatter
+      prepared: ReturnType<typeof externalizeAdfMetadata>
+    }, SyncError> =>
       Effect.gen(function*() {
         const adfJson = version.body?.atlas_doc_format?.value ?? ""
-        const markdown = yield* converter.adfToMarkdown(adfJson)
+        const rawMarkdown = yield* converter.adfToMarkdown(adfJson)
+        const prepared = prepareMarkdownForFile(filePath, rawMarkdown, pageId)
+        const { markdown } = prepared
         const contentHash = yield* hashBody(markdown)
 
         // Get author info
@@ -374,7 +464,7 @@ export const layer: Layer.Layer<
           ...(author?.email ? { authorEmail: author.email } : {})
         }
 
-        return { markdown, frontMatter }
+        return { markdown, frontMatter, prepared }
       })
 
     /**
@@ -387,7 +477,11 @@ export const layer: Layer.Layer<
       options: PullOptions,
       gitInitialized: boolean,
       knownParentId?: string
-    ): Effect.Effect<{ pulled: number; commits: number }, SyncError> =>
+    ): Effect.Effect<
+      { pulled: number; commits: number },
+      SyncError | PlatformError.PlatformError,
+      Terminal.Terminal
+    > =>
       Effect.gen(function*() {
         const pageId = page.id as PageId
         // Get children to determine if this is a folder
@@ -448,7 +542,7 @@ export const layer: Layer.Layer<
             versionIdx++
             // Report progress
             if (options.onProgress) {
-              options.onProgress(versionIdx, totalVersions, `${fullPage.title} v${versionInfo.number}`)
+              yield* options.onProgress(versionIdx, totalVersions, `${fullPage.title} v${versionInfo.number}`)
             }
 
             // Check if body content is available from the versions list
@@ -472,7 +566,8 @@ export const layer: Layer.Layer<
                 }
               }
             }
-            const { frontMatter, markdown } = yield* versionToMarkdown(
+            const { frontMatter, prepared } = yield* versionToMarkdown(
+              filePath,
               pageId,
               versionContent,
               versionInfo.page?.title ?? fullPage.title,
@@ -481,7 +576,7 @@ export const layer: Layer.Layer<
             )
 
             // Write file
-            yield* localFs.writeMarkdownFile(filePath, frontMatter, markdown)
+            yield* writePreparedMarkdownWithAdfMetadata(filePath, frontMatter, prepared)
 
             // Save source ADF JSON if configured
             if (config.saveSource && versionContent.body?.atlas_doc_format?.value) {
@@ -520,7 +615,7 @@ export const layer: Layer.Layer<
 
           // Simple pull without history replay
           const adfJson = fullPage.body?.atlas_doc_format?.value ?? ""
-          let markdown = yield* converter.adfToMarkdown(adfJson)
+          let rawMarkdown = yield* converter.adfToMarkdown(adfJson)
 
           // Add child page links for index pages
           if (hasChildren && config.spaceKey) {
@@ -530,9 +625,11 @@ export const layer: Layer.Layer<
                 return `- [${child.title}](${pageUrl})`
               })
               .join("\n")
-            markdown = markdown.trim() + "\n\n## Child Pages\n\n" + childLinks + "\n"
+            rawMarkdown = rawMarkdown.trim() + "\n\n## Child Pages\n\n" + childLinks + "\n"
           }
 
+          const prepared = prepareMarkdownForFile(filePath, rawMarkdown, pageId)
+          const { markdown } = prepared
           const contentHash = yield* hashBody(markdown)
 
           // Get author info
@@ -552,7 +649,7 @@ export const layer: Layer.Layer<
             ...(author?.email ? { authorEmail: author.email } : {})
           }
 
-          yield* localFs.writeMarkdownFile(filePath, frontMatter, markdown)
+          yield* writePreparedMarkdownWithAdfMetadata(filePath, frontMatter, prepared)
 
           // Save source ADF JSON if configured
           if (config.saveSource && adfJson) {
@@ -574,7 +671,9 @@ export const layer: Layer.Layer<
         return { pulled: 1 + childPulled, commits: totalCommits + childCommits }
       })
 
-    const pull = (options: PullOptions): Effect.Effect<PullResult, SyncError> =>
+    const pull = (
+      options: PullOptions
+    ): Effect.Effect<PullResult, SyncError | PlatformError.PlatformError, Terminal.Terminal> =>
       Effect.gen(function*() {
         yield* localFs.ensureDir(docsPath)
 
@@ -609,7 +708,7 @@ export const layer: Layer.Layer<
             yield* git.checkout(originalBranch)
             yield* git.merge("origin/confluence", {
               message: `Merge remote changes from Confluence`
-            }).pipe(Effect.catchAll(() => Effect.void)) // May fail if no changes
+            }).pipe(Effect.catchIf(() => true, () => Effect.void)) // May fail if no changes
           }
 
           return {
@@ -629,11 +728,11 @@ export const layer: Layer.Layer<
           Effect.ensuring(
             hasRemoteBranch && originalBranch
               ? git.checkout(originalBranch).pipe(
-                Effect.catchAll((error) =>
+                Effect.catchCause((cause) =>
                   Effect.logWarning(
                     `pull: could not restore branch '${originalBranch}' — the repo may still be on origin/confluence. ` +
                       `Restore manually with \`git checkout ${originalBranch}\` (stash local changes first if needed). Cause: ${
-                        String(error)
+                        String(cause)
                       }`
                   )
                 )
@@ -667,22 +766,18 @@ export const layer: Layer.Layer<
 
           // For new pages, re-parse front-matter to get title
           // The localFile only has the content (body), not the original front-matter
-          const title = yield* Effect.tryPromise({
-            try: async () => {
-              const fs = await import("node:fs/promises")
-              const matter = await import("gray-matter")
-              const rawFile = await fs.readFile(filePath, "utf-8")
-              const parsed = matter.default(rawFile)
-              return (parsed.data as { title?: string }).title ?? baseName
-            },
-            catch: (cause) => new FileSystemError({ operation: "read", path: filePath, cause })
-          })
+          const rawFile = yield* fs.readFileString(filePath).pipe(
+            Effect.mapError((cause) => new FileSystemError({ operation: "read", path: filePath, cause }))
+          )
+          const parsed = yield* parseMarkdown(filePath, rawFile)
+          const title = parsed.frontMatter?.title ?? baseName
 
           // Resolve parent from directory structure
           const parentId = yield* resolveParent(filePath, pageIdMap)
 
           // Convert markdown to ADF
-          const adfValue = yield* converter.markdownToAdf(localFile.content)
+          const hydratedContent = yield* hydrateMarkdownForFile(filePath, localFile.content)
+          const adfValue = yield* converter.markdownToAdf(hydratedContent)
 
           // Create the page
           const createdPage = yield* client.createPage({
@@ -697,7 +792,7 @@ export const layer: Layer.Layer<
 
           // Set editor version to v2 (new editor)
           yield* client.setEditorVersion(createdPage.id as PageId, "v2").pipe(
-            Effect.catchAll((error) => {
+            Effect.catchIf(() => true, (error) => {
               // Log warning but don't fail the push
               return Effect.logWarning(`Failed to set editor v2 for page ${createdPage.id}: ${error.message}`)
             })
@@ -706,7 +801,9 @@ export const layer: Layer.Layer<
           // Fetch canonical content back from Confluence
           const canonicalPage = yield* client.getPage(createdPage.id as PageId)
           const canonicalAdf = canonicalPage.body?.atlas_doc_format?.value ?? ""
-          const canonicalMarkdown = yield* converter.adfToMarkdown(canonicalAdf)
+          const rawCanonicalMarkdown = yield* converter.adfToMarkdown(canonicalAdf)
+          const preparedCanonicalMarkdown = prepareMarkdownForFile(filePath, rawCanonicalMarkdown, createdPage.id)
+          const { markdown: canonicalMarkdown } = preparedCanonicalMarkdown
           const canonicalHash = yield* hashBody(canonicalMarkdown)
 
           // Write canonical content with full front-matter
@@ -718,7 +815,7 @@ export const layer: Layer.Layer<
             parentId: parentId as PageId,
             contentHash: canonicalHash
           }
-          yield* localFs.writeMarkdownFile(filePath, newFrontMatter, canonicalMarkdown)
+          yield* writePreparedMarkdownWithAdfMetadata(filePath, newFrontMatter, preparedCanonicalMarkdown)
 
           // Update pageIdMap with new page
           const key = relativePath.replace(/\.md$/, "")
@@ -736,7 +833,8 @@ export const layer: Layer.Layer<
 
         // Fetch current version to avoid conflicts
         const remotePage = yield* client.getPage(fm.pageId)
-        const adfValue = yield* converter.markdownToAdf(localFile.content)
+        const hydratedContent = yield* hydrateMarkdownForFile(filePath, localFile.content)
+        const adfValue = yield* converter.markdownToAdf(hydratedContent)
         const updatedPage = yield* client.updatePage({
           id: fm.pageId,
           title: fm.title,
@@ -754,7 +852,9 @@ export const layer: Layer.Layer<
         // Fetch canonical content back from Confluence
         const canonicalPage = yield* client.getPage(fm.pageId)
         const canonicalAdf = canonicalPage.body?.atlas_doc_format?.value ?? ""
-        const canonicalMarkdown = yield* converter.adfToMarkdown(canonicalAdf)
+        const rawCanonicalMarkdown = yield* converter.adfToMarkdown(canonicalAdf)
+        const preparedCanonicalMarkdown = prepareMarkdownForFile(filePath, rawCanonicalMarkdown, fm.pageId)
+        const { markdown: canonicalMarkdown } = preparedCanonicalMarkdown
         const canonicalHash = yield* hashBody(canonicalMarkdown)
 
         // Write canonical content with updated front-matter
@@ -764,7 +864,7 @@ export const layer: Layer.Layer<
           updated: new Date(canonicalPage.version.createdAt ?? new Date().toISOString()),
           contentHash: canonicalHash
         }
-        yield* localFs.writeMarkdownFile(filePath, newFrontMatter, canonicalMarkdown)
+        yield* writePreparedMarkdownWithAdfMetadata(filePath, newFrontMatter, preparedCanonicalMarkdown)
 
         return { pushed: true, created: false }
       })
@@ -874,13 +974,12 @@ export const layer: Layer.Layer<
               spaceId,
               pageIdMap
             ).pipe(
-              Effect.catchAll((error) =>
+              Effect.catchIf(() => true, (error) =>
                 Effect.succeed({
                   pushed: false,
                   created: false,
                   error: `Failed: ${error._tag}`
-                })
-              )
+                }))
             )
             if (result.error) errors.push(result.error)
             if (result.pushed) pushed++
@@ -937,13 +1036,13 @@ export const layer: Layer.Layer<
                 const match = content.match(/pageId:\s*['"]?(\d+)['"]?/)
                 return match ? match[1] : null
               }),
-              Effect.catchAll(() => Effect.succeed(null))
+              Effect.catchIf(() => true, () => Effect.succeed(null))
             )
 
             if (pageIdFromOrigin) {
               yield* client.deletePage(PageId(pageIdFromOrigin)).pipe(
                 Effect.tap(() => Effect.sync(() => deleted++)),
-                Effect.catchAll((error) => {
+                Effect.catchIf(() => true, (error) => {
                   errors.push(`Failed to delete page ${pageIdFromOrigin}: ${error.message}`)
                   return Effect.void
                 })
@@ -954,13 +1053,12 @@ export const layer: Layer.Layer<
 
         for (const filePath of sortedFiles) {
           const result = yield* pushFile(filePath, revisionMessage, spaceId, pageIdMap).pipe(
-            Effect.catchAll((error) =>
+            Effect.catchIf(() => true, (error) =>
               Effect.succeed({
                 pushed: false,
                 created: false,
                 error: `Failed to push ${filePath}: ${error._tag}`
-              })
-            )
+              }))
           )
           if (result.error) errors.push(result.error)
           if (result.pushed) pushed++
@@ -970,7 +1068,7 @@ export const layer: Layer.Layer<
         // Amend the last commit with canonical content
         yield* git.addAll()
         yield* git.amend({ noEdit: true }).pipe(
-          Effect.catchAll(() => Effect.void)
+          Effect.catchIf(() => true, () => Effect.void)
         )
 
         // Two-branch model: update origin/confluence to match HEAD
@@ -1006,15 +1104,15 @@ export const layer: Layer.Layer<
           const currentHash = yield* computeHash(localFile.content).pipe(Effect.provide(HashServiceLive))
 
           // Fetch remote page
-          const remotePage = yield* Effect.either(client.getPage(fm.pageId))
+          const remotePage = yield* Effect.result(client.getPage(fm.pageId))
 
-          if (remotePage._tag === "Left") {
+          if (Result.isFailure(remotePage)) {
             statuses.push({ _tag: "LocalOnly", path: filePath, title: fm.title })
             localOnly++
             continue
           }
 
-          const page = remotePage.right
+          const page = remotePage.success
           const localChanged = currentHash !== fm.contentHash
           const remoteChanged = page.version.number > fm.version