@erclx/canon 4.114.0 → 4.116.0

package/src/audits/catalog.ts

@@ -2,6 +2,7 @@ import type { SkillsAuditRefusal } from '@/claude/skills-audit'
 import type { RankRefusal } from '@/claude/skills-rank'
 import type { ReachRefusal } from '@/claude/skills-reach'
 import type { ContextAuditRefusal } from '@/context/audit'
+import type { SweepVerdict } from '@/context/classify/patterns'
 import type { AuditRefusal } from '@/deps/audit'
 import type { RestatedRefusal } from '@/gov/restated'
 import type { LabelAuditRefusal } from '@/labels/audit'
@@ -199,6 +200,45 @@ function architectureCounts(
   }
 }
 
+/**
+ * The retained key for each verdict the sweep can return. A record rather than
+ * a list, so the compiler fails here when the classifier gains a verdict,
+ * instead of that verdict's sections dropping out of the tally.
+ */
+const PLACEMENT_KEYS: Record<SweepVerdict, string> = {
+  KEEP: 'keep',
+  REWRITE: 'rewrite',
+  MOVE: 'move',
+}
+
+function isPlacementVerdict(value: unknown): value is SweepVerdict {
+  return typeof value === 'string' && Object.hasOwn(PLACEMENT_KEYS, value)
+}
+
+/**
+ * Tallies the sweep's findings by verdict, with a zero for a verdict nothing
+ * returned, so a baseline reads the same three keys on every run.
+ *
+ * `KEEP` is retained beside the two that ask for a change. It moves when a
+ * section is added or split, which is what tells a falling `rewrite` count
+ * from a corpus that shrank.
+ */
+function placementCounts(record: unknown): Record<string, number> | undefined {
+  const findings = asObject(record)?.findings
+  if (!Array.isArray(findings)) return undefined
+
+  const counts: Record<string, number> = Object.fromEntries(
+    Object.values(PLACEMENT_KEYS).map((key) => [key, 0]),
+  )
+  for (const finding of findings) {
+    const verdict = asObject(finding)?.verdict
+    if (!isPlacementVerdict(verdict)) return undefined
+    counts[PLACEMENT_KEYS[verdict]] += 1
+  }
+
+  return counts
+}
+
 function contextCounts(record: unknown): Record<string, number> | undefined {
   const root = asObject(record)
   if (root === undefined) return undefined
@@ -502,6 +542,18 @@ export const AUDITS: readonly AuditSpec[] = [
     absentReasons: ['no-folders'] satisfies ContextAuditRefusal[],
     counts: contextCounts,
   },
+  {
+    id: 'placement',
+    label: 'Context placement',
+    // Pinned to the regex layer rather than the resolved classifier setting.
+    // A count that moves with whichever model a machine runs is not
+    // comparable across clones, and the model layer turns a sub-second read
+    // into a multi-minute one. `document-health` is where the model reads.
+    argv: ['context', 'classify', 'sweep', '--backend', 'off', '--json'],
+    gatingExits: [],
+    corpus: 'tracked',
+    counts: placementCounts,
+  },
   {
     id: 'markdown',
     label: 'Markdown corpus',

package/src/commands/context.ts

@@ -14,6 +14,8 @@ import {
   missingSections,
   PROVENANCE_FOLDER,
   REQUIRED_SECTIONS,
+  REQUIRED_SECTIONS_BY_FOLDER,
+  requiredSections,
   type SectionFinding,
 } from '@/context/audit'
 import {
@@ -129,8 +131,9 @@ export function register(program: Command): void {
         'it holds more decisions than the cap. A record stating neither is',
         'reported and never gated. --gate widens the gate to the other two',
         'findings that are facts rather than judgments: a missing required',
-        'section and index',
-        'drift. Entry length, reference form, table, provenance, narration,',
+        'section and index drift. A context entry requires Overview and',
+        'Layout, and a wireframe requires Regions, States, Copy, and Not on',
+        'this surface. Entry length, reference form, table, provenance, narration,',
         'and the record claim classification are judgments under both.',
         '',
         'Depth and bullet weight are stated over every markdown file rather',
@@ -740,6 +743,10 @@ async function runAudit(
           renderWidth: RENDER_WIDTH,
           provenanceFolder: PROVENANCE_FOLDER,
           requiredSections: REQUIRED_SECTIONS,
+          // Keyed on the audited folder name. The flat key above stays for a
+          // caller that read it before wireframes owed a section, since turning
+          // it into this map would break that caller without an error.
+          requiredSectionsByFolder: REQUIRED_SECTIONS_BY_FOLDER,
           // Three states rather than two, so a record showing no finding says
           // which terms were looked for. The key is absent when the run never
           // scanned, which is `--citations-only`, and null when it scanned and
@@ -946,7 +953,8 @@ function reportReferenceForm(
 
 /**
  * Names the path each finding belongs to, which is an entry in the folder named
- * under `.claude/` and the folder itself in a domain split across one. States
+ * under `.claude/`, the folder itself in a domain split across one, and the
+ * file in any wireframe folder. States
  * the reach on every run for the reason the provenance report does.
  *
  * This prints ahead of the four readability measures because a missing section
@@ -959,19 +967,31 @@ function reportSections(
 ): void {
   logStep('Sections')
 
-  const governed = folders.filter(governsContent)
-  if (governed.length === 0) {
+  const names = [
+    ...new Set(
+      folders
+        .filter((folder) => requiredSections(folder).length > 0)
+        .map((folder) => folder.name),
+    ),
+  ]
+  if (names.length === 0) {
     logInfo(
-      `Out of scope. The list is stated in the standard governing canon/${PROVENANCE_FOLDER}/, and no audited folder is that one.`,
+      `Out of scope. The lists are stated in the standards governing ${Object.keys(
+        REQUIRED_SECTIONS_BY_FOLDER,
+      )
+        .map((name) => `canon/${name}/`)
+        .join(' and ')}, and no audited folder is one of them.`,
     )
     return
   }
 
+  for (const name of names) {
+    logInfo(
+      `canon/${name}/ requires ${REQUIRED_SECTIONS_BY_FOLDER[name].join(', ')}.`,
+    )
+  }
   logInfo(
-    `Covers canon/${PROVENANCE_FOLDER}/ alone, whose standard requires ${REQUIRED_SECTIONS.join(' and ')}.`,
-  )
-  logInfo(
-    'A heading at any level counts. Each entry answers for itself, except in a domain split across a folder, where a sibling answers for the rest.',
+    'A heading at any level counts. Each entry answers for itself, except in a context domain split across a folder, where a sibling answers for the rest. A wireframe answers for itself in every folder.',
   )
 
   if (missing.length === 0) {

package/src/commands/sessions.ts

@@ -10,6 +10,11 @@ import {
   type SessionReport,
   selfOf,
 } from '@/sessions/resolve'
+import {
+  type Behind,
+  exportSession,
+  importSession,
+} from '@/sessions/transfer/bundle'
 import {
   intro,
   logInfo,
@@ -19,6 +24,7 @@ import {
   pipeOutput,
   plural,
 } from '@/ui'
+import { mainWorktreeRoot } from '@/worktree'
 
 interface ListCommandOptions {
   readonly json?: boolean
@@ -144,6 +150,222 @@ export function register(program: Command): void {
     .action(async (opts: ListCommandOptions) => {
       process.exitCode = await runList(opts)
     })
+
+  sessions
+    .command('export')
+    .description(
+      'Pack a session transcript, its side folder, and a manifest into one local bundle',
+    )
+    .helpOption('-h, --help', 'Show this help message')
+    .argument('<id>', 'The sessionId to export')
+    .option(
+      '--out <path>',
+      'Write the bundle here rather than under .canon/tmp/session-export/',
+    )
+    .option('--json', 'Add a machine-readable record on stdout')
+    .addHelpText(
+      'after',
+      [
+        '',
+        'Exit codes:',
+        '  0  the bundle was written',
+        '  1  refused, with the reason on stderr and in the record',
+        '',
+        'The bundle is a gzip tarball on local disk and is never uploaded. It',
+        'holds whatever tool output passed through the session, so treat it as',
+        'private. Export runs no skill: write and push a handoff first where one',
+        'is wanted, and the manifest reports whether one was found and pushed.',
+        '',
+        'Refusal reasons: "not-found" (no transcript carries the id) and',
+        '"no-archive" (this Bun has no Bun.Archive).',
+        '',
+        'Examples:',
+        '  canon sessions export <id>',
+        '  canon sessions export <id> --out ~/session.tar.gz --json',
+        '',
+      ].join('\n'),
+    )
+    .action(async (id: string, opts: ExportCommandOptions) => {
+      process.exitCode = await runExport(id, opts)
+    })
+
+  sessions
+    .command('import')
+    .description(
+      'Place an exported session under this machine so claude can resume it',
+    )
+    .helpOption('-h, --help', 'Show this help message')
+    .argument('<bundle>', 'The bundle an export wrote')
+    .option(
+      '--root <path>',
+      'The repository to resume in. Defaults to the main worktree',
+    )
+    .option('--json', 'Add a machine-readable record on stdout')
+    .addHelpText(
+      'after',
+      [
+        '',
+        'Exit codes:',
+        '  0  the session was placed, with any lag reported in "behind"',
+        '  1  refused, with the reason on stderr and in the record',
+        '',
+        'Refusal reasons: "not-a-bundle", "other-repository" (the origin',
+        'differs), "exists" (the transcript or side folder is already there),',
+        '"live-here" (the id is live on this machine), "write-failed" (a',
+        'write failed partway), and "no-archive". A failure partway removes',
+        'every file this run placed, and names any it could not remove.',
+        '',
+        '"behind" lists "repository-behind" when this checkout lacks the',
+        'exported HEAD, and "records-behind" when the records history lacks',
+        'the exported records commit, which canon records pull brings.',
+        '',
+        'Examples:',
+        '  canon sessions import session.tar.gz',
+        '  canon sessions import session.tar.gz --root ~/repos/canon --json',
+        '',
+      ].join('\n'),
+    )
+    .action(async (bundle: string, opts: ImportCommandOptions) => {
+      process.exitCode = await runImport(bundle, opts)
+    })
+}
+
+interface ExportCommandOptions {
+  readonly out?: string
+  readonly json?: boolean
+}
+
+interface ImportCommandOptions {
+  readonly root?: string
+  readonly json?: boolean
+}
+
+/**
+ * Whether a session id is live in the local roster. An unreadable roster
+ * answers false, since the roster is advisory here and the manifest says so.
+ */
+async function isLiveHere(id: string): Promise<boolean> {
+  const report = await resolveSessions()
+  return (
+    report.kind === 'resolved' &&
+    report.sessions.some((session) => session.sessionId === id)
+  )
+}
+
+function writeRecord(json: boolean | undefined, record: object): void {
+  if (json) process.stdout.write(`${JSON.stringify(record)}\n`)
+}
+
+async function runExport(
+  id: string,
+  opts: ExportCommandOptions,
+): Promise<number> {
+  const outcome = await exportSession({
+    id,
+    out: opts.out ? resolve(opts.out) : undefined,
+    isLive: isLiveHere,
+  })
+
+  intro('canon sessions export')
+
+  if (!outcome.ok) {
+    logStep('Refused')
+    logWarn(outcome.message)
+    outro()
+    writeRecord(opts.json, { ...outcome, sessionId: id })
+    return 1
+  }
+
+  const { manifest } = outcome
+  logStep('Bundle')
+  logInfo(`Wrote ${outcome.path}`)
+  logInfo(`${plural(outcome.files.length, 'side file')} beside the transcript`)
+
+  if (manifest.live) {
+    logWarn(
+      'The session is live, so the copy stops at its last whole line and resuming elsewhere forks it.',
+    )
+  }
+
+  logStep('Handoff')
+  if (manifest.handoff === null) {
+    logInfo(
+      'No compact note since the session began, so resume the transcript.',
+    )
+  } else if (manifest.handoffCommitted) {
+    logInfo(`${manifest.handoff} is in the records history. Prefer it.`)
+  } else {
+    logWarn(
+      `${manifest.handoff} is not in the records history yet. Run canon records push so the other machine can pull it.`,
+    )
+  }
+  outro()
+
+  writeRecord(opts.json, {
+    ok: true,
+    path: outcome.path,
+    sessionId: id,
+    files: outcome.files,
+    manifest,
+  })
+  return 0
+}
+
+const BEHIND_REMEDIES: Record<Behind, string> = {
+  'repository-behind':
+    'This checkout lacks the exported HEAD. Fetch and check out the branch before resuming.',
+  'records-behind':
+    'The records history lacks the exported commit. Run canon records pull to bring the handoff.',
+}
+
+async function runImport(
+  bundle: string,
+  opts: ImportCommandOptions,
+): Promise<number> {
+  const root = opts.root ? resolve(opts.root) : await mainWorktreeRoot()
+  const outcome = await importSession({
+    bundle: resolve(bundle),
+    root,
+    isLive: isLiveHere,
+  })
+
+  intro('canon sessions import')
+
+  if (!outcome.ok) {
+    logStep('Refused')
+    logWarn(outcome.message)
+    outro()
+    writeRecord(opts.json, outcome)
+    return 1
+  }
+
+  logStep('Placed')
+  logInfo(outcome.transcript)
+  logInfo(
+    `Folder ${outcome.folder}, derived from ${root}. --continue looks there, and --resume finds the id in any folder.`,
+  )
+  for (const lag of outcome.behind) logWarn(BEHIND_REMEDIES[lag])
+
+  logStep('Resume')
+  logInfo(
+    outcome.manifest.recommend === 'handoff'
+      ? `Recommended: the handoff at ${outcome.manifest.handoff}, since the transcript carries the source machine's absolute paths.`
+      : 'Recommended: the transcript, since no handoff was written since the session began.',
+  )
+  for (const route of outcome.routes) logInfo(route)
+  outro()
+
+  writeRecord(opts.json, {
+    ok: true,
+    sessionId: outcome.manifest.sessionId,
+    folder: outcome.folder,
+    transcript: outcome.transcript,
+    files: outcome.files,
+    behind: outcome.behind,
+    routes: outcome.routes,
+    manifest: outcome.manifest,
+  })
+  return 0
 }
 
 async function runList(opts: ListCommandOptions): Promise<number> {

package/src/commands/teach.ts

@@ -393,9 +393,16 @@ export function register(program: Command): void {
         '  1  refused, with the reason on stderr or in the JSON record',
         '',
         'Reads a JSON array of blocks from stdin, each a heading, paragraph,',
-        'list, or raw block, and renders it through the same components the',
-        'fixture lesson is generated from. Content the three cannot express',
-        'takes type raw, carrying its own html verbatim, unescaped.',
+        'list, refs, or raw block, and renders it through the same components',
+        'the fixture lesson is generated from. Content the structured blocks',
+        'cannot express takes type raw, carrying its own html verbatim,',
+        'unescaped.',
+        '',
+        'A paragraph takes an optional cites array of reference numbers,',
+        'rendered as footnote markers after its text. The one refs block',
+        'lists { title, url?, note? } items numbered from 1, and a cite that',
+        'resolves to no item, a cite on a lede, or a second refs block is',
+        'refused. A url must be http or https.',
         '',
         'Takes no topic and no --root: the verb is a stateless transform,',
         'reading nothing off a workspace on disk.',
@@ -797,7 +804,9 @@ function reportNav(
         root: outcome.root,
         contents: outcome.contents,
         lessons: outcome.lessons,
+        reference: outcome.reference,
         skipped: outcome.skipped,
+        unresolved: outcome.unresolved,
       })}\n`,
     )
     return 0
@@ -810,14 +819,23 @@ function reportNav(
   for (const path of outcome.contents) logInfo(path)
   logStep('Lessons rewritten')
   logInfo(String(outcome.lessons))
+  logStep('Reference pages rendered')
+  logInfo(String(outcome.reference))
 
   if (outcome.skipped.length > 0) {
-    logStep('Refused, missing a chrome marker')
+    logStep('Refused, missing a chrome marker or the markdown renderer')
     for (const skip of outcome.skipped) {
       logWarn(`${skip.file}: no ${skip.missing}`)
     }
   }
 
+  if (outcome.unresolved.length > 0) {
+    logStep('Lesson references naming no lesson')
+    for (const reference of outcome.unresolved) {
+      logWarn(`${reference.file}: lesson ${reference.lesson}`)
+    }
+  }
+
   outro()
   return 0
 }

package/src/context/audit.ts

@@ -45,19 +45,35 @@ export const CATALOG_ROW_CHECKPOINT = 6
 const CATALOG_NAMED_RATIO = 0.6
 
 /**
- * Sections `standards/context.md` marks required, in the order it states them.
+ * Required sections per audited folder name, each in the order its standard
+ * states them.
  *
- * The list is held here rather than read out of the standard, the way the four
- * checkpoints above quote their numbers. A parser over the standard's prose
+ * The lists are held here rather than read out of the standards, the way the
+ * four checkpoints above quote their numbers. A parser over a standard's prose
  * would decide which sections are required from the wording around them, so it
  * fails on a rewrite of that wording rather than on a defect in an entry.
  *
  * These names do not generalize the way a length threshold does, which is why
- * the measure is scoped to the folder `governsContent` names. A diagram entry
- * declares a heading per kind and a wireframe entry per screen, and neither
- * sibling standard states a required section at all.
+ * each list is keyed on the folder whose standard states it. `context.md`
+ * requires an overview and a layout. `wireframes.md` asks four questions of a
+ * surface and answers each in a section, so those four are required and
+ * `## Behavior` is not, since a static surface has no interaction to state. A
+ * diagram entry declares a heading per kind and its standard requires none.
  */
-export const REQUIRED_SECTIONS: readonly string[] = ['Overview', 'Layout']
+export const REQUIRED_SECTIONS_BY_FOLDER: Readonly<
+  Record<string, readonly string[]>
+> = {
+  context: ['Overview', 'Layout'],
+  wireframes: ['Regions', 'States', 'Copy', 'Not on this surface'],
+}
+
+/**
+ * The context standard's list, kept as its own export because the audit record
+ * has published it flat under `checkpoints.requiredSections` since before any
+ * other folder required a section.
+ */
+export const REQUIRED_SECTIONS: readonly string[] =
+  REQUIRED_SECTIONS_BY_FOLDER.context
 
 const HEADING_TEXT = /^#{1,6}\s+(.+?)\s*$/
 const TABLE_ROW = /^\s*\|/
@@ -226,7 +242,7 @@ export interface EntryReport {
   readonly bareReferences: readonly BareReferenceFinding[]
   /**
    * Required sections this entry declares, in the standard's order, and empty
-   * outside the folder whose standard names them. What the folder is short of
+   * outside a folder whose standard names them. What the folder is short of
    * is `missingSections`, since one entry answers for its siblings.
    */
   readonly sections: readonly string[]
@@ -550,17 +566,20 @@ function narration(
  * Fenced blocks are skipped for the reason the scans above skip them. A
  * standard quoted inside an example declares nothing about the entry quoting it.
  */
-function declaredSections(lines: readonly BodyLine[]): string[] {
+function declaredSections(
+  lines: readonly BodyLine[],
+  required: readonly string[],
+): string[] {
   const found = new Set<string>()
 
   for (const line of lines) {
     if (line.fenced) continue
 
     const match = line.text.match(HEADING_TEXT)
-    if (match && REQUIRED_SECTIONS.includes(match[1])) found.add(match[1])
+    if (match && required.includes(match[1])) found.add(match[1])
   }
 
-  return REQUIRED_SECTIONS.filter((section) => found.has(section))
+  return required.filter((section) => found.has(section))
 }
 
 /**
@@ -611,7 +630,9 @@ function bareReferences(
  * The caller passes jurisdiction rather than deriving it from `rel`, because a
  * path prefix hardcodes what `--folder` exists to override and misses a domain
  * split into `context/<sub-area>/`. Sibling names arrive the same way and for
- * the same reason, since the folder an entry sits in is what holds them.
+ * the same reason, since the folder an entry sits in is what holds them. The
+ * required sections arrive apart from jurisdiction, since a wireframe owes
+ * sections under a standard that states no provenance rule.
  */
 export function measureEntry(
   rel: string,
@@ -619,6 +640,7 @@ export function measureEntry(
   governsContent = true,
   terms?: NarrationTerms,
   siblings: readonly string[] = [],
+  required: readonly string[] = governsContent ? REQUIRED_SECTIONS : [],
 ): EntryReport {
   const lines = bodyLines(source)
 
@@ -632,7 +654,7 @@ export function measureEntry(
     provenance: governsContent ? provenance(lines) : [],
     narration: governsContent && terms ? narration(lines, terms) : [],
     bareReferences: bareReferences(lines, siblings),
-    sections: governsContent ? declaredSections(lines) : [],
+    sections: declaredSections(lines, required),
     stub: isStubSeed(source),
     governed: governsContent,
   }
@@ -713,6 +735,7 @@ export async function measureFolders(
           governsContent(folder),
           terms,
           names.filter((name) => name !== self),
+          requiredSections(folder),
         ),
       )
     }
@@ -726,6 +749,13 @@ export function governsContent(folder: AuditedFolder): boolean {
   return folder.name === PROVENANCE_FOLDER
 }
 
+/** Names the sections the folder's standard requires, empty where it states none. */
+export function requiredSections(folder: AuditedFolder): readonly string[] {
+  return Object.hasOwn(REQUIRED_SECTIONS_BY_FOLDER, folder.name)
+    ? REQUIRED_SECTIONS_BY_FOLDER[folder.name]
+    : []
+}
+
 /**
  * Reports whether a bare sibling name here is a reference by construction.
  *
@@ -765,6 +795,11 @@ export function matchesSiblings(folder: AuditedFolder): boolean {
  * The standard sanctions omitting `## Layout` from a domain owning no paths,
  * which no measure can tell from an entry that forgot it. An entry of that
  * shape therefore reports, which is a reason this is printed and never gated on.
+ *
+ * A wireframe folder answers per file whether nested or not, since its
+ * standard keeps one surface per file. A subfolder of wireframes groups
+ * surfaces the way the named context folder groups domains, so a conforming
+ * sibling there says nothing about the surface beside it.
  */
 export function missingSections(
   root: string,
@@ -774,11 +809,12 @@ export function missingSections(
   const byRel = new Map(entries.map((entry) => [entry.rel, entry]))
   const findings: SectionFinding[] = []
 
-  const shortOf = (declared: readonly string[]): string[] =>
-    REQUIRED_SECTIONS.filter((name) => !declared.includes(name))
-
   for (const folder of folders) {
-    if (!governsContent(folder) || folder.entries.length === 0) continue
+    const required = requiredSections(folder)
+    if (required.length === 0 || folder.entries.length === 0) continue
+
+    const shortOf = (declared: readonly string[]): string[] =>
+      required.filter((name) => !declared.includes(name))
 
     // A stub owes no sections, so it is dropped before either branch rather
     // than inside them. Leaving one in the split-folder aggregate would let a
@@ -790,7 +826,7 @@ export function missingSections(
 
     if (reports.length === 0) continue
 
-    if (folder.nested) {
+    if (folder.nested && governsContent(folder)) {
       const missing = shortOf(reports.flatMap((entry) => entry.sections))
       if (missing.length > 0) findings.push({ rel: folder.rel, missing })
       continue

package/src/records/backup.ts

@@ -318,7 +318,7 @@ function failed(action: string, result: GitResult): BackupRefused {
  * as written passes a records origin that publishes the payload through the
  * other protocol.
  */
-function remoteIdentity(url: string): string {
+export function remoteIdentity(url: string): string {
   return url
     .trim()
     .toLowerCase()

package/src/sandbox/census.ts

@@ -69,7 +69,7 @@ export function listSkills(root: string): string[] {
 /**
  * Maps a scenario to the skill it drives, trying two spellings in order.
  *
- * `<category>-<command>` is the rule `canon/context/sandbox/coverage.md` states, and it
+ * `<category>-<command>` is the rule `canon/context/sandbox/coverage/census.md` states, and it
  * alone pairs 29 of 54 skills. The bare `<command>` fallback is what reaches the
  * rest: `claude/target-setup.sh` drives the `target-setup` skill, not a `claude-target-setup` that
  * does not exist. Stating one spelling and shipping two is what let the audit

package/src/sessions/registry.ts

@@ -48,19 +48,23 @@ export interface SessionRecord {
 }
 
 /**
- * Resolves the folder holding one file per session.
+ * Resolves the client's configuration directory, which holds both the session
+ * registry and the projects folder a transcript lives in.
  *
  * `CLAUDE_CONFIG_DIR` comes first because a client honouring it writes its
  * records nowhere near the home directory, and a read that ignored it would
  * report an empty roster on a machine running sessions.
  */
-export function registryDir(): string {
+export function claudeConfigDir(): string {
   const configured = process.env.CLAUDE_CONFIG_DIR
-  const base =
-    configured && configured.length > 0
-      ? configured
-      : join(homedir(), '.claude')
-  return join(base, 'sessions')
+  return configured && configured.length > 0
+    ? configured
+    : join(homedir(), '.claude')
+}
+
+/** Resolves the folder holding one file per session. */
+export function registryDir(): string {
+  return join(claudeConfigDir(), 'sessions')
 }
 
 /**