trajectories 0.1.1 → 0.1.3

package/legacy/src/reader.ts

@@ -15,6 +15,7 @@ import { SCHEMA_VERSION } from "./schema.js";
 import { classifyReadStore, formatMismatchMessage, incompleteStoreMessage } from "./schema-gate.js";
 import type {
   CanonicalDbRecord,
+  IngestDiagnosticRecord,
   QueryResult,
   RecordMatchType,
   RecordSearchHit,
@@ -1220,6 +1221,26 @@ export class TrajectoryReader {
     return sessionRecords(this.db, sessionId);
   }
 
+  /** Read normalization uncertainty without opening a writer or reviving a tombstone. */
+  getSessionDiagnostics(sessionId: string): IngestDiagnosticRecord[] {
+    if (!this.getSession(sessionId)) return [];
+    return this.db.query<IngestDiagnosticRecord, [string]>(
+      `SELECT session_id, source, code, occurrence_count, sample, first_seen_at, last_seen_at
+       FROM ingest_diagnostics WHERE session_id = ? ORDER BY code ASC`,
+    ).all(sessionId);
+  }
+
+  /** Pin one source generation before sending its complete history to a remote. */
+  readSessionForSync(sessionId: string): {
+    session: SessionRecord; records: CanonicalDbRecord[]; diagnostics: IngestDiagnosticRecord[];
+  } | null {
+    return this.db.transaction(() => {
+      const session = this.getSession(sessionId);
+      if (!session) return null;
+      return { session, records: this.getSessionRecords(sessionId), diagnostics: this.getSessionDiagnostics(sessionId) };
+    }).deferred();
+  }
+
   getSessionCount(): number {
     return countSessions(this.db);
   }

package/legacy/src/shared.ts

@@ -0,0 +1,217 @@
+import { closeSync, constants, existsSync, fstatSync, openSync, readFileSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { parseArgs } from 'node:util';
+import { resolveCanonicalDbPath } from './canonical.js';
+import { ensurePrivateDirectory } from './private-storage.js';
+import { acquireWriterLease, isMemoryStorePath } from './writer-lease.js';
+import { TrajectoryReader } from './reader.js';
+import { TrajectoryDb } from './db.js';
+import { listSessions } from '../../src/log.js';
+import type { PageCursor } from '../../src/log-types.js';
+import { TrajectoriesError } from '../../src/log-types.js';
+import { exportManagedDelta } from '../../src/shared-managed.js';
+import { safeId } from '../../src/log-io.js';
+import { createSharedClient, createSharedHandler, sharedObservationId } from '../../src/shared.js';
+import type { ObservedState } from '../../src/shared.js';
+
+const help = `trajectories remote — cross-machine canonical history
+  remote serve --store <shared-directory> --token-file <0600-file>
+    [--host 127.0.0.1] [--port 8789]
+  remote push --url <endpoint> --token-file <0600-file> --machine <stable-id>
+    [--db <SQLite>] [--store <managed-store>] [--session <id>]
+  remote pull --url <endpoint> --token-file <0600-file> [--db <SQLite>]
+    [--store <managed-mirror>] [--machine <stable-origin-id>]
+  remote list --url <endpoint> --token-file <0600-file>
+Token path fallback: TRAJECTORIES_REMOTE_TOKEN_FILE. Tokens never belong in URLs.
+Push publishes observed canonical records; native files are not uploaded by this lane.
+--store additionally synchronizes managed logs and their referenced objects.
+Pull updates the existing SQLite lexical index; it never launches native harnesses.
+Pull --machine skips that originating machine's observed rows already stored locally.
+`;
+
+function required(value: string | undefined, option: string): string {
+  if (!value) throw new Error(`${option} is required.`);
+  return value;
+}
+
+/** Read an owner-only regular file through the validated descriptor. */
+function readToken(path: string): string {
+  const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const stat = fstatSync(fd);
+    if (!stat.isFile() || stat.nlink !== 1 || (stat.mode & 0o777) !== 0o600 || (process.getuid && stat.uid !== process.getuid())) {
+      throw new Error('Remote token file must be an owner-owned regular file with mode 0600.');
+    }
+    if (stat.size > 4096) throw new Error('Remote token file is too large.');
+    const token = readFileSync(fd, 'utf8').trim();
+    if (!token || /[\s\x00-\x1f\x7f]/u.test(token)) throw new Error('Remote token file must contain one nonempty token.');
+    return token;
+  } finally { closeSync(fd); }
+}
+
+function project(state: ObservedState) {
+  const id = `shared:${state.id}`;
+  return {
+    session: { ...state.session, id, source_path: `shared://${state.machineId}/${encodeURIComponent(state.session.id)}`,
+      // The remote immutable head covers both record and metadata changes.
+      content_hash: state.head,
+      parent_session_id: state.session.parent_session_id
+        ? `shared:${sharedObservationId(state.machineId, state.session.parent_session_id)}` : null,
+    },
+    records: state.records.map(record => ({ ...record, id: `${id}:${record.id}`, session_id: id })),
+  };
+}
+
+export async function runSharedCli(argv: string[]): Promise<void> {
+  // Help must not open SQLite, managed stores, credentials or sockets.
+  if (!argv.length || argv.some(value => value === '--help' || value === '-h') || argv[0] === 'help') { console.log(help); return; }
+  const command = argv[0];
+  if (!['serve', 'push', 'pull', 'list'].includes(command!)) throw new Error('Expected remote serve, push, pull or list.');
+  const { values, positionals } = parseArgs({ args: argv.slice(1), strict: true, allowPositionals: true, options: {
+    store: { type: 'string' }, host: { type: 'string' }, port: { type: 'string' },
+    url: { type: 'string' }, 'token-file': { type: 'string' }, machine: { type: 'string' },
+    db: { type: 'string' }, session: { type: 'string' }, robot: { type: 'boolean' }, json: { type: 'boolean' },
+  }});
+  if (positionals.length) throw new Error('Unexpected remote positional arguments.');
+  const allowed: Record<string, Set<string>> = {
+    serve: new Set(['store', 'host', 'port', 'token-file', 'json', 'robot']),
+    push: new Set(['url', 'token-file', 'machine', 'db', 'store', 'session', 'json', 'robot']),
+    pull: new Set(['url', 'token-file', 'db', 'store', 'machine', 'json', 'robot']),
+    list: new Set(['url', 'token-file', 'json', 'robot']),
+  };
+  for (const option of Object.keys(values)) {
+    if (!allowed[command!]!.has(option)) throw new Error(`--${option} is not supported by remote ${command}.`);
+  }
+  const machine = values.machine === undefined ? undefined : safeId(values.machine);
+  const port = values.port === undefined ? 8789 : Number(values.port);
+  if (command === 'serve' && (!Number.isInteger(port) || port < 0 || port > 65535)) throw new Error('--port must be an integer from 0 through 65535.');
+  const token = readToken(required(values['token-file'] ?? process.env.TRAJECTORIES_REMOTE_TOKEN_FILE, '--token-file'));
+  const emit = (value: unknown) => console.log(JSON.stringify(value));
+  if (command === 'serve') {
+    const store = resolve(required(values.store, '--store'));
+    const server = Bun.serve({ hostname: values.host ?? '127.0.0.1', port,
+      maxRequestBodySize: 64 * 1024 * 1024, fetch: createSharedHandler({ store, token }),
+    });
+    const close = () => { server.stop(true); process.removeListener('SIGINT', close); process.removeListener('SIGTERM', close); };
+    process.on('SIGINT', close); process.on('SIGTERM', close);
+    emit({ command: 'serve', host: server.hostname, port: server.port });
+    return;
+  }
+  const client = createSharedClient({ url: required(values.url, '--url'), token });
+  if (command === 'list') {
+    const observed = await client.listObserved();
+    const managed = await client.listManaged();
+    emit({ observed: observed.map(item => ({ id: item.id, head: item.head, machineId: item.machineId,
+      source: item.session.source, records: item.session.record_count })),
+      managed: managed.map(item => ({ id: item.id, head: item.head })),
+    });
+    return;
+  }
+  const dbPath = values.db ?? resolveCanonicalDbPath();
+  if (command === 'push') {
+    const machineId = required(machine, '--machine');
+    const observed = [];
+    let selected = false;
+    // An explicit managed store without --db selects only the managed lane.
+    if (!values.store || values.db) {
+      const reader = new TrajectoryReader(dbPath);
+      try {
+        const ids = values.session ? [values.session] : reader.getAllSessions().map(session => session.id);
+        for (const id of ids) {
+          const captured = reader.readSessionForSync(id);
+          if (!captured) continue;
+          const { session, records } = captured;
+          // Derived mirrors and managed projections cannot become native originals.
+          if (session.source === 'managed' || session.id.startsWith('managed:') || session.source_path.startsWith('shared://')) continue;
+          selected = true;
+          const diagnostics = captured.diagnostics.map(item => ({ code: item.code,
+            occurrenceCount: item.occurrence_count, sample: item.sample, firstSeenAt: item.first_seen_at }));
+          observed.push(await client.pushObserved({ machineId, session: { ...session, diagnostics }, records }));
+        }
+      } finally { reader.close(); }
+    }
+    const managed = [];
+    if (values.store) {
+      const store = resolve(values.store);
+      let cursor: PageCursor | undefined;
+      do {
+        const page = await listSessions(store, { cursor, limit: 1000 });
+        for (const session of page.items) {
+          if (values.session && session.id !== values.session) continue;
+          selected = true;
+          managed.push(await client.pushManaged(store, session.id));
+        }
+        cursor = page.nextCursor ?? undefined;
+      } while (cursor);
+    }
+    if (values.session && !selected) throw new Error('Selected original session was not found; managed projections require --store.');
+    emit({ command, observed, managed });
+    return;
+  }
+  if (!isMemoryStorePath(dbPath)) {
+    if (!values.db && !process.env.TRAJECTORIES_DB && !process.env.LEDGER_DB) ensurePrivateDirectory(dirname(dbPath));
+    else await mkdir(dirname(dbPath), { recursive: true, mode: 0o700 });
+  }
+  const observed = [];
+  for (const item of await client.listObserved()) {
+    if (item.machineId === machine) {
+      observed.push({ id: item.id, head: item.head, outcome: 'skipped-origin' });
+      continue;
+    }
+    if (!isMemoryStorePath(dbPath) && existsSync(dbPath)) {
+      const reader = new TrajectoryReader(dbPath);
+      try {
+        const local = reader.getSession(`shared:${item.id}`);
+        if (local?.source_path.startsWith('shared://') && local.content_hash === item.head) {
+          observed.push({ id: item.id, head: item.head, records: local.record_count, outcome: 'unchanged' });
+          continue;
+        }
+      } finally { reader.close(); }
+    }
+    const state = await client.getObserved(item.id);
+    const lease = isMemoryStorePath(dbPath) ? null : acquireWriterLease(dbPath, { holder: 'trajectories remote pull' });
+    try {
+      const db = new TrajectoryDb(dbPath);
+      try {
+        const projection = project(state);
+        if (db.getTombstone(projection.session.id)) { observed.push({ id: item.id, head: state.head, outcome: 'deleted' }); continue; }
+        const saved = db.saveSession(projection.session, projection.records, state.session.diagnostics);
+        observed.push({ id: item.id, head: state.head, records: projection.records.length,
+          outcome: saved.inserted ? 'inserted' : saved.updated ? 'updated' : 'unchanged' });
+      } finally { db.close(); }
+    } finally { lease?.close(); }
+  }
+  const managed = [];
+  let conflicts = 0;
+  if (values.store) {
+    const store = resolve(values.store);
+    for (const session of await client.listManaged()) {
+      try { managed.push({ ...await client.pullManaged(store, session.id), outcome: 'pulled' }); }
+      catch (error) {
+        if (!(error instanceof TrajectoriesError) || !['STALE_HEAD', 'INTENT_CONFLICT'].includes(error.code)) throw error;
+        // The failed pull may have observed a newer branch than the original list.
+        const remote = (await client.listManaged()).find(item => item.id === session.id);
+        let ahead;
+        try { if (remote) ahead = await exportManagedDelta(store, session.id, { afterHead: remote.head }); }
+        catch (proofError) {
+          if (!(proofError instanceof TrajectoriesError) || !['STALE_HEAD', 'NOT_FOUND'].includes(proofError.code)) throw proofError;
+        }
+        if (remote && ahead?.frames.length && ahead.head !== remote.head) {
+          managed.push({ id: session.id, head: ahead.head, remoteHead: remote.head, outcome: 'ahead' });
+        } else {
+          conflicts++;
+          managed.push({ id: session.id, remoteHead: remote?.head, outcome: 'conflict', code: error.code });
+        }
+      }
+    }
+    // Existing indexer preserves accepted managed ordering, FTS and tombstones.
+    // Its summary is emitted separately and contains no record bodies.
+    if (managed.length) {
+      const { runManagedCli } = await import('./managed.js');
+      await runManagedCli('index', ['--store', resolve(values.store), '--db', dbPath, '--robot']);
+    }
+  }
+  emit({ command, observed, managed });
+  if (conflicts) throw new TrajectoriesError('STALE_HEAD', `${conflicts} managed session(s) conflict; other histories were pulled and indexed. Local branches were preserved.`);
+}

package/legacy/src/sync.ts

@@ -630,12 +630,26 @@ function retryAt(now: Date, attempts: number): string {
   return new Date(now.getTime() + delayMs).toISOString();
 }
 
+declare const TRAJECTORIES_STANDALONE: boolean;
+declare const TRAJECTORIES_BUNDLED_CLI: boolean;
+
+function syncEntry(command: string): string[] {
+  // Compiled distributions execute the same private verbs in a fresh process.
+  if (typeof TRAJECTORIES_STANDALONE !== "undefined" && TRAJECTORIES_STANDALONE) {
+    return [process.execPath, command];
+  }
+  if (typeof TRAJECTORIES_BUNDLED_CLI !== "undefined" && TRAJECTORIES_BUNDLED_CLI) {
+    return [process.execPath, process.argv[1]!, command];
+  }
+  return [process.execPath, fileURLToPath(new URL("../bin/ledger-core.ts", import.meta.url)), command];
+}
+
 function workerEntry(): string[] {
-  return [process.execPath, fileURLToPath(new URL("../bin/ledger-core.ts", import.meta.url)), "__sync-worker"];
+  return syncEntry("__sync-worker");
 }
 
 function maintenanceEntry(): string[] {
-  return [process.execPath, fileURLToPath(new URL("../bin/ledger-core.ts", import.meta.url)), "__sync-maintenance"];
+  return syncEntry("__sync-maintenance");
 }
 
 export function workerReservation(
@@ -863,7 +877,7 @@ async function prepareInChild(options: SyncOptions, scanLimit: number, maxRecord
   if (remaining <= 0) throw new SyncPreparationError("timed_out");
   const result = await spawnJsonChild<SyncPreparationReply | PreparationFailure>({ protocol_version: SYNC_PROTOCOL_VERSION,
     db_path: options.dbPath, sources: options.sources, roots: options.roots, scan_limit: scanLimit, max_record_bytes: maxRecordBytes },
-    remaining, options.preparationCommand ?? [process.execPath, fileURLToPath(new URL("../bin/ledger-core.ts", import.meta.url)), "__sync-prepare"],
+    remaining, options.preparationCommand ?? syncEntry("__sync-prepare"),
     parsePreparationReply, { label: "sync_preparation" });
   if (result.status !== "ok" || !result.reply) throw new SyncPreparationError(result.status);
   if (result.reply.type === "sync_preparation_error") {

package/ops/README.md

@@ -7,10 +7,40 @@ session/log store, which requires an explicit `index --store` command.
 
 ## Install the CLI
 
+### Native CLI
+
+Native releases require no Bun, Node or npm. The repository is currently private,
+so GitHub downloads require an authenticated `gh` client with repository access.
+On an Apple Silicon Mac:
+
+```sh
+gh release download 'trajectories@0.1.2' --repo archeism/oh-my-ai \
+  --pattern 'trajectories-0.1.2-darwin-arm64.tar.gz*'
+shasum -a 256 --check trajectories-0.1.2-darwin-arm64.tar.gz.sha256
+mkdir -p "$HOME/.local/share/trajectories/native"
+tar -xzf trajectories-0.1.2-darwin-arm64.tar.gz -C "$HOME/.local/share/trajectories/native"
+bash "$HOME/.local/share/trajectories/native/trajectories-0.1.2-darwin-arm64/install.sh"
+trajectories --version
+```
+
+On Linux, choose `linux-x64` or `linux-arm64`, and use `sha256sum --check`.
+The installer refuses existing commands unless `--force` explicitly authorizes
+replacement. It creates a symlink to the retained release directory; do not
+delete that directory or separate the executable from `lib/`. It does not change
+the search database or enable an indexing service. Ensure `~/.local/bin` is on PATH.
+Local ONNX inference requires glibc 2.28+ on Linux or macOS 14+ on Apple Silicon. Deep Agents SQLite conversion
+still uses the harness's own Python/LangGraph environment.
+
+The service installers below are for source/npm installations and invoke Bun.
+For a native service, its command is the installed `trajectories sync` executable
+directly; the CLI's bounded sync and scheduler protocol are unchanged.
+
+### npm or source CLI
+
 For the npm distribution, use Bun 1.4.2 or newer:
 
 ```sh
-bun add --global trajectories@0.1.0
+bun add --global trajectories@0.1.2
 trajectories --version
 trajectories status --robot
 ```

package/ops/install-native.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+# Run from an extracted native release kept in a permanent directory.
+set -euo pipefail
+RELEASE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
+BIN_DIR="${TRAJECTORIES_BIN_DIR:-$HOME/.local/bin}"
+FORCE=0
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --bin-dir) [[ $# -ge 2 && -n "$2" ]] || { echo '--bin-dir requires a directory.' >&2; exit 1; }; BIN_DIR="$2"; shift 2 ;;
+    --force) FORCE=1; shift ;;
+    --help|-h) echo 'Usage: install.sh [--bin-dir DIR] [--force]'; exit 0 ;;
+    *) echo "Unknown option: $1" >&2; exit 1 ;;
+  esac
+done
+[[ -x "$RELEASE_DIR/trajectories" && -d "$RELEASE_DIR/lib" ]] || {
+  echo 'Keep install.sh, the trajectories executable, and lib/ together in the extracted release.' >&2; exit 1;
+}
+"$RELEASE_DIR/trajectories" --version
+mkdir -p "$BIN_DIR"
+TARGET="$BIN_DIR/trajectories"
+if [[ -e "$TARGET" || -L "$TARGET" ]]; then
+  if [[ -L "$TARGET" && "$(readlink "$TARGET")" == "$RELEASE_DIR/trajectories" ]]; then
+    echo "Already installed: $TARGET"; exit 0
+  fi
+  [[ "$FORCE" == 1 && ! -d "$TARGET" ]] || {
+    echo "Refusing to overwrite $TARGET; use --force for an explicit cutover." >&2; exit 1;
+  }
+fi
+STAGE="$(mktemp -d "$BIN_DIR/.trajectories-install.XXXXXX")"
+trap 'rm -rf "$STAGE"' EXIT
+ln -s "$RELEASE_DIR/trajectories" "$STAGE/trajectories"
+mv -f "$STAGE/trajectories" "$TARGET"
+echo "Installed: $TARGET"
+echo "Keep the release directory: $RELEASE_DIR"
+case ":$PATH:" in *":$BIN_DIR:"*) ;; *) echo "Add $BIN_DIR to PATH." ;; esac

package/package.json

@@ -1,22 +1,61 @@
 {
   "name": "trajectories",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Portable coding-agent sessions: read, search, convert, and continue across harnesses.",
   "type": "module",
   "license": "Apache-2.0",
-  "engines": { "node": ">=22.13.0", "bun": ">=1.4.2" },
-  "exports": { ".": { "types": "./dist/index.d.ts", "import": "./dist/index.js" } },
-  "bin": { "trajectories": "./dist/cli.js" },
-  "files": ["dist", "docs", "legacy/src", "legacy/bin", "legacy/scripts", "legacy/NOTICE.md", "ops", "skills", "README.md", "CHANGELOG.md", "LICENSE"],
+  "engines": {
+    "node": ">=22.13.0",
+    "bun": ">=1.4.2"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "trajectories": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "docs",
+    "legacy/src",
+    "legacy/bin",
+    "legacy/scripts",
+    "legacy/NOTICE.md",
+    "ops",
+    "skills",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json && bun build src/index.ts --target node --format esm --outfile dist/index.js && bun build src/normalization-runtime.ts --target bun --format esm --outfile dist/normalization-runtime.js && bun build src/cli.ts --target bun --format esm --outfile dist/cli.js && bun -e \"require('node:fs').chmodSync('dist/cli.js', 0o755)\"",
+    "build": "tsc -p tsconfig.build.json && bun build src/index.ts --target node --format esm --outfile dist/index.js && bun build src/normalization-runtime.ts --target bun --format esm --outfile dist/normalization-runtime.js && bun build src/cli.ts --target bun --format esm --external onnxruntime-node --define TRAJECTORIES_BUNDLED_CLI=true --outfile dist/cli.js && bun scripts/build-assets.ts",
+    "build:native": "bun run build && bun scripts/build-native.ts",
     "test": "bun test ./test/*.test.ts",
     "verify": "bun run build && tsc -p tsconfig.legacy.json && bun run test && bun test ./legacy/tests",
-    "test:package": "bun run build && bun test ./smoke/package.test.ts"
+    "test:native": "bun scripts/check-native.ts",
+    "test:package": "bun run build && bun test ./smoke/package.test.ts && bun run test:native"
+  },
+  "dependencies": {
+    "@letta-ai/trajectory": "0.4.3"
+  },
+  "optionalDependencies": {
+    "onnxruntime-node": "^1.29.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.1",
+    "@types/bun": "1.3.14",
+    "typescript": "^5.9.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/archeism/oh-my-ai.git",
+    "directory": "packages/trajectories"
+  },
+  "publishConfig": {
+    "access": "public"
   },
-  "dependencies": { "@letta-ai/trajectory": "0.4.3" },
-  "optionalDependencies": { "onnxruntime-node": "^1.29.0" },
-  "devDependencies": { "@types/node": "^22.20.1", "@types/bun": "1.3.14", "typescript": "^5.9.3" },
-  "repository": { "type": "git", "url": "git+https://github.com/archeism/oh-my-ai.git", "directory": "packages/trajectories" },
-  "publishConfig": { "access": "public" }
+  "gitHead": "fa1591e54eaeec7d48a8edfaa086d46fd9b2d4f3"
 }

package/dist/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env bun
-export {};