Add newcomer guide, agent guide, and sample app files

DIACHRON.md explains the framework to newcomers joining a
diachron-based project.  diachron/AGENTS.md helps AI coding
agents work with the framework conventions and commands.
backend/types.ts and backend/services.ts are sample starting
points for application-specific types and services.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

DIACHRON.md

@@ -0,0 +1,168 @@
+# What is diachron?
+
+diachron is a web framework for TypeScript and Node.js.  It uses a Go-based
+master process that handles file watching, building, process management, and
+request proxying.  The application code is TypeScript running on Express.js.
+
+If you're joining a project that uses diachron, this document will orient you.
+
+## Why diachron exists
+
+diachron was built around a few frustrations with mainstream web frameworks:
+
+- **No dev/prod split.**  Most frameworks behave differently in development and
+  production.  diachron doesn't.  The master process watches files, rebuilds,
+  and manages workers the same way everywhere.  There is no `NODE_ENV`.
+
+- **Managed tooling.**  Node.js, pnpm, and other tools are downloaded and
+  pinned to exact versions inside the project.  You don't install them
+  system-wide.  Everyone on the team runs the same binaries.
+
+- **PostgreSQL, directly.**  No ORM, no database abstraction layer.  You write
+  SQL (via Kysely for type safety) and talk to PostgreSQL.  If you need
+  MySQL or SQLite support, this is not the framework for you.
+
+- **Debuggability over magic.**  Everything is explicit and inspectable.
+  Logging and observability are first-class concerns, not afterthoughts.
+
+diachron is inspired by the
+[Taking PHP Seriously](https://slack.engineering/taking-php-seriously/) essay
+from Slack Engineering.  It's designed for small to medium systems (what we
+call "Ring 0 and Ring 1") -- not heavy-compliance or banking-scale
+applications.
+
+## How it works
+
+When you run `./master`, the following happens:
+
+1. The Go master process starts and watches your TypeScript source files.
+2. It builds the backend using `@vercel/ncc`, producing a single bundled JS
+   file.
+3. It starts one or more Node.js worker processes running your Express app.
+4. It proxies HTTP requests from port 8080 to the workers.
+5. When you edit a source file, it rebuilds and restarts the workers
+   automatically.
+6. If a worker crashes, it restarts automatically.
+
+There is no separate "dev server" or "hot module replacement."  The master
+process is the only way to run the application.
+
+## Project structure
+
+A diachron project looks like this:
+
+```
+.
+├── DIACHRON.md      # This file (framework overview for newcomers)
+├── master/          # Go master process (framework-owned)
+├── logger/          # Go logging service (framework-owned)
+├── diachron/        # Managed binaries, shims, framework library
+│   ├── AGENTS.md    # Guide for AI coding agents
+│   ├── binaries/    # Downloaded Node.js, pnpm (gitignored)
+│   ├── cmd.d/       # Commands available via ./cmd
+│   ├── shims/       # Wrappers that use managed binaries
+│   └── ...
+├── backend/         # Your application code
+│   ├── app.ts       # Entry point
+│   ├── routes.ts    # Route definitions
+│   ├── handlers.ts  # Route handlers
+│   ├── services.ts  # Service layer
+│   ├── types.ts     # Application types
+│   ├── config.ts    # Application configuration
+│   └── diachron/    # Framework library code (framework-owned)
+├── cmd              # Run managed commands (./cmd pnpm install, etc.)
+├── develop          # Development-only commands (./develop reset-db, etc.)
+├── mgmt             # Management commands safe for production
+├── sync.sh          # Install/update all dependencies
+├── master           # The compiled master binary (after sync)
+└── docker-compose.yml
+```
+
+### File ownership
+
+There are two owners of files in a diachron project:
+
+- **You own** everything in `backend/` (except `backend/diachron/`), plus
+  `docker-compose.yml`, `package.json`, and anything else you create.
+- **The framework owns** `master/`, `logger/`, `diachron/`,
+  `backend/diachron/`, and the top-level scripts (`cmd`, `develop`, `mgmt`,
+  `sync.sh`, `check.sh`).
+
+Don't modify framework-owned files.  This separation keeps framework upgrades
+clean.
+
+## Getting started
+
+```bash
+# Install dependencies and build the master process
+./sync.sh
+
+# Start the application
+./master
+```
+
+The app will be available at `http://localhost:8080`.
+
+You need Linux or macOS on x86_64.  For the full stack (database, Redis,
+etc.), you also need `docker compose`.
+
+## The command system
+
+diachron has three types of commands, separated by intent and safety:
+
+- **`./cmd <command>`** -- Run managed tools (node, pnpm, tsx, etc.).  These
+  use the project's pinned versions, not whatever is installed on your system.
+
+  ```bash
+  ./cmd pnpm install
+  ./cmd pnpm test
+  ```
+
+- **`./mgmt <command>`** -- Management commands that are safe to run in
+  production.  Migrations, user management, that sort of thing.
+
+  ```bash
+  ./mgmt migrate
+  ./mgmt add-user
+  ```
+
+- **`./develop <command>`** -- Development commands that may be destructive.
+  Database resets, fixture loading, etc.  These are gated in production.
+
+  ```bash
+  ./develop reset-db
+  ./develop db           # Open a database shell
+  ```
+
+The rule of thumb: if you'd run it at 3am while tired and worried, it's a
+`mgmt` command.  If it destroys data on purpose, it's a `develop` command.
+
+## Key concepts
+
+### Call and Result
+
+diachron wraps Express's `Request` and `Response` in its own types called
+`Call` and `Result`.  This avoids shadowing and keeps the framework's
+interface distinct from Express internals.  Your handlers receive a `Call`
+and return a `Result`.
+
+### Routes
+
+Routes are defined as data (arrays of `Route` objects in `routes.ts`), not
+through decorators or method chaining.  The framework processes them into
+Express handlers.
+
+### No environment variables for behavior
+
+There is no `NODE_ENV`, no `DEBUG`, no mode switching.  Configuration that
+must vary between deployments (database URLs, secrets) lives in
+configuration files, but the application's behavior doesn't branch on
+environment.
+
+## Further reading
+
+- `README.md` -- Project introduction and requirements
+- `diachron/AGENTS.md` -- Guide for AI coding agents
+- `docs/` -- Design documents and philosophy
+- `docs/commands.md` -- Detailed explanation of the command system
+- `docs/concentric-circles.md` -- What diachron is (and isn't) designed for

README.md

@@ -49,6 +49,16 @@ enough libc to run golang binaries.
 
 To run a more complete system, you also need to have docker compose installed.
 
+### Database
+
+To connect to the database, you need psql (PostgreSQL client, for
+`./diachron/common.d/db`)
+
+- macOS: `brew install libpq` (and follow the caveat to add it to your PATH),
+  or `brew install postgresql`
+- Debian/Ubuntu: `apt install postgresql-client`
+- Fedora/RHEL: `dnf install postgresql`
+
 ### Development requirements
 
 To hack on diachron itself, you need the following:

TODO.md

@@ -56,6 +56,13 @@ CREATE TABLE app.customer_metadata (...);
       leaves around `master-bin`, `logger-bin`, and `diachron:nnnn` processes.
       Huge problem.
 
+- [ ] Fix format used by master (and logger?)'s output: it should be logfmt
+  - A lot of other stuff should probably be logfmt too but maybe we can get to
+    that later
+
+- [ ] master rebuilds (or tries to) too many times; need some sort of debounce
+      or whatever it's called
+
 ## medium importance
 
 - [ ] Add a log viewer

backend/.npmrc

@@ -0,0 +1 @@
+shamefully-hoist=true

backend/app.ts

@@ -1,172 +1,20 @@
-import express, {
-    type Request as ExpressRequest,
-    type Response as ExpressResponse,
-} from "express";
-import { match } from "path-to-regexp";
-import { Session } from "./diachron/auth";
-import { cli } from "./diachron/cli";
-import { contentTypes } from "./diachron/content-types";
-import { runWithContext } from "./diachron/context";
+// This is a sample file provided by diachron.  You are encouraged to modify it.
+
+
+
+
 import { core } from "./diachron/core";
-import { httpCodes } from "./diachron/http-codes";
-import { request } from "./diachron/request";
-// import { URLPattern } from 'node:url';
-import {
-    AuthenticationRequired,
-    AuthorizationDenied,
-    type Call,
-    type InternalHandler,
-    isRedirect,
-    type Method,
-    massageMethod,
-    methodParser,
-    type ProcessedRoute,
-    type Result,
-    type Route,
-} from "./diachron/types";
+
 import { routes } from "./routes";
+import {makeApp}from'./diachron/app'
 
-const app = express();
 
-// Parse request bodies
-app.use(express.json());
-app.use(express.urlencoded({ extended: true }));
+const app = makeApp({routes});
+
 
 core.logging.log({ source: "logging", text: ["1"] });
-const processedRoutes: { [K in Method]: ProcessedRoute[] } = {
-    GET: [],
-    POST: [],
-    PUT: [],
-    PATCH: [],
-    DELETE: [],
-};
 
-function _isPromise<T>(value: T | Promise<T>): value is Promise<T> {
-    return typeof (value as any)?.then === "function";
-}
 
-routes.forEach((route: Route, _idx: number, _allRoutes: Route[]) => {
-    // const pattern /*: URLPattern */ = new URLPattern({ pathname: route.path });
-    const matcher = match<Record<string, string>>(route.path);
-    const methodList = route.methods;
 
-    const handler: InternalHandler = async (
-        expressRequest: ExpressRequest,
-    ): Promise<Result> => {
-        const method = massageMethod(expressRequest.method);
 
-        console.log("method", method);
-
-        if (!methodList.includes(method)) {
-            // XXX: Worth asserting this?
-        }
-
-        console.log("request.originalUrl", expressRequest.originalUrl);
-
-        // Authenticate the request
-        const auth = await request.auth.validateRequest(expressRequest);
-
-        const req: Call = {
-            pattern: route.path,
-            path: expressRequest.originalUrl,
-            method,
-            parameters: { one: 1, two: 2 },
-            request: expressRequest,
-            user: auth.user,
-            session: new Session(auth.session, auth.user),
-        };
-
-        try {
-            const retval = await runWithContext({ user: auth.user }, () =>
-                route.handler(req),
-            );
-            return retval;
-        } catch (error) {
-            // Handle authentication errors
-            if (error instanceof AuthenticationRequired) {
-                return {
-                    code: httpCodes.clientErrors.Unauthorized,
-                    contentType: contentTypes.application.json,
-                    result: JSON.stringify({
-                        error: "Authentication required",
-                    }),
-                };
-            }
-            if (error instanceof AuthorizationDenied) {
-                return {
-                    code: httpCodes.clientErrors.Forbidden,
-                    contentType: contentTypes.application.json,
-                    result: JSON.stringify({ error: "Access denied" }),
-                };
-            }
-            throw error;
-        }
-    };
-
-    for (const [_idx, method] of methodList.entries()) {
-        const pr: ProcessedRoute = { matcher, method, handler };
-
-        processedRoutes[method].push(pr);
-    }
-});
-
-async function handler(
-    req: ExpressRequest,
-    _res: ExpressResponse,
-): Promise<Result> {
-    const method = await methodParser.parseAsync(req.method);
-
-    const byMethod = processedRoutes[method];
-    console.log(
-        "DEBUG: req.path =",
-        JSON.stringify(req.path),
-        "method =",
-        method,
-    );
-    for (const [_idx, pr] of byMethod.entries()) {
-        const match = pr.matcher(req.path);
-        console.log("DEBUG: trying pattern, match result =", match);
-        if (match) {
-            console.log("match", match);
-            const resp = await pr.handler(req);
-
-            return resp;
-        }
-    }
-
-    const retval: Result = {
-        code: httpCodes.clientErrors.NotFound,
-        contentType: contentTypes.text.plain,
-        result: "not found!",
-    };
-
-    return retval;
-}
-
-app.use(async (req: ExpressRequest, res: ExpressResponse) => {
-    const result0 = await handler(req, res);
-
-    const code = result0.code.code;
-    const result = result0.result;
-
-    console.log(result);
-
-    // Set any cookies from the result
-    if (result0.cookies) {
-        for (const cookie of result0.cookies) {
-            res.cookie(cookie.name, cookie.value, cookie.options ?? {});
-        }
-    }
-
-    if (isRedirect(result0)) {
-        res.redirect(code, result0.redirect);
-    } else {
-        res.status(code).send(result);
-    }
-});
-
-process.title = `diachron:${cli.listen.port}`;
-
-app.listen(cli.listen.port, cli.listen.host, () => {
-    console.log(`Listening on ${cli.listen.host}:${cli.listen.port}`);
-});
+app.start()

backend/build.sh

@@ -6,4 +6,4 @@ DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
 cd "$DIR"
 
-../cmd pnpm ncc build ./app.ts -o dist
+../cmd pnpm ncc build ./app.ts -o dist --source-map

backend/check-deps.ts

@@ -0,0 +1,66 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+interface PackageJson {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+}
+
+function readPackageJson(path: string): PackageJson {
+    const content = readFileSync(path, "utf-8");
+    return JSON.parse(content);
+}
+
+function getAllDependencyNames(pkg: PackageJson): Set<string> {
+    const names = new Set<string>();
+    for (const name of Object.keys(pkg.dependencies ?? {})) {
+        names.add(name);
+    }
+    for (const name of Object.keys(pkg.devDependencies ?? {})) {
+        names.add(name);
+    }
+    return names;
+}
+
+const diachronPkgPath = join(__dirname, "diachron", "package.json");
+const backendPkgPath = join(__dirname, "package.json");
+
+const diachronPkg = readPackageJson(diachronPkgPath);
+const backendPkg = readPackageJson(backendPkgPath);
+
+const diachronDeps = getAllDependencyNames(diachronPkg);
+const backendDeps = getAllDependencyNames(backendPkg);
+
+const duplicates: string[] = [];
+
+for (const dep of diachronDeps) {
+    if (backendDeps.has(dep)) {
+        duplicates.push(dep);
+    }
+}
+
+if (duplicates.length > 0) {
+    console.error("Error: Duplicate dependencies found.");
+    console.error("");
+    console.error(
+        "The following dependencies exist in both backend/package.json and backend/diachron/package.json:",
+    );
+    console.error("");
+    for (const dep of duplicates.sort()) {
+        console.error(`  - ${dep}`);
+    }
+    console.error("");
+    console.error(
+        "Dependencies in backend/diachron/package.json are provided by the framework",
+    );
+    console.error(
+        "and must not be duplicated in backend/package.json. Remove them from",
+    );
+    console.error("backend/package.json to fix this error.");
+    process.exit(1);
+}
+
+console.log("No duplicate dependencies found.");

backend/check.sh

@@ -11,4 +11,5 @@ out_dir="$check_dir/out"
 source "$check_dir"/../diachron/shims/common
 source "$check_dir"/../diachron/shims/node.common
 
+$ROOT/cmd tsx "$check_dir/check-deps.ts"
 $ROOT/cmd pnpm tsc --outDir "$out_dir"

backend/diachron/app.ts

@@ -0,0 +1,137 @@
+// FIXME: rename this to make-app.ts and adjust imports accordingly
+
+import{contentTypes} from './content-types'
+import{httpCodes}from'./http-codes'
+import express, {
+type Express,
+    type NextFunction,
+    type Request as ExpressRequest,
+    type Response as ExpressResponse,
+} from "express";
+import { formatError, formatErrorHtml } from "./errors";
+import {isRedirect,     InternalHandler,    AuthenticationRequired,
+    AuthorizationDenied, Call,type Method, type ProcessedRoute,methodParser, type Result, type Route,massageMethod } from "./types";
+
+
+
+import { cli } from "./cli";
+import{processRoutes}from'./routing'
+
+
+process.on('uncaughtException', (err) => {
+    console.error(formatError(err));
+    process.exit(1);
+});
+
+process.on('unhandledRejection', (reason) => {
+    console.error(formatError(reason));
+});
+
+
+type MakeAppArgs={routes:Route[],
+    processTitle?: string,
+}
+ 
+export interface DiachronApp extends Express {
+    start: () => void 
+}
+
+const makeApp = ({routes, processTitle}: MakeAppArgs) => {
+    if (process.title) {
+        process.title = `diachron:${cli.listen.port}`;
+    }
+
+    const processedRoutes = processRoutes(routes)
+
+    async function handler(
+    req: ExpressRequest,
+    _res: ExpressResponse,
+): Promise<Result> {
+    const method = await methodParser.parseAsync(req.method);
+
+    const byMethod = processedRoutes[method];
+    console.log(
+        "DEBUG: req.path =",
+        JSON.stringify(req.path),
+        "method =",
+        method,
+    );
+    for (const [_idx, pr] of byMethod.entries()) {
+        const match = pr.matcher(req.path);
+        console.log("DEBUG: trying pattern, match result =", match);
+        if (match) {
+            console.log("match", match);
+            const resp = await pr.handler(req);
+
+            return resp;
+        }
+    }
+
+    const retval: Result = {
+        code: httpCodes.clientErrors.NotFound,
+        contentType: contentTypes.text.plain,
+        result: "not found!",
+    };
+
+    return retval;
+}
+
+    // I don't like going around tsc but this is simple enough that it's probably OK.
+    const app = express() as DiachronApp
+    app.start = function() {
+        this.listen(cli.listen.port, cli.listen.host, () => {
+            console.log(`Listening on ${cli.listen.host}:${cli.listen.port}`);
+        });
+    };
+    
+
+
+
+
+    app.use(express.json())
+
+    app.use(express.urlencoded({ extended: true }));
+
+    app.use(async (req: ExpressRequest, res: ExpressResponse) => {
+        const result0 = await handler(req, res);
+        
+        const code = result0.code.code;
+    const result = result0.result;
+
+    console.log(result);
+
+    // Set any cookies from the result
+    if (result0.cookies) {
+        for (const cookie of result0.cookies) {
+            res.cookie(cookie.name, cookie.value, cookie.options ?? {});
+        }
+    }
+
+    if (isRedirect(result0)) {
+        res.redirect(code, result0.redirect);
+    } else {
+        res.status(code).send(result);
+    }
+    });
+
+    app.use(
+        (
+            err: Error,
+            _req: ExpressRequest,
+            res: ExpressResponse,
+            _next: NextFunction,
+        ) => {
+            console.error(formatError(err));
+            res.status(500).type("html").send(formatErrorHtml(err));
+        },
+    );
+
+return app;
+}
+
+export{makeApp};
+
+function _isPromise<T>(value: T | Promise<T>): value is Promise<T> {
+    return typeof (value as any)?.then === "function";
+}
+

backend/diachron/basic/routes.ts

@@ -10,9 +10,16 @@ const routes: Record<string, Route> = {
     hello: {
         path: "/hello",
         methods: ["GET"],
-        handler: async (_call: Call): Promise<Result> => {
+        handler: async (call: Call): Promise<Result> => {
             const now = DateTime.now();
-            const c = await render("basic/hello", { now });
+            const args: {now: DateTime,greeting?: string} = {now};
+
+            if (call.path !== '/hello') {
+                const greeting = call. path.replaceAll('/','').replaceAll('-', ' ')
+                args.greeting = greeting;
+            }
+
+            const c = await render("basic/hello", args);
 
             return html(c);
         },

backend/diachron/core/index.ts

@@ -1,5 +1,6 @@
 import nunjucks from "nunjucks";
 import { db, migrate, migrationStatus } from "../database";
+import { formatError, formatErrorHtml } from "../errors";
 import { getLogs, log } from "../logging";
 
 // FIXME: This doesn't belong here; move it somewhere else.
@@ -40,6 +41,7 @@ const misc = {
 const core = {
     conf,
     database,
+    errors: { formatError, formatErrorHtml },
     logging,
     misc,
     random,

backend/diachron/errors.ts

@@ -0,0 +1,229 @@
+// ANSI escape codes
+const bold = "\x1b[1m";
+const red = "\x1b[31m";
+const cyan = "\x1b[36m";
+const dim = "\x1b[2m";
+const reset = "\x1b[0m";
+
+interface ParsedFrame {
+    raw: string;
+    fn: string;
+    file: string;
+    line: string;
+    col: string;
+    isApp: boolean;
+}
+
+const frameRe = /^\s*at\s+(?:(.+?)\s+)?\(?((?:\/|[a-zA-Z]:\\).+?):(\d+):(\d+)\)?$/;
+
+function parseFrame(line: string): ParsedFrame | null {
+    const m = line.match(frameRe);
+    if (!m) return null;
+
+    const fn = m[1] ?? "<anonymous>";
+    const file = m[2];
+    const lineNum = m[3];
+    const col = m[4];
+
+    const isApp =
+        !file.includes("node_modules") && !file.startsWith("node:");
+
+    return { raw: line, fn, file, line: lineNum, col, isApp };
+}
+
+function relativePath(absPath: string): string {
+    const marker = "backend/";
+    const idx = absPath.lastIndexOf(marker);
+    if (idx !== -1) return absPath.slice(idx);
+    return absPath;
+}
+
+function libraryName(file: string): string {
+    const nmIdx = file.indexOf("node_modules/");
+    if (nmIdx === -1) return "node";
+    const after = file.slice(nmIdx + "node_modules/".length);
+    // Handle scoped packages like @scope/pkg
+    if (after.startsWith("@")) {
+        const parts = after.split("/");
+        return `${parts[0]}/${parts[1]}`;
+    }
+    return after.split("/")[0];
+}
+
+interface ParsedError {
+    message: string;
+    frames: ParsedFrame[];
+}
+
+function parseError(error: unknown): ParsedError {
+    if (!(error instanceof Error)) {
+        return { message: String(error), frames: [] };
+    }
+
+    const message = error.message ?? String(error);
+    const stack = error.stack ?? "";
+
+    const lines = stack.split("\n");
+    const frameLines: string[] = [];
+    for (const line of lines) {
+        if (line.trimStart().startsWith("at ")) {
+            frameLines.push(line);
+        }
+    }
+
+    const frames = frameLines
+        .map(parseFrame)
+        .filter((f): f is ParsedFrame => f !== null);
+
+    return { message, frames };
+}
+
+// Group consecutive library frames into collapsed runs
+type FrameGroup =
+    | { kind: "app"; frame: ParsedFrame }
+    | { kind: "lib"; count: number; names: string[] };
+
+function groupFrames(frames: ParsedFrame[]): FrameGroup[] {
+    const groups: FrameGroup[] = [];
+    let i = 0;
+    while (i < frames.length) {
+        if (frames[i].isApp) {
+            groups.push({ kind: "app", frame: frames[i] });
+            i++;
+        } else {
+            const libNames = new Set<string>();
+            let count = 0;
+            while (i < frames.length && !frames[i].isApp) {
+                libNames.add(libraryName(frames[i].file));
+                count++;
+                i++;
+            }
+            groups.push({ kind: "lib", count, names: [...libNames] });
+        }
+    }
+    return groups;
+}
+
+function libSummary(count: number, names: string[]): string {
+    const s = count === 1 ? "" : "s";
+    return `... ${count} internal frame${s} (${names.join(", ")})`;
+}
+
+// --- Console formatting (ANSI) ---
+
+function formatError(error: unknown): string {
+    const { message, frames } = parseError(error);
+    if (frames.length === 0) {
+        return `${bold}${red}ERROR${reset}  ${message}`;
+    }
+
+    const parts: string[] = [];
+    parts.push(`${bold}${red}ERROR${reset}  ${message}`);
+    parts.push("");
+
+    for (const group of groupFrames(frames)) {
+        if (group.kind === "app") {
+            const rel = relativePath(group.frame.file);
+            const loc = `${rel}:${group.frame.line}`;
+            parts.push(
+                `  ${bold}${cyan}${loc.padEnd(24)}${reset}at ${group.frame.fn}`,
+            );
+        } else {
+            parts.push(
+                `  ${dim}${libSummary(group.count, group.names)}${reset}`,
+            );
+        }
+    }
+
+    return parts.join("\n");
+}
+
+// --- HTML formatting (browser) ---
+
+function esc(s: string): string {
+    return s
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+
+function formatErrorHtml(error: unknown): string {
+    const { message, frames } = parseError(error);
+    const groups = groupFrames(frames);
+
+    let frameRows = "";
+    for (const group of groups) {
+        if (group.kind === "app") {
+            const rel = relativePath(group.frame.file);
+            const loc = `${rel}:${group.frame.line}`;
+            frameRows += `<tr class="app">
+  <td class="loc">${esc(loc)}</td>
+  <td class="fn">at ${esc(group.frame.fn)}</td>
+</tr>\n`;
+        } else {
+            frameRows += `<tr class="lib">
+  <td colspan="2">${esc(libSummary(group.count, group.names))}</td>
+</tr>\n`;
+        }
+    }
+
+    return `<!doctype html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>Error</title>
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body {
+    font-family: "SF Mono", "Menlo", "Consolas", monospace;
+    font-size: 14px;
+    background: #1a1a2e;
+    color: #e0e0e0;
+    padding: 40px;
+  }
+  .error-label {
+    display: inline-block;
+    background: #e74c3c;
+    color: #fff;
+    font-weight: 700;
+    font-size: 12px;
+    padding: 2px 8px;
+    border-radius: 3px;
+    letter-spacing: 0.5px;
+  }
+  .message {
+    margin-top: 12px;
+    font-size: 18px;
+    font-weight: 600;
+    color: #f8f8f2;
+    line-height: 1.4;
+  }
+  table {
+    margin-top: 24px;
+    border-collapse: collapse;
+  }
+  tr.app td { padding: 4px 0; }
+  tr.app .loc {
+    color: #56d4dd;
+    font-weight: 600;
+    padding-right: 24px;
+    white-space: nowrap;
+  }
+  tr.app .fn { color: #ccc; }
+  tr.lib td {
+    color: #666;
+    padding: 4px 0;
+    font-style: italic;
+  }
+</style>
+</head>
+<body>
+  <span class="error-label">ERROR</span>
+  <div class="message">${esc(message)}</div>
+  <table>${frameRows}</table>
+</body>
+</html>`;
+}
+
+export { formatError, formatErrorHtml };

backend/diachron/package.json

@@ -1,5 +1,5 @@
 {
-    "name": "express",
+    "name": "diachron",
     "version": "1.0.0",
     "description": "",
     "main": "index.js",

backend/diachron/routing.ts

@@ -0,0 +1,93 @@
+import { contentTypes } from "./content-types";
+import { httpCodes } from "./http-codes";
+import express, {
+    type NextFunction,
+    type Request as ExpressRequest,
+    type Response as ExpressResponse,
+} from "express";
+
+import {isRedirect,     InternalHandler,    AuthenticationRequired,
+    AuthorizationDenied, Call,type Method, type ProcessedRoute,methodParser, type Result, type Route,massageMethod } from "./types";
+import { runWithContext } from "./context";
+import { Session } from "./auth";import { request } from "./request";
+import { match } from "path-to-regexp";
+
+type ProcessedRoutes= {[K in Method]: ProcessedRoute[] }
+const processRoutes=(routes:Route[]) :ProcessedRoutes => {
+    const    retval:ProcessedRoutes= {
+        GET: [],
+        POST: [],
+        PUT: [],
+        PATCH: [],
+        DELETE: [],
+    };
+
+    routes.forEach((route: Route, _idx: number, _allRoutes: Route[]) => {
+        // const pattern /*: URLPattern */ = new URLPattern({ pathname: route.path });
+        const matcher = match<Record<string, string>>(route.path);
+        const methodList = route.methods;
+        
+        const handler: InternalHandler = async (
+            expressRequest: ExpressRequest,
+        ): Promise<Result> => {
+            const method = massageMethod(expressRequest.method);
+            
+            console.log("method", method);
+            
+            if (!methodList.includes(method)) {
+                // XXX: Worth asserting this?
+            }
+            
+            console.log("request.originalUrl", expressRequest.originalUrl);
+            
+            // Authenticate the request
+            const auth = await request.auth.validateRequest(expressRequest);
+            
+            const req: Call = {
+                pattern: route.path,
+                path: expressRequest.originalUrl,
+                method,
+                parameters: { one: 1, two: 2 },
+                request: expressRequest,
+                user: auth.user,
+                session: new Session(auth.session, auth.user),
+            };
+            
+            try {
+                const retval = await runWithContext({ user: auth.user }, () =>
+                    route.handler(req),
+                );
+                return retval;
+            } catch (error) {
+                // Handle authentication errors
+                if (error instanceof AuthenticationRequired) {
+                    return {
+                        code: httpCodes.clientErrors.Unauthorized,
+                        contentType: contentTypes.application.json,
+                        result: JSON.stringify({
+                            error: "Authentication required",
+                        }),
+                    };
+                }
+                if (error instanceof AuthorizationDenied) {
+                    return {
+                        code: httpCodes.clientErrors.Forbidden,
+                        contentType: contentTypes.application.json,
+                        result: JSON.stringify({ error: "Access denied" }),
+                    };
+                }
+                throw error;
+            }
+        };
+        
+        for (const [_idx, method] of methodList.entries()) {
+            const pr: ProcessedRoute = { matcher, method, handler };
+            
+          retval[method].push(pr);
+        }
+    });
+    
+    return retval;
+}
+
+export{processRoutes}

backend/handlers.spec.ts

@@ -4,12 +4,12 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import type { Request as ExpressRequest } from "express";
-import { Session } from "./auth/types";
-import { contentTypes } from "./content-types";
+import { Session } from "./diachron/auth/types";
+import { contentTypes } from "./diachron/content-types";
 import { multiHandler } from "./handlers";
-import { httpCodes } from "./http-codes";
-import type { Call } from "./types";
-import { anonymousUser } from "./user";
+import { httpCodes } from "./diachron/http-codes";
+import type { Call } from "./diachron/types";
+import { anonymousUser } from "./diachron/user";
 
 // Helper to create a minimal mock Call
 function createMockCall(overrides: Partial<Call> = {}): Call {

backend/handlers.ts

@@ -1,7 +1,9 @@
-import { contentTypes } from "./content-types";
-import { core } from "./core";
-import { httpCodes } from "./http-codes";
-import type { Call, Handler, Result } from "./types";
+// This is a sample file provided by diachron.  You are encouraged to modify it.
+
+import { contentTypes } from "./diachron/content-types";
+import { core } from "./diachron/core";
+import { httpCodes } from "./diachron/http-codes";
+import type { Call, Handler, Result } from "./diachron/types";
 
 const multiHandler: Handler = async (call: Call): Promise<Result> => {
     const code = httpCodes.success.OK;

backend/package.json

@@ -14,6 +14,7 @@
     "license": "ISC",
     "packageManager": "pnpm@10.12.4",
     "dependencies": {
+        "diachron": "workspace:*"
     },
     "devDependencies": {
     }

backend/routes.ts

@@ -1,3 +1,5 @@
+// This is a sample file provided by diachron.  You are encouraged to modify it.
+
 /// <reference lib="dom" />
 
 import nunjucks from "nunjucks";
@@ -6,7 +8,7 @@ import { authRoutes } from "./diachron/auth/routes";
 import { routes as basicRoutes } from "./diachron/basic/routes";
 import { contentTypes } from "./diachron/content-types";
 import { core } from "./diachron/core";
-import { multiHandler } from "./diachron/handlers";
+import { multiHandler } from "./handlers";
 import { httpCodes } from "./diachron/http-codes";
 import type { Call, Result, Route } from "./diachron/types";
 
@@ -27,6 +29,9 @@ const routes: Route[] = [
     ...authRoutes,
     basicRoutes.home,
     basicRoutes.hello,
+    {...basicRoutes.hello,
+     path: "/yo-whats-up"
+},
     basicRoutes.login,
     basicRoutes.logout,
     {
@@ -35,7 +40,7 @@ const routes: Route[] = [
         handler: async (_call: Call): Promise<Result> => {
             console.log("starting slow request");
 
-            await core.misc.sleep(2);
+            await core.misc.sleep(5000);
 
             console.log("finishing slow request");
             const retval = okText("that was slow");
@@ -72,7 +77,6 @@ const routes: Route[] = [
 `;
             const result = nunjucks.renderString(template, { rrr });
 
-            const _listing = lr(routes).join(", ");
             return {
                 code,
                 result,

backend/run.sh

@@ -6,4 +6,4 @@ DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
 cd "$DIR"
 
-exec ../cmd node dist/index.js "$@"
+exec ../cmd node --enable-source-maps dist/index.js "$@"

backend/services.ts

@@ -0,0 +1,15 @@
+// This is a sample file provided by diachron.  You are encouraged to modify it.
+
+// Application services go here.  A service encapsulates a capability that
+// handlers depend on: database queries, external API calls, business logic
+// that doesn't belong in a handler.
+//
+// The framework provides core services via `core` (from ./diachron/core):
+// core.database, core.logging, core.misc, etc.  This file is for your
+// application's own services.
+
+import { core } from "./diachron/core";
+
+const db = core.database.db;
+
+export { db };

backend/tsconfig.json

@@ -10,5 +10,5 @@
         "types": ["node"],
         "outDir": "out"
     },
-    "exclude": ["**/*.spec.ts", "**/*.test.ts"]
+    "exclude": ["**/*.spec.ts", "**/*.test.ts", "check-deps.ts"]
 }

backend/types.ts

@@ -0,0 +1,8 @@
+// This is a sample file provided by diachron.  You are encouraged to modify it.
+
+// Application-specific types go here.  Framework types (Call, Result, Route,
+// Handler, etc.) are defined in ./diachron/types and should be imported from
+// there.
+//
+// This file is for your domain types: the nouns and shapes that are specific
+// to your application.

bootstrap.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+# shellcheck disable=SC2002
+
+set -eu
+set -o pipefail
+IFS=$'\n\t'
+
+# print useful message on failure
+trap 's=$?; echo >&2 "$0: Error on line "$LINENO": $BASH_COMMAND"; exit $s' ERR
+
+# shellcheck disable=SC2034
+DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# cd "$DIR"
+here="$PWD"
+
+"$DIR/update-cached-repository.sh"
+
+# repository="${2:-https://gitea.philologue.net/philologue/diachron}"
+repository="${2:-$HOME/.cache/diachron/v1/repositories/diachron.git}"
+ref="${1:-hydrators-kysely}"
+
+echo will bootstrap ref "$ref" of repo "$repository"
+
+into=$(mktemp -d)
+cd "$into"
+echo I am in $(pwd)
+echo I will clone repository "$repository", ref "$ref"
+git clone "$repository"
+
+r=$(ls -1)
+
+cd "$r"
+
+echo I am in $(pwd)
+
+git checkout "$ref"
+
+ls
+echo working dir: $PWD
+# ls backend
+
+# exit 0
+
+tar cvf - $(cat "$PWD/file-list" | grep -v '^#') | (cd "$here" && tar xf -)
+
+echo "$ref" > .diachron-version
+
+echo "Now, run the command ./sync.sh"

diachron/AGENTS.md

@@ -0,0 +1,191 @@
+# Working with diachron (Agent Guide)
+
+This document helps AI coding agents work effectively with projects built on
+the diachron framework.  It covers the conventions, commands, and structures
+you need to know.
+
+## Quick orientation
+
+diachron is a TypeScript/Express web framework with a Go master process.
+Your application code lives in `backend/`.  The framework owns `master/`,
+`logger/`, `diachron/`, and `backend/diachron/`.
+
+**Do not modify framework-owned files** unless explicitly asked to work on
+the framework itself.
+
+## Running the application
+
+```bash
+./sync.sh       # Install dependencies (run once, or after pulling changes)
+./master        # Start the application (watches files, rebuilds, proxies)
+```
+
+By default, the app listens on port 8080 (proxy) and workers run on
+ports starting at 3000.
+
+## Commands you'll need
+
+All tools (node, pnpm, tsx, etc.) are managed by the framework.  Do not
+invoke system-installed versions.
+
+```bash
+./cmd pnpm install          # Install npm packages
+./cmd pnpm test             # Run tests
+./cmd pnpm biome check .    # Lint (run from backend/)
+./develop db                # Open database shell
+./develop reset-db          # Drop and recreate database
+./develop migrate           # Run migrations (development)
+./mgmt migrate              # Run migrations (production-safe)
+```
+
+### Formatting and linting
+
+```bash
+cd backend && ../cmd pnpm biome check --write .
+```
+
+### Building Go code
+
+```bash
+cd master && go build
+cd logger && go build
+```
+
+### Quality checks
+
+```bash
+./check.sh                  # shellcheck + golangci-lint
+```
+
+## Application structure
+
+### Where to put code
+
+| What                     | Where                       |
+|--------------------------|-----------------------------|
+| Application entry point  | `backend/app.ts`            |
+| Route definitions        | `backend/routes.ts`         |
+| Route handlers           | `backend/handlers.ts`       |
+| Service layer            | `backend/services.ts`       |
+| Application types        | `backend/types.ts`          |
+| Application config       | `backend/config.ts`         |
+| Database migrations      | `backend/migrations/`       |
+| Framework library code   | `backend/diachron/`         |
+
+### Types and naming
+
+- HTTP request wrapper: `Call` (not Request)
+- HTTP response wrapper: `Result` (not Response)
+- Route definitions: arrays of `Route` objects
+- Handlers: functions that take a `Call` and return a `Result`
+
+These names are intentional.  Use them consistently.
+
+Import framework types from `./diachron/types`:
+
+```typescript
+import type { Call, Result, Route, Handler } from "./diachron/types";
+```
+
+Application-specific domain types go in `backend/types.ts`.
+
+### Services
+
+Application services go in `backend/services.ts`.  Framework services are
+accessed through the `core` object:
+
+```typescript
+import { core } from "./diachron/core";
+
+core.database.db     // Kysely database instance
+core.logging.log     // Logging
+core.misc.sleep      // Utilities
+```
+
+### Exports
+
+When a TypeScript file exports symbols, they should be listed in
+alphabetical order.
+
+## Database
+
+diachron uses PostgreSQL exclusively, accessed through Kysely (type-safe
+query builder).  There is no ORM.
+
+- Write SQL via Kysely, not raw query strings (unless Kysely can't express
+  the query)
+- Migrations live in `backend/migrations/`
+- Run `./develop codegen` after schema changes to regenerate Kysely types
+
+## Key conventions
+
+### No dev/prod distinction
+
+There is no `NODE_ENV`.  The application behaves identically everywhere.
+Do not introduce environment-based branching.
+
+### Managed tooling
+
+Never reference globally installed `node`, `npm`, `npx`, or `pnpm`.
+Always use `./cmd node`, `./cmd pnpm`, etc.
+
+### File ownership boundary
+
+```
+You may edit:          backend/* (except backend/diachron/)
+Do not edit:           master/*, logger/*, diachron/*, backend/diachron/*
+```
+
+If a task requires framework changes, confirm with the user first.
+
+### Command safety tiers
+
+- `./cmd` -- Tool wrappers, always safe
+- `./mgmt` -- Production-safe operations (migrations, user management)
+- `./develop` -- Destructive operations, development only
+
+Never use `./develop` commands against production data.
+
+## Common tasks
+
+### Add a new route
+
+1. Define the route in `backend/routes.ts` as a `Route` object
+2. Implement the handler in `backend/handlers.ts`
+3. Add any needed types to `backend/types.ts`
+
+### Add a database migration
+
+1. Create a migration file in `backend/migrations/`
+2. Run `./develop migrate` to apply it
+3. Run `./develop codegen` to regenerate Kysely types
+
+### Install a package
+
+```bash
+cd backend && ../cmd pnpm add <package>
+```
+
+### Run a one-off TypeScript script
+
+```bash
+./develop tsx backend/path/to/script.ts
+```
+
+## file-list
+
+The root `file-list` file is a manifest of all files that ship with the
+framework.  When you create or delete a file that is part of the project
+(not a scratch file or generated output), you must update `file-list` to
+match.  Keep it sorted alphabetically.
+
+## Things to avoid
+
+- Do not introduce `.env` files or `dotenv` without checking with the
+  team first.  The configuration story is still being decided.
+- Do not introduce webpack, vite, or other bundlers.  The master process
+  handles building via `@vercel/ncc`.
+- Do not add express middleware directly.  Use the framework's route
+  processing in `backend/diachron/routing.ts`.
+- Do not use `npm` or globally installed `pnpm`.  Use `./cmd pnpm`.
+- Do not add `NODE_ENV` checks or development/production branches.

diachron/common.d/check-deps

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+set -eu
+
+DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+ROOT="$DIR/../.."
+
+cd "$ROOT/backend/diachron"
+
+"$ROOT/cmd" tsx check-deps.ts "$@"

diachron/common.d/migrate

@@ -5,5 +5,5 @@ set -eu
 DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 ROOT="$DIR/../.."
 
-cd "$ROOT/backend"
+cd "$ROOT/backend/diachron"
 "$DIR"/tsx migrate.ts "$@"

diachron/develop.d/check-deps

@@ -0,0 +1 @@
+../common.d/check-deps

diachron/develop.d/tsx

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+"$DIR"/../shims/pnpm tsx "$@"

diachron/mgmt.d/add-user

@@ -5,5 +5,5 @@ set -eu
 DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 ROOT="$DIR/../.."
 
-cd "$ROOT/backend"
+cd "$ROOT/backend/diachron"
 "$DIR"/../cmd.d/tsx mgmt/add-user.ts "$@"

diachron/mgmt.d/check-deps

@@ -0,0 +1 @@
+../common.d/check-deps

diachron/mgmt.d/tsx

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+"$DIR"/../shims/pnpm tsx "$@"

docs/nomenclature.md

@@ -1,4 +1,4 @@
-We use `Call` and `Result` for our own types that wrap `Request` and
+diachron uses `Call` and `Result` for its own types that wrap `Request` and
 `Response`.
 
 This hopefully will make things less confusing and avoid problems with shadowing.

file-list

@@ -1,14 +1,40 @@
 # please keep this file sorted alphabetically
 
+.gitignore
+.go-version
+DIACHRON.md
+backend/.gitignore
+backend/.npmrc
+backend/app.ts
+backend/build.sh
+backend/check-deps.ts
+backend/check.sh
 backend/diachron
+backend/generated
+backend/group.ts
+backend/handlers.spec.ts
+backend/handlers.ts
 backend/package.json
 backend/pnpm-workspace.yaml
-# express/framework
+backend/routes.ts
+backend/run.sh
+backend/services.ts
+backend/show-config.sh
+backend/tsconfig.json
+backend/types.ts
+backend/watch.sh
+bootstrap.sh
 cmd
 develop
 diachron
+diachron/AGENTS.md
+file-list
 logger
 master
 mgmt
 sync.sh
-templates
+templates
+update-cached-repository.sh
+upgrade.sh
+
+

sync.sh

@@ -1,7 +1,5 @@
 #!/bin/bash
 
-# Note: This is kind of AI slop and needs to be more carefully reviewed.
-
 set -eu
 
 DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
@@ -25,50 +23,66 @@ pnpm_checksum_var="pnpm_checksum_${platform}"
 pnpm_binary_url="${!pnpm_binary_var}"
 pnpm_checksum="${!pnpm_checksum_var}"
 
-# Set up paths for shims to use
-nodejs_dist_dir="diachron/binaries/$nodejs_dirname"
-nodejs_bin_dir="$nodejs_dist_dir/bin"
+cache_dir="$HOME/.cache/diachron/v1/binaries"
+local_dir="$DIR/diachron/binaries"
+mkdir -p "$cache_dir" "$local_dir"
 
-# Ensure correct node version is installed
-node_installed_checksum_file="$DIR/diachron/binaries/.node.checksum"
-node_installed_checksum=""
-if [ -f "$node_installed_checksum_file" ]; then
-    node_installed_checksum=$(cat "$node_installed_checksum_file")
-fi
+# read_checksum_file <path>
+# Prints the contents of a checksum file, or empty string
+# if the file does not exist.
+read_checksum_file() {
+    if [ -f "$1" ]; then
+        cat "$1"
+    fi
+}
 
-if [ "$node_installed_checksum" != "$nodejs_checksum" ]; then
+# Ensure Node.js is in the cache
+cached_node_checksum=$(read_checksum_file "$cache_dir/.node.checksum")
+if [ "$cached_node_checksum" != "$nodejs_checksum" ]; then
     echo "Downloading Node.js for $platform..."
-    node_archive="$DIR/diachron/downloads/node.tar.xz"
+    node_archive="$cache_dir/node.tar.xz"
     curl -fsSL "$nodejs_binary" -o "$node_archive"
 
     echo "Verifying checksum..."
     echo "$nodejs_checksum  $node_archive" | sha256_check
 
     echo "Extracting Node.js..."
-    tar -xf "$node_archive" -C "$DIR/diachron/binaries"
+    rm -rf "${cache_dir:?}/$nodejs_dirname"
+    tar -xf "$node_archive" -C "$cache_dir"
     rm "$node_archive"
 
-    echo "$nodejs_checksum" >"$node_installed_checksum_file"
+    echo "$nodejs_checksum" >"$cache_dir/.node.checksum"
 fi
 
-# Ensure correct pnpm version is installed
-pnpm_binary="$DIR/diachron/binaries/pnpm"
-pnpm_installed_checksum_file="$DIR/diachron/binaries/.pnpm.checksum"
-pnpm_installed_checksum=""
-if [ -f "$pnpm_installed_checksum_file" ]; then
-    pnpm_installed_checksum=$(cat "$pnpm_installed_checksum_file")
+# Copy Node.js into the working directory if needed
+local_node_checksum=$(read_checksum_file "$local_dir/.node.checksum")
+if [ "$local_node_checksum" != "$nodejs_checksum" ]; then
+    echo "Installing Node.js into project..."
+    rm -rf "${local_dir:?}/$nodejs_dirname"
+    cp -R "$cache_dir/$nodejs_dirname" "$local_dir/$nodejs_dirname"
+    echo "$nodejs_checksum" >"$local_dir/.node.checksum"
 fi
 
-if [ "$pnpm_installed_checksum" != "$pnpm_checksum" ]; then
+# Ensure pnpm is in the cache
+cached_pnpm_checksum=$(read_checksum_file "$cache_dir/.pnpm.checksum")
+if [ "$cached_pnpm_checksum" != "$pnpm_checksum" ]; then
     echo "Downloading pnpm for $platform..."
-    curl -fsSL "$pnpm_binary_url" -o "$pnpm_binary"
+    curl -fsSL "$pnpm_binary_url" -o "$cache_dir/pnpm"
 
     echo "Verifying checksum..."
-    echo "$pnpm_checksum  $pnpm_binary" | sha256_check
+    echo "$pnpm_checksum  $cache_dir/pnpm" | sha256_check
 
-    chmod +x "$pnpm_binary"
+    chmod +x "$cache_dir/pnpm"
 
-    echo "$pnpm_checksum" >"$pnpm_installed_checksum_file"
+    echo "$pnpm_checksum" >"$cache_dir/.pnpm.checksum"
+fi
+
+# Copy pnpm into the working directory if needed
+local_pnpm_checksum=$(read_checksum_file "$local_dir/.pnpm.checksum")
+if [ "$local_pnpm_checksum" != "$pnpm_checksum" ]; then
+    echo "Installing pnpm into project..."
+    cp "$cache_dir/pnpm" "$local_dir/pnpm"
+    echo "$pnpm_checksum" >"$local_dir/.pnpm.checksum"
 fi
 
 # Get golang binaries in place

templates/basic/hello.html.njk

@@ -2,7 +2,7 @@
   <head></head>
   <body>
     <p>
-      Hello.
+      {{ greeting | default("hello")}}
     </p>
     <p>
       The current time is {{ now }}.

update-cached-repository.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+set -eu
+set -o pipefail
+IFS=$'\n\t'
+
+trap 's=$?; echo >&2 "$0: Error on line "$LINENO": $BASH_COMMAND"; exit $s' ERR
+
+upstream=https://gitea.philologue.net/philologue/diachron
+cache_dir="$HOME/.cache/diachron/v1/repositories"
+cached_repo="$cache_dir/diachron.git"
+
+mkdir -p "$cache_dir"
+
+if [ -d "$cached_repo" ]; then
+    echo "Updating cached repository..."
+    git -C "$cached_repo" fetch --prune origin
+else
+    echo "Creating cached repository..."
+    git clone --mirror "$upstream" "$cached_repo"
+fi
+

upgrade.sh

@@ -0,0 +1,109 @@
+#!/bin/bash
+
+set -eu
+set -o pipefail
+IFS=$'\n\t'
+
+DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+new_ref="${1:?Usage: upgrade.sh <new-ref>}"
+
+cached_repo="$HOME/.cache/diachron/v1/repositories/diachron.git"
+tmpdir=""
+
+cleanup() {
+    if [ -n "$tmpdir" ]; then
+        rm -rf "$tmpdir"
+    fi
+}
+trap cleanup EXIT
+
+echo "=== Diachron Framework Upgrade ==="
+echo ""
+echo "This will replace all framework files in your project."
+echo "Make sure you have committed or backed up any local changes."
+echo ""
+read -r -p "Continue? [y/N] " answer
+if [[ ! "$answer" =~ ^[Yy]$ ]]; then
+    echo "Aborted."
+    exit 0
+fi
+
+# Update cached repository
+"$DIR/update-cached-repository.sh"
+
+# Read current version
+if [ ! -f "$DIR/.diachron-version" ]; then
+    echo "Error: .diachron-version not found." >&2
+    echo "Is this a diachron project?" >&2
+    exit 1
+fi
+old_ref=$(cat "$DIR/.diachron-version")
+
+# Verify both refs exist in cached repo
+if ! git -C "$cached_repo" rev-parse --verify "$old_ref^{commit}" >/dev/null 2>&1; then
+    echo "Error: current version '$old_ref' not found in cached repository." >&2
+    exit 1
+fi
+if ! git -C "$cached_repo" rev-parse --verify "$new_ref^{commit}" >/dev/null 2>&1; then
+    echo "Error: target version '$new_ref' not found in cached repository." >&2
+    exit 1
+fi
+
+# Require a clean working tree
+if [ -n "$(git -C "$DIR" status --porcelain)" ]; then
+    echo "Error: working tree is not clean." >&2
+    echo "Commit or stash all changes (including untracked files) before upgrading." >&2
+    exit 1
+fi
+
+echo ""
+echo "Upgrading: $old_ref -> $new_ref"
+echo ""
+
+# Read current file-list (files to remove)
+old_files=()
+while IFS= read -r line; do
+    [[ "$line" =~ ^[[:space:]]*# ]] && continue
+    [[ -z "$line" ]] && continue
+    old_files+=("$line")
+done < "$DIR/file-list"
+
+# Clone and checkout new version into a temp directory
+tmpdir=$(mktemp -d)
+git clone --quiet "$cached_repo" "$tmpdir/diachron"
+git -C "$tmpdir/diachron" checkout --quiet "$new_ref"
+
+# Read new file-list (files to add)
+new_files=()
+while IFS= read -r line; do
+    [[ "$line" =~ ^[[:space:]]*# ]] && continue
+    [[ -z "$line" ]] && continue
+    new_files+=("$line")
+done < "$tmpdir/diachron/file-list"
+
+# Remove old framework files
+for f in "${old_files[@]}"; do
+    git -C "$DIR" rm -rf --quiet --ignore-unmatch "$f"
+done
+
+# Copy in new framework files
+(cd "$tmpdir/diachron" && tar cvf - "${new_files[@]}") | (cd "$DIR" && tar xf -)
+
+# Stage them
+for f in "${new_files[@]}"; do
+    git -C "$DIR" add "$f"
+done
+
+# Update version marker
+echo "$new_ref" > "$DIR/.diachron-version"
+git -C "$DIR" add "$DIR/.diachron-version"
+
+echo "=== Upgrade staged: $old_ref -> $new_ref ==="
+echo ""
+echo "Framework files have been removed, replaced, and staged."
+echo ""
+echo "Next steps:"
+echo "  1. Review:   git diff --cached"
+echo "  2. Commit:   git commit -m 'Upgrade diachron to $new_ref'"
+echo "  3. Install:  ./sync.sh"