@triflux/remote 10.50.1 → 10.50.2

package/cto/collect.mjs

@@ -1,23 +1,23 @@
 import { execFileSync } from "node:child_process";
 import {
-  appendFileSync,
-  closeSync,
   existsSync,
   mkdirSync,
-  openSync,
   readdirSync,
   readFileSync,
-  renameSync,
   statSync,
-  unlinkSync,
-  writeFileSync,
 } from "node:fs";
 import { homedir } from "node:os";
-import { basename, dirname, join, relative } from "node:path";
+import { join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import { renderBrief } from "./brief.mjs";
-import { resolveLakeRootDir } from "./lake-root.mjs";
+import { appendCtoEvent } from "./events.mjs";
+import {
+  firstExisting,
+  readJsonLines,
+  resolveLakeRootDir,
+  writeAtomic,
+} from "./lake-root.mjs";
 
 const SCHEMA_VERSION = "cto-lake.v1";
 const SOURCE_REGISTRY = [
@@ -69,24 +69,6 @@ const SOURCE_REGISTRY = [
     probe: ".omx/handoffs/*",
     enabled: true,
   },
-  {
-    id: "session_vault",
-    kind: "optional-durable-ref",
-    probe: ".triflux/session-vault.json, sessions_v2.db, or .session-vault",
-    enabled: true,
-  },
-  {
-    id: "agy",
-    kind: "optional-durable-ref",
-    probe: ".agy/state.json or .agy/refs.json",
-    enabled: true,
-  },
-  {
-    id: "gbrain",
-    kind: "optional-durable-ref",
-    probe: ".gbrain/refs.json or .gbrain/config.json",
-    enabled: true,
-  },
 ];
 const SOURCE_IDS = SOURCE_REGISTRY.map((source) => source.id);
 
@@ -104,10 +86,6 @@ function isoNow(opts) {
   return value.toISOString();
 }
 
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
 function sourceState(available, status, detail, collectedAt) {
   return {
     available,
@@ -130,25 +108,6 @@ function readJson(filePath) {
   return JSON.parse(readFileSync(filePath, "utf8"));
 }
 
-function readJsonLines(filePath, limit = 20) {
-  if (!existsSync(filePath)) return [];
-  const lines = readFileSync(filePath, "utf8")
-    .split(/\r?\n/u)
-    .map((line) => line.trim())
-    .filter(Boolean);
-  return lines.slice(-limit).flatMap((line) => {
-    try {
-      return [JSON.parse(line)];
-    } catch {
-      return [];
-    }
-  });
-}
-
-function findFirstExisting(candidates) {
-  return candidates.find((candidate) => existsSync(candidate)) || null;
-}
-
 function listDirFiles(dirPath, rootDir, limit = 10) {
   if (!existsSync(dirPath)) return [];
   try {
@@ -237,7 +196,7 @@ function collectJsonArtifact(
   collectedAt,
   summarize = safeSummary,
 ) {
-  const filePath = findFirstExisting(candidates);
+  const filePath = firstExisting(candidates);
   if (!filePath) {
     return missingSource(
       "no_shell_readable_artifact",
@@ -429,59 +388,6 @@ function collectHandoffs(rootDir, collectedAt) {
   );
 }
 
-function collectDurableRefs(
-  id,
-  candidates,
-  rootDir,
-  collectedAt,
-  unavailableStatus = "no_shell_readable_artifact",
-) {
-  const filePath = findFirstExisting(candidates);
-  if (!filePath) {
-    return missingSource(
-      unavailableStatus,
-      `${id} exposes no shell-readable durable artifact`,
-      collectedAt,
-    );
-  }
-  try {
-    const stat = statSync(filePath);
-    if (stat.isDirectory()) {
-      return sourceState(
-        true,
-        "ok",
-        {
-          path: relPath(rootDir, filePath),
-          files: listDirFiles(filePath, rootDir, 10),
-        },
-        collectedAt,
-      );
-    }
-    const parsed = basename(filePath).endsWith(".json")
-      ? readJson(filePath)
-      : readFileSync(filePath, "utf8");
-    return sourceState(
-      true,
-      "ok",
-      {
-        path: relPath(rootDir, filePath),
-        summary: safeSummary(parsed),
-      },
-      collectedAt,
-    );
-  } catch (error) {
-    return sourceState(
-      true,
-      "read_error",
-      {
-        path: relPath(rootDir, filePath),
-        error: error?.message || `${id} read failed`,
-      },
-      collectedAt,
-    );
-  }
-}
-
 function buildSummary(current) {
   const repo = current.repo;
   const omxGoals = current.sources.ultragoal_omx.detail?.active_goals || [];
@@ -633,48 +539,6 @@ function validateCurrent(current) {
   }
 }
 
-function writeAtomic(filePath, body) {
-  mkdirSync(dirname(filePath), { recursive: true });
-  const tmpPath = join(
-    dirname(filePath),
-    `.${basename(filePath)}.${process.pid}.${Date.now()}.tmp`,
-  );
-  writeFileSync(tmpPath, body, "utf8");
-  renameSync(tmpPath, filePath);
-}
-
-async function appendLedgerEvent(lakeRoot, event, stderr) {
-  mkdirSync(lakeRoot, { recursive: true });
-  const ledgerPath = join(lakeRoot, "ledger.jsonl");
-  const lockPath = join(lakeRoot, "ledger.jsonl.lock");
-  let fd = null;
-  for (let attempt = 0; attempt < 3; attempt += 1) {
-    try {
-      fd = openSync(lockPath, "wx", 0o600);
-      break;
-    } catch (error) {
-      if (error?.code !== "EEXIST") throw error;
-      if (attempt < 2) await sleep(100);
-    }
-  }
-  if (fd === null) {
-    stderr.write(
-      "[tfx cto collect] warning: ledger lock timeout; skipped ledger append\n",
-    );
-    return false;
-  }
-
-  try {
-    appendFileSync(ledgerPath, `${JSON.stringify(event)}\n`, "utf8");
-    return true;
-  } finally {
-    closeSync(fd);
-    try {
-      unlinkSync(lockPath);
-    } catch {}
-  }
-}
-
 function collectSources(rootDir, collectedAt, execFileSyncFn, opts = {}) {
   const home = homedir();
   const hostArtifactCandidates =
@@ -748,34 +612,6 @@ function collectSources(rootDir, collectedAt, execFileSyncFn, opts = {}) {
       collectedAt,
     ),
     handoffs: collectHandoffs(rootDir, collectedAt),
-    session_vault: collectDurableRefs(
-      "session_vault",
-      [
-        join(rootDir, ".triflux", "session-vault.json"),
-        join(rootDir, "sessions_v2.db"),
-        join(rootDir, ".session-vault"),
-      ],
-      rootDir,
-      collectedAt,
-      "not_shell_collectable",
-    ),
-    agy: collectDurableRefs(
-      "agy",
-      [join(rootDir, ".agy", "state.json"), join(rootDir, ".agy", "refs.json")],
-      rootDir,
-      collectedAt,
-      "not_shell_collectable",
-    ),
-    gbrain: collectDurableRefs(
-      "gbrain",
-      [
-        join(rootDir, ".gbrain", "refs.json"),
-        join(rootDir, ".gbrain", "config.json"),
-      ],
-      rootDir,
-      collectedAt,
-      "not_shell_collectable",
-    ),
   };
 
   return { repo: git.repo, sources };
@@ -786,6 +622,12 @@ function hasFlag(args, flag) {
 }
 
 export async function runCollect(args = [], opts = {}) {
+  if (hasFlag(args, "--help")) {
+    (opts.stdout || process.stdout).write(
+      "Usage: tfx cto collect [--json]\nRefresh the CTO lake from durable authority sources.\n",
+    );
+    return;
+  }
   const rootDir = opts.rootDir || resolveLakeRootDir(process.cwd());
   const lakeRoot = opts.lakeRoot || join(rootDir, ".triflux", "lake");
   const stdout = opts.stdout || process.stdout;
@@ -822,7 +664,7 @@ export async function runCollect(args = [], opts = {}) {
       sources_json: "sources.json",
     },
   };
-  const appended = await appendLedgerEvent(lakeRoot, event, stderr);
+  const { appended } = await appendCtoEvent(lakeRoot, event, { stderr });
   if (appended) current.ledger_tail = readLedgerTail(lakeRoot);
 
   validateCurrent(current);

package/cto/current.schema.json

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://triflux.local/schemas/cto/current.schema.json",
   "title": "Triflux CTO Lake Current Authority State",
-  "description": "Contract for .triflux/lake/current.json. .triflux/lake is a triflux-owned, namespace-neutral cross-agent rollup for durable artifacts across Claude, Codex/OMX, OMC, AGY, gstack, gbrain, and Triflux state. It reads and aggregates .omx/ultragoal and .omc/ultragoal execution ledgers without replacing or duplicating their authority. ledger.jsonl and sources.json companion contracts are documented in $defs.",
+  "description": "Contract for .triflux/lake/current.json. .triflux/lake is a triflux-owned, namespace-neutral cross-agent rollup for durable artifacts across Claude, Codex/OMX, OMC, and Triflux state. It reads and aggregates .omx/ultragoal and .omc/ultragoal execution ledgers without replacing or duplicating their authority. ledger.jsonl and sources.json companion contracts are documented in $defs.",
   "type": "object",
   "additionalProperties": false,
   "required": [
@@ -44,7 +44,7 @@
     },
     "sources": {
       "type": "object",
-      "description": "Durable artifact source states only. Live Claude /goal state and AGY internal state are not shell-collectable; a source reports available:false when no shell-readable durable artifact exists.",
+      "description": "Durable artifact source states only. A source reports available:false when no shell-readable durable artifact exists.",
       "additionalProperties": false,
       "required": [
         "git",
@@ -54,10 +54,7 @@
         "tfx_synapse",
         "ultragoal_omx",
         "ultragoal_omc",
-        "handoffs",
-        "session_vault",
-        "agy",
-        "gbrain"
+        "handoffs"
       ],
       "properties": {
         "git": {
@@ -83,21 +80,12 @@
         },
         "handoffs": {
           "$ref": "#/$defs/sourceState"
-        },
-        "session_vault": {
-          "$ref": "#/$defs/sourceState"
-        },
-        "agy": {
-          "$ref": "#/$defs/sourceState"
-        },
-        "gbrain": {
-          "$ref": "#/$defs/sourceState"
         }
       }
     },
     "summary": {
       "type": "object",
-      "description": "Human- and dashboard-oriented synthesized authority summary derived from durable artifacts and live Triflux synapse session status. Phase 1 may add source-derived fields here without changing the top-level contract.",
+      "description": "Human-oriented synthesized authority summary derived from durable artifacts and live Triflux synapse session status. Phase 1 may add source-derived fields here without changing the top-level contract.",
       "additionalProperties": true
     },
     "ledger_tail": {

package/cto/events.mjs

@@ -6,12 +6,13 @@ import {
   unlinkSync,
 } from "node:fs";
 import { basename, join } from "node:path";
-import { resolveLakeRootDir } from "./lake-root.mjs";
+import { pathLabel, shortHash, toIsoTime } from "./lake-root.mjs";
 
 export const CTO_EVENT_SCHEMA_VERSION = "cto-event.v1";
 export const DEFAULT_CTO_EVENT_SOURCE = "tfx_cto_event";
 
 export const CTO_EVENT_TYPES = Object.freeze([
+  "collect",
   "session_started",
   "session_heartbeat",
   "session_stale",
@@ -42,98 +43,6 @@ export const CTO_HYGIENE_STATUSES = Object.freeze([
 const EVENT_TYPE_SET = new Set(CTO_EVENT_TYPES);
 const STATUS_SET = new Set(CTO_HYGIENE_STATUSES);
 
-const EVENT_PRESETS = Object.freeze({
-  "context-save": {
-    event: "checkpoint_saved",
-    source: "gstack_context_save",
-    actor: { cli: "gstack context-save" },
-    ownerSurface: "gstack context-save -> tfx cto event context-save",
-  },
-  "checkpoint-saved": {
-    event: "checkpoint_saved",
-    ownerSurface: "checkpoint wrapper -> tfx cto event checkpoint-saved",
-  },
-  "context-restore": {
-    event: "checkpoint_restored",
-    source: "gstack_context_restore",
-    actor: { cli: "gstack context-restore" },
-    ownerSurface: "gstack context-restore -> tfx cto event context-restore",
-  },
-  "checkpoint-restored": {
-    event: "checkpoint_restored",
-    ownerSurface: "checkpoint wrapper -> tfx cto event checkpoint-restored",
-  },
-  "pr-created": {
-    event: "pr_created",
-    source: "tfx_pr_lifecycle",
-    actor: { cli: "gh pr create" },
-    ownerSurface: "gh pr create/merge/close -> tfx cto event pr-created",
-  },
-  "pr-merged": {
-    event: "pr_merged_or_closed",
-    source: "tfx_pr_lifecycle",
-    status: "completed",
-    actor: { cli: "gh pr merge" },
-    ownerSurface:
-      "gh pr create/merge/close -> tfx cto event pr-merged-or-closed",
-  },
-  "pr-closed": {
-    event: "pr_merged_or_closed",
-    source: "tfx_pr_lifecycle",
-    status: "completed",
-    actor: { cli: "gh pr close" },
-    ownerSurface:
-      "gh pr create/merge/close -> tfx cto event pr-merged-or-closed",
-  },
-  "pr-merged-or-closed": {
-    event: "pr_merged_or_closed",
-    source: "tfx_pr_lifecycle",
-    actor: { cli: "gh pr merge/close" },
-    ownerSurface:
-      "gh pr create/merge/close -> tfx cto event pr-merged-or-closed",
-  },
-});
-
-const OPTION_KEYS = Object.freeze({
-  event: "event",
-  "event-type": "event",
-  source: "source",
-  summary: "summary",
-  now: "now",
-  ts: "ts",
-  status: "status",
-  "session-id": "session_id",
-  "parent-session-id": "parent_session_id",
-  "restored-from-session-id": "restored_from_session_id",
-  "checkpoint-id": "checkpoint_id",
-  "artifact-path": "artifact_path",
-  artifact: "artifact_path",
-  "task-id": "task_id",
-  branch: "branch",
-  "last-seen-at": "last_seen_at",
-  "stale-reason": "stale_reason",
-  "hygiene-key": "hygiene_key",
-  "hygiene-kind": "hygiene_kind",
-  "hygiene-id": "hygiene_id",
-  "hygiene-action": "hygiene_action",
-  "project-root": "project_root",
-  "worktree-path": "worktree_path",
-  worktree: "worktree_path",
-  issue: "issue_refs",
-  "issue-ref": "issue_refs",
-  "issue-refs": "issue_refs",
-  pr: "pr_refs",
-  "pr-ref": "pr_refs",
-  "pr-refs": "pr_refs",
-  "actor-cli": "actor.cli",
-  "actor-session-id": "actor.session_id",
-  "actor-agent-id": "actor.agent_id",
-  "actor-host": "actor.host",
-  "owner-surface": "owner_surface",
-});
-
-const COLLECTION_KEYS = new Set(["issue_refs", "pr_refs"]);
-
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -144,31 +53,6 @@ function maybeString(value) {
   return trimmed || null;
 }
 
-function toIsoTime(value) {
-  if (typeof value === "string" && value.trim()) return value;
-  if (value instanceof Date) return value.toISOString();
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return new Date(value).toISOString();
-  }
-  return new Date().toISOString();
-}
-
-function shortHash(value) {
-  const str = String(value ?? "");
-  let h = 5381;
-  for (let i = 0; i < str.length; i += 1) {
-    h = (h * 33) ^ str.charCodeAt(i);
-  }
-  return (h >>> 0).toString(36);
-}
-
-function pathLabel(value) {
-  const str = String(value ?? "").replace(/[/\\]+$/u, "");
-  if (!str) return null;
-  const segments = str.split(/[/\\]+/u);
-  return segments[segments.length - 1] || null;
-}
-
 function normalizeNumericRefs(values) {
   const rawValues = Array.isArray(values)
     ? values
@@ -200,124 +84,6 @@ function normalizeActor(actor) {
   return Object.keys(normalized).length > 0 ? normalized : null;
 }
 
-function optionName(raw) {
-  return String(raw || "")
-    .replace(/^--?/u, "")
-    .trim();
-}
-
-function appendCollection(target, key, value) {
-  const values = String(value ?? "")
-    .split(",")
-    .map((item) => item.trim())
-    .filter(Boolean);
-  if (values.length === 0) return;
-  if (!Array.isArray(target[key])) target[key] = [];
-  target[key].push(...values);
-}
-
-function putPathValue(target, keyPath, value) {
-  if (keyPath.startsWith("actor.")) {
-    const key = keyPath.slice("actor.".length);
-    target.actor ||= {};
-    target.actor[key] = value;
-    return;
-  }
-  if (COLLECTION_KEYS.has(keyPath)) {
-    appendCollection(target, keyPath, value);
-    return;
-  }
-  target[keyPath] = value;
-}
-
-function parseEventArgs(args = []) {
-  const fields = {};
-  const positional = [];
-  let json = false;
-
-  for (let i = 0; i < args.length; i += 1) {
-    const arg = args[i];
-    if (arg === "--json") {
-      json = true;
-      continue;
-    }
-    if (!arg?.startsWith?.("--")) {
-      positional.push(arg);
-      continue;
-    }
-
-    const eqIndex = arg.indexOf("=");
-    const rawName = eqIndex >= 0 ? arg.slice(0, eqIndex) : arg;
-    const name = optionName(rawName);
-    const mapped = OPTION_KEYS[name];
-    if (!mapped) {
-      throw new Error(`unknown tfx cto event option: --${name}`);
-    }
-
-    let value = eqIndex >= 0 ? arg.slice(eqIndex + 1) : null;
-    if (value === null) {
-      const next = args[i + 1];
-      if (typeof next === "string" && !next.startsWith("--")) {
-        value = next;
-        i += 1;
-      } else {
-        value = "true";
-      }
-    }
-    putPathValue(fields, mapped, value);
-  }
-
-  return {
-    presetName: positional[0] || null,
-    extraPositionals: positional.slice(1),
-    fields,
-    json,
-  };
-}
-
-function mergeActor(defaultActor, overrideActor) {
-  const actor = { ...(defaultActor || {}), ...(overrideActor || {}) };
-  return Object.keys(actor).length > 0 ? actor : undefined;
-}
-
-function defaultEventSummary(input) {
-  if (input.event === "checkpoint_saved") {
-    return `context-save checkpoint ${input.checkpoint_id}`;
-  }
-  if (input.event === "checkpoint_restored") {
-    return `context-restore checkpoint ${input.checkpoint_id}`;
-  }
-  if (input.event === "pr_created") {
-    const [pr] = normalizeNumericRefs(input.pr_refs);
-    return pr ? `PR #${pr} created` : "PR created";
-  }
-  if (input.event === "pr_merged_or_closed") {
-    const [pr] = normalizeNumericRefs(input.pr_refs);
-    return pr ? `PR #${pr} merged or closed` : "PR merged or closed";
-  }
-  return undefined;
-}
-
-function validateRunEventInput(input) {
-  if (!input.event) {
-    throw new Error("tfx cto event requires a preset or --event <event_type>");
-  }
-
-  if (
-    ["checkpoint_saved", "checkpoint_restored"].includes(input.event) &&
-    !maybeString(input.checkpoint_id)
-  ) {
-    throw new Error(`tfx cto event ${input.event} requires --checkpoint-id`);
-  }
-
-  if (
-    ["pr_created", "pr_merged_or_closed"].includes(input.event) &&
-    normalizeNumericRefs(input.pr_refs).length === 0
-  ) {
-    throw new Error(`tfx cto event ${input.event} requires --pr`);
-  }
-}
-
 function putString(target, key, value) {
   const normalized = maybeString(value);
   if (normalized) target[key] = normalized;
@@ -341,7 +107,16 @@ export function normalizeCtoEvent(input = {}) {
     throw new Error(`invalid CTO status: ${status}`);
   }
 
-  const ts = toIsoTime(input.now ?? input.ts);
+  const ts = toIsoTime(input.now ?? input.ts) || new Date().toISOString();
+  if (eventType === "collect") {
+    return {
+      ts,
+      event: eventType,
+      source: maybeString(input.source) || "tfx_cto_collect",
+      summary: maybeString(input.summary) || eventType,
+      ref: input.ref ?? null,
+    };
+  }
   const ref = {
     schema_version: CTO_EVENT_SCHEMA_VERSION,
     event_type: eventType,
@@ -416,7 +191,7 @@ export async function appendCtoEvent(lakeRoot, input, opts = {}) {
 
   if (fd === null) {
     stderr.write(
-      "[tfx cto event] warning: ledger lock timeout; skipped ledger append\n",
+      "[tfx cto] warning: ledger lock timeout; skipped ledger append\n",
     );
     return { appended: false, event };
   }
@@ -431,59 +206,3 @@ export async function appendCtoEvent(lakeRoot, input, opts = {}) {
     } catch {}
   }
 }
-
-export async function runEvent(args = [], opts = {}) {
-  const parsed = parseEventArgs(args);
-  if (parsed.extraPositionals.length > 0) {
-    throw new Error(
-      `unexpected tfx cto event argument: ${parsed.extraPositionals[0]}`,
-    );
-  }
-  const preset = parsed.presetName ? EVENT_PRESETS[parsed.presetName] : null;
-  if (parsed.presetName && !preset && !parsed.fields.event) {
-    throw new Error(`unknown tfx cto event preset: ${parsed.presetName}`);
-  }
-
-  const rootDir = opts.rootDir || resolveLakeRootDir(process.cwd());
-  const lakeRoot = opts.lakeRoot || join(rootDir, ".triflux", "lake");
-  const stdout = opts.stdout || process.stdout;
-  const jsonOut = opts.json === true || parsed.json;
-  const ownerSurface =
-    parsed.fields.owner_surface ||
-    preset?.ownerSurface ||
-    "external wrapper -> tfx cto event --event";
-
-  const input = {
-    ...(preset || {}),
-    ...parsed.fields,
-    actor: mergeActor(preset?.actor, parsed.fields.actor),
-  };
-  delete input.ownerSurface;
-  delete input.owner_surface;
-  if (!input.project_root) input.project_root = rootDir;
-  if (!input.summary) input.summary = defaultEventSummary(input);
-
-  validateRunEventInput(input);
-
-  const result = await appendCtoEvent(lakeRoot, input, {
-    stderr: opts.stderr,
-    lockRetries: opts.ledgerLockRetries,
-    lockRetryDelayMs: opts.ledgerLockRetryDelayMs,
-  });
-  const payload = {
-    appended: result.appended,
-    owner_surface: ownerSurface,
-    event: result.event,
-  };
-
-  if (jsonOut) {
-    stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
-  } else {
-    const status = result.appended ? "appended" : "skipped";
-    stdout.write(
-      `[tfx cto event] ${status} ${result.event.event} via ${ownerSurface}\n`,
-    );
-  }
-
-  return payload;
-}