@mediamonks/canopy-cli 0.7.36 → 0.7.38

package/dist/{ai-DHLnyqfq.mjs → ai-CjvrcBIz.mjs}

@@ -1,5 +1,5 @@
-import { i as apiRequest, o as withContext } from "./api-C4rMhE7i.mjs";
-import { r as reportErrors } from "./ui-C_jSc1Kz.mjs";
+import { i as apiRequest, o as withContext } from "./api-BPEYm9ts.mjs";
+import { r as reportErrors } from "./ui-CHfKV6lG.mjs";
 import { defineCommand } from "citty";
 //#region src/ai.ts
 /**

package/dist/{api-C4rMhE7i.mjs → api-BPEYm9ts.mjs}

@@ -92,6 +92,26 @@ const ERROR_COPY = {
 		why: "the description is invalid (at most 1000 characters)",
 		fix: "Shorten the description to 1000 characters or fewer."
 	},
+	user_session_required: {
+		why: "this needs your own sign-in, and a project-scoped token (dev, agent, worker, deploy) was used",
+		fix: "Run it yourself after `canopy login`, or use the dashboard."
+	},
+	invalid_retention: {
+		why: "retention must be a whole number of days from 1 to 365, or off",
+		fix: "Pass e.g. `--retention 30`, or `--retention off` to keep snapshots until deleted."
+	},
+	retention_shorter_than_schedule: {
+		why: "retention is shorter than the schedule, so some days would have no snapshot at all",
+		fix: "Use at least 1 day for a daily schedule and 7 for a weekly one."
+	},
+	invalid_schedule: {
+		why: "the schedule must be off, daily or weekly",
+		fix: "Pass `--schedule off`, `--schedule daily` or `--schedule weekly`."
+	},
+	invalid_retention_scope: {
+		why: "the retention scope must be all or scheduled",
+		fix: "Pass `--retention-scope all` (every snapshot) or `--retention-scope scheduled`."
+	},
 	snapshot_not_found: {
 		why: "no snapshot with that id exists for this project",
 		fix: "Run `canopy db snapshots` to list available snapshots."
@@ -335,6 +355,7 @@ async function apiDataRequest(method, path, projectSlug, body, rawContentType, c
 		body: body === void 0 ? void 0 : rawContentType !== void 0 ? body : JSON.stringify(body)
 	});
 	if (!response.ok) return fail(response, isDeployToken, method, path);
+	if (response.status === 204) return void 0;
 	return await response.json();
 }
 //#endregion

package/dist/{browse-Dycwj0V_.mjs → browse-CBelCgnW.mjs}

@@ -1,5 +1,5 @@
 import { d as tryResolveProject, n as siteConfig } from "./site-DM2J10CB.mjs";
-import { i as apiRequest, t as ApiError } from "./api-C4rMhE7i.mjs";
+import { i as apiRequest, t as ApiError } from "./api-BPEYm9ts.mjs";
 import { defineCommand } from "citty";
 //#region src/browse.ts
 /**

package/dist/{db-BB6O6085.mjs → db-CbqgjfYz.mjs}

@@ -1,7 +1,7 @@
 import { c as resolveProject, o as projectFlagArgs } from "./site-DM2J10CB.mjs";
-import { i as apiRequest, n as apiDataRequest, o as withContext } from "./api-C4rMhE7i.mjs";
-import { a as unwrap, i as requireTty, r as reportErrors } from "./ui-C_jSc1Kz.mjs";
-import { n as migrateProject, r as readMigrationFiles, t as describeMigrateResult } from "./migrations-Czlcddyz.mjs";
+import { i as apiRequest, n as apiDataRequest, o as withContext } from "./api-BPEYm9ts.mjs";
+import { a as unwrap, i as requireTty, r as reportErrors } from "./ui-CHfKV6lG.mjs";
+import { n as migrateProject, r as readMigrationFiles, t as describeMigrateResult } from "./migrations-CF1iNZ7F.mjs";
 import { defineCommand } from "citty";
 import { readFileSync, writeFileSync } from "node:fs";
 import * as p from "@clack/prompts";
@@ -12,7 +12,8 @@ import * as p from "@clack/prompts";
 *
 * pull      download a fresh SQL dump of the project database
 * snapshot  store a dump server-side (restorable from CLI or dashboard)
-* snapshots list stored snapshots
+* snapshots list stored snapshots; `snapshots delete` and `snapshots settings`
+*           (schedule and retention, OpenSpec snapshot-schedules)
 * restore   replace ALL project data from a snapshot or a local .sql file
 * migrate   apply pending schema migrations (docs/13-migrations-and-drizzle.md)
 * access    show or set what the app's pages may do with the database (docs/35)
@@ -84,25 +85,170 @@ const snapshotCommand = defineCommand({
 		console.log(`Restore anytime with \`canopy db restore --snapshot ${created.key}\`.`);
 	})
 });
-const snapshotsCommand = defineCommand({
+/** `--retention`: a whole number of days, or off. Range is the server's call. */
+function parseRetention(value) {
+	const v = value.trim().toLowerCase();
+	if (v === "off" || v === "none") return null;
+	if (!/^\d+$/.test(v)) throw new Error(`--retention takes a number of days or "off", not "${value}".`);
+	return Number(v);
+}
+const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+/** One line on when scheduled snapshots happen, e.g. "daily at 03:00 UTC". */
+function describeSchedule(settings) {
+	if (settings.schedule === "off") return "off";
+	const time = `${String(settings.slot.hour).padStart(2, "0")}:00 UTC`;
+	return settings.schedule === "weekly" && settings.slot.weekday ? `weekly on ${capitalize(settings.slot.weekday)} at ${time}` : `daily at ${time}`;
+}
+function describeRetention(settings) {
+	if (settings.retentionDays === null) return "off (snapshots are kept until deleted)";
+	const days = `${settings.retentionDays} day${settings.retentionDays === 1 ? "" : "s"}`;
+	return settings.retentionScope === "scheduled" ? `${days}, scheduled snapshots only` : `${days}, all snapshots (manual, scheduled, pre-migrate, pre-promote)`;
+}
+function describeLastRun(lastRun) {
+	if (!lastRun) return "never";
+	return lastRun.ok ? `${lastRun.at} — stored ${lastRun.detail ?? ""}`.trimEnd() : `${lastRun.at} — FAILED: ${lastRun.detail ?? "unknown error"}`;
+}
+function printSettings(slug, settings) {
+	console.log(`${slug} snapshot settings`);
+	console.log(`  schedule   ${describeSchedule(settings)}`);
+	console.log(`  retention  ${describeRetention(settings)}`);
+	if (settings.schedule !== "off" || settings.lastRun) console.log(`  last run   ${describeLastRun(settings.lastRun)}`);
+}
+let snapshotsSubcommandRan = false;
+const snapshotsDeleteCommand = defineCommand({
 	meta: {
-		name: "snapshots",
-		description: "List stored snapshots"
+		name: "delete",
+		description: "Delete a stored snapshot for good"
 	},
 	args: {
 		...projectFlagArgs,
-		...stagingFlagArgs
+		...stagingFlagArgs,
+		key: {
+			type: "positional",
+			description: "Snapshot key (from `canopy db snapshots`)",
+			required: true
+		},
+		yes: {
+			type: "boolean",
+			default: false,
+			description: "Skip the confirmation"
+		}
+	},
+	run: reportErrors("db snapshots delete", async ({ args }) => {
+		snapshotsSubcommandRan = true;
+		const { slug } = resolveProject(args);
+		if (!args.yes) {
+			requireTty("pass --yes to delete without confirmation.");
+			if (!unwrap(await p.confirm({
+				message: `Delete snapshot ${args.key} of "${slug}"${channelNote(args)} for good? It can't be restored afterwards.`,
+				initialValue: false
+			}))) {
+				p.cancel("Aborted.");
+				return;
+			}
+		}
+		await withContext(apiDataRequest("DELETE", `/db/snapshots/${encodeURIComponent(args.key)}`, slug, void 0, void 0, channelOf(args)), { action: `delete snapshot ${args.key} of "${slug}"` });
+		p.log.success(`Deleted ${args.key}${channelNote(args)}.`);
+	})
+});
+const snapshotsSettingsCommand = defineCommand({
+	meta: {
+		name: "settings",
+		description: "Show or change the snapshot schedule and retention"
+	},
+	args: {
+		...projectFlagArgs,
+		schedule: {
+			type: "string",
+			description: "off | daily | weekly"
+		},
+		retention: {
+			type: "string",
+			description: "Delete snapshots older than this many days (1–365), or off"
+		},
+		"retention-scope": {
+			type: "string",
+			description: "Which snapshots retention deletes: all (default) | scheduled"
+		},
+		yes: {
+			type: "boolean",
+			default: false,
+			description: "Don't ask before a retention change that deletes snapshots"
+		},
+		json: {
+			type: "boolean",
+			default: false,
+			description: "Print the settings as JSON"
+		}
 	},
-	run: reportErrors("db snapshots", async ({ args }) => {
+	run: reportErrors("db snapshots settings", async ({ args }) => {
+		snapshotsSubcommandRan = true;
 		const { slug } = resolveProject(args);
-		const { snapshots } = await apiDataRequest("GET", "/db/snapshots", slug, void 0, void 0, channelOf(args));
-		if (snapshots.length === 0) {
-			console.log(`No snapshots for ${slug} yet — run \`canopy db snapshot\`.`);
+		const path = `/projects/${slug}/snapshot-settings`;
+		const change = {};
+		if (args.schedule !== void 0) change.schedule = args.schedule.trim().toLowerCase();
+		if (args.retention !== void 0) change.retentionDays = parseRetention(args.retention);
+		if (args["retention-scope"] !== void 0) change.retentionScope = args["retention-scope"].trim().toLowerCase();
+		if (Object.keys(change).length === 0) {
+			const settings = await withContext(apiRequest("GET", path), { action: `read the snapshot settings of "${slug}"` });
+			if (args.json) console.log(JSON.stringify(settings, null, 2));
+			else printSettings(slug, settings);
+			return;
+		}
+		const context = { action: `change the snapshot settings of "${slug}"` };
+		const preview = await withContext(apiRequest("PUT", path, {
+			...change,
+			dryRun: true
+		}), context);
+		if ((preview.wouldExpire ?? 0) > 0 && !args.yes) {
+			requireTty("pass --yes to apply a retention that deletes existing snapshots.");
+			const n = preview.wouldExpire;
+			if (!unwrap(await p.confirm({
+				message: `This deletes ${n} existing snapshot${n === 1 ? "" : "s"} of "${slug}" within the hour. Continue?`,
+				initialValue: false
+			}))) {
+				p.cancel("Aborted.");
+				return;
+			}
+		}
+		const settings = await withContext(apiRequest("PUT", path, change), context);
+		if (args.json) {
+			console.log(JSON.stringify(settings, null, 2));
 			return;
 		}
-		for (const snapshot of snapshots) console.log(`${snapshot.key}  ${formatSize(snapshot.size).padStart(9)}  ${snapshot.createdAt}`);
+		printSettings(slug, settings);
+		if ((settings.wouldExpire ?? 0) > 0) console.log(`\n${settings.wouldExpire} snapshot(s) past retention will be deleted within the hour.`);
 	})
 });
+const listSnapshotsRun = reportErrors("db snapshots", async ({ args }) => {
+	const { slug } = resolveProject(args);
+	const [{ snapshots }, settings] = await Promise.all([apiDataRequest("GET", "/db/snapshots", slug, void 0, void 0, channelOf(args)), apiRequest("GET", `/projects/${slug}/snapshot-settings`).catch(() => null)]);
+	if (settings) {
+		console.log(`Schedule: ${describeSchedule(settings)} · retention: ${describeRetention(settings)}`);
+		if (settings.lastRun) console.log(`Last scheduled run: ${describeLastRun(settings.lastRun)}`);
+		console.log("");
+	}
+	if (snapshots.length === 0) {
+		console.log(`No snapshots for ${slug}${channelNote(args)} yet — run \`canopy db snapshot\`.`);
+		return;
+	}
+	for (const snapshot of snapshots) console.log(`${snapshot.key}  ${(snapshot.kind ?? "").padEnd(11)}  ${formatSize(snapshot.size).padStart(9)}  ${snapshot.createdAt}`);
+});
+const snapshotsCommand = defineCommand({
+	meta: {
+		name: "snapshots",
+		description: "List stored snapshots (and delete, settings)"
+	},
+	args: {
+		...projectFlagArgs,
+		...stagingFlagArgs
+	},
+	subCommands: {
+		delete: snapshotsDeleteCommand,
+		settings: snapshotsSettingsCommand
+	},
+	run: (context) => snapshotsSubcommandRan ? void 0 : listSnapshotsRun(context)
+});
 const restoreCommand = defineCommand({
 	meta: {
 		name: "restore",

package/dist/{deploy-Ka2lHkyy.mjs → deploy-CqCyry4o.mjs}

@@ -1,7 +1,7 @@
 import { a as projectDirArgs, c as resolveProject, l as stagingUrl, n as siteConfig, o as projectFlagArgs, s as projectUrl, u as tryReadCanopyJson } from "./site-DM2J10CB.mjs";
-import { i as apiRequest, n as apiDataRequest, o as withContext, r as apiDownload } from "./api-C4rMhE7i.mjs";
-import { a as unwrap, r as reportErrors, t as formatDateTime } from "./ui-C_jSc1Kz.mjs";
-import { n as migrateProject, r as readMigrationFiles, t as describeMigrateResult } from "./migrations-Czlcddyz.mjs";
+import { i as apiRequest, n as apiDataRequest, o as withContext, r as apiDownload } from "./api-BPEYm9ts.mjs";
+import { a as unwrap, r as reportErrors, t as formatDateTime } from "./ui-CHfKV6lG.mjs";
+import { n as migrateProject, r as readMigrationFiles, t as describeMigrateResult } from "./migrations-CF1iNZ7F.mjs";
 import { builtinModules } from "node:module";
 import { defineCommand } from "citty";
 import { mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";

package/dist/{dev-BdXslHoA.mjs → dev-BtnEuAnS.mjs}

@@ -1,7 +1,7 @@
 import { a as projectDirArgs, c as resolveProject, i as projectDialect, n as siteConfig, u as tryReadCanopyJson } from "./site-DM2J10CB.mjs";
-import { i as apiRequest, o as withContext, t as ApiError } from "./api-C4rMhE7i.mjs";
-import { r as reportErrors, t as formatDateTime } from "./ui-C_jSc1Kz.mjs";
-import { r as readMigrationFiles } from "./migrations-Czlcddyz.mjs";
+import { i as apiRequest, o as withContext, t as ApiError } from "./api-BPEYm9ts.mjs";
+import { r as reportErrors, t as formatDateTime } from "./ui-CHfKV6lG.mjs";
+import { r as readMigrationFiles } from "./migrations-CF1iNZ7F.mjs";
 import { i as stampWorkerHeaders, n as WORKER_ATTEST_HEADER } from "./src-CxzGOEhP.mjs";
 import { n as writeDevServerRecord } from "./dev-server-file-Dk9pk4AR.mjs";
 import { createRequire } from "node:module";
@@ -251,7 +251,7 @@ async function devRemote(flags, slug) {
 async function devLocal(flags, slug) {
 	let dump;
 	if (flags.pull) {
-		const { fetchProjectDump } = await import("./local-Cyl39_Zu.mjs");
+		const { fetchProjectDump } = await import("./local-BfqTheMP.mjs");
 		console.log(`Pulling a fresh export of ${slug}${flags.staging ? " [staging]" : ""}…`);
 		dump = await fetchProjectDump(slug, flags.staging ? "staging" : "live");
 	}
@@ -267,7 +267,7 @@ async function devLocal(flags, slug) {
 		console.log(`Note: ai/services will be unavailable — could not reach the platform (${reason}).`);
 	}
 	const workerAttest = randomBytes(24).toString("base64url");
-	const { createSandbox } = await import("./local-Cyl39_Zu.mjs");
+	const { createSandbox } = await import("./local-BfqTheMP.mjs");
 	const sandbox = await createSandbox({
 		slug,
 		persistDir: join(flags.dir, ".canopy", "local"),

package/dist/dev-D_qzeLng.mjs

@@ -0,0 +1,2 @@
+import { n as devCommand } from "./dev-BtnEuAnS.mjs";
+export { devCommand };

package/dist/docs/cli-create.md

@@ -11,6 +11,7 @@ description: Register a new project on Canopy and scaffold it locally from a sta
 canopy create                             # fully interactive
 canopy create "My Portfolio" --slug my-portfolio --template spa
 canopy create existing-app --no-scaffold  # register only, no files written
+canopy create "My Retro" --from retro-board  # start from a template
 ```
 
 ## Arguments & flags
@@ -20,6 +21,7 @@ canopy create existing-app --no-scaffold  # register only, no files written
 - `--template <id>` — starter to scaffold: `static` (plain HTML/CSS/JS, no build step, untyped SDK from the platform — simplest apps), `spa` (Vite + React + TypeScript with the typed SDK from npm — best for real SDK use or growth), or `worker` (`spa` plus a backend worker in `worker/` — for server-side code: secrets, schedules, calling external APIs). A picker appears when omitted on a TTY; `static` is the default otherwise.
 - `--scaffold` / `--no-scaffold` — whether to write `./<slug>/` from the template. When neither is given, the CLI scaffolds unless the current directory already has a `canopy.json` (in which case it assumes you're registering an existing app and only registers).
 - `--repo` / `--no-repo` — also create a git repository for the project on Canopy and set up the new folder to push to it (see [`canopy repo`](https://docs.canopy.website/cli/repo)). When neither is given, an interactive run asks (default no) on sites that offer repositories; non-interactive runs create none.
+- `--from <template>` — start from a template project instead of a starter: the new project gets a copy of the template's code in its own git repository, cloned into `./<slug>/`, plus the setup the code needs. The CLI shows what comes along and asks before creating. `--template`, `--scaffold` and `--repo` don't apply. See [Start from a template](https://docs.canopy.website/guides/templates).
 - `--profile <site>` — global flag (or `CANOPY_PROFILE`): which site to create the project on. The chosen profile is pinned into the scaffolded `canopy.json`.
 
 ## How it works

package/dist/docs/cli-db.md

@@ -13,6 +13,9 @@ The habit that makes restores safe: **always `canopy db snapshot` before `canopy
 canopy db pull [--out <file>] [--project <slug>]
 canopy db snapshot [--project <slug>]
 canopy db snapshots [--project <slug>]
+canopy db snapshots delete <key> [--yes] [--project <slug>]
+canopy db snapshots settings [--schedule off|daily|weekly] [--retention <days>|off]
+                             [--retention-scope all|scheduled] [--yes] [--json] [--project <slug>]
 canopy db restore [file.sql] [--snapshot <key>] [--yes] [--project <slug>]
 canopy db migrate [--plan] [--project <slug>]
 ```
@@ -37,7 +40,27 @@ Stores a dump **server-side**, restorable anytime from the CLI or the dashboard.
 
 ### canopy db snapshots
 
-Lists stored snapshots for the project — one line per snapshot with its key, size, and creation time. If there are none yet, it points you at `canopy db snapshot`.
+Lists stored snapshots for the project — one line per snapshot with its key, kind, size, and creation time — under a line with the project's schedule, retention and last scheduled run. The kind says what made it: `manual` (you), `scheduled` (Canopy, on the schedule), `pre-migrate` or `pre-promote` (Canopy, before applying migrations). If there are none yet, it points you at `canopy db snapshot`.
+
+### canopy db snapshots delete
+
+Deletes one stored snapshot for good: it can't be restored afterwards. Asks for confirmation unless `--yes` is passed. Use `--staging` for a snapshot in the staging history.
+
+Deleting needs your own sign-in (`canopy login`). Project tokens, such as the ones `canopy dev` or an agent uses, can't delete snapshots.
+
+### canopy db snapshots settings
+
+Shows or changes when Canopy takes snapshots by itself and how long snapshots are kept. With no flags it prints the current settings.
+
+- `--schedule off|daily|weekly` — Canopy snapshots the live database once a day or once a week, at a fixed time it picks for the project (shown in UTC). The staging database is not snapshotted on a schedule.
+- `--retention <days>` — delete snapshots older than this many days (1 to 365), once a day. `--retention off` keeps snapshots until you delete them. Retention works with or without a schedule, and covers both the live and the staging history.
+- `--retention-scope all|scheduled` — which snapshots retention deletes: `all` (the default) includes the ones you took by hand and the ones taken before migrations; `scheduled` only deletes the ones Canopy took on the schedule.
+- `--yes` — when a new retention would delete existing snapshots, the CLI says how many and asks first. `--yes` skips that.
+- `--json` — print the settings as JSON.
+
+A daily schedule needs at least 1 day of retention and a weekly one at least 7, so there is never a stretch without a snapshot. Like deleting, changing the settings needs your own sign-in.
+
+Canopy also keeps short-lived backups of its own databases and storage for disaster recovery. Those expire on their own within 30 days and can't be restored from the CLI.
 
 ### canopy db restore
 
@@ -73,6 +96,12 @@ canopy db snapshot && canopy db pull
 
 Belt and braces before risky work: a server-side snapshot you can restore from the dashboard, plus a local dump on disk.
 
+```bash
+canopy db snapshots settings --schedule daily --retention 30
+```
+
+A daily backup, with snapshots older than 30 days deleted automatically.
+
 ```bash
 canopy db restore --snapshot snap-2026-08-11-1200 --yes --project my-app
 ```

package/dist/docs/cli-projects.md

@@ -10,12 +10,14 @@ description: List your Canopy projects with their status, role, and live URLs.
 ```bash
 canopy projects
 canopy projects --all
+canopy projects --templates
 canopy --profile staging projects
 ```
 
 ## Arguments & flags
 
 - `--all` — include projects you can't edit. By default the list shows only projects where you're an owner or editor (admins always see everything, since they can edit everything).
+- `--templates` — list the templates anyone can start a project from, with their owners. See [Start from a template](https://docs.canopy.website/guides/templates).
 - `--profile <site>` — global flag (or `CANOPY_PROFILE`): each site has its own project registry, so listing on `staging` shows a completely different set than `main`.
 
 ## Details

package/dist/docs/cli-secrets.md

@@ -25,7 +25,8 @@ target directory, or `--project <slug>` to override — and honor the global
 `--profile <site>` / `CANOPY_PROFILE`.
 
 - `list` — print the secret names and when each was last set. Values are
-  never shown.
+  never shown. For a project started from a template, names it still needs a
+  value for are listed as missing.
 - `set <name>` — store a value. Names are `UPPER_SNAKE_CASE`, up to 64
   characters. The value comes from **stdin** when piped (one trailing newline
   is trimmed, so `echo` works too), from `--from-env <VAR>` to read an

package/dist/docs/cli-template.md

@@ -0,0 +1,47 @@
+---
+title: canopy template
+description: Offer a project as a template, or see what a template gives a new project.
+---
+
+`canopy template` controls whether others can start a project from yours, and
+shows what a template gives a new project. To start from one, use
+[`canopy create --from`](https://docs.canopy.website/cli/create).
+
+## Usage
+
+```bash
+canopy template mark [--yes]
+canopy template unmark
+canopy template show <slug>
+```
+
+## Arguments & flags
+
+`mark` and `unmark` resolve the project the usual way: `canopy.json` in the
+target folder, or `--project <slug>`. All of them honour the global
+`--profile <site>` / `CANOPY_PROFILE`.
+
+- `mark` — let anyone on the site start a project from this one. Owner only.
+  The project needs a Canopy git repository with code pushed to it. Asks for
+  confirmation; `--yes` skips it in scripts. Warns when `canopy.json` names no
+  migrations folder, because new projects then start without any tables.
+- `unmark` — stop new projects starting from this one. Existing copies are not
+  affected.
+- `show <slug>` — what a new project gets from a template: the code, outbound
+  hosts, page settings, Google access, schedules (turned off) and secret names.
+
+## Examples
+
+```bash
+canopy template mark
+```
+
+Offers the project in this folder as a template.
+
+```bash
+canopy template show retro-board
+```
+
+Shows what `canopy create --from retro-board` would give you.
+
+Read [Start from a template](https://docs.canopy.website/guides/templates) for the bigger picture.

package/dist/docs/data.md

@@ -61,6 +61,17 @@ canopy db snapshots    # list stored snapshots
 Snapshots live on the platform and can be restored at any time — handy before a
 risky change.
 
+Canopy can also take them for you, and clean up old ones:
+
+```bash
+canopy db snapshots settings --schedule daily --retention 30   # daily backup, keep 30 days
+canopy db snapshots settings --retention-scope scheduled       # never auto-delete your own
+canopy db snapshots delete <key>                               # delete one for good
+```
+
+The same settings are on the dashboard's Data tab. See
+[`canopy db`](https://docs.canopy.website/cli/db#canopy-db-snapshots-settings) for every option.
+
 ## Restore — destructive
 
 > **Warning:** Restoring **replaces ALL project data**. Take a snapshot first — a snapshot taken seconds earlier

package/dist/docs/index.json

@@ -72,6 +72,11 @@
           "title": "Keep your code in git",
           "summary": "Give your project a git repository on Canopy — history, backup and sharing, no GitHub account needed."
         },
+        {
+          "slug": "templates",
+          "title": "Start from a template",
+          "summary": "Begin a project from someone else's working one — a copy of their code and setup, never their data."
+        },
         {
           "slug": "agent-tools",
           "title": "Agent tools (MCP)",
@@ -266,6 +271,11 @@
           "title": "canopy repo",
           "summary": "Create, clone and set up the project's git repository on Canopy."
         },
+        {
+          "slug": "cli-template",
+          "title": "canopy template",
+          "summary": "Offer a project as a template, or see what a template gives a new project."
+        },
         {
           "slug": "cli-egress",
           "title": "canopy egress",

package/dist/docs/platform-project-data.md

@@ -45,8 +45,28 @@ The Data tab's **Data safety** card is your undo button for data:
   confirm.
 - **Export** downloads a dump to your machine.
 
-Snapshots live server-side and stay available until you delete the project,
-so you can restore from days ago, not just from your last session.
+Snapshots live server-side, so you can restore from days ago, not just from
+your last session. Each one shows what made it: you, the schedule, or Canopy
+before applying migrations. You can delete one you no longer need; it's gone
+for good.
+
+## Scheduled snapshots and retention
+
+In the same card you can have Canopy take a snapshot of the live database
+**daily** or **weekly**, at a fixed time it picks for the project. You don't
+need a worker or any code for it.
+
+**Retention** deletes snapshots older than a number of days you choose, once a
+day. Choose whether it applies to all snapshots or only the scheduled ones, so
+your own restore points stay until you delete them. Retention also works
+without a schedule. Without retention, snapshots stay until you delete them or
+the project.
+
+Changing these settings and deleting snapshots needs a project member signed
+in as themselves.
+
+Canopy also keeps short-lived backups of its own databases and storage for
+disaster recovery. Those expire on their own within 30 days.
 
 > **Warning:** Restoring replaces **all** current data with the snapshot's contents. Take a fresh snapshot first
 > if there's anything recent you might want back.
@@ -58,7 +78,7 @@ Everything above is also available to you (and your coding agent) via the CLI:
 ```bash
 canopy db pull        # download a fresh SQL dump
 canopy db snapshot    # store a dump server-side
-canopy db snapshots   # list stored snapshots
+canopy db snapshots   # list stored snapshots (delete, settings)
 canopy db restore     # replace project data with a snapshot
 canopy db access      # what the app's own pages may do with the database
 ```

package/dist/docs/templates.md

@@ -0,0 +1,84 @@
+---
+title: Start from a template
+description: Begin a project from someone else's working one — a copy of their code and setup, never their data.
+---
+
+Some projects are worth starting from: a retro board, a feedback form, a small
+dashboard on an internal API. When the owner offers one as a **template**,
+anyone on Canopy can start a project of their own from it. You get a copy of
+the code and the setup the code needs, then change it however you like.
+
+Your copy is yours. Later changes to the template don't reach it, and nothing
+you do reaches the template.
+
+## Find one
+
+```bash
+canopy projects --templates
+canopy template show retro-board
+```
+
+`show` lists exactly what a new project gets. In the dashboard, switch on the
+**Templates** filter on the project list; each template has a **Use as
+template** button that shows the same list.
+
+## Start your project
+
+```bash
+canopy create "My Retro" --slug my-retro --from retro-board
+```
+
+Canopy creates the project, gives it its own git repository with the
+template's code in one fresh commit, and clones it into `./my-retro/`. It then
+tells you what is left, usually:
+
+```bash
+cd my-retro
+canopy secrets set OPENAI_KEY
+canopy deploy
+```
+
+The first deploy runs the template's migrations, so your database starts with
+its tables and nothing else.
+
+## What you get, and what you don't
+
+You get:
+
+- the code in the template's repository, as it is right now, without its
+  history;
+- its allowed outbound hosts and page settings;
+- the Google access it asks visitors for (restricted Google access stays off
+  until a Canopy admin unlocks it for your project);
+- its schedules, **turned off** — turn each one on when you're ready;
+- the **names** of its secrets, so you know what to fill in. `canopy secrets
+list` shows the ones still missing.
+
+You never get its data, stored files, secret values, members, client password,
+budgets, feedback or deploy history. Your project starts with the usual
+defaults for those.
+
+## Offer your project as a template
+
+Your project needs a Canopy git repository with your code pushed to it (see
+[Keep your code in git](https://docs.canopy.website/guides/git)). Then:
+
+```bash
+canopy template mark
+```
+
+or **Settings → Template** in the dashboard. Only the owner can do this.
+
+Before you do:
+
+- **Everyone on the site can copy the code.** Make sure the repository holds no
+  keys, passwords or client data.
+- **Put sample data in migrations.** The database never comes along, so any
+  starting rows belong in your migrations. Without a migrations folder, new
+  projects start with an empty database.
+- **Explain setup in the README.** It's the first thing people read in their
+  copy.
+
+`canopy template unmark` stops new copies. Projects already started from it
+are not affected. The template's Settings page shows how many projects started
+from it.

package/dist/{docs-Bb9hSk4h.mjs → docs-T1nuu00A.mjs}

@@ -1,7 +1,7 @@
-import { t as version } from "./package-lYhex2Gp.mjs";
+import { t as version } from "./package-CdDH35SE.mjs";
 import { n as siteConfig } from "./site-DM2J10CB.mjs";
 import { i as latestKnownVersion, r as compareSemver } from "./version-check-CcsA1QjI.mjs";
-import { r as reportErrors } from "./ui-C_jSc1Kz.mjs";
+import { r as reportErrors } from "./ui-CHfKV6lG.mjs";
 import { defineCommand } from "citty";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";

package/dist/{egress-If_Gsx_M.mjs → egress-ButFsQ2N.mjs}

@@ -1,6 +1,6 @@
 import { a as projectDirArgs, c as resolveProject } from "./site-DM2J10CB.mjs";
-import { i as apiRequest, o as withContext } from "./api-C4rMhE7i.mjs";
-import { a as unwrap, i as requireTty, r as reportErrors, t as formatDateTime } from "./ui-C_jSc1Kz.mjs";
+import { i as apiRequest, o as withContext } from "./api-BPEYm9ts.mjs";
+import { a as unwrap, i as requireTty, r as reportErrors, t as formatDateTime } from "./ui-CHfKV6lG.mjs";
 import { defineCommand } from "citty";
 import * as p from "@clack/prompts";
 //#region src/egress.ts

package/dist/{feedback-DzEKQlP6.mjs → feedback-C5NKCOXQ.mjs}

@@ -1,7 +1,7 @@
-import { t as version } from "./package-lYhex2Gp.mjs";
+import { t as version } from "./package-CdDH35SE.mjs";
 import { a as projectDirArgs, c as resolveProject, d as tryResolveProject, n as siteConfig, u as tryReadCanopyJson } from "./site-DM2J10CB.mjs";
-import { a as apiUpload, i as apiRequest, r as apiDownload } from "./api-C4rMhE7i.mjs";
-import { r as reportErrors, t as formatDateTime } from "./ui-C_jSc1Kz.mjs";
+import { a as apiUpload, i as apiRequest, r as apiDownload } from "./api-BPEYm9ts.mjs";
+import { r as reportErrors, t as formatDateTime } from "./ui-CHfKV6lG.mjs";
 import { defineCommand } from "citty";
 import { basename, extname, join } from "node:path";
 import { readFile, writeFile } from "node:fs/promises";