@mnstry/atelier 0.2.0-alpha.1 → 0.2.0-alpha.10

package/src/vault/service.mjs

@@ -0,0 +1,131 @@
+import { verifyVaultPrivacy, createVaultContext } from './privacy.mjs'
+import { renderVaultHome, vaultHomePolicy } from './interface.mjs'
+/** Optional hosted artifact service. No default network, storage, or identity provider. */
+const TYPES = Object.freeze({ html: 'text/html; charset=utf-8', css: 'text/css; charset=utf-8', txt: 'text/plain; charset=utf-8', png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', webp: 'image/webp', pdf: 'application/pdf' })
+const LIMIT = 4 * 1024 * 1024
+const encoder = new TextEncoder()
+const validId = value => typeof value === 'string' && /^[a-z][a-z0-9-]{0,62}$/.test(value)
+const validPath = value => typeof value === 'string' && value.length <= 512 && value.split('/').every(p => /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(p) && p !== '.' && p !== '..')
+const validExt = value => value === undefined || (value !== null && typeof value === 'object' && !Array.isArray(value))
+const sameOwner = (a, b) => a && b && typeof a.issuer === 'string' && a.issuer.length > 0 && typeof a.subject === 'string' && a.subject.length > 0 && a.issuer === b.issuer && a.subject === b.subject
+const headers = {
+  'Cache-Control': 'private, no-store',
+  'Content-Security-Policy': "sandbox; default-src 'none'; img-src 'self'; style-src 'self' 'unsafe-inline'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'",
+  'X-Content-Type-Options': 'nosniff',
+  'Referrer-Policy': 'no-referrer',
+  'X-Robots-Tag': 'noindex, nofollow',
+}
+export async function digest(bytes) {
+  return Array.from(new Uint8Array(await crypto.subtle.digest('SHA-256', bytes)), b => b.toString(16).padStart(2, '0')).join('')
+}
+function reply(status, text = '', extra = {}) { return new Response(text, { status, headers: { ...headers, 'Content-Type': 'text/plain; charset=utf-8', ...extra } }) }
+async function boundedBody(request) {
+  if (!request.body) throw new Error('invalid')
+  const reader = request.body.getReader()
+  let size = 0
+  const chunks = []
+  try {
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      size += value.byteLength
+      if (size > LIMIT) { await reader.cancel(); throw new Error('too-large') }
+      chunks.push(value)
+    }
+  } finally { reader.releaseLock() }
+  const bytes = new Uint8Array(size)
+  let offset = 0
+  for (const chunk of chunks) { bytes.set(chunk, offset); offset += chunk.length }
+  return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes))
+}
+export async function preparePublication(input) {
+  if (!input || input.schema !== 'atelier-vault-publication/v1' || (input.contractVersion !== undefined && (typeof input.contractVersion !== 'string' || !/^1\.[0-9]+\.[0-9]+$/.test(input.contractVersion))) || !validExt(input.ext) || !Number.isSafeInteger(input.expectedRevision) || input.expectedRevision < 0 || input.expectedRevision >= Number.MAX_SAFE_INTEGER || Object.keys(input).some(key => !['schema', 'contractVersion', 'expectedRevision', 'files', 'ext'].includes(key)) || !Array.isArray(input.files) || !input.files.length || input.files.length > 100) throw new Error('invalid')
+  if (encoder.encode(JSON.stringify(input)).length > LIMIT) throw new Error('too-large')
+  const seen = new Set()
+  const files = []
+  let total = 0
+  for (const file of input.files) {
+    if (!file || !validExt(file.ext) || Object.keys(file).some(key => !['path', 'base64', 'ext'].includes(key)) || !validPath(file.path) || seen.has(file.path) || typeof file.base64 !== 'string' || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(file.base64)) throw new Error('invalid')
+    const type = TYPES[file.path.split('.').at(-1)]
+    if (typeof type !== 'string') throw new Error('invalid')
+    seen.add(file.path)
+    const bytes = Uint8Array.from(atob(file.base64), c => c.charCodeAt(0))
+    total += bytes.length
+    if (total > LIMIT) throw new Error('too-large')
+    files.push({ path: file.path, type, size: bytes.length, sha256: await digest(bytes), bytes })
+  }
+  files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0)
+  const manifest = files.map(({ bytes, ...record }) => record)
+  return { files, manifest, publication: await digest(encoder.encode(JSON.stringify(manifest))) }
+}
+/**
+ * identity.read(request) -> verified {issuer,subject}, or null (revocation checked).
+ * identity.publish(request,vault) -> verified owner identity, or null; MUST use
+ * a revocable vault-scoped machine credential, never browser cookies.
+ * metadata.get(vault) -> {owner, revision, manifest}, or null.
+ * metadata.commit(vault,{owner,expectedRevision,manifest,publication}) -> boolean;
+ * MUST atomically compare both owner and revision before replacing manifest.
+ * storage.get/put accepts service-generated keys only and uses private storage.
+ */
+export function createVaultService({ identity, metadata, storage, privacy, deployment }) {
+  for (const [object, methods] of [[identity, ['read', 'publish']], [metadata, ['get', 'commit']], [storage, ['get', 'put']]]) {
+    if (!object || methods.some(method => typeof object[method] !== 'function')) throw new TypeError('Incomplete vault adapter')
+  }
+  return async function handle(request) {
+    try {
+      const url = new URL(request.url)
+      if (/%|\\/.test(url.pathname)) return reply(400)
+      const parts = url.pathname.slice(1).split('/')
+      const publishing = parts[0] === '_publish'
+      const vault = publishing ? parts[1] : parts[0]
+      if (!validId(vault)) return reply(404)
+      const home = !publishing && (parts.length === 1 || (parts.length === 2 && parts[1] === ''))
+      if (url.search && (publishing || (home && ( [...url.searchParams.keys()].some(key => key !== 'q') || url.searchParams.getAll('q').length > 1 || (url.searchParams.get('q') || '').length > 200)))) return reply(400)
+      if (publishing) {
+        if (parts.length !== 2 || !['GET', 'POST'].includes(request.method)) return reply(405, '', { Allow: 'GET, POST' })
+        // Browser-originated writes are not a machine publication channel.
+        if (request.headers.has('origin') || request.headers.has('cookie')) return reply(403)
+        const principal = await identity.publish(request, vault)
+        if (!principal) return reply(401, '', { 'WWW-Authenticate': 'Bearer realm="vault-publication"' })
+        const record = await metadata.get(vault)
+        if (!sameOwner(principal, record?.owner)) return reply(404)
+        if (request.method === 'GET') {
+          return new Response(JSON.stringify({ schema: 'atelier-vault-status/v1', vault, revision: record.revision, publication: record.publication ?? null }), { headers: { ...headers, 'Content-Type': 'application/json' } })
+        }
+        if (request.headers.get('content-type')?.split(';')[0].trim().toLowerCase() !== 'application/json') return reply(415)
+        let input, prepared
+        try { input = await boundedBody(request); prepared = await preparePublication(input) }
+        catch (error) { return reply(error.message === 'too-large' ? 413 : 400) }
+        if (input.expectedRevision !== record.revision) return reply(409)
+        const context = createVaultContext({ vault, record: { owner: record.owner, publication: prepared.publication, revision: input.expectedRevision + 1, manifest: prepared.manifest }, deployment, request: { origin: url.origin, path: url.pathname } })
+        const before = await verifyVaultPrivacy(privacy, { ...context, phase: 'before-upload' })
+        if (before.status !== 'verified') return reply(503, before.reason)
+        for (const file of prepared.files) await storage.put(`${vault}/${file.sha256}`, file.bytes)
+        const after = await verifyVaultPrivacy(privacy, { ...context, phase: 'before-activation' })
+        if (after.status !== 'verified' || after.policyRevision !== before.policyRevision) return reply(503, 'Protection changed or could not be verified. Publication was not activated.')
+        // Revalidate the credential after uploads and activation checks, immediately before commit.
+        const current = await identity.publish(request, vault)
+        if (!sameOwner(principal, current)) return reply(401, '', { 'WWW-Authenticate': 'Bearer realm="vault-publication"' })
+        const committed = await metadata.commit(vault, { owner: principal, expectedRevision: input.expectedRevision, manifest: prepared.manifest, publication: prepared.publication })
+        if (!committed) return reply(409)
+        return new Response(JSON.stringify({ schema: 'atelier-vault-receipt/v1', vault, revision: input.expectedRevision + 1, publication: prepared.publication }), { status: 201, headers: { ...headers, 'Content-Type': 'application/json' } })
+      }
+      if (!['GET', 'HEAD'].includes(request.method)) return reply(405, '', { Allow: 'GET, HEAD' })
+      const principal = await identity.read(request)
+      if (!principal) return reply(401)
+      const record = await metadata.get(vault)
+      if (!sameOwner(principal, record?.owner)) return reply(404)
+      if (!home && !record.manifest.some(file => file.path === parts.slice(1).join('/'))) return reply(404)
+      const protection = await verifyVaultPrivacy(privacy, createVaultContext({ vault, record, deployment, request: { origin: url.origin, path: url.pathname } }))
+      if (home) return new Response(request.method === 'HEAD' ? null : renderVaultHome({ vault, revision: record.revision, manifest: record.manifest, privacy: protection, query: url.searchParams.get('q') || '' }), { headers: { ...headers, 'Content-Type': 'text/html; charset=utf-8', 'Content-Security-Policy': vaultHomePolicy } })
+      if (protection.status !== 'verified') return reply(503, protection.reason)
+      const path = parts.slice(1).join('/')
+      if (!validPath(path)) return reply(404)
+      const file = record.manifest.find(entry => entry.path === path)
+      if (!file || !/^[a-f0-9]{64}$/.test(file.sha256) || !Object.values(TYPES).includes(file.type)) return reply(404)
+      const bytes = await storage.get(`${vault}/${file.sha256}`)
+      if (!bytes || bytes.length !== file.size || await digest(bytes) !== file.sha256) return reply(503)
+      return new Response(request.method === 'HEAD' ? null : bytes, { headers: { ...headers, 'Content-Type': file.type, 'Content-Length': String(bytes.length), ...(file.type === 'application/pdf' ? { 'Content-Disposition': 'attachment' } : {}) } })
+    } catch { return reply(503) }
+  }
+}

package/src/vault/source.mjs

@@ -0,0 +1,45 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { preparePublication } from './service.mjs'
+const LIMIT = 4 * 1024 * 1024
+/** Node-only bundle preparation. Select paths explicitly; never scan a repo. */
+export async function prepareVaultSource({ root, paths, expectedRevision }) {
+  if (typeof root !== 'string' || !path.isAbsolute(root) || !Array.isArray(paths) || !paths.length || paths.length > 100) throw new TypeError('Absolute artifact root and explicit paths required')
+  if (fs.lstatSync(root).isSymbolicLink()) throw new Error('Artifact root must not be a symlink')
+  const realRoot = fs.realpathSync(root)
+  if (!fs.statSync(realRoot).isDirectory()) throw new Error('Artifact root must be a directory')
+  let total = 0
+  const files = []
+  for (const name of paths) {
+    if (typeof name !== 'string' || name.length > 512 || !name.split('/').every(part => /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(part))) throw new Error('Invalid selected artifact path')
+    let file = realRoot
+    for (const part of name.split('/')) {
+      file = path.join(file, part)
+      if (fs.lstatSync(file).isSymbolicLink()) throw new Error('Selected artifacts must not traverse symlinks')
+    }
+    const before = fs.lstatSync(file)
+    if (!before.isFile() || before.nlink !== 1 || before.size > LIMIT) throw new Error('Selected artifact must be a bounded, unlinked regular file')
+    const fd = fs.openSync(file, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0))
+    try {
+      const opened = fs.fstatSync(fd)
+      const resolved = fs.realpathSync(file)
+      if ((path.relative(realRoot, resolved).startsWith('..' + path.sep) || path.isAbsolute(path.relative(realRoot, resolved))) || opened.ino !== before.ino || opened.dev !== before.dev || !opened.isFile() || opened.nlink !== 1 || opened.size > LIMIT) throw new Error('Artifact changed during selection')
+      const data = Buffer.alloc(opened.size)
+      let offset = 0
+      while (offset < data.length) {
+        const count = fs.readSync(fd, data, offset, data.length - offset, offset)
+        if (!count) throw new Error('Artifact changed during read')
+        offset += count
+      }
+      const after = fs.fstatSync(fd)
+      const current = fs.lstatSync(file)
+      if (after.nlink !== 1 || current.nlink !== 1 || after.size !== opened.size || after.mtimeMs !== opened.mtimeMs || after.ctimeMs !== opened.ctimeMs || current.ino !== opened.ino || current.dev !== opened.dev || fs.realpathSync(file) !== resolved) throw new Error('Artifact changed during read')
+      total += data.length
+      if (total > LIMIT) throw new Error('Artifact bundle too large')
+      files.push({ path: name, base64: data.toString('base64') })
+    } finally { fs.closeSync(fd) }
+  }
+  const request = { schema: 'atelier-vault-publication/v1', contractVersion: '1.0.0', expectedRevision, files }
+  const prepared = await preparePublication(request)
+  return { request, publication: prepared.publication, manifest: prepared.manifest }
+}

package/src/vault/storage.mjs

@@ -0,0 +1,23 @@
+/** Provider SDKs/bindings are explicitly supplied by the host, never auto-loaded. */
+export function r2PrivateStorage(bucket) {
+  return {
+    async put(key, bytes) { await bucket.put(key, bytes) },
+    async get(key) {
+      const object = await bucket.get(key)
+      return object ? new Uint8Array(await object.arrayBuffer()) : null
+    },
+  }
+}
+export function vercelPrivateStorage(blob) {
+  return {
+    async put(key, bytes) {
+      await blob.put(key, bytes, { access: 'private', addRandomSuffix: false, allowOverwrite: true, contentType: 'application/octet-stream' })
+    },
+    async get(key) {
+      const object = await blob.get(key, { access: 'private', useCache: false })
+      if (!object) return null
+      if (object.statusCode !== 200 || !object.stream) throw new Error('Private storage unavailable')
+      return new Uint8Array(await new Response(object.stream).arrayBuffer())
+    },
+  }
+}

package/templates/distribution-workspace/.claude/launch.json

@@ -3,8 +3,12 @@
   "configurations": [
     {
       "name": "atelier",
-      "runtimeExecutable": "npx",
-      "runtimeArgs": ["atelier", "server"],
+      "runtimeExecutable": "node",
+      "runtimeArgs": [
+        "--input-type=module",
+        "--eval",
+        "import { runCli } from '@mnstry/atelier/cli'; process.exit(await runCli({ argv: ['server', ...process.argv.slice(1)] }));"
+      ],
       "port": 8137,
       "autoPort": true
     }

package/templates/distribution-workspace/gitignore

@@ -1,4 +1,5 @@
 .atelier-local/
+.atelier-local/obsidian.json
 atelier.local.json
 atelier.workspace.local.json
 atelier-attestation-key.local.json

package/templates/distribution-workspace/project/README.md

@@ -2,10 +2,10 @@
 title: "Shared Project Seed"
 kg:
   id: "project-alpha:seed"
-  type: "project-note"
+  type: "document"
   domain: "project"
   lifecycle: "draft"
-  status: "seed"
+  status: "draft"
   audience: "team"
   relations: []
 ---

package/templates/external-project-workspace/README.md

@@ -0,0 +1,45 @@
+# External-project adapter starter
+
+This invented example uses MNSTRY Atelier. The adapter owns configuration and
+a sample extension pack; the separate source repository owns canonical text.
+Runs, answers and review history remain ignored local state. Public audience
+labels do not grant publication, consent or runtime access.
+
+Create this scaffold with `atelier init --template external-project --target DIR`.
+The target must not exist. No Git repository, hook or remote is created.
+Initialize the adapter and its source directory as separate repositories when
+ready; the adapter ignores `source/`. To connect an existing repository instead,
+pass `--repo-path source=PATH` consistently, or use an ignored local overlay.
+Keep domain vocabulary and methods in your own adapter and source repositories.
+Replace the synthetic actor in the boundary policy with your actual policy.
+
+Using the installed package's CLI, from the adapter directory:
+
+```sh
+atelier lock provenance
+atelier config check --explain
+atelier extension-pack validate
+atelier graph
+atelier project
+atelier readiness
+atelier review packs
+atelier review run sample.readiness:contract-gate --answers answers.example.json
+atelier dev --review
+```
+
+Open `/review` on the displayed local address. Use repository `source` and
+`README.md` to leave a question. Use the returned run ID to review its claims.
+The evaluator measures answer completeness only. Read and judge the evidence;
+acceptance creates a handoff, never a canonical edit. Use `atelier review history`
+and `atelier review handoff REQUEST_ID` to inspect records locally.
+
+Real answers and responses belong in ignored local state, not the tracked
+example answer file. Reopening recovers saved contributions; missing or failed
+saves remain visible. Stop/start the foreground sidecar with the same project
+and reopen the same document. This does not establish cross-computer access.
+
+For CI, compose the root's existing consumer, portability, boundary and
+private-disclosure checks. No new CI run or provider is triggered by this template.
+Before changing the pack, run `atelier upgrade --dry-run`, retain historical
+pack content, update its lifecycle declaration and lock through your reviewed
+migration process, and run the checks again. Never reinterpret old run evidence.

package/templates/external-project-workspace/answers.example.json

@@ -0,0 +1,4 @@
+{
+  "scope.name": "Sample observation",
+  "scope.sourceRef": "sample-source:observation"
+}

package/templates/external-project-workspace/atelier.project.json

@@ -0,0 +1,40 @@
+{
+  "schema": "mnstry.atelier-project-config@v1",
+  "name": "sample-adapter",
+  "roots": {
+    "workspace": ".",
+    "repoOps": "."
+  },
+  "graph": {
+    "repoAccessPath": "repo-access.v1.json",
+    "outputPath": "atelier-output/knowledge.graph.json"
+  },
+  "projection": {
+    "outputRoot": "atelier-output",
+    "readinessPath": "atelier-output/atelier-readiness.json"
+  },
+  "boundaries": {
+    "policyPath": "boundary-policy.v1.json",
+    "strictNewRepos": true
+  },
+  "repos": [
+    {
+      "name": "source",
+      "path": "source",
+      "readBoundary": "private"
+    }
+  ],
+  "ext": {
+    "mnstry.atelier": {
+      "extensionPacks": [
+        {
+          "id": "sample.readiness",
+          "version": "v1",
+          "path": "packs/sample-pack.v1.json",
+          "enabled": true
+        }
+      ],
+      "extensionPackLifecycle": "pack-lifecycle.json"
+    }
+  }
+}

package/templates/external-project-workspace/boundary-policy.v1.json

@@ -0,0 +1,60 @@
+{
+  "schema": "mnstry.atelier-boundary-policy@v1",
+  "mode": "strict",
+  "actors": {
+    "sample-author": {
+      "githubLogin": "sample-author",
+      "gitEmails": [
+        "sample@example.invalid"
+      ],
+      "privateDomainRepo": "source"
+    }
+  },
+  "repos": {
+    "source": {
+      "kind": "private_domain",
+      "ownerActor": "sample-author",
+      "readBoundary": "private",
+      "allowedAudiences": [
+        "private"
+      ],
+      "forbiddenAudiences": [
+        "public"
+      ],
+      "autoCommit": "guarded"
+    }
+  },
+  "forbiddenPaths": [
+    ".atelier-local/**",
+    "atelier.local.json",
+    "atelier.workspace.local.json",
+    ".mnstry-local/**",
+    ".atelier-proposals/**",
+    ".atelier-current",
+    ".atelier-current.json",
+    ".atelier-presence.json",
+    ".atelier-nonce",
+    ".atelier-capability-grants.json",
+    ".atelier-grants/**",
+    ".atelier-events.jsonl",
+    ".atelier-audit.jsonl",
+    ".atelier-audit/**",
+    ".atelier-session.json",
+    ".atelier-session.jsonl",
+    ".atelier-session/**",
+    ".atelier-sessions/**",
+    ".atelier-support/**",
+    ".atelier-support.json",
+    "support-bundle*",
+    "support-bundles/**",
+    "prompts/**",
+    "transcripts/**",
+    "node_modules/**",
+    ".DS_Store"
+  ],
+  "promotion": {
+    "requiresGitPromote": true,
+    "recordsPath": "governance/git-promote-events.jsonl"
+  },
+  "governanceLedgerPath": "governance/repo-boundary-ledger.md"
+}

package/templates/external-project-workspace/gitignore

@@ -0,0 +1,8 @@
+node_modules/
+.atelier-local/
+.atelier-local/obsidian.json
+atelier-output/
+atelier.local.json
+atelier.workspace.local.json
+source/
+.claude/

package/templates/external-project-workspace/pack-lifecycle.json

@@ -0,0 +1,14 @@
+{
+  "schema": "atelier-pack-lifecycle@v1",
+  "packs": [
+    {
+      "id": "sample.readiness",
+      "version": "v1",
+      "digest": "sha256:0eff795765e0bbd4c2510acda2e492201c23bc870df6c354eef623484643ab11",
+      "compatibleRootVersions": [
+        "0.2.0-alpha.10"
+      ],
+      "status": "active"
+    }
+  ]
+}

package/templates/external-project-workspace/packs/protocols/contract-gate.v1.json

@@ -0,0 +1,109 @@
+{
+  "schema": "atelier-readiness-protocol@v1",
+  "id": "sample.readiness:contract-gate",
+  "slug": "contract-gate",
+  "version": "v1",
+  "stage": "formation",
+  "title": "Sample contract gate",
+  "purpose": "Verify neutral protocol inputs before a readiness run is accepted.",
+  "questions": [
+    {
+      "id": "scope",
+      "prompt": "What neutral scope is being prepared?",
+      "inputFields": ["scope.name", "scope.sourceRef"],
+      "required": true
+    }
+  ],
+  "inputFields": [
+    {
+      "id": "scope.name",
+      "type": "string",
+      "required": true,
+      "description": "Neutral scope name."
+    },
+    {
+      "id": "scope.sourceRef",
+      "type": "string",
+      "required": true,
+      "description": "Evidence reference for the scope."
+    }
+  ],
+  "outputHints": [
+    {
+      "id": "contract-gate.summary",
+      "text": "Render scope and evidence before review."
+    }
+  ],
+  "outputs": {
+    "runSchema": "atelier-readiness-run@v1",
+    "artifacts": [
+      {
+        "id": "sample.readiness:contract-gate.summary",
+        "kind": "draft",
+        "schema": "atelier-readiness-run@v1",
+        "description": "Draft readiness summary."
+      }
+    ]
+  },
+  "claimMappings": [
+    {
+      "id": "sample.readiness:contract-gate.scope-supports-review",
+      "claimPredicate": "supports",
+      "sourceFields": ["scope.name"],
+      "target": "atelier-claim@v1",
+      "evidence": "scope.sourceRef"
+    }
+  ],
+  "readinessRules": [
+    {
+      "id": "sample.readiness:contract-gate.scope-present",
+      "severity": "blocker",
+      "condition": "Scope name and evidence are present.",
+      "remediation": "Add scope.name and scope.sourceRef.",
+      "failClosed": true
+    }
+  ],
+  "graphLenses": [
+    {
+      "id": "sample.readiness:contract-gate.lens",
+      "title": "Sample contract gate lens",
+      "query": { "protocolId": "sample.readiness:contract-gate" }
+    }
+  ],
+  "exportMappings": [
+    {
+      "id": "sample.readiness:contract-gate.export",
+      "sourceField": "scope",
+      "sourceTerm": "sample.readiness:contract-gate.scope",
+      "target": "core.artifact",
+      "runtimeOwner": "audit",
+      "targetCollection": "staffPrep"
+    }
+  ],
+  "ui": {
+    "section": "readiness-journey",
+    "title": "Sample contract gate",
+    "description": "Neutral protocol fixture.",
+    "agentPrompt": "Run atelier readiness run sample.readiness:contract-gate --project ./atelier.project.json."
+  },
+  "safety": {
+    "runtimeMutation": false,
+    "runtimeImport": false,
+    "canonicalWrites": false,
+    "claimOnly": true,
+    "telemetry": false,
+    "egress": false,
+    "sendPath": false,
+    "browserApply": false,
+    "dryRunOnly": true
+  },
+  "safetyPosture": {
+    "runtimeMutation": false,
+    "externalEgress": false,
+    "defaultVisibility": "private",
+    "authority": "proposal-only",
+    "reviewMode": "static-inspection",
+    "failClosedOnMissingEvidence": true,
+    "refuses": ["runtime writes"]
+  }
+}

package/templates/external-project-workspace/packs/sample-pack.v1.json

@@ -0,0 +1,48 @@
+{
+  "schema": "mnstry-atelier-extension-pack@v1",
+  "id": "sample.readiness",
+  "namespace": "sample",
+  "version": "v1",
+  "terms": [
+    {
+      "id": "sample.readiness:scope",
+      "label": "Sample scope",
+      "kind": "concept"
+    }
+  ],
+  "migrations": [],
+  "fixtures": [],
+  "protocols": [
+    {
+      "id": "sample.readiness:contract-gate",
+      "schema": "atelier-readiness-protocol@v1",
+      "path": "protocols/contract-gate.v1.json",
+      "gate": "required",
+      "title": "Sample contract gate"
+    }
+  ],
+  "lenses": [
+    {
+      "id": "sample.readiness:contract-gate-lens",
+      "title": "Sample contract gate lens",
+      "query": {
+        "protocolId": "sample.readiness:contract-gate"
+      }
+    }
+  ],
+  "readinessRules": [
+    {
+      "id": "sample.readiness:scope-present",
+      "severity": "blocker",
+      "condition": "Scope name and evidence are present."
+    }
+  ],
+  "actionRules": [],
+  "exportMappings": [
+    {
+      "id": "sample.readiness:scope-export",
+      "sourceTerm": "sample.readiness:scope",
+      "target": "core.artifact"
+    }
+  ]
+}

package/templates/external-project-workspace/repo-access.v1.json

@@ -0,0 +1,9 @@
+{
+  "schema": "mnstry.atelier-repo-access@v1",
+  "defaultReadBoundary": "private",
+  "repos": {
+    "source": {
+      "readBoundary": "private"
+    }
+  }
+}

package/templates/external-project-workspace/source/README.md

@@ -0,0 +1,11 @@
+---
+title: Sample observation
+kg:
+  id: "sample-source:observation"
+  type: "document"
+  status: "active"
+  audience: "private"
+---
+# Sample observation
+
+The sample observation needs an owner to confirm its interpretation.

package/templates/launch.json

@@ -3,8 +3,12 @@
   "configurations": [
     {
       "name": "atelier",
-      "runtimeExecutable": "npx",
-      "runtimeArgs": ["atelier", "server"],
+      "runtimeExecutable": "node",
+      "runtimeArgs": [
+        "--input-type=module",
+        "--eval",
+        "import { runCli } from '@mnstry/atelier/cli'; process.exit(await runCli({ argv: ['server', ...process.argv.slice(1)] }));"
+      ],
       "port": 8137,
       "autoPort": true
     }

package/templates/private-domain-workspace/.claude/launch.json

@@ -3,8 +3,12 @@
   "configurations": [
     {
       "name": "atelier",
-      "runtimeExecutable": "npx",
-      "runtimeArgs": ["atelier", "server"],
+      "runtimeExecutable": "node",
+      "runtimeArgs": [
+        "--input-type=module",
+        "--eval",
+        "import { runCli } from '@mnstry/atelier/cli'; process.exit(await runCli({ argv: ['server', ...process.argv.slice(1)] }));"
+      ],
       "port": 8137,
       "autoPort": true
     }

package/templates/private-domain-workspace/domain/README.md

@@ -2,10 +2,10 @@
 title: "Private Domain Seed"
 kg:
   id: "tenant-private-domain:seed"
-  type: "domain-note"
+  type: "document"
   domain: "example-domain"
   lifecycle: "draft"
-  status: "seed"
+  status: "draft"
   audience: "private"
   relations: []
 ---

package/templates/private-domain-workspace/gitignore

@@ -1,4 +1,5 @@
 .atelier-local/
+.atelier-local/obsidian.json
 atelier.local.json
 atelier.workspace.local.json
 atelier-attestation-key.local.json