Memory, per-turn usage accounting, full AGY cognition, and durable-write fixes

.github/workflows/ci.yml

@@ -8,6 +8,8 @@ on:
 
 jobs:
   test:
+    name: harness + runtime tests
+    timeout-minutes: 25
     runs-on: ubuntu-latest
     steps:
       - name: Check out

.github/workflows/publish.yml

@@ -14,6 +14,8 @@ concurrency:
 
 jobs:
   publish:
+    name: publish @noopolis/daimon to npm
+    timeout-minutes: 20
     runs-on: ubuntu-latest
     steps:
       - name: Check out

.gitignore

@@ -1,5 +1,5 @@
 node_modules/
 dist/
+dist-test-runtime/
 .runtime/
 *.tsbuildinfo
-

AGENTS.md

@@ -25,3 +25,23 @@ deployment. Daimon owns only the per-agent runtime boundary.
   policy, recall, or MCP.
 - Pi-specific logic belongs under `src/pi/`.
 - Examples should be runnable with `npm run e2e:pi-agent`.
+
+## Branches and pull requests
+
+**Never commit to `main`.** Every change lands through a pull request, without
+exception — including one-line fixes, CI configuration, documentation, and
+version bumps. Work on a branch, push it, open the PR, and let CI run.
+
+Direct commits to `main` bypass the checks that catch what local runs do not.
+A zero-byte receipt store, a package that ships without its native binary, and
+a two-week-red pipeline all reached `main` in this ecosystem while every local
+gate was green — CI found them the first time it ran over the code.
+
+- Branch names describe the change: `feat/…`, `fix/…`, `ci/…`, `docs/…`.
+- Commit messages are conventional and single-line (`feat:`, `fix:`, `docs:`,
+  `ci:`, `chore:`, `refactor:`, `test:`).
+- Never add co-author lines, sign-offs, or AI attributions.
+- Commit as you go rather than in one batch at the end, so history shows how
+  the work progressed.
+- Merge with a merge commit rather than a squash when the individual commits
+  carry meaning; squashing collapses that history irreversibly.

Dockerfile.test-runtime

@@ -0,0 +1,8 @@
+FROM node:22-bookworm-slim
+WORKDIR /opt/noopolis/daimon-test
+COPY package.json package-lock.json ./
+RUN npm ci --omit=dev --ignore-scripts && npm cache clean --force
+COPY dist-test-runtime /opt/noopolis/daimon-test/dist
+LABEL org.noopolis.daimon.explicit-test-runtime="true"
+USER 65534:65534
+ENTRYPOINT ["/usr/local/bin/node", "/opt/noopolis/daimon-test/dist/runtime/testRuntimeSubprocess.js"]

MIGRATION_PLAN.md

@@ -0,0 +1,117 @@
+# Daimon organization-runtime migration plan
+
+## Phase 1A: public contract — complete
+
+- Add only the versioned, organization-neutral
+  `noopolis.daimon.organization-runtime.v1` parser, schema, public types, and
+  `@noopolis/daimon/runtime` export.
+- The v1 config is a strict flat projection: host control binding plus an
+  unordered, non-empty collection of isolated agent records. It cannot carry
+  organization graph, coordination, scheduling, deployment, or Moltnet data.
+  The standard JSON Schema covers structure; the pure public parser is
+  normative for semantic checks such as duplicate agent ids.
+- Define the host, wake, activity, health, and shutdown interfaces now. Phase
+  1A is validation-only; Phase 1B provides the host, process, server, engine
+  dispatch, and CLI implementation while retaining the same public contract.
+
+## Phase 1B: isolated runtime host — complete
+
+- Add the organization-neutral `noopolis.daimon.organization-runtime.v1`
+  host implementation behind the already published public API.
+- A host reads one config, validates it, creates one isolated existing Daimon
+  harness per agent record, routes authenticated wake, health, and activity
+  operations by agent id, serializes each agent's wakes independently, and
+  quiesces all children on shutdown.
+- The schema is a strict flat projection. It enumerates only: schema version,
+  agent id, runtime-home path, workspace path, engine intent, control endpoint,
+  and surface bindings. It rejects every unknown field and specifically rejects
+  team, parent, member, role, edge, schedule, wake-selection, deployment, and
+  Moltnet-topology semantics. The host does no wake generation or coordination;
+  it only provides agent-id routing, per-agent queue/lifecycle/health/activity.
+- Engine process creation remains in Daimon. The public runtime does not accept
+  arbitrary commands, raw process handles, or caller-supplied environment maps.
+  Fake engines are test-only injection points and make this phase deterministic.
+
+The exact v1 JSON shape is:
+
+```ts
+type OrganizationRuntimeEngineIntent =
+  | { kind: "codex" | "grok" | "agy" };
+type OrganizationRuntimeAgentConfig = Readonly<{
+  id: string;
+  name: string;
+  instructions: string;
+  runtimeHomePath: string;
+  workspacePath: string;
+  engine: OrganizationRuntimeEngineIntent;
+}>;
+type OrganizationRuntimeConfig = Readonly<{
+  version: "noopolis.daimon.organization-runtime.v1";
+  host: Readonly<{
+    bindHost: string;
+    port: number;
+    controlTokenEnv: string;
+  }>;
+  agents: readonly OrganizationRuntimeAgentConfig[];
+}>;
+```
+
+All objects are strict; there are no optional properties or arbitrary metadata
+bags in v1. `id` is unique, root agent paths are absolute, caller-created real
+directories, and physically isolated by held directory identities. Runtime
+homes must be owned `0700`; workspaces must be owned and not group/other
+writable. The
+control token is identified only by a safe environment-variable name; secret
+material never appears in the config. Unknown schema versions are rejected
+before a host starts or a child is constructed. The public signatures are:
+
+```ts
+parseOrganizationRuntimeConfig(value: unknown): OrganizationRuntimeConfig;
+
+interface OrganizationRuntimeHost {
+  start(): Promise<void>;
+  wake(request: OrganizationRuntimeWakeRequest): Promise<OrganizationRuntimeWakeResult>;
+  health(agentId?: string): Promise<OrganizationRuntimeHealth>;
+  activity(request: OrganizationRuntimeActivityRequest): Promise<OrganizationRuntimeActivityPage>;
+  stop(): Promise<OrganizationRuntimeShutdownCompletion>;
+}
+```
+
+`OrganizationRuntimeHost` exposes `wake`, `health`, `activity`, and idempotent
+`stop`; each request is keyed by an agent id and the host exposes no
+coordination/wake-generation API. Fake engine construction is internal
+test-only injection, never config data or a public production escape hatch.
+The CLI is exactly `daimon-runtime run --config <path>`.
+
+## Files
+
+- Add `src/runtime/` with its own `AGENTS.md` and `CLAUDE.md` symlink. It now
+  contains the strict contract, isolated host, control server, CLI, and focused
+  tests, with each source file kept below 400 lines.
+- Additive pre-1.0 bump to `0.2.0`; retain the existing `.`, `./pi`, and
+  `./observability` entrypoints unchanged, then add `./runtime`.
+- Update docs only as required to expose this exact contract and retain safe
+  compatible per-agent APIs.
+
+## Tests and verification
+
+- Contract coverage: invalid config; forbidden organization fields; safe auth
+  environment names; agent-home/workspace path syntax and physical roots;
+  duplicate ids; closed Codex/Grok/AGY engine intents; public method types;
+  retained imports; package closure.
+- Run typecheck, focused tests, full unit suite, build, `npm pack`, install the
+  packed tarball into a clean temporary consumer, import the retained and new
+  entrypoints there, and inspect the final diff for forbidden consumer
+  terminology and raw credential/process APIs.
+
+## Migration and terminal conditions
+
+- This completed phase introduces the Daimon host and public contract only; it does not
+  change any downstream consumer. A deferred downstream compiler/consumer E2E
+  phase will emit one compiled v1 config, start one container entrypoint/host
+  process, verify N isolated one-agent runtimes with targeted and concurrent
+  fake wakes, and prove that the consumer never instantiates Daimon handles or
+  engines. No Docker work is permitted in this Daimon phase.
+- Stop and return for review when implementation, test evidence, package
+  closure, and an explicit public-contract summary are complete. Do not touch
+  credentials, Docker, live repositories, or external services.