@inerrata-corporation/errata 2.0.0-dev.36 → 2.0.0-dev.38

package/errata.mjs

@@ -20608,6 +20608,24 @@ var init_oauth = __esm({
 
 // ../../packages/cloud-client/src/client.ts
 import { randomUUID } from "node:crypto";
+function wirePerContext(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const out2 = {};
+  for (const [bucket, entry] of Object.entries(value)) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+    const e = entry;
+    const confirmed = asWireCount(e["confirmed"]);
+    if (confirmed === null) continue;
+    const independent = asWireCount(e["independent"]);
+    const inferredIndependent = asWireCount(e["inferredIndependent"]);
+    out2[bucket] = {
+      confirmed,
+      ...independent !== null ? { independent } : {},
+      ...inferredIndependent !== null ? { inferredIndependent } : {}
+    };
+  }
+  return Object.keys(out2).length > 0 ? out2 : null;
+}
 function sidecarForNodes(sidecar, nodes) {
   if (!sidecar) return void 0;
   const present = /* @__PURE__ */ new Set();
@@ -20632,32 +20650,152 @@ function toWirePayload(batch, runId) {
     attrs: n.attrs ?? {},
     extractionSource: n.extractionSource
   }));
-  const edges = batch.edges.map((e) => ({
-    fromCanonicalId: e.from,
-    toCanonicalId: e.to,
-    type: e.type,
-    attrs: {
-      ...typeof e.confidence === "number" ? { confidence: clamp012(e.confidence) } : {}
-    }
-  }));
+  const edges = batch.edges.map((e) => {
+    const perContext = wirePerContext(e.attrs?.["perContext"]);
+    return {
+      fromCanonicalId: e.from,
+      toCanonicalId: e.to,
+      type: e.type,
+      attrs: {
+        ...typeof e.confidence === "number" ? { confidence: clamp012(e.confidence) } : {},
+        ...perContext ? { perContext } : {}
+      }
+    };
+  });
   const symbolSummaries = sidecarForNodes(batch.symbolSummaries, nodes);
   return { runId, source: "daemon", nodes, edges, ...symbolSummaries ? { symbolSummaries } : {} };
 }
 function clamp012(x) {
   return Math.max(0, Math.min(1, x));
 }
+function compactAttrs(input) {
+  const out2 = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (value !== void 0) out2[key] = value;
+  }
+  return out2;
+}
+function textOrThrow(value, field) {
+  const text = value.trim();
+  if (!text) throw new TypeError(`${field} must be a non-empty string`);
+  return text;
+}
+function optionalEdgeAttrs(confidence) {
+  return typeof confidence === "number" ? { confidence: clamp012(confidence) } : void 0;
+}
+function makeEdge(fromCanonicalId, type, toCanonicalId, confidence) {
+  const attrs = optionalEdgeAttrs(confidence);
+  return {
+    fromCanonicalId,
+    toCanonicalId,
+    type,
+    ...attrs ? { attrs } : {}
+  };
+}
+function makeNode(args2) {
+  return {
+    canonicalId: args2.canonicalId,
+    label: args2.label,
+    description: args2.description,
+    attrs: compactAttrs(args2.attrs),
+    extractionSource: "agent-observed",
+    ...args2.validationSource ? { validationSource: args2.validationSource } : {}
+  };
+}
+function normalizeProblem(input, opts) {
+  if (typeof input === "string") {
+    return {
+      id: void 0,
+      description: textOrThrow(input, "problem"),
+      kind: opts.problemKind,
+      error: opts.errorMessage?.trim() || void 0,
+      attrs: opts.attrs,
+      confidence: void 0,
+      validationSource: opts.validationSource
+    };
+  }
+  return {
+    id: input.id,
+    description: textOrThrow(input.description, "problem.description"),
+    kind: input.kind,
+    error: input.error?.trim() || void 0,
+    attrs: input.attrs,
+    confidence: input.confidence,
+    validationSource: input.validationSource ?? opts.validationSource
+  };
+}
+function normalizeTriage(input) {
+  if (input === void 0) return null;
+  if (typeof input === "string") {
+    return {
+      id: void 0,
+      statement: textOrThrow(input, "triage"),
+      route: void 0,
+      attrs: void 0,
+      confidence: void 0,
+      validationSource: void 0
+    };
+  }
+  return {
+    id: input.id,
+    statement: textOrThrow(input.statement, "triage.statement"),
+    route: input.route,
+    attrs: input.attrs,
+    confidence: input.confidence,
+    validationSource: input.validationSource
+  };
+}
+function normalizeRootCause(input) {
+  if (input === void 0) return null;
+  if (typeof input === "string") {
+    return {
+      id: void 0,
+      description: textOrThrow(input, "rootCause"),
+      attrs: void 0,
+      confidence: void 0,
+      validationSource: void 0
+    };
+  }
+  return {
+    id: input.id,
+    description: textOrThrow(input.description, "rootCause.description"),
+    attrs: input.attrs,
+    confidence: input.confidence,
+    validationSource: input.validationSource
+  };
+}
+function normalizeSolution(input) {
+  if (input === void 0) return null;
+  if (typeof input === "string") {
+    return {
+      id: void 0,
+      description: textOrThrow(input, "solution"),
+      attrs: void 0,
+      confidence: void 0,
+      validationSource: void 0
+    };
+  }
+  return {
+    id: input.id,
+    description: textOrThrow(input.description, "solution.description"),
+    attrs: input.attrs,
+    confidence: input.confidence,
+    validationSource: input.validationSource
+  };
+}
 function chunkArray(items, size) {
   if (items.length <= size) return items.length ? [[...items]] : [];
   const out2 = [];
   for (let i2 = 0; i2 < items.length; i2 += size) out2.push(items.slice(i2, i2 + size));
   return out2;
 }
-var INGEST_NODE_CHUNK, CloudClient, CloudError;
+var asWireCount, INGEST_NODE_CHUNK, CloudClient, CloudError;
 var init_client = __esm({
   "../../packages/cloud-client/src/client.ts"() {
     "use strict";
     init_oauth();
     init_src();
+    asWireCount = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0 ? Math.floor(n) : null;
     INGEST_NODE_CHUNK = 25;
     CloudClient = class {
       baseUrl;
@@ -20762,6 +20900,122 @@ var init_client = __esm({
       async ingestWire(payload) {
         return this.json("POST", "/v2/ingest", payload);
       }
+      /**
+       * SDK v2 graph-native write. It remembers a typed diagnostic spine through
+       * `/v2/ingest` instead of the legacy forum question/answer routes:
+       *
+       *   Problem --TRIAGED_BY--> Triage --INDICATES/CONFIRMS--> RootCause
+       *   RootCause --FIXED_BY--> Solution
+       *
+       * Shorthand inputs are accepted for low-friction use, but object inputs keep
+       * the graph labels explicit for adapters and agents that already know their
+       * node types.
+       */
+      async remember(problemInput, opts = {}) {
+        const runId = opts.runId ?? randomUUID();
+        const problem = normalizeProblem(problemInput, opts);
+        const triage = normalizeTriage(opts.triage);
+        const rootCause = normalizeRootCause(opts.rootCause);
+        const solution = normalizeSolution(opts.solution);
+        const languageInput = opts.language ?? opts.lang;
+        const language = languageInput ? textOrThrow(languageInput, "language") : void 0;
+        const hasLanguage = language !== void 0;
+        const commonAttrs = compactAttrs({
+          sdk: "cloud-client",
+          sdkVersion: "v2",
+          tags: opts.tags && opts.tags.length > 0 ? [...opts.tags] : void 0,
+          lang: language,
+          model: opts.model,
+          context: opts.context
+        });
+        const problemId = problem.id ?? (problem.kind === "runtime" || problem.error ? identityId({ kind: "RuntimeProblem", error: problem.error ?? problem.description }) : identityId({ kind: "DesignProblem", statement: problem.description }));
+        const nodes = [
+          makeNode({
+            canonicalId: problemId,
+            label: "Problem",
+            description: problem.description,
+            attrs: { ...problem.attrs ?? {}, ...commonAttrs },
+            validationSource: problem.validationSource
+          })
+        ];
+        const edges = [];
+        let triageId;
+        if (triage) {
+          triageId = triage.id ?? identityId({ kind: "Triage", statement: triage.statement });
+          nodes.push(
+            makeNode({
+              canonicalId: triageId,
+              label: "Triage",
+              description: triage.statement,
+              attrs: { ...triage.attrs ?? {}, ...commonAttrs },
+              validationSource: triage.validationSource ?? opts.validationSource
+            })
+          );
+          edges.push(makeEdge(problemId, "TRIAGED_BY", triageId, triage.confidence));
+        }
+        let rootCauseId;
+        if (rootCause) {
+          rootCauseId = rootCause.id ?? genericCanonicalId("dcause", { statement: rootCause.description });
+          nodes.push(
+            makeNode({
+              canonicalId: rootCauseId,
+              label: "RootCause",
+              description: rootCause.description,
+              attrs: { ...rootCause.attrs ?? {}, ...commonAttrs },
+              validationSource: rootCause.validationSource ?? opts.validationSource
+            })
+          );
+          if (triageId) {
+            const routeType = triage?.route === "confirms" ? "CONFIRMS" : "INDICATES";
+            edges.push(makeEdge(triageId, routeType, rootCauseId, rootCause.confidence));
+          } else {
+            edges.push(makeEdge(problemId, "CAUSED_BY", rootCauseId, rootCause.confidence));
+          }
+        }
+        let solutionId;
+        if (solution) {
+          solutionId = solution.id ?? genericCanonicalId("dfix", { problemId: rootCauseId ?? problemId, fix: solution.description });
+          nodes.push(
+            makeNode({
+              canonicalId: solutionId,
+              label: "Solution",
+              description: solution.description,
+              attrs: { ...solution.attrs ?? {}, ...commonAttrs },
+              validationSource: solution.validationSource ?? opts.validationSource
+            })
+          );
+          edges.push(
+            makeEdge(rootCauseId ?? problemId, rootCauseId ? "FIXED_BY" : "SOLVED_BY", solutionId, solution.confidence)
+          );
+        }
+        let languageId;
+        if (hasLanguage) {
+          languageId = languageCanonicalId(language);
+          nodes.push(
+            makeNode({
+              canonicalId: languageId,
+              label: "Language",
+              description: language,
+              attrs: { sdk: "cloud-client", sdkVersion: "v2" },
+              validationSource: opts.validationSource
+            })
+          );
+          edges.push(makeEdge(problemId, "OCCURS_IN", languageId));
+        }
+        const payload = { runId, source: "agent", nodes, edges };
+        const result = await this.ingestWire(payload);
+        return {
+          runId,
+          problemId,
+          ...triageId ? { triageId } : {},
+          ...rootCauseId ? { rootCauseId } : {},
+          ...solutionId ? { solutionId } : {},
+          ...languageId ? { languageId } : {},
+          nodes,
+          edges,
+          result
+        };
+      }
       // ─── reads ─────────────────────────────────────────────────────────
       /** Daemon pull/merge search (`?shape=castalia`): graph nodes reconstructed
        *  into local-mergeable CastaliaNodes, marked `attrs.source: 'cloud'` so the
@@ -41397,13 +41651,21 @@ function isSyncableRoute(edge2, shared, triage, ignorePatterns = []) {
 function generalizeRouteForSync(edge2, level) {
   const disc = edge2.attrs["discriminator"];
   const local = edge2.attrs["perContext"] ?? {};
-  const confirmed = {};
-  for (const [b, c] of Object.entries(local)) confirmed[b] = c.confirmed;
+  const perContext = {};
+  for (const [b, c] of Object.entries(local)) {
+    const independent = c.independent ?? c.contributors?.length;
+    const inferredIndependent = c.inferredIndependent ?? c.inferredContributors?.length;
+    perContext[b] = {
+      confirmed: c.confirmed,
+      ...typeof independent === "number" && independent > 0 ? { independent } : {},
+      ...typeof inferredIndependent === "number" && inferredIndependent > 0 ? { inferredIndependent } : {}
+    };
+  }
   return {
     ...edge2,
     attrs: {
       driftKind: edge2.attrs["driftKind"],
-      perContext: confirmed,
+      perContext,
       provisional: false,
       ...typeof disc === "string" && disc.trim() ? { discriminator: generalize(disc, { level }).text } : {}
     },
@@ -42216,7 +42478,7 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.0-dev.36" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.0-dev.38" : "2.0.0-alpha.0";
 var IGNORED_PATH = /[\\/](?:\.git|node_modules|\.errata|\.claude|\.codex|\.cursor|\.turbo|\.next|dist|coverage|test-results|playwright-report|__pycache__)(?:[\\/]|$)/;
 var IGNORED_NOISE = /castalia\.db|eventlog\.sqlite|turn-cursors/;
 var GIT_OP_MUTE_MS = 4e3;
@@ -45124,7 +45386,7 @@ function parseBurstArgs(args2) {
 // src/login-mode.ts
 var OAUTH_DEFAULT_ENV = "ERRATA_DAEMON_OAUTH_DEFAULT";
 function isDaemonOAuthDefaultEnabled(env2 = process.env) {
-  return env2[OAUTH_DEFAULT_ENV] === "1";
+  return env2[OAUTH_DEFAULT_ENV] !== "0";
 }
 function shouldUseOAuthLogin(flags2, env2 = process.env) {
   return Boolean(flags2.oauth || !flags2.device && isDaemonOAuthDefaultEnabled(env2));
@@ -45306,7 +45568,7 @@ Commands:
                       Flags: --port N (default 7891)
   mcp                 Run the MCP stdio server \u2014 the agent's full errata tool
                       surface (navigation, problems, claims, burst, health)
-  login               Sign in with the cloud (device-code by default; --oauth for OAuth)
+  login               Sign in with the cloud (OAuth by default; --device for legacy device-code)
   logout              Clear local cloud credentials
   sync now            Flush outbox to the cloud once
   privacy             Show what is collected/scrubbed + your consent state
@@ -45321,7 +45583,7 @@ Commands:
 Environment:
   ERRATA_CLOUD_URL                Cloud base URL (default ${DEFAULT_CLOUD_URL})
   ERRATA_ALLOW_DIRECT_V1_CLOUD=1  Allow non-local legacy v1 cloud testing
-  ${OAUTH_DEFAULT_ENV}=1       Internal dogfood: plain \`errata login\` uses OAuth
+  ${OAUTH_DEFAULT_ENV}=0       Test/dev escape hatch: plain \`errata login\` uses legacy device-code
 `);
 }
 function resolveHookPort(explicit) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inerrata-corporation/errata",
-  "version": "2.0.0-dev.36",
+  "version": "2.0.0-dev.38",
   "description": "errata - local-first observation engine for AI coding agents",
   "type": "module",
   "bin": {