spexcode 0.6.7 → 0.6.8

package/README.md

@@ -83,13 +83,18 @@ spex init --harness claude,codex,opencode,pi,zcode,claude-headless,opencode-head
 ```
 
 That's the whole adoption. The example lists all the built-in harnesses; remove the ones you don't
-use (`--harness` is required and takes any one id or comma-separated subset).
-`spex init` is additive: it works on any existing git repo, never overwrites your files, and does
-three things. It seeds a root `.spec/project/spec.md` plus a starter `spexcode.json`, installs the
-git hooks, and **materializes** the workflow rules into the files your agent already reads
-(`CLAUDE.md`, `AGENTS.md`): read the governing spec before the code, land spec and code in one
-commit, propose merges instead of performing them. Any agent that opens the repo discovers the
-workflow on its own.
+use (`--harness` is required and takes any one id or comma-separated subset). Want the spec asset and
+nothing wired into an agent? `--harness none` adopts L0 alone and writes nothing into any agent's config.
+`spex init` works on any existing git repo and does three things: it seeds a root
+`.spec/project/spec.md` plus a starter `spexcode.json`, installs the git hooks, and **materializes**
+the workflow rules into the files your agent already reads (`CLAUDE.md`, `AGENTS.md`): read the
+governing spec before the code, land spec and code in one commit, propose merges instead of
+performing them. Any agent that opens the repo discovers the workflow on its own.
+
+It is additive, and never replaces a file you own. Where a harness discovers its hooks inside your own
+config (`.claude/settings.json`, `.codex/hooks.json`), only SpexCode's entries are merged in — your
+permissions, env and hooks stay — and `spex uninstall` takes back exactly those entries. A skill or
+agent name you already use is skipped and reported, never overwritten.
 
 When you want the live board (the graph, sessions, evals), start the runtime:
 

package/node_modules/@spexcode/session-application/dist/index.d.ts

@@ -0,0 +1,17 @@
+import type { Message, MessageInput, SessionProtocol } from '@spexcode/session-protocol';
+import type { SessionTopology, TopologyEdge } from '@spexcode/session-topology';
+export interface NotificationResult {
+    edge: TopologyEdge | null;
+    recipients: string[];
+    messages: Message[];
+}
+export interface SessionApplication {
+    notifyRecipients(subjectSessionId: string, message: MessageInput): NotificationResult;
+    attachAndNotify(fromSessionId: string, subjectSessionId: string, relationType: string, message: MessageInput): NotificationResult;
+}
+export declare function openSessionApplication(protocol: SessionProtocol, topology: SessionTopology): SessionApplication;
+export { openProjectSessionApplication } from './production.js';
+export { jsonMigrationFencePath, legacyResidueExists, migrateJsonSessionRecords, MIGRATED_MESSAGE_EVENT, MIGRATED_STATE_EVENT } from './migration.js';
+export type { CommittedSessionChange, ConversationMessageInput, CreateSessionInput, LocalityPrecondition, NativeRuntimeIdentity, ProductionSessionApplication, ProjectSessionApplicationOptions, SessionState, SessionStateChange, TransitionSessionInput, } from './production.js';
+export type { SessionEvent } from '@spexcode/session-events';
+export type { JsonMigrationRecord, JsonResidueMigrationReport, JsonSessionMigrationOptions, JsonSessionMigrationReport, } from './migration.js';

package/node_modules/@spexcode/session-application/dist/index.js

@@ -0,0 +1,35 @@
+function enqueueForRecipients(tx, topology, subjectSessionId, message) {
+    const recipients = topology.recipients(subjectSessionId, tx);
+    const messages = recipients.map(recipient => tx.enqueue(recipient, {
+        ...message,
+        senderSessionId: message.senderSessionId === undefined
+            ? subjectSessionId
+            : message.senderSessionId,
+    }));
+    return { edge: null, recipients, messages };
+}
+export function openSessionApplication(protocol, topology) {
+    if (!protocol || typeof protocol.withTransaction !== 'function') {
+        throw new TypeError('session application requires a live protocol handle');
+    }
+    if (!topology || typeof topology.recipients !== 'function' || typeof topology.attach !== 'function') {
+        throw new TypeError('session application requires a live topology handle');
+    }
+    const run = (subjectSessionId, message, edge, tx) => {
+        const result = enqueueForRecipients(tx, topology, subjectSessionId, message);
+        return { ...result, edge };
+    };
+    return {
+        notifyRecipients(subjectSessionId, message) {
+            return protocol.withTransaction(tx => run(subjectSessionId, message, null, tx));
+        },
+        attachAndNotify(fromSessionId, subjectSessionId, relationType, message) {
+            return protocol.withTransaction(tx => {
+                const edge = topology.attach(tx, fromSessionId, subjectSessionId, relationType);
+                return run(subjectSessionId, message, edge, tx);
+            });
+        },
+    };
+}
+export { openProjectSessionApplication } from './production.js';
+export { jsonMigrationFencePath, legacyResidueExists, migrateJsonSessionRecords, MIGRATED_MESSAGE_EVENT, MIGRATED_STATE_EVENT } from './migration.js';

package/node_modules/@spexcode/session-application/dist/migration.d.ts

@@ -0,0 +1,51 @@
+import { type LocalityPrecondition, type ProductionSessionApplication } from './production.js';
+/** Migrated legacy history keeps the live payload shapes under its own ignorable types: a timeline projection
+ * shows it beside live events, while state replay (which knows only the live types) skips it as history. */
+export declare const MIGRATED_STATE_EVENT = "session.state.migrated.v1";
+export declare const MIGRATED_MESSAGE_EVENT = "session.message.migrated.v1";
+export interface JsonMigrationRecord {
+    session_id: string;
+    status: string;
+    parent?: string | null;
+    createdAt?: number;
+    [key: string]: unknown;
+}
+export interface JsonSessionMigrationOptions {
+    databasePath: string;
+    recordsRoot: string;
+    locality: LocalityPrecondition;
+    backupRoot?: string;
+    now?: () => number;
+    orphanParentPolicy?: 'fail' | 'tombstone';
+    /** A caller that already owns the open canonical application lends it for residue import; otherwise the
+     * importer opens and closes its own handle. */
+    application?: ProductionSessionApplication;
+}
+/** The durable fence shared by the one-time importer and legacy JSON writers. */
+export declare function jsonMigrationFencePath(recordsRoot: string): string;
+export interface JsonResidueMigrationReport {
+    sourceDigest: string;
+    records: number;
+    events: number;
+    parentEdges: number;
+    watchEdges: number;
+    pending: number;
+    unclaimed: string[];
+    backupRoot: string;
+}
+export interface JsonSessionMigrationReport {
+    version: number;
+    sourceDigest: string;
+    records: number;
+    parentEdges: number;
+    watchEdges: number;
+    events: number;
+    orphanParents: string[];
+    backupRoot: string;
+    markerPath: string;
+    replayed: boolean;
+    residue?: JsonResidueMigrationReport;
+}
+/** Whether the legacy tree still holds anything the canonical store must absorb before the tree is retired. */
+export declare function legacyResidueExists(recordsRoot: string): boolean;
+export declare function migrateJsonSessionRecords(options: JsonSessionMigrationOptions): JsonSessionMigrationReport;