spawnfile 0.1.13 → 0.1.17

package/README.md

@@ -1,11 +1,11 @@
 # Spawnfile
 
-> A spec and compiler for autonomous agent runtimes. Write your agent once, compile for any runtime.
+> Write your agent team once. Compile it for different runtimes.
 
 <p align="center">
   <a href="https://www.npmjs.com/package/spawnfile"><img src="https://img.shields.io/npm/v/spawnfile?style=flat-square&color=d4604a&label=npm" alt="npm"></a>
   <a href="https://www.npmjs.com/package/spawnfile"><img src="https://img.shields.io/npm/dm/spawnfile?style=flat-square&color=d4604a" alt="downloads"></a>
-  <a href="#from-source"><img src="https://img.shields.io/node/v/spawnfile?style=flat-square&color=d4604a" alt="node"></a>
+  <a href="#try-it"><img src="https://img.shields.io/node/v/spawnfile?style=flat-square&color=d4604a" alt="node"></a>
   <a href="LICENSE"><img src="https://img.shields.io/npm/l/spawnfile?style=flat-square&color=d4604a" alt="MIT"></a>
   <a href="https://spawnfile.com"><img src="https://img.shields.io/website?url=https%3A%2F%2Fspawnfile.com&style=flat-square&label=spawnfile.com&color=d4604a" alt="website"></a>
 </p>
@@ -14,156 +14,96 @@
   <img src="website/public/new-claw-images.png" alt="Spawnfile compiles one agent source into multiple runtimes" width="420" />
 </p>
 
-Spawnfile is a **portable source format** for autonomous agents and teams. You write one canonical project — identity docs, skills, MCP connections, model and sandbox intent, team structure, and declared communication surfaces — and `spawnfile compile` lowers it into the runtime-specific config and workspace each adapter needs.
+Describe your agents, give them identities and tools, and keep the whole team in one source project. Spawnfile compiles that project into the configuration and workspaces their runtimes need, then builds and deploys it with Docker.
 
-It's not a runtime-to-runtime translator. The compiler starts from the canonical source, emits each declared adapter's output, and reports per-capability support as `supported`, `degraded`, or `unsupported`.
-
-Pairs with [**Moltnet**](https://moltnet.dev) as the first provider for `team.networks[]`, letting compiled agents share declared rooms, DMs, and history across runtimes without Spawnfile injecting its own message router.
-
-## Install
-
-```bash
-npm install -g spawnfile
-spawnfile --version
-spawnfile --help
+```text
+Spawnfile + workspace ─→ compile ─→ runtime files
 ```
 
-Node.js 22+ required. See [source install](#from-source) for local development.
+## Try it
 
-## The happy path
+Start with one agent. Requires **Node.js 22.19+**; compilation needs no Docker or model credentials.
 
 ```bash
-spawnfile init                                   # scaffold an agent (defaults to openclaw)
-spawnfile validate                               # check the graph
-spawnfile view .                                 # read-only graph view; writes no files
-spawnfile compile                                # lower to runtime-native output
-spawnfile status .                               # read declared/compiled status
-spawnfile auth sync --profile dev --env-file .env
-spawnfile build  --tag my-agent                  # compile + docker build
-spawnfile up . --context gpu-4090 --detach       # build and run on a Docker context
-spawnfile dev up . --auth-profile dev            # detached dev loop in .spawn-dev
-spawnfile dev apply . --agent researcher         # hot-add/reload one Pi agent
-spawnfile dev activity . --agent researcher      # inspect buffered Pi activity events
-spawnfile run    --tag my-agent --auth-profile dev --detach
-spawnfile status . --live                        # inspect the detached deployment
-spawnfile publish . --tag you/my-agent:1.0.0     # compile + build + verify + push
+npm install -g spawnfile
+spawnfile init my-agent
+cd my-agent
+spawnfile validate
+spawnfile compile
 ```
 
-Compiled output lands under `.spawn/` by default, including a `Dockerfile`, `entrypoint.sh`, `.env.example`, and a prebuilt `container/rootfs/` tree. `spawnfile build` uses the pinned runtime artifacts from `runtimes.yaml`; it does not rebuild runtimes from source. Daimon, OpenClaw, and PicoClaw use published copyable artifact images by default, so normal prompt/config edits reuse their dependency layers. To test a local runtime artifact instead, set `SPAWNFILE_DAIMON_RUNTIME_IMAGE`, `SPAWNFILE_OPENCLAW_RUNTIME_IMAGE`, or `SPAWNFILE_PICOCLAW_RUNTIME_IMAGE` to a local image tag. For Pi-heavy orgs, build a reusable runtime base with `npm run runtime:pi-base -- noopolis/spawnfile-pi-runtime:0.79.9-node24`, then set `SPAWNFILE_PI_RUNTIME_BASE_IMAGE` during `spawnfile up`. For `build`/`up` on a docker `--context`, Moltnet release assets are staged for that context's architecture (`amd64` or `arm64`); for local-only manual compile targeting a fixed architecture, set `SPAWNFILE_MOLTNET_TARGET_ARCH=amd64|arm64`.
-
-`spawnfile status` is read-only. By default it shows authored and compiled state without Docker, runtime, or Moltnet calls. With `--live`, it reads the selected detached deployment record, inspects the recorded Docker target, runs adapter-owned runtime probes, and checks Moltnet metadata without reading message bodies. Add `--logs` for a redacted Docker log tail, or `--watch` to refresh status continuously. For a remote Docker context where the local record is missing, pass `--context <name>` with `--live` to recover the deployment from Spawnfile container labels.
+`init` creates an OpenClaw project with `IDENTITY.md`, `SOUL.md`, and `AGENTS.md`. `compile` writes runtime configuration, the generated workspace, and container files into `.spawn/`. Read `spawnfile-report.json` there to see how your source was compiled. **The agent is configured, but has not started.**
 
-`spawnfile dev` is the source-backed interactive loop. It uses `.spawn-dev/` by default, starts a detached dev deployment with `spawnfile dev up`, and can hot-apply one Daimon runtime agent with `spawnfile dev apply --agent <id>` without restarting the rest of the org. Hot apply recompiles source, copies the selected agent workspace, Daimon config, matching Moltnet node configs, and managed Moltnet server configs into the running container, loads it through the Daimon control endpoint, and starts only that agent's Moltnet bridges when it is new. `spawnfile dev activity` reads the generated Daimon app's bounded activity buffer as JSON lines so operators can see queued wakes, turn starts/completions, runtime event types, output completions, and errors without mixing those diagnostics into Moltnet chat. Running managed Moltnet servers keep their current in-memory room membership until an operator-token `moltnet apply` or server restart reconciles the copied server config.
+Edit the Markdown files to define who the agent is and what it should do, then compile again. Keep the source in Git; `.spawn/` is generated and ignored.
 
-Compiled images are self-describing: `spawnfile publish` pushes one to any OCI registry, and anyone can run it with no source — `spawnfile up you/my-agent:1.0.0 --deployment prod --detach --auth-profile me` — or inspect what it needs first with `spawnfile status you/my-agent:1.0.0`. See [`specs/DISTRIBUTION.md`](specs/DISTRIBUTION.md).
+## From one agent to a team
 
-Declare external credentials in `secrets:` and provide values through an ignored env file or the shell environment. `spawnfile auth sync --env-file .env` stores declared model auth and project secrets in a local auth profile; `spawnfile run --env-file .env` can inject the same values directly for a single run. This is the intended pattern for credentials like `GH_TOKEN`, MCP tokens, and provider API keys.
+A team has its own `Spawnfile`, which references the member agent projects. Create its directory with `spawnfile init my-team --team`. Once you have two projects with distinct agent names under `my-team/agents/`, put their references in `my-team/Spawnfile`:
 
-## Project structure
-
-A Spawnfile project is either an `agent` or a `team`.
-
-**Agent**
-
-```text
-my-agent/
-├── Spawnfile
-├── IDENTITY.md         # who the agent is
-├── SOUL.md             # tone and personality
-├── AGENTS.md           # system prompt
-├── MEMORY.md           # long-lived memory
-├── HEARTBEAT.md        # periodic prompt for scheduled wakes
-├── skills/
-│   └── web_search/SKILL.md
-└── subagents/
-    └── researcher/Spawnfile
+```yaml
+spawnfile_version: "0.1"
+kind: team
+name: research-team
+mode: swarm
+members:
+  - id: researcher
+    ref: ./agents/researcher
+  - id: writer
+    ref: ./agents/writer
 ```
 
-**Team**
+Each member has its own Spawnfile, identity, and runtime. Teams can share instructions and resources, contain nested teams, and declare [Moltnet](https://moltnet.dev) rooms. The [team guide](https://spawnfile.com/guides/teams/) covers the full setup; [examples](examples/) show complete projects.
 
-```text
-my-team/
-├── Spawnfile
-├── TEAM.md
-├── shared/skills/...
-└── agents/
-    ├── orchestrator/Spawnfile
-    ├── researcher/Spawnfile
-    └── writer/Spawnfile
-```
+## What travels with your team
 
-Team members may target different runtimes; the compiler resolves each member independently. Subagents are internal helpers owned by a parent agent — not the same thing as team members. Team coordination is through shared declared agent surfaces and declared team networks, not a Spawnfile-owned router.
+- **Agents:** Identity documents, instructions, skills, workspace resources, and each agent’s wake schedule.
+- **Tools and models:** MCP connections, model selection, and declared secret requirements.
+- **Team structure:** Members, nested teams, and shared resources.
+- **Communication:** Declared [Moltnet](https://moltnet.dev) networks and rooms for agents to exchange messages across runtimes.
+- **Deployment:** Runtime configuration, container files, and a capability report built from the same source.
 
-Not every file is required. Spawnfile names the portable roles; adapters decide how to lower them into runtime-native surfaces. See [`specs/SPEC.md`](specs/SPEC.md) for the full shape.
+A team declaration alone does not create a conversation or a useful division of work. Give the agents a task, configure their communication, and choose how they wake. Start with the [team guide](https://spawnfile.com/guides/teams/) and [example projects](examples/).
 
-## Runtime support
+## Run and share it
 
-v0.1 targets autonomous agent runtimes that share a markdown workspace identity model.
+Once the prompts and configuration are ready:
 
-| Runtime   | Status        | Default | Surfaces                                      |
-|-----------|---------------|---------|-----------------------------------------------|
-| OpenClaw  | active        | ✅      | Discord, Telegram, WhatsApp, Slack            |
-| PicoClaw  | active        |         | Discord, Telegram, Slack (WhatsApp blocked)   |
-| Pi        | active        |         | Embedded org app, Moltnet client config       |
-| NullClaw  | exploratory   |         | No active adapter yet                         |
-| ZeroClaw  | exploratory   |         | No active adapter yet                         |
-| OpenFang  | exploratory   |         | No active adapter yet                         |
-| Hermes Agent | exploratory |        | No active adapter yet                         |
-| OpenCode  | exploratory   |         | No active adapter yet                         |
+1. **Provide credentials.** Import an existing subscription login or configure provider credentials with [auth profiles](https://spawnfile.com/guides/docker/). Keep secret values out of Git.
+2. **Build and start.** With Docker available, `spawnfile up . --detach --auth-profile <profile>` compiles, builds, and starts the project. A Docker context can target another machine.
+3. **Check the deployment.** `spawnfile status . --live` probes the running deployment; `spawnfile status .` reads only local declared and compiled state.
+4. **Share an image.** `spawnfile publish` packages the project for an OCI registry so another operator can run it without the source, using their own credentials.
 
-Each adapter maps the portable schema into its native forms. The compiler reports a machine-readable `spawnfile-report.json` with the resolved graph, chosen runtimes, and capability outcomes (`supported`, `degraded`, `unsupported`). See [`specs/RUNTIMES.md`](specs/RUNTIMES.md) for the live matrix and pinned versions, or [`runtimes.yaml`](runtimes.yaml) for the registry source of truth.
+See [container deployment](specs/CONTAINERS.md), [status](specs/STATUS.md), and [image distribution](specs/DISTRIBUTION.md) for complete commands and requirements.
 
-## Why
-
-Autonomous agent runtimes already share a meaningful core: markdown workspace identity, skill folders, MCP, model selection, sandboxing. Today that core is re-authored by hand for each runtime. Spawnfile makes it canonical so one source project can ship to any compatible runtime.
-
-## Docs
-
-Hosted docs with rendered specs, runtime guides, and a capability matrix: **[spawnfile.com](https://spawnfile.com)** — start at [Introduction](https://spawnfile.com/introduction/), [Quickstart](https://spawnfile.com/quickstart/), or the [Runtimes overview](https://spawnfile.com/runtimes/overview/).
-
-The source-of-truth specs live in this repo:
-
-- [`specs/INDEX.md`](specs/INDEX.md) — map of all specs
-- [`specs/SPEC.md`](specs/SPEC.md) — canonical source format
-- [`specs/COMPILER.md`](specs/COMPILER.md) — compiler architecture and adapter contract
-- [`specs/CONTAINERS.md`](specs/CONTAINERS.md) — container compilation
-- [`specs/RUNTIMES.md`](specs/RUNTIMES.md) — runtime registry and version pinning
-- [`specs/SURFACES.md`](specs/SURFACES.md) — messaging surface model
-- [`specs/STATUS.md`](specs/STATUS.md) — static and live operational status
-- [`specs/DISTRIBUTION.md`](specs/DISTRIBUTION.md) — image distribution, publish, and sourceless run
-- [`fixtures/`](fixtures/) — canonical example projects
-
-## From source
-
-```bash
-git clone https://github.com/noopolis/spawnfile.git
-cd spawnfile
-nvm use
-npm install
-npm run build
-npm link
-```
+## Runtime support
 
-To clone pinned runtimes and generate reference blueprints:
+| Runtime | Use it for |
+|---|---|
+| **Daimon** | Agents using subscription CLI engines such as Codex and Claude Code, with Moltnet and memory integration. |
+| **OpenClaw** | OpenClaw agents and their native messaging surfaces. The default agent scaffold. |
+| **PicoClaw** | PicoClaw agents and their native messaging surfaces. |
 
-```bash
-npm run runtimes:sync
-```
+Daimon requires a pinned runtime image matching the compiler contract. The older `pi` adapter remains available for existing projects.
 
-For local development without linking globally:
+Portability is capability-specific: the compiler reports each feature as **supported**, **degraded**, or **unsupported**. Read that report before switching runtimes. Exact versions live in [runtimes.yaml](runtimes.yaml); the [runtime specification](specs/RUNTIMES.md) describes the adapter model.
 
-```bash
-npm run dev -- validate fixtures/single-agent
-```
+## Go further
 
-## Contributing
+| I want to… | Read |
+|---|---|
+| Understand the source format | [Spawnfile specification](specs/SPEC.md) |
+| Explore complete projects | [Examples](examples/) |
+| Add an adapter or contribute | [Contributing](CONTRIBUTING.md) |
+| Integrate with deployment tooling | [Target and lifecycle contracts](specs/TARGETS.md) |
+| Plan isolated agent training | [Paideia training handoff](specs/TRAINING.md) |
+| Find a detailed contract | [Specification index](specs/INDEX.md) |
 
-See [CONTRIBUTING.md](CONTRIBUTING.md) for local setup, tests, and the runtime adapter contract.
+Spawnfile is part of [Noopolis](https://github.com/noopolis). [Moltnet](https://moltnet.dev) supplies messaging; [Daimon](https://github.com/noopolis/daimon) runs individual agents; [Simfile](https://simfile.org) builds simulation worlds around organizations. You can use Spawnfile on its own.
 
 ## License
 
-MIT — see [LICENSE](LICENSE).
+[MIT](LICENSE)
 
 ---
 
-**[spawnfile.com](https://spawnfile.com)** · **[github.com/noopolis/spawnfile](https://github.com/noopolis/spawnfile)**
+**[spawnfile.com](https://spawnfile.com)** · **[Examples](examples/)** · **[Contributing](CONTRIBUTING.md)**

package/dist/audit/auditCli.d.ts

@@ -0,0 +1,19 @@
+export interface AuditCliOptions {
+    compiledOutput?: string;
+    fixtures?: string;
+    ledger?: string;
+    out?: string;
+    requiredSecret?: string[];
+}
+/**
+ * `npm run audit:generate` entry point / `tsx src/audit/auditCli.ts`. Two
+ * input modes: `--fixtures <dir>` treats one directory as BOTH the
+ * compiled-output root (`Dockerfile`/`entrypoint.sh`/`runtime/app.mjs`) and
+ * the ledger root (`*.jsonl` + `expected-denials.json`) — the shape every
+ * `src/audit/fixtures/<name>/` directory uses. `--compiled-output <dir>` /
+ * `--ledger <dir>` set them independently, for a real `spawnfile compile`
+ * output paired with a separately-located ledger capture. Prints the report
+ * JSON to stdout (or writes it to `--out <path>`), a one-line summary to
+ * stderr, and exits 1 if any check failed.
+ */
+export declare const runAuditCli: (argv: string[]) => Promise<void>;

package/dist/audit/auditCli.js

@@ -0,0 +1,63 @@
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+import { Command } from "commander";
+import { generateAudit } from "./generateAudit.js";
+const collectRepeatable = (value, previous) => [...previous, value];
+/**
+ * `npm run audit:generate` entry point / `tsx src/audit/auditCli.ts`. Two
+ * input modes: `--fixtures <dir>` treats one directory as BOTH the
+ * compiled-output root (`Dockerfile`/`entrypoint.sh`/`runtime/app.mjs`) and
+ * the ledger root (`*.jsonl` + `expected-denials.json`) — the shape every
+ * `src/audit/fixtures/<name>/` directory uses. `--compiled-output <dir>` /
+ * `--ledger <dir>` set them independently, for a real `spawnfile compile`
+ * output paired with a separately-located ledger capture. Prints the report
+ * JSON to stdout (or writes it to `--out <path>`), a one-line summary to
+ * stderr, and exits 1 if any check failed.
+ */
+export const runAuditCli = async (argv) => {
+    const command = new Command();
+    command
+        .name("spawnfile audit:generate")
+        .description("Generate a deterministic offline spawnfile.audit.v1 security-audit report")
+        .option("--fixtures <dir>", "Directory used as both the compiled-output and ledger root")
+        .option("--compiled-output <dir>", "Compiled-output directory (Dockerfile/entrypoint.sh/runtime/app.mjs)")
+        .option("--ledger <dir>", "Ledger directory (*.jsonl + expected-denials.json)")
+        .option("--required-secret <name>", "Required secret env var name (repeatable)", collectRepeatable, [])
+        .option("--out <path>", "Write the report JSON to this path instead of stdout");
+    await command.parseAsync(argv, { from: "user" });
+    const options = command.opts();
+    const compiledOutputDirPath = options.compiledOutput ?? options.fixtures;
+    const ledgerDirPath = options.ledger ?? options.fixtures;
+    if (!compiledOutputDirPath) {
+        throw new Error("audit:generate requires --fixtures <dir> or --compiled-output <dir>");
+    }
+    const report = await generateAudit({
+        compiledOutputDirPath,
+        ledgerDirPath,
+        requiredSecrets: options.requiredSecret
+    });
+    const json = `${JSON.stringify(report, null, 2)}\n`;
+    if (options.out) {
+        await writeFile(path.resolve(options.out), json, "utf8");
+    }
+    else {
+        process.stdout.write(json);
+    }
+    process.stderr.write(`spawnfile audit: ${report.summary.passed} passed, ${report.summary.failed} failed, ${report.summary.na} n/a\n`);
+    if (report.summary.failed > 0) {
+        process.exitCode = 1;
+    }
+};
+// Only run when invoked directly (`tsx src/audit/auditCli.ts ...`), never on
+// import — this keeps `runAuditCli` safely testable in isolation. Not
+// unit-testable itself (import.meta.url never equals process.argv[1] under
+// vitest), mirroring how src/ledger/causalConformanceCli.ts's own bottom
+// bootstrap is excluded from coverage.
+/* v8 ignore start -- process entrypoint bootstrap, exercised by `npm run audit:generate` / the CLI-run validate step, not by unit tests */
+if (import.meta.url === `file://${process.argv[1]}`) {
+    runAuditCli(process.argv.slice(2)).catch((error) => {
+        process.stderr.write(`${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`);
+        process.exitCode = 1;
+    });
+}
+/* v8 ignore stop */

package/dist/audit/checks.d.ts

@@ -0,0 +1,100 @@
+import type { RunLedgerEvidence, StaticContainerEvidence } from "./checksShared.js";
+import type { AuditCheck } from "./types.js";
+export type { RunLedgerEvidence, StaticContainerEvidence } from "./checksShared.js";
+/**
+ * Check 1 — `causal.principals-authenticated` (run). Grounded in
+ * `runRealConformance` reporting zero issues over the ledger jsonl, and in
+ * `isAuthenticatedPrincipal` (src/ledger/principal.ts:87) rejecting a bare,
+ * literal-`anonymous`, or `system:moltnet.anonymous` principal
+ * (principal.ts:45,93). Fails on either a nonempty `issues` list (any
+ * schema/seq/payload/principal/chain problem `runRealConformance` found) or
+ * an event whose `principal_id` is not authenticated — evidence names the
+ * offending event and principal directly rather than relying on issue-
+ * message string matching.
+ */
+export declare const checkPrincipalsAuthenticated: (evidence: RunLedgerEvidence | undefined) => AuditCheck;
+/**
+ * Check 2 — `causal.denied-ledger-visible` (run). Grounded in
+ * `DEFAULT_PAYLOAD_MINIMUMS` (conformance.ts:67-69) for every `*.denied`
+ * type: any such event that appears must carry its required keys. Also
+ * detects a silent drop — this fixture's `expected-denials.json` asserted a
+ * denial type occurred, but no matching `*.denied` event exists in the
+ * ledger — which fails even when every event that *is* present is well
+ * shaped.
+ *
+ * `not_applicable`, never `pass`, when there is no `expected-denials.json`
+ * manifest AND zero `*.denied` events are present in the ledger — with
+ * neither an assertion to check against nor an event to inspect, there is
+ * nothing here to actually assess (see AGENTS.md's cardinal rule: absent
+ * evidence is `not_applicable`, never `pass`). A manifest being present is
+ * enough to keep evaluating (silent-drop detection needs no observed event
+ * to fire), and any `*.denied` event that *is* present is always
+ * key-validated regardless of manifest presence.
+ */
+export declare const checkDeniedLedgerVisible: (evidence: RunLedgerEvidence | undefined) => AuditCheck;
+/**
+ * Check 3 — `control.wake-fail-closed` (static). Grounded in
+ * appControlSource.ts:31-47 (B62 Option B): the operator wake endpoint must
+ * fail closed when `SPAWNFILE_PI_CONTROL_TOKEN` is unset, never treat an
+ * unset token as "auth disabled". Passes only when the compiled Pi app
+ * source references the token env, contains the verbatim fail-closed
+ * rejection text, and never bakes a literal default value for it.
+ */
+export declare const checkControlWakeFailClosed: (evidence: StaticContainerEvidence) => AuditCheck;
+/**
+ * Check 4 — `container.no-baked-secrets` (static). Grounded in
+ * containerEntrypointRender.ts:232-233: every required secret is emitted as
+ * a `require_env <name>` runtime check, never a literal value baked into the
+ * Dockerfile build layer or the entrypoint script. Passes only when every
+ * `requiredSecrets` name is `require_env`-guarded in the entrypoint AND no
+ * name is ever followed by a literal (non-`$`) assignment anywhere in the
+ * compiled Dockerfile/entrypoint text.
+ */
+export declare const checkContainerNoBakedSecrets: (evidence: StaticContainerEvidence) => AuditCheck;
+/**
+ * Check 5 — `memory.cross-scope-capability` (run). Grounded in mneme's
+ * `mneme.cap.system.v1` foreign-scope escalation capability
+ * (ecosystem/mneme/src/policy/capability.ts:28) and the
+ * `memory.write.denied` payload minimum (conformance.ts:68:
+ * `requested_scope`, `reason`). `mneme.cap.system.v1` is carried as an
+ * informational `grounding` string only — this function performs no static
+ * check against mneme's source, so the status is never driven by that
+ * literal.
+ *
+ * `not_applicable`, never `pass`, when no `memory.write.denied` event is
+ * present in the ledger: enforcement was never exercised in this run, and
+ * "nothing to violate" is not evidence the capability guard works (see
+ * AGENTS.md). When one or more denial events are present, every one must
+ * carry both `requested_scope` and `reason` to pass.
+ */
+export declare const checkMemoryCrossScopeCapability: (evidence: RunLedgerEvidence | undefined) => AuditCheck;
+/**
+ * Check 6 — `network.non-member-write-denied` (run). Grounded in moltnet's
+ * `writeForbiddenError` (ecosystem/moltnet/internal/rooms/access_policy.go:23,71-72)
+ * and the `message.denied` payload minimum (conformance.ts:67: `target`,
+ * `reason`, `content_sha256`). The `writeForbiddenError` path is carried as
+ * an informational `grounding` string only — this function performs no
+ * static check against moltnet's source, so the status is never driven by
+ * that literal.
+ *
+ * `not_applicable`, never `pass`, when no `message.denied` event is present:
+ * non-member-write enforcement was never exercised in this run, which is not
+ * evidence it works (see AGENTS.md). When one or more denial events are
+ * present, every one must carry `target`, `reason`, and `content_sha256` to
+ * pass.
+ */
+export declare const checkNonMemberWriteDenied: (evidence: RunLedgerEvidence | undefined) => AuditCheck;
+/**
+ * Check 7 — `provenance.signed-report` — always `not_applicable`. Report
+ * signing/provenance is deferred to B66; this audit generator has no
+ * signing input to check and must never claim it. Takes no evidence input
+ * on purpose: there is nothing yet for it to inspect.
+ */
+export declare const checkProvenanceSignedReport: () => AuditCheck;
+/**
+ * The seven check ids in the order `generateAudit.ts` assembles
+ * `AuditReport.checks` in (each check function above takes a different
+ * evidence shape, so this is a documentation/ordering list only — not a
+ * uniformly-callable array).
+ */
+export declare const AUDIT_CHECK_IDS: readonly ["causal.principals-authenticated", "causal.denied-ledger-visible", "control.wake-fail-closed", "container.no-baked-secrets", "memory.cross-scope-capability", "network.non-member-write-denied", "provenance.signed-report"];