@mnmal-ai/cortext 0.0.0-stage → 1.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,72 @@
-# Temporary Holding Version
+# @mnmal-ai/cortext
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Substrate plugins for the agent's persistent context store: a coordinator and its kernel-tier sibling, shipped as one package.
+
+Owns the `cortext` namespace — `Todo`, `Decision`, `SessionLog`, `AgentRule`, `AnchorIntent`, `Concept`, `ConceptLink`, `Memory`, `CouncilSession`, `AgentIdentity`, `AgentMessage`, `Skill`. This is the data backbone that lets a session restart and pick up where it left off: cold-start hooks query this namespace to inject recent context; mutations during a session land here too. Compaction sweeps stale rows by per-type retention rules. Code-review findings that outlive a session live in a sibling `architecture` namespace this plugin also owns.
+
+## Where it fits
+
+Installed into a substrate deployment's `SUBSTRATE_PLUGIN_DIR` (manifest-driven loader). The manifest's `substrate.plugins` declares two entries, `kernel` and `coordinator`, and the loader brings up both. The only runtime peer is `@mnmal-ai/substrate`: the type DSL comes from `@mnmal-ai/substrate/sdk`, and semantic-recall hooks are contributed by substrate's recall plugin, which walks the `embed.source` metadata declared here.
+
+## Kernel plugin
+
+`src/kernel/` holds the kernel-tier plugin (runtime name `cortext-kernel`, exported as `createCortextKernelPlugin()` from `@mnmal-ai/cortext/kernel`). It owns the postgres-level invariants for the `cortext/*` and `architecture/*` namespaces that cannot live in the engine-side validator: vocabulary CHECK constraints, partial unique indexes and one-time body normalisations, as migrations `0001`-`0008` in `src/kernel/migrations/`. Migration order is load-bearing; see `src/kernel/plugin.ts`.
+
+On every boot its `onKernelReady` handler audits those objects against the catalog and reports any that are missing, left NOT VALID, or scoped to a namespace no coordinator declares (`src/kernel/invariant-audit.ts`). Repair is opt-in via `SYNOPTIC_CORTEXT_REPAIR` (`src/kernel/repair.ts`). It takes no operator config (`kernel.default-config.json` is `{}`).
+
+## Usage
+
+```bash
+npm install --prefix /opt/substrate/plugins @mnmal-ai/cortext
+```
+
+Defaults (`namespace=cortext`, `architectureNamespace=architecture`, `compactRetention=7`) ship in `default-config.json`. To override, drop a `<SUBSTRATE_PLUGIN_DIR>/cortext.config.json`:
+
+```json
+{
+  "namespace": "cortext",
+  "architectureNamespace": "architecture",
+  "compactRetention": 14
+}
+```
+
+## Auth posture
+
+The context store is the agent's memory estate; what anonymous callers may do
+with it is an operator knob, not a baked-in choice:
+
+```json
+{
+  "auth": {
+    "reads": "open",
+    "writes": "identity",
+    "deletes": "identity"
+  }
+}
+```
+
+Each surface is `"open"` (anonymous allowed) or `"identity"` (verified token
+required). Defaults: `reads`/`writes` open, `deletes` identity-gated — a fresh
+install works keyless end to end; only anonymous hard-deletes (incl. `purge`)
+are refused, with `archived: true` as the open soft path. Strictness must be
+monotonic along `reads → writes → deletes`; the config loader rejects
+incoherent postures (e.g. gated reads over open writes) at boot.
+
+The knob maps to plugin-level policy combinators at compose time
+(`src/auth-policy.ts`) covering **both** namespaces. AutoCRUD type definitions
+are untouched — tightening posture later is config-only, no schema or client
+migration. Pair with attribute-mode auth so consumers can adopt signing keys
+before any enforcement flips (key issuance and the retrofit path are
+documented in the substrate repo, not here).
+The plugin's scheduled compact task writes with a
+`{kind:'system', id:'cortext:compact'}` envelope and keeps working under
+gated writes.
+
+Read-surface coverage: substrate's `/substrate/v1/recall` route and its
+`recall` MCP tool honour these same policies via
+`engine.evaluateReadPolicy` — semantic recall is not a
+side-channel around `reads: "identity"`.
+
+## More
+
+- Type definitions: `src/namespace.ts`

package/config.schema.json

@@ -0,0 +1,62 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "namespace": {
+      "default": "cortext",
+      "type": "string",
+      "minLength": 1
+    },
+    "architectureNamespace": {
+      "default": "architecture",
+      "type": "string",
+      "minLength": 1
+    },
+    "compactRetention": {
+      "default": 7,
+      "type": "integer",
+      "exclusiveMinimum": 0,
+      "maximum": 9007199254740991
+    },
+    "autoCompactIntervalMs": {
+      "type": "number",
+      "exclusiveMinimum": 0
+    },
+    "auth": {
+      "default": {
+        "reads": "open",
+        "writes": "open",
+        "deletes": "identity"
+      },
+      "type": "object",
+      "properties": {
+        "reads": {
+          "default": "open",
+          "type": "string",
+          "enum": [
+            "open",
+            "identity"
+          ]
+        },
+        "writes": {
+          "default": "open",
+          "type": "string",
+          "enum": [
+            "open",
+            "identity"
+          ]
+        },
+        "deletes": {
+          "default": "identity",
+          "type": "string",
+          "enum": [
+            "open",
+            "identity"
+          ]
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "additionalProperties": false
+}

package/default-config.json

@@ -0,0 +1,10 @@
+{
+  "namespace": "cortext",
+  "architectureNamespace": "architecture",
+  "compactRetention": 7,
+  "auth": {
+    "reads": "open",
+    "writes": "open",
+    "deletes": "identity"
+  }
+}

package/dist/auth-policy.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Auth-posture → policy mapping.
+ *
+ * The posture knob deliberately lives OUTSIDE the autoCRUD type definitions —
+ * it maps onto plugin-level policy combinators at compose time, which is what
+ * makes it retrofit-capable: a deployment can start fully open and tighten to
+ * identity-gated writes (or full lockdown) later by config alone. No schema
+ * migration, no client changes — consumers that already sign never notice the
+ * flip. The wire mechanism for this is attribute-mode auth: tokens are
+ * verified and attributed whenever present, so credential adoption can run
+ * ahead of enforcement.
+ *
+ * Monotonicity: strictness must be non-decreasing along reads → writes →
+ * deletes. "Anonymous may write but not read" has no coherent threat model;
+ * rejecting it keeps the mapping a simple ladder.
+ *
+ * Read-surface coverage: substrate's /substrate/v1/recall route and its
+ * recall MCP tool honour these same policies via
+ * `engine.evaluateReadPolicy` — recall is not a side-channel
+ * around `reads: 'identity'`. Any future embeddings-fetch route must inherit
+ * the same check.
+ */
+import type { Policy } from '@mnmal-ai/substrate/sdk';
+import type { CortextAuthConfig } from './config.js';
+/**
+ * The default: anonymous read/create/update under
+ * attribute mode, identity-gated hard-deletes. Archive stays the open soft path.
+ */
+export declare const DEFAULT_AUTH: CortextAuthConfig;
+/** Strictness must be non-decreasing along reads → writes → deletes. */
+export declare function isMonotonicAuth(auth: CortextAuthConfig): boolean;
+/**
+ * Map a posture to the plugin-level policy list. Combinator order matters:
+ * `or()` returns the LAST deny verbatim, so the deny arm's actionable reason
+ * surfaces on denial instead of requireIdentity's terse default.
+ *
+ * Monotonicity makes the mapping a ladder — the strictest gated surface
+ * determines the single composed policy:
+ *   reads gated   → everything requires identity
+ *   writes gated  → create/update/delete require identity, reads stay open
+ *   deletes gated → only the destructive verbs require identity
+ *   fully open    → no policy contributed at all
+ */
+export declare function buildAuthPolicies(auth: CortextAuthConfig): Policy[];

package/dist/bootstrap.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Structured-config bootstrap for `@mnmal-ai/cortext`.
+ *
+ * The canonical entry consumed by the binary's `SUBSTRATE_PLUGIN_DIR` loader.
+ *
+ * Operator JSON config supplies the env-shape knobs (namespace,
+ * architectureNamespace, compactRetention, autoCompactIntervalMs); the
+ * bootstrap parses + validates and hands off to `createCortextPlugin`.
+ * Embeddable types (Memory, SessionLog, Decision, AnchorIntent, Concept)
+ * declare `embed.source` metadata; substrate's recall plugin walks this at compose time
+ * and chains an embedding postWrite per match via `contributePostWrites`.
+ */
+import { z } from 'zod';
+export declare const CortextBootstrapConfigSchema: z.ZodObject<{
+    namespace: z.ZodDefault<z.ZodString>;
+    architectureNamespace: z.ZodDefault<z.ZodString>;
+    compactRetention: z.ZodDefault<z.ZodNumber>;
+    autoCompactIntervalMs: z.ZodOptional<z.ZodNumber>;
+    auth: z.ZodDefault<z.ZodObject<{
+        reads: z.ZodDefault<z.ZodEnum<{
+            identity: "identity";
+            open: "open";
+        }>>;
+        writes: z.ZodDefault<z.ZodEnum<{
+            identity: "identity";
+            open: "open";
+        }>>;
+        deletes: z.ZodDefault<z.ZodEnum<{
+            identity: "identity";
+            open: "open";
+        }>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CortextBootstrapConfig = z.infer<typeof CortextBootstrapConfigSchema>;
+export declare const bootstrap: import("@mnmal-ai/substrate/sdk").CoordinatorBootstrap;
+export default bootstrap;

package/dist/bootstrap.js

@@ -0,0 +1,69 @@
+import { E as isMonotonicAuth, t as createCortextPlugin, w as DEFAULT_AUTH } from "./src-BKaGTnRw.js";
+import { D as ARCHITECTURE_NAMESPACE, k as CORTEXT_NAMESPACE } from "./plugin-27UpMnoE.js";
+import "./kernel.js";
+import { defineBootstrap } from "@mnmal-ai/substrate/sdk";
+import { z } from "zod";
+
+//#region src/bootstrap.ts
+/**
+* Structured-config bootstrap for `@mnmal-ai/cortext`.
+*
+* The canonical entry consumed by the binary's `SUBSTRATE_PLUGIN_DIR` loader.
+*
+* Operator JSON config supplies the env-shape knobs (namespace,
+* architectureNamespace, compactRetention, autoCompactIntervalMs); the
+* bootstrap parses + validates and hands off to `createCortextPlugin`.
+* Embeddable types (Memory, SessionLog, Decision, AnchorIntent, Concept)
+* declare `embed.source` metadata; substrate's recall plugin walks this at compose time
+* and chains an embedding postWrite per match via `contributePostWrites`.
+*/
+const NamespaceSchema = z.string().min(1, "must not be empty").refine((s) => !s.includes("/"), { message: "must not contain '/'" });
+/**
+* Namespace overrides stay SUPPORTED. The kernel cannot follow a renamed
+* namespace, so using one silently disables every kernel invariant — that
+* is reported at boot by `reportUncoveredNamespaces` (./kernel-invariants.ts),
+* wired into the plugin's `onStart`.
+*
+* They are not pinned to the kernel's literals: per-cohort context stores are a
+* designed capability with a test that names `codex` explicitly. The knob
+* stays; only the silence goes.
+*/
+const AuthModeSchema = z.enum(["open", "identity"]);
+/**
+* Auth posture knob. Defaults: reads/writes open, hard-deletes
+* identity-gated. Operators
+* tighten (or fully open) per deployment — see ./auth-policy.ts for the
+* posture → policy mapping and the monotonicity invariant.
+*/
+const AuthPostureSchema = z.object({
+	reads: AuthModeSchema.default(DEFAULT_AUTH.reads),
+	writes: AuthModeSchema.default(DEFAULT_AUTH.writes),
+	deletes: AuthModeSchema.default(DEFAULT_AUTH.deletes)
+}).strict();
+const CortextBootstrapConfigSchema = z.object({
+	namespace: NamespaceSchema.default(CORTEXT_NAMESPACE),
+	architectureNamespace: NamespaceSchema.default(ARCHITECTURE_NAMESPACE),
+	compactRetention: z.number().int().positive().default(7),
+	/** Auto-compact tick interval in milliseconds. Omitted = disabled. */
+	autoCompactIntervalMs: z.number().positive().optional(),
+	auth: AuthPostureSchema.default({ ...DEFAULT_AUTH })
+}).strict().refine((cfg) => cfg.namespace !== cfg.architectureNamespace, {
+	message: "architectureNamespace must differ from namespace",
+	path: ["architectureNamespace"]
+}).refine((cfg) => isMonotonicAuth(cfg.auth), {
+	message: "auth posture must be monotonic — strictness non-decreasing along reads → writes → deletes (e.g. writes:'identity' requires deletes:'identity')",
+	path: ["auth"]
+});
+const bootstrap = defineBootstrap.coordinator({
+	schema: CortextBootstrapConfigSchema,
+	build: (config) => createCortextPlugin({
+		namespace: config.namespace,
+		architectureNamespace: config.architectureNamespace,
+		compactRetention: config.compactRetention,
+		autoCompactIntervalMs: config.autoCompactIntervalMs,
+		auth: config.auth
+	})
+});
+
+//#endregion
+export { CortextBootstrapConfigSchema, bootstrap, bootstrap as default };

package/dist/compact.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Compact route — archives old sessions and cascades the archive flag onto
+ * their decisions:
+ *   1. Read live SessionLog rows newest first; keep the newest `retention`
+ *      PER PROJECT (a global window lets a busy project empty a quiet one).
+ *   2. Cascade-archive every live Decision whose `sessionId` points at a
+ *      session being archived, or that another Decision's `supersedes`
+ *      names (not the Decision CARRYING `supersedes`, which is the current one).
+ *   3. Archive the decisions, then the sessions, so a failure between the
+ *      two writes is recomputed by the next run instead of lost.
+ *
+ * `EngineHandle` is namespace-agnostic — the caller
+ * supplies qualified keys (§4.7) — so we wrap the engine locally with two
+ * tiny adapters: `queryAll` (envelope → typed rows) and `mutateOne` (run one
+ * mutation by name). Both thread through a `RequestContext` that mirrors what
+ * the HTTP route layer constructs.
+ */
+import type { EngineHandle, PluginRouteContext, PluginRouter } from '@mnmal-ai/substrate/sdk';
+import type { CortextAuthConfig } from './config.js';
+export interface CompactResult {
+    dryRun: boolean;
+    sessionsArchived: number;
+    decisionsArchived: number;
+    sessionsRetained: number;
+    messagesArchived: number;
+}
+/**
+ * Tunables for the per-call compact behaviour beyond the session-retention
+ * count. `mailMaxAgeMs` exists primarily for tests — `_metadata` timestamps
+ * are server-stamped, so a test can't author old mail; it shrinks the window
+ * instead.
+ */
+export interface CompactOptions {
+    mailMaxAgeMs?: number;
+}
+export declare function runCompact(engine: EngineHandle, ns: string, retention: number, dryRun: boolean, opts?: CompactOptions): Promise<CompactResult>;
+export declare function registerCompactRoute(router: PluginRouter, ctx: PluginRouteContext, retention: number, namespace: string, auth?: CortextAuthConfig): void;

package/dist/config.d.ts

@@ -0,0 +1,40 @@
+/**
+ * cortext plugin config type.
+ *
+ * Pure type definition — config is supplied to `createCortextPlugin` either
+ * by the structured-config bootstrap (operator JSON config + optional
+ * code-shaped extras) or by direct programmatic callers (tests). Validation
+ * and defaults live in the bootstrap layer (zod schema in `bootstrap.ts`).
+ */
+/** Per-surface auth posture: anonymous allowed, or authenticated identity required. */
+export type CortextAuthMode = 'open' | 'identity';
+/**
+ * Auth posture knob ("open initially, retrofit-capable").
+ * Maps onto plugin-level policy combinators at compose time; autoCRUD type
+ * definitions are untouched, so any deployment can tighten posture later by
+ * config alone. Strictness must be monotonic: reads ≤ writes ≤ deletes.
+ */
+export interface CortextAuthConfig {
+    /** Type queries + get<T> (and subscribe/stream dispatch). */
+    reads: CortextAuthMode;
+    /** create<T> + update<T>. */
+    writes: CortextAuthMode;
+    /** delete<T>, incl. purge<T> via its verb:'delete' stamp. */
+    deletes: CortextAuthMode;
+}
+export interface CortextPluginConfig {
+    /** Namespace the context-store types register under. */
+    namespace: string;
+    /**
+     * Namespace the architecture-findings type (`ArchitectureConcern`) registers
+     * under. Kept separate from the context store so compaction / retention /
+     * audit policies diverge.
+     */
+    architectureNamespace: string;
+    /** Number of recent sessions to keep live during compaction. */
+    compactRetention: number;
+    /** Auto-compact interval in milliseconds. Undefined = disabled. */
+    autoCompactIntervalMs: number | undefined;
+    /** Auth posture. Undefined = DEFAULT_AUTH (reads/writes open, deletes identity). */
+    auth: CortextAuthConfig | undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @mnmal-ai/cortext — coordinator plugin that persists Claude Code
+ * context (sessions, decisions, todos, rules, reviews, councils, skills) plus
+ * Claude-lineage architecture findings.
+ *
+ * Binds the context store onto the coordinator plugin seam (§5.11):
+ *   - `namespaces[0]` — the 13-type context-store surface (see `./namespace.ts`).
+ *   - `namespaces[1]` — the `architecture` surface (`ArchitectureConcern`),
+ *     kept in a distinct namespace so lifecycle policies (compaction,
+ *     retention, audit) diverge from session-scoped rationale.
+ *   - `routes` — `/onboard` (static agent self-description) and `/compact`
+ *     (session archiver — operates on the claude namespace only).
+ *   - `schedule` — an auto-compact task when `autoCompactIntervalMs` is set
+ *     in the operator's `cortext.config.json`; otherwise the plugin
+ *     ships with no scheduled tasks and relies on explicit
+ *     `POST /substrate/v1/plugins/cortext/compact` calls.
+ *
+ * `createCortextPlugin` is a pure factory taking a fully-resolved
+ * `CortextPluginConfig`. Recall/embedding wiring is entirely declarative:
+ * embeddable types declare `embed.source` slots on their namespace definitions,
+ * and kernel plugins (e.g. substrate's recall plugin) walk that metadata at compose
+ * time to contribute postWrite hooks via the engine's kernel-walk.
+ */
+import type { CoordinatorPlugin } from '@mnmal-ai/substrate/sdk';
+import type { CortextPluginConfig } from './config.js';
+export { buildAuthPolicies, DEFAULT_AUTH, isMonotonicAuth } from './auth-policy.js';
+export { type CompactResult, registerCompactRoute, runCompact } from './compact.js';
+export type { CortextAuthConfig, CortextAuthMode, CortextPluginConfig } from './config.js';
+export { AGENT_MESSAGE_STATUS_VOCAB, AGENT_RULE_CATEGORY_VOCAB, AGENT_RULE_SEVERITY_ALIASES, AGENT_RULE_SEVERITY_VOCAB, ARCHITECTURE_TYPE_NAMES, buildArchitectureNamespace, buildClaudeNamespace, CLAUDE_TYPE_NAMES, DECISION_STATUS_ALIASES, DECISION_STATUS_VOCAB, HOST_INSTALL_CHECK_STATES, HOST_INSTALL_FRAGMENT_STATES, TODO_RESOLUTION_ALIASES, TODO_STATUS_ALIASES, TODO_STATUS_IMPLIES } from './namespace.js';
+export { registerOnboardRoute } from './onboard.js';
+export { buildReleaseSurface, bumpClass, classifySurfaceChange, classSatisfies, type ReleaseClass, type ReleaseSurface, type SurfaceChange, type SurfaceField } from './release-surface.js';
+export { type ClosedTodoText, inferTodoResolution, type TodoResolution } from './todo-resolution.js';
+export declare function createCortextPlugin(cfg: CortextPluginConfig): CoordinatorPlugin;

package/dist/index.js

@@ -0,0 +1,5 @@
+import { C as runCompact, E as isMonotonicAuth, S as registerCompactRoute, T as buildAuthPolicies, _ as TODO_RESOLUTION_ALIASES, a as classSatisfies, b as buildArchitectureNamespace, c as AGENT_RULE_CATEGORY_VOCAB, d as ARCHITECTURE_TYPE_NAMES, f as CLAUDE_TYPE_NAMES, g as HOST_INSTALL_FRAGMENT_STATES, h as HOST_INSTALL_CHECK_STATES, i as bumpClass, l as AGENT_RULE_SEVERITY_ALIASES, m as DECISION_STATUS_VOCAB, n as inferTodoResolution, o as classifySurfaceChange, p as DECISION_STATUS_ALIASES, r as buildReleaseSurface, s as registerOnboardRoute, t as createCortextPlugin, u as AGENT_RULE_SEVERITY_VOCAB, v as TODO_STATUS_ALIASES, w as DEFAULT_AUTH, x as buildClaudeNamespace, y as TODO_STATUS_IMPLIES } from "./src-BKaGTnRw.js";
+import { g as AGENT_MESSAGE_STATUS_VOCAB } from "./plugin-27UpMnoE.js";
+import "./kernel.js";
+
+export { AGENT_MESSAGE_STATUS_VOCAB, AGENT_RULE_CATEGORY_VOCAB, AGENT_RULE_SEVERITY_ALIASES, AGENT_RULE_SEVERITY_VOCAB, ARCHITECTURE_TYPE_NAMES, CLAUDE_TYPE_NAMES, DECISION_STATUS_ALIASES, DECISION_STATUS_VOCAB, DEFAULT_AUTH, HOST_INSTALL_CHECK_STATES, HOST_INSTALL_FRAGMENT_STATES, TODO_RESOLUTION_ALIASES, TODO_STATUS_ALIASES, TODO_STATUS_IMPLIES, buildArchitectureNamespace, buildAuthPolicies, buildClaudeNamespace, buildReleaseSurface, bumpClass, classSatisfies, classifySurfaceChange, createCortextPlugin, inferTodoResolution, isMonotonicAuth, registerCompactRoute, registerOnboardRoute, runCompact };

package/dist/kernel/bootstrap.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Structured-config bootstrap for cortext's kernel plugin
+ * (mirrors the recall + plane bootstrap pattern).
+ *
+ * No operator-overridable surface today — the plugin contributes a
+ * static migration list and nothing else. Reserved for future schema-
+ * level controls if any emerge.
+ */
+type CortextKernelHostDeps = Record<string, never>;
+export declare const bootstrap: import("@mnmal-ai/substrate/sdk").KernelBootstrap<CortextKernelHostDeps>;
+export default bootstrap;