@mnstry/atelier 0.2.0-alpha.4 → 0.2.0-alpha.5

package/src/collaboration/proposals.mjs

@@ -1,12 +1,18 @@
 import crypto from 'node:crypto'
 import fs from 'node:fs'
 import path from 'node:path'
+import { createCollaborationEventLedger } from './event-ledger.mjs'
+import {
+  atomicReplacePrivateText,
+  ensureContainedPrivateDirectory,
+  readRegularTextNoFollow,
+} from '../project/private-state.mjs'
 
 export const ATELIER_PROPOSAL_SCHEMA = 'atelier-proposal@v1'
 export const ATELIER_PROPOSALS_SCHEMA = 'atelier-proposals@v1'
 export const PROPOSAL_REVIEW_STATUSES = new Set(['reviewed', 'accepted', 'rejected', 'superseded'])
-
-const DIRECT_WRITE_ACTION_RE = /(?:^|[._:-])(apply|write|commit|persist|mutate|db|database)(?:$|[._:-])/i
+export const COPY_ONLY_PROPOSAL_CAPABILITY = 'proposal.copy-only'
+const PROPOSAL_ID_PATTERN = /^proposal-[a-z0-9]+(?:-[a-z0-9]+)*$/
 
 function nowIso() {
   return new Date().toISOString()
@@ -20,6 +26,10 @@ function stableCompare(left, right) {
   return String(left).localeCompare(String(right), 'en')
 }
 
+function isRecord(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
 function safeJsonText(value, max = 50000) {
   if (value == null) return ''
   if (typeof value === 'string') return value.slice(0, max)
@@ -30,24 +40,20 @@ function safeJsonText(value, max = 50000) {
   }
 }
 
-function ensurePrivateDir(dir) {
-  fs.mkdirSync(dir, { recursive: true, mode: 0o700 })
-  try {
-    fs.chmodSync(dir, 0o700)
-  } catch {
-    // Best effort on filesystems that do not support chmod.
-  }
+function secureWriteJson(file, payload) {
+  atomicReplacePrivateText(file, `${JSON.stringify(payload, null, 2)}\n`)
 }
 
-function secureWriteJson(file, payload) {
-  ensurePrivateDir(path.dirname(file))
-  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`
-  fs.writeFileSync(tmp, `${JSON.stringify(payload, null, 2)}\n`, { mode: 0o600 })
-  fs.renameSync(tmp, file)
+function readRegularJson(file) {
+  return JSON.parse(readRegularTextNoFollow(file))
+}
+
+function writeSnapshotProjectionWith(writer, file, payload) {
   try {
-    fs.chmodSync(file, 0o600)
-  } catch {
-    // Best effort on filesystems that do not support chmod.
+    writer(file, payload)
+    return []
+  } catch (error) {
+    return [{ code: 'proposal-snapshot-write-failed', message: `compatibility snapshot was not updated: ${error.message}` }]
   }
 }
 
@@ -61,15 +67,25 @@ function proposalId(seed = crypto.randomBytes(16).toString('hex')) {
   return `proposal-${crypto.createHash('sha256').update(seed).digest('hex').slice(0, 32)}`
 }
 
-export function actionIsCopyOnly(action) {
-  const value = String(action || '')
-  return Boolean(value) && !DIRECT_WRITE_ACTION_RE.test(value)
+export function validateCopyOnlyProposalAuthority(input = {}) {
+  const authority = input.authority && typeof input.authority === 'object' ? input.authority : {}
+  const capability = input.capability ?? authority.capability
+  const directWrite = input.directWrite ?? authority.directWrite
+  const applyEndpoint = input.applyEndpoint ?? authority.applyEndpoint
+  const issues = []
+  if (capability != null && capability !== COPY_ONLY_PROPOSAL_CAPABILITY) {
+    issues.push(`capability must be ${COPY_ONLY_PROPOSAL_CAPABILITY}`)
+  }
+  if (directWrite != null && directWrite !== false) issues.push('direct-write capability must be false')
+  if (applyEndpoint != null) issues.push('applyEndpoint must be null')
+  return issues.length ? { ok: false, status: 409, issues } : { ok: true, status: 200 }
 }
 
 export function copyOnlyActionSummary(action) {
   return {
     action: String(action || ''),
-    copyOnly: actionIsCopyOnly(action),
+    capability: COPY_ONLY_PROPOSAL_CAPABILITY,
+    copyOnly: true,
     directWrite: false,
     applyEndpoint: null,
   }
@@ -107,15 +123,24 @@ export function acceptedProposalCopy(record) {
 
 export function createProposalStore({
   workspaceRoot = process.cwd(),
-  proposalsDir = path.join(workspaceRoot, '.atelier-proposals'),
+  proposalsDir: requestedProposalsDir = path.join(workspaceRoot, '.atelier-proposals'),
   workspaceId = null,
+  snapshotWriter = secureWriteJson,
 } = {}) {
   const workspaceRootReal = fs.realpathSync(workspaceRoot)
-  ensurePrivateDir(proposalsDir)
+  const proposalsDir = ensureContainedPrivateDirectory({
+    workspaceRoot,
+    directory: requestedProposalsDir,
+    label: 'proposal state directory',
+  })
+  const eventLedger = createCollaborationEventLedger({
+    workspaceRoot,
+    ledgerPath: path.join(proposalsDir, 'events.ndjson'),
+  })
 
   function proposalPath(id) {
-    const clean = String(id || '').replace(/[^a-z0-9-]/gi, '')
-    if (!clean) throw new Error('proposal id is required')
+    const clean = String(id || '')
+    if (clean.length > 200 || !PROPOSAL_ID_PATTERN.test(clean)) throw new Error('proposal id is invalid')
     const file = path.join(proposalsDir, `${clean}.json`)
     const candidateDir = fs.realpathSync(proposalsDir)
     if (!pathContainedBy(workspaceRootReal, candidateDir)) {
@@ -124,47 +149,189 @@ export function createProposalStore({
     return file
   }
 
-  // Read is a lookup, not an assertion: an unusable id and an unreadable file
-  // are both "no such proposal", never a throw. Callers render 404 from null.
-  // listProposals() has always guarded its parse; this is the same contract.
-  function readProposal(id) {
+  function reduceProposal(state, event) {
+    if (event.type === 'proposal-created' || event.type === 'proposal-imported') {
+      return event.payload.record
+    }
+    if (event.type === 'proposal-reviewed' && state) {
+      if (event.payload.record) return event.payload.record
+      const next = {
+        ...state,
+        proposal: {
+          ...state.proposal,
+          status: event.payload.status,
+          updatedAt: event.at,
+          review: event.payload.review,
+          eventVersion: event.version,
+        },
+      }
+      if (event.payload.copyable) next.copyable = event.payload.copyable
+      else delete next.copyable
+      return next
+    }
+    return state
+  }
+
+  function reduceProposalEvents(id, events) {
+    if (events.length === 0) {
+      return { ok: false, status: 404, error: 'proposal not found', record: null }
+    }
+    let state = null
+    let previousVersion = 0
+    for (const event of events) {
+      if (state === null) {
+        if (event.version !== 1 || !['proposal-created', 'proposal-imported'].includes(event.type)) {
+          return { ok: false, status: 422, error: 'proposal ledger does not begin with a canonical record', record: null }
+        }
+        const record = event.payload?.record
+        if (
+          !isRecord(record) || record.schema !== ATELIER_PROPOSAL_SCHEMA ||
+          !isRecord(record.proposal) || record.proposal.id !== id ||
+          !['proposed', ...PROPOSAL_REVIEW_STATUSES].includes(record.proposal.status)
+        ) {
+          return { ok: false, status: 422, error: 'proposal ledger record is invalid', record: null }
+        }
+      } else {
+        const checkpoint = event.payload?.record
+        const checkpointValid = (
+          isRecord(checkpoint) && checkpoint.schema === ATELIER_PROPOSAL_SCHEMA &&
+          isRecord(checkpoint.proposal) && checkpoint.proposal.id === id &&
+          checkpoint.proposal.status === event.payload?.status &&
+          checkpoint.proposal.eventVersion === event.version
+        )
+        const hasCompactionGap = event.version > previousVersion + 1
+        if (
+          event.type !== 'proposal-reviewed' || !PROPOSAL_REVIEW_STATUSES.has(event.payload?.status) ||
+          !isRecord(event.payload?.review) ||
+          (checkpoint !== undefined && !checkpointValid) ||
+          (hasCompactionGap && !checkpointValid) ||
+          (!hasCompactionGap && !canTransitionProposal(state.proposal.status, event.payload.status))
+        ) {
+          return { ok: false, status: 422, error: 'proposal ledger review sequence is invalid', record: null }
+        }
+      }
+      state = reduceProposal(state, event)
+      previousVersion = event.version
+    }
+    return { ok: true, status: 200, record: state }
+  }
+
+  function materializedProposal(id) {
+    const result = eventLedger.eventsFor(id)
+    if (!result.ok) return { ...result, record: null }
+    return { ...result, ...reduceProposalEvents(id, result.events) }
+  }
+
+  function readCompatibilitySnapshot(id) {
     let file
     try {
       file = proposalPath(id)
     } catch {
-      return null
+      return { ok: false, status: 404, error: 'proposal not found', record: null }
     }
-    if (!fs.existsSync(file)) return null
+    if (!fs.existsSync(file)) return { ok: false, status: 404, error: 'proposal not found', record: null }
     try {
-      return JSON.parse(fs.readFileSync(file, 'utf8'))
-    } catch {
-      return null
+      const resolved = fs.realpathSync(file)
+      if (!pathContainedBy(fs.realpathSync(proposalsDir), resolved)) {
+        throw new Error('proposal snapshot escapes workspace')
+      }
+      const record = readRegularJson(file)
+      if (record?.proposal?.id !== id) throw new Error('proposal snapshot id does not match its filename')
+      return { ok: true, status: 200, record, source: 'compatibility-snapshot' }
+    } catch (error) {
+      return { ok: false, status: 422, error: `proposal snapshot cannot be read: ${error.message}`, record: null }
+    }
+  }
+
+  // Read is a lookup, not an assertion: an unusable id and an unreadable file
+  // are both "no such proposal", never a throw. New records materialize from
+  // the append-only ledger. Per-proposal JSON remains a compatibility snapshot.
+  function readProposal(id) {
+    if (String(id || '').length > 200 || !PROPOSAL_ID_PATTERN.test(String(id || ''))) {
+      return { ok: false, status: 404, error: 'proposal not found', record: null }
     }
+    const materialized = materializedProposal(id)
+    if (materialized.ok) {
+      if (materialized.record?.proposal?.id !== id) {
+        return { ok: false, status: 422, error: 'proposal ledger identity mismatch', record: null }
+      }
+      return materialized
+    }
+    if (materialized.status !== 404) return materialized
+    return readCompatibilitySnapshot(id)
   }
 
   function listProposals() {
-    if (!fs.existsSync(proposalsDir)) return []
-    return fs.readdirSync(proposalsDir)
-      .filter((name) => name.endsWith('.json'))
-      .sort(stableCompare)
-      .map((name) => {
-        try {
-          return JSON.parse(fs.readFileSync(path.join(proposalsDir, name), 'utf8'))
-        } catch {
-          return null
-        }
-      })
-      .filter(Boolean)
+    if (!fs.existsSync(proposalsDir)) return { ok: true, status: 200, proposals: [] }
+    const ledger = eventLedger.readAll()
+    if (!ledger.ok) return { ...ledger, proposals: [] }
+    const ledgerEvents = new Map()
+    for (const event of ledger.events) {
+      if (!PROPOSAL_ID_PATTERN.test(event.aggregateId)) {
+        return { ok: false, status: 422, error: 'proposal ledger contains an invalid identity', proposals: [] }
+      }
+      const events = ledgerEvents.get(event.aggregateId) ?? []
+      events.push(event)
+      ledgerEvents.set(event.aggregateId, events)
+    }
+    const ledgerRecords = new Map()
+    for (const [id, events] of ledgerEvents) {
+      const reduced = reduceProposalEvents(id, events)
+      if (!reduced.ok) return { ...reduced, proposals: [] }
+      ledgerRecords.set(id, reduced.record)
+    }
+    const ledgerIds = [...ledgerRecords.keys()]
+    const snapshotEntries = fs.readdirSync(proposalsDir, { withFileTypes: true })
+      .filter((entry) => entry.name.endsWith('.json'))
+    const unsafeSnapshot = snapshotEntries.find((entry) => !entry.isFile())
+    if (unsafeSnapshot) {
+      return { ok: false, status: 422, error: 'proposal snapshot cannot be read: state leaf is not a regular file', proposals: [] }
+    }
+    const snapshotIds = snapshotEntries.map((entry) => entry.name.slice(0, -'.json'.length))
+    const readIds = [...new Set([...ledgerIds, ...snapshotIds])].sort(stableCompare)
+    const reads = readIds.map((id) => {
+      const record = ledgerRecords.get(id)
+      if (record) return { ok: true, status: 200, record, source: 'event-ledger' }
+      return readCompatibilitySnapshot(id)
+    })
+    const failed = reads.find((result) => !result.ok)
+    if (failed) return { ...failed, proposals: [] }
+    if (reads.some((result, index) => result.record?.proposal?.id !== readIds[index])) {
+      return { ok: false, status: 422, error: 'proposal identity does not match its state key', proposals: [] }
+    }
+    const proposals = reads
+      .map((result) => result.record)
       .sort((left, right) => stableCompare(right.proposal?.updatedAt || '', left.proposal?.updatedAt || ''))
+    return { ok: true, status: 200, proposals, diagnostics: ledger.diagnostics, stats: ledger.stats }
+  }
+
+  function ensureLedgerSeed(id, record) {
+    const existing = eventLedger.eventsFor(id)
+    if (!existing.ok) return existing
+    if (existing.events.length > 0) return { ok: true, version: existing.currentVersion }
+    const seeded = eventLedger.append({
+      aggregateId: id,
+      expectedVersion: 0,
+      type: 'proposal-imported',
+      actor: 'atelier compatibility importer',
+      at: record.proposal?.createdAt || nowIso(),
+      payload: { record },
+    })
+    if (!seeded.ok) return seeded
+    return { ok: true, version: seeded.event.version }
   }
 
   function createProposal(body = {}) {
     const action = cleanIdentity(body.action || body.proposal?.action || 'copy.repoPath', 120)
-    if (!actionIsCopyOnly(action)) {
+    const authority = validateCopyOnlyProposalAuthority({
+      ...(body.proposal && typeof body.proposal === 'object' ? body.proposal : {}),
+      ...body,
+    })
+    if (!authority.ok) {
       return {
         ok: false,
-        status: 409,
-        error: 'direct-write proposal action refused',
+        status: authority.status,
+        error: `proposal authority refused: ${authority.issues.join('; ')}`,
       }
     }
 
@@ -196,19 +363,30 @@ export function createProposalStore({
           ignored: true,
         },
         authority: copyOnlyActionSummary(action),
+        eventVersion: 1,
       },
       diff: safeJsonText(body.diff || body.proposal?.diff || ''),
       payload: body.proposal && typeof body.proposal === 'object' ? body.proposal : {},
     }
-    secureWriteJson(proposalPath(id), record)
-    return { ok: true, status: 200, record }
+    const appended = eventLedger.append({
+      aggregateId: id,
+      expectedVersion: 0,
+      type: 'proposal-created',
+      actor: cleanIdentity(body.actor || body.proposal?.createdBy || 'local contributor', 160),
+      at: createdAt,
+      payload: { record },
+    })
+    if (!appended.ok) {
+      return { ok: false, status: appended.status, error: appended.error }
+    }
+    const diagnostics = writeSnapshotProjectionWith(snapshotWriter, proposalPath(id), record)
+    return { ok: true, status: 200, record, diagnostics }
   }
 
   function reviewProposal(id, body = {}) {
-    const record = readProposal(id)
-    if (!record) {
-      return { ok: false, status: 404, error: 'proposal not found' }
-    }
+    const read = readProposal(id)
+    if (!read.ok) return read
+    const record = read.record
     if (body.proposalId && body.proposalId !== id) {
       return { ok: false, status: 409, error: 'ambiguous proposal review refused' }
     }
@@ -232,27 +410,49 @@ export function createProposalStore({
     }
 
     const updatedAt = nowIso()
-    record.proposal = {
+    const review = {
+      reviewer: cleanIdentity(body.reviewer || 'unknown reviewer', 160),
+      notes: cleanIdentity(body.notes, 2000),
+      reviewedAt: updatedAt,
+    }
+    const nextProposal = {
       ...record.proposal,
       status: nextStatus,
       updatedAt,
-      review: {
-        reviewer: cleanIdentity(body.reviewer || 'unknown reviewer', 160),
-        notes: cleanIdentity(body.notes, 2000),
-        reviewedAt: updatedAt,
-      },
+      review,
     }
+    const nextRecord = { ...record, proposal: nextProposal }
     if (nextStatus === 'accepted') {
-      record.copyable = acceptedProposalCopy(record)
+      nextRecord.copyable = acceptedProposalCopy(nextRecord)
     } else {
-      delete record.copyable
+      delete nextRecord.copyable
+    }
+    const seeded = ensureLedgerSeed(id, record)
+    if (!seeded.ok) return seeded
+    nextRecord.proposal.eventVersion = seeded.version + 1
+    const appended = eventLedger.append({
+      aggregateId: id,
+      expectedVersion: seeded.version,
+      type: 'proposal-reviewed',
+      actor: review.reviewer,
+      at: updatedAt,
+      payload: {
+        status: nextStatus,
+        review,
+        record: nextRecord,
+        ...(nextRecord.copyable ? { copyable: nextRecord.copyable } : {}),
+      },
+    })
+    if (!appended.ok) {
+      return { ok: false, status: appended.status, error: appended.error }
     }
-    secureWriteJson(proposalPath(id), record)
-    return { ok: true, status: 200, record }
+    const diagnostics = writeSnapshotProjectionWith(snapshotWriter, proposalPath(id), nextRecord)
+    return { ok: true, status: 200, record: nextRecord, diagnostics }
   }
 
   return {
     proposalsDir,
+    eventLedger,
     proposalPath,
     readProposal,
     listProposals,

package/src/commands/attestation.mjs

@@ -37,7 +37,7 @@ Subcommands:
 
   keygen --key-id ID [--algorithm ed25519|es256] [--out FILE]
       Generate a signing key pair. Writes the private key file (default
-      ${LOCAL_KEY_FILE}, mode 0600, refuses to overwrite)
+      ${LOCAL_KEY_FILE}, mode 0600 on POSIX, refuses to overwrite)
       and prints only the public key document.
 
 Exit codes: 0 success or valid, 1 verify judged the attestation invalid,
@@ -162,11 +162,24 @@ function runKeygen(argv) {
     fail(`--algorithm must be ed25519 or es256, got ${algorithm}`)
   }
   const outPath = path.resolve(options.out ?? LOCAL_KEY_FILE)
+  // On Windows, O_EXCL alone can still follow a planted dangling symlink.
+  // lstat examines the directory entry itself, so refuse every existing entry
+  // (including a dangling link) before the exclusive create. The subsequent
+  // 'wx' retains the atomic no-overwrite guarantee for ordinary files created
+  // after this check.
+  try {
+    fs.lstatSync(outPath)
+    fail(`refusing to write signing key file: path already exists or is a symlink: ${outPath}`)
+  } catch (error) {
+    if (error?.code !== 'ENOENT') {
+      if (error?.code === undefined) throw error
+      fail(`cannot inspect signing key file path: ${outPath}`)
+    }
+  }
   const { privateKeyDoc, publicKeyDoc } = generateKeyPair({ algorithm, keyId })
-  // Atomic create-exclusive ('wx' = O_CREAT|O_EXCL, mode 0600): fails on any
-  // existing path AND on symlinks — including dangling ones — so a planted
-  // link can never redirect the private key to an attacker-chosen path, and
-  // there is no check-then-write race window. Error output stays path-only.
+  // Atomic create-exclusive ('wx' = O_CREAT|O_EXCL, mode 0600 on POSIX): an
+  // ordinary competing create cannot overwrite the destination. Error output
+  // stays path-only.
   let fd = null
   try {
     fd = fs.openSync(outPath, 'wx', 0o600)
@@ -181,7 +194,8 @@ function runKeygen(argv) {
   } finally {
     fs.closeSync(fd)
   }
-  console.error(`signing key file written to ${outPath} (mode 0600). Keep it out of version control; ${LOCAL_KEY_FILE} is gitignored by default.`)
+  const permissions = process.platform === 'win32' ? 'containing-directory Windows ACLs inherited' : 'mode 0600'
+  console.error(`signing key file written to ${outPath} (${permissions}). Keep it out of version control; ${LOCAL_KEY_FILE} is gitignored by default.`)
   console.log(JSON.stringify(publicKeyDoc, null, 2))
 }
 

package/src/commands/disclosure.mjs

@@ -0,0 +1,133 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import {
+  compileDisclosurePatterns,
+  isPathIgnored,
+  isPathTracked,
+  scanDisclosureContent,
+} from '../disclosure/content-scan.mjs'
+
+export function runDisclosureCommand(argv = process.argv.slice(2), { env = process.env, stdout = console.log, stderr = console.error } = {}) {
+  let root = process.cwd()
+  let staged = false
+  let structuralOnly = false
+  let untrusted = false
+  let failOnBinary = false
+  let denylistPath = null
+
+  try {
+    for (let index = 0; index < argv.length; index += 1) {
+      const arg = argv[index]
+      if (arg === 'check') continue
+      if (arg === '--root') {
+        root = requiredValue(argv, ++index, '--root')
+      } else if (arg === '--denylist') {
+        denylistPath = requiredValue(argv, ++index, '--denylist')
+      } else if (arg === '--staged') {
+        staged = true
+      } else if (arg === '--structural-only') {
+        structuralOnly = true
+      } else if (arg === '--untrusted') {
+        untrusted = true
+      } else if (arg === '--fail-on-binary') {
+        failOnBinary = true
+      } else {
+        return usageError(stderr, `unknown argument: ${arg}`)
+      }
+    }
+  } catch (error) {
+    return usageError(stderr, error.message)
+  }
+
+  const resolvedRoot = path.resolve(root)
+  let denylistPatterns = []
+  if (!structuralOnly) {
+    const denylist = loadDenylist({ root: resolvedRoot, denylistPath, env, stderr })
+    if (!denylist.ok) return 2
+    try {
+      denylistPatterns = compileDisclosurePatterns(denylist.document.patterns)
+    } catch (error) {
+      stderr(`[disclosure:check] ${error.message}`)
+      return 2
+    }
+  }
+
+  let report
+  try {
+    report = scanDisclosureContent({
+      root: resolvedRoot,
+      staged,
+      denylistPatterns,
+      failOnBinary,
+    })
+  } catch (error) {
+    stderr(`[disclosure:check] ${error.message}`)
+    return 2
+  }
+
+  if (!report.ok) {
+    if (untrusted) {
+      stderr('[disclosure:check] findings present (details suppressed: untrusted tree)')
+    } else {
+      for (const finding of report.findings) {
+        const location = finding.line === null ? finding.path : `${finding.path}:${finding.line}`
+        stderr(`[disclosure:check] ${finding.label}: ${location}`)
+      }
+      stderr(`[disclosure:check] ${report.findings.length} finding(s)`)
+    }
+    return 1
+  }
+
+  const binaryNote = report.skippedBinary.length > 0
+    ? `; ${report.skippedBinary.length} binary file(s) skipped${failOnBinary ? '' : ' (use --fail-on-binary for public text-only surfaces)'}`
+    : ''
+  stdout(`[disclosure:check] clean: ${report.scannedFiles} ${staged ? 'staged' : 'tracked'} text file(s)${binaryNote}`)
+  return 0
+}
+
+function loadDenylist({ root, denylistPath, env, stderr }) {
+  if (env.ATELIER_DENYLIST_JSON) {
+    try {
+      return { ok: true, document: JSON.parse(env.ATELIER_DENYLIST_JSON) }
+    } catch {
+      stderr('[disclosure:check] ATELIER_DENYLIST_JSON is not valid JSON')
+      return { ok: false }
+    }
+  }
+
+  const candidate = path.resolve(root, denylistPath ?? '.atelier-local/disclosure-denylist.json')
+  if (!fs.existsSync(candidate)) {
+    stderr('[disclosure:check] private denylist unavailable; provide ATELIER_DENYLIST_JSON, --denylist FILE, or pass --structural-only explicitly')
+    return { ok: false }
+  }
+  if (isPathTracked(root, candidate)) {
+    stderr('[disclosure:check] refusing a Git-tracked private denylist')
+    return { ok: false }
+  }
+  if (path.resolve(candidate).startsWith(`${path.resolve(root)}${path.sep}`) && !isPathIgnored(root, candidate)) {
+    stderr('[disclosure:check] a repository-local private denylist must be covered by .gitignore')
+    return { ok: false }
+  }
+
+  try {
+    return { ok: true, document: JSON.parse(fs.readFileSync(candidate, 'utf8')) }
+  } catch {
+    stderr('[disclosure:check] private denylist is not valid JSON')
+    return { ok: false }
+  }
+}
+
+function requiredValue(argv, index, flag) {
+  if (!argv[index]) throw new Error(`${flag} requires a value`)
+  return argv[index]
+}
+
+function usageError(stderr, message) {
+  stderr(`[disclosure:check] ${message}`)
+  return 2
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  process.exitCode = runDisclosureCommand()
+}

package/src/commands/distribution.mjs

@@ -22,7 +22,8 @@ const logError = (message) => console.error(`${PREFIX} ${message}`)
 
 // Paths in output stay relative to the checked distribution so logs never
 // leak machine-local absolute paths.
-const displayPath = (target, file) => path.relative(target, file) || path.basename(file)
+const portablePath = (file) => file.split(path.sep).join('/')
+const displayPath = (target, file) => portablePath(path.relative(target, file) || path.basename(file))
 
 function checkReadmeAttribution(target) {
   const readmePath = path.join(target, 'README.md')

package/src/commands/extension-pack.mjs

@@ -86,6 +86,7 @@ function declaredEntries(project) {
 }
 
 const LOCK_MISMATCH_PATTERN = /^lock (version|digest) mismatch/
+const portablePath = (file) => file.split(path.sep).join('/')
 
 // One row per declared entry, in declaration order, joining the loader report
 // back onto the declaration. Loader messages without a usable packId (project-
@@ -107,7 +108,7 @@ function buildRows(project, result) {
     // (same rationale as distribution.mjs) so neither text nor --json output
     // ever leaks machine-local absolute paths.
     const resolvedPath = record?.path ?? (declaredPath ? path.resolve(project.configDir, declaredPath) : null)
-    const displayPath = resolvedPath ? path.relative(project.configDir, resolvedPath) || '.' : null
+    const displayPath = resolvedPath ? portablePath(path.relative(project.configDir, resolvedPath) || '.') : null
     return {
       id: label,
       status,

package/src/commands/init.mjs

@@ -3,9 +3,10 @@ import { spawnSync } from 'node:child_process'
 import fs from 'node:fs'
 import path from 'node:path'
 import { parseArgs, resolveProjectConfig, writeJson } from '../project/config.mjs'
+import { packageRootFrom } from '../project/package-root.mjs'
 import { writeAtelierLock } from '../upgrade/upgrade.mjs'
 
-const packageRoot = path.resolve(new URL('../..', import.meta.url).pathname)
+const packageRoot = packageRootFrom(import.meta.url)
 
 function slug(value) {
   return String(value || '')

package/src/commands/server.mjs

@@ -1,6 +1,3 @@
 #!/usr/bin/env node
 import { runServerCommand } from '../server/server.mjs'
-runServerCommand().catch((error) => {
-  console.error(error.message)
-  process.exit(1)
-})
+await runServerCommand()