signetai 0.195.4 → 0.196.0

package/dist/mcp-stdio.js

@@ -40736,6 +40736,62 @@ function up126(db) {
 			ON dreaming_attention (agent_id, resolved_at, priority DESC, created_at ASC);
 	`);
 }
+function up127(db) {
+  db.exec(`
+		CREATE TABLE IF NOT EXISTS ontology_contradictions (
+			id TEXT PRIMARY KEY,
+			agent_id TEXT NOT NULL DEFAULT 'default',
+			entity_id TEXT,
+			entity_name TEXT NOT NULL,
+			aspect_id TEXT,
+			aspect_name TEXT NOT NULL,
+			group_key TEXT NOT NULL DEFAULT 'general',
+			claim_key TEXT NOT NULL,
+			left_attribute_id TEXT,
+			right_attribute_id TEXT,
+			left_content TEXT NOT NULL,
+			right_content TEXT NOT NULL,
+			left_confidence REAL NOT NULL DEFAULT 0.0
+				CHECK (left_confidence >= 0.0 AND left_confidence <= 1.0),
+			right_confidence REAL NOT NULL DEFAULT 0.0
+				CHECK (right_confidence >= 0.0 AND right_confidence <= 1.0),
+			left_scope TEXT,
+			right_scope TEXT,
+			left_visibility TEXT,
+			right_visibility TEXT,
+			left_source_kind TEXT,
+			left_source_id TEXT,
+			left_source_path TEXT,
+			left_source_root TEXT,
+			right_source_kind TEXT,
+			right_source_id TEXT,
+			right_source_path TEXT,
+			right_source_root TEXT,
+			left_evidence TEXT NOT NULL DEFAULT '[]',
+			right_evidence TEXT NOT NULL DEFAULT '[]',
+			detector TEXT NOT NULL CHECK (detector IN ('lexical', 'semantic', 'manual')),
+			reason TEXT NOT NULL,
+			confidence REAL NOT NULL DEFAULT 0.0
+				CHECK (confidence >= 0.0 AND confidence <= 1.0),
+			status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'resolved')),
+			detected_at TEXT NOT NULL,
+			resolved_at TEXT,
+			resolution_reason TEXT,
+			created_at TEXT NOT NULL,
+			updated_at TEXT NOT NULL,
+			UNIQUE (agent_id, left_attribute_id, right_attribute_id)
+		);
+
+		CREATE INDEX IF NOT EXISTS idx_ontology_contradictions_agent_status
+			ON ontology_contradictions(agent_id, status, updated_at DESC);
+		CREATE INDEX IF NOT EXISTS idx_ontology_contradictions_agent_slot
+			ON ontology_contradictions(agent_id, entity_id, aspect_id, group_key, claim_key, status);
+		CREATE INDEX IF NOT EXISTS idx_ontology_contradictions_attributes
+			ON ontology_contradictions(agent_id, left_attribute_id, right_attribute_id);
+		CREATE INDEX IF NOT EXISTS idx_ontology_contradictions_sources
+			ON ontology_contradictions(agent_id, left_source_id, right_source_id);
+	`);
+}
 var MIGRATIONS = [
   {
     version: 1,
@@ -41756,6 +41812,12 @@ var MIGRATIONS = [
     name: "dreaming-surprisal-attention",
     up: up126,
     artifacts: { tables: ["dreaming_attention"] }
+  },
+  {
+    version: 127,
+    name: "ontology-contradictions",
+    up: up127,
+    artifacts: { tables: ["ontology_contradictions"] }
   }
 ];
 var LATEST_SCHEMA_VERSION = MIGRATIONS[MIGRATIONS.length - 1]?.version ?? 0;
@@ -44876,6 +44938,443 @@ function getOntologyClaimEvidence(accessor, params) {
   };
 }
 
+// ../../platform/daemon/src/pipeline/antonyms.ts
+var NEGATION_TOKENS = new Set([
+  "not",
+  "no",
+  "never",
+  "cannot",
+  "cant",
+  "doesnt",
+  "dont",
+  "isnt",
+  "wasnt",
+  "wont",
+  "without"
+]);
+var PROSPECTIVE_ANTONYM_PAIRS = [
+  ["enabled", "disabled"],
+  ["allow", "deny"],
+  ["accept", "reject"],
+  ["always", "never"],
+  ["on", "off"],
+  ["true", "false"]
+];
+var ANTONYM_PAIRS = [
+  ["enabled", "disabled"],
+  ["allow", "deny"],
+  ["accept", "reject"],
+  ["always", "never"],
+  ["on", "off"],
+  ["true", "false"],
+  ["yes", "no"],
+  ["together", "apart"],
+  ["dating", "single"],
+  ["married", "divorced"],
+  ["friends", "strangers"],
+  ["close", "distant"],
+  ["love", "hate"],
+  ["like", "dislike"],
+  ["prefer", "avoid"],
+  ["enjoy", "dread"],
+  ["want", "refuse"],
+  ["start", "stop"],
+  ["begin", "end"],
+  ["open", "close"],
+  ["join", "leave"],
+  ["arrive", "depart"],
+  ["buy", "sell"],
+  ["alive", "dead"],
+  ["active", "inactive"],
+  ["positive", "negative"],
+  ["increase", "decrease"],
+  ["before", "after"]
+];
+var ANTONYM_SET = new Set(ANTONYM_PAIRS.flatMap(([a, b]) => [`${a}:${b}`, `${b}:${a}`]));
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((token) => token.length >= 2);
+}
+function hasNegation(tokens) {
+  return tokens.some((token) => NEGATION_TOKENS.has(token));
+}
+function overlapCount(left, right) {
+  const rightSet = new Set(right);
+  let overlap = 0;
+  for (const token of left) {
+    if (rightSet.has(token))
+      overlap++;
+  }
+  return overlap;
+}
+function hasAntonymConflict(leftTokens, rightTokens, pairs = ANTONYM_PAIRS) {
+  for (const [a, b] of pairs) {
+    const leftHasA = leftTokens.has(a);
+    const leftHasB = leftTokens.has(b);
+    const rightHasA = rightTokens.has(a);
+    const rightHasB = rightTokens.has(b);
+    const leftExclusive = leftHasA !== leftHasB;
+    const rightExclusive = rightHasA !== rightHasB;
+    const opposite = leftHasA && rightHasB || leftHasB && rightHasA;
+    if (leftExclusive && rightExclusive && opposite) {
+      return true;
+    }
+  }
+  return false;
+}
+function detectProspectiveContradictionRisk(candidate, existing) {
+  const candidateTokens = tokenize(candidate);
+  const existingTokens = tokenize(existing);
+  const lexicalOverlap = overlapCount(candidateTokens, existingTokens);
+  if (candidateTokens.length === 0 || existingTokens.length === 0 || lexicalOverlap < 2) {
+    return { detected: false, lexicalOverlap, reason: null };
+  }
+  if (hasNegation(candidateTokens) !== hasNegation(existingTokens)) {
+    return { detected: true, lexicalOverlap, reason: "negation_mismatch" };
+  }
+  if (hasAntonymConflict(new Set(candidateTokens), new Set(existingTokens), PROSPECTIVE_ANTONYM_PAIRS)) {
+    return { detected: true, lexicalOverlap, reason: "antonym_conflict" };
+  }
+  return { detected: false, lexicalOverlap, reason: null };
+}
+
+// ../../platform/daemon/src/ontology-contradictions.ts
+var CONTRADICTION_SELECT = `
+	SELECT
+		c.*
+	FROM ontology_contradictions c`;
+function parseJsonArray2(value) {
+  if (typeof value !== "string")
+    return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [{ raw: value, parseError: "invalid_json_array" }];
+  }
+}
+function trim(value) {
+  if (typeof value !== "string")
+    return null;
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function clamp01(value) {
+  if (!Number.isFinite(value))
+    return 0;
+  return Math.min(Math.max(value, 0), 1);
+}
+function rowToContradiction(row) {
+  return {
+    id: row.id,
+    agentId: row.agent_id,
+    entityId: row.entity_id,
+    entityName: row.entity_name,
+    aspectId: row.aspect_id,
+    aspectName: row.aspect_name,
+    groupKey: row.group_key,
+    claimKey: row.claim_key,
+    leftAttributeId: row.left_attribute_id,
+    rightAttributeId: row.right_attribute_id,
+    leftContent: row.left_content,
+    rightContent: row.right_content,
+    leftConfidence: row.left_confidence,
+    rightConfidence: row.right_confidence,
+    leftScope: row.left_scope,
+    rightScope: row.right_scope,
+    leftVisibility: row.left_visibility,
+    rightVisibility: row.right_visibility,
+    leftSourceKind: row.left_source_kind,
+    leftSourceId: row.left_source_id,
+    leftSourcePath: row.left_source_path,
+    leftSourceRoot: row.left_source_root,
+    rightSourceKind: row.right_source_kind,
+    rightSourceId: row.right_source_id,
+    rightSourcePath: row.right_source_path,
+    rightSourceRoot: row.right_source_root,
+    leftEvidence: parseJsonArray2(row.left_evidence),
+    rightEvidence: parseJsonArray2(row.right_evidence),
+    detector: row.detector,
+    reason: row.reason,
+    confidence: row.confidence,
+    status: row.status,
+    detectedAt: row.detected_at,
+    resolvedAt: row.resolved_at,
+    resolutionReason: row.resolution_reason,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function claimSelect() {
+  return `
+		SELECT
+			attr.id,
+			asp.entity_id AS entity_id,
+			e.name AS entity_name,
+			asp.id AS aspect_id,
+			asp.name AS aspect_name,
+			COALESCE(attr.group_key, 'general') AS group_key,
+			attr.claim_key,
+			COALESCE(attr.kind, 'attribute') AS kind,
+			attr.content,
+			attr.confidence,
+			attr.memory_id,
+			mem.scope,
+			mem.visibility,
+			attr.source_kind,
+			attr.source_id,
+			attr.source_path,
+			attr.source_root,
+			attr.proposal_evidence
+		FROM entity_attributes attr
+		JOIN entity_aspects asp ON asp.id = attr.aspect_id AND asp.agent_id = attr.agent_id
+		JOIN entities e ON e.id = asp.entity_id AND e.agent_id = asp.agent_id
+		LEFT JOIN memories mem ON mem.id = attr.memory_id AND mem.agent_id = attr.agent_id`;
+}
+function claimFromRow(row) {
+  const id = trim(row.id);
+  const entityId = trim(row.entity_id);
+  const entityName = trim(row.entity_name);
+  const aspectId = trim(row.aspect_id);
+  const aspectName = trim(row.aspect_name);
+  const claimKey = trim(row.claim_key);
+  const content = trim(row.content);
+  if (id === null || entityId === null || entityName === null || aspectId === null || aspectName === null)
+    return null;
+  if (claimKey === null || content === null)
+    return null;
+  return {
+    id,
+    entityId,
+    entityName,
+    aspectId,
+    aspectName,
+    groupKey: trim(row.group_key) ?? "general",
+    claimKey,
+    kind: trim(row.kind) ?? "attribute",
+    content,
+    confidence: clamp01(typeof row.confidence === "number" ? row.confidence : 0),
+    memoryId: trim(row.memory_id),
+    scope: trim(row.scope),
+    visibility: trim(row.visibility),
+    sourceKind: trim(row.source_kind),
+    sourceId: trim(row.source_id),
+    sourcePath: trim(row.source_path),
+    sourceRoot: trim(row.source_root),
+    evidence: parseJsonArray2(row.proposal_evidence)
+  };
+}
+function claimSnapshot(claim) {
+  const evidence = [...claim.evidence];
+  if (claim.sourceKind !== null || claim.sourceId !== null || claim.sourcePath !== null || claim.sourceRoot !== null) {
+    evidence.push({
+      source_kind: claim.sourceKind,
+      source_id: claim.sourceId,
+      source_path: claim.sourcePath,
+      source_root: claim.sourceRoot
+    });
+  }
+  if (claim.memoryId !== null)
+    evidence.push({ memory_id: claim.memoryId });
+  return {
+    id: claim.id,
+    content: claim.content,
+    confidence: claim.confidence,
+    scope: claim.scope,
+    visibility: claim.visibility,
+    sourceKind: claim.sourceKind,
+    sourceId: claim.sourceId,
+    sourcePath: claim.sourcePath,
+    sourceRoot: claim.sourceRoot,
+    evidence
+  };
+}
+function canonicalPair(first, second) {
+  const firstSnapshot = claimSnapshot(first);
+  const secondSnapshot = claimSnapshot(second);
+  if (first.id < second.id)
+    return { left: firstSnapshot, right: secondSnapshot };
+  return { left: secondSnapshot, right: firstSnapshot };
+}
+function readActiveClaim(db, agentId, attributeId) {
+  if (attributeId === null)
+    return null;
+  const row = db.prepare(`${claimSelect()}
+			WHERE attr.id = ? AND attr.agent_id = ? AND attr.status = 'active'
+			  AND COALESCE(asp.status, 'active') = 'active'
+			  AND COALESCE(e.status, 'active') = 'active'`).get(attributeId, agentId);
+  return row == null ? null : claimFromRow(row);
+}
+function readClaim(db, agentId, attributeId) {
+  const row = db.prepare(`${claimSelect()}
+			WHERE attr.id = ? AND attr.agent_id = ?`).get(attributeId, agentId);
+  return row == null ? null : claimFromRow(row);
+}
+function insertOrReactivateContradiction(db, input) {
+  const existing = db.prepare(`SELECT id, status FROM ontology_contradictions
+			 WHERE agent_id = ? AND left_attribute_id = ? AND right_attribute_id = ?`).get(input.agentId, input.left.id, input.right.id);
+  const timestamp = new Date().toISOString();
+  if (existing != null) {
+    db.prepare(`UPDATE ontology_contradictions
+			 SET entity_id = ?, entity_name = ?, aspect_id = ?, aspect_name = ?,
+			     group_key = ?, claim_key = ?, left_content = ?, right_content = ?,
+			     left_confidence = ?, right_confidence = ?, left_scope = ?, right_scope = ?,
+			     left_visibility = ?, right_visibility = ?, left_source_kind = ?, left_source_id = ?,
+			     left_source_path = ?, left_source_root = ?, right_source_kind = ?, right_source_id = ?,
+			     right_source_path = ?, right_source_root = ?, left_evidence = ?, right_evidence = ?,
+			     detector = 'lexical', reason = ?, confidence = 1.0, status = 'active',
+			     detected_at = ?, resolved_at = NULL, resolution_reason = NULL, updated_at = ?
+			 WHERE id = ? AND agent_id = ?`).run(input.entityId, input.entityName, input.aspectId, input.aspectName, input.groupKey, input.claimKey, input.left.content, input.right.content, input.left.confidence, input.right.confidence, input.left.scope, input.right.scope, input.left.visibility, input.right.visibility, input.left.sourceKind, input.left.sourceId, input.left.sourcePath, input.left.sourceRoot, input.right.sourceKind, input.right.sourceId, input.right.sourcePath, input.right.sourceRoot, JSON.stringify(input.left.evidence), JSON.stringify(input.right.evidence), input.reason, timestamp, timestamp, existing.id, input.agentId);
+    return existing.id;
+  }
+  const id = crypto.randomUUID();
+  db.prepare(`INSERT INTO ontology_contradictions
+		 (id, agent_id, entity_id, entity_name, aspect_id, aspect_name, group_key, claim_key,
+		  left_attribute_id, right_attribute_id, left_content, right_content,
+		  left_confidence, right_confidence, left_scope, right_scope, left_visibility, right_visibility,
+		  left_source_kind, left_source_id, left_source_path, left_source_root,
+		  right_source_kind, right_source_id, right_source_path, right_source_root,
+		  left_evidence, right_evidence, detector, reason, confidence, status,
+		  detected_at, created_at, updated_at)
+		 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,
+		         'lexical', ?, 1.0, 'active', ?, ?, ?)`).run(id, input.agentId, input.entityId, input.entityName, input.aspectId, input.aspectName, input.groupKey, input.claimKey, input.left.id, input.right.id, input.left.content, input.right.content, input.left.confidence, input.right.confidence, input.left.scope, input.right.scope, input.left.visibility, input.right.visibility, input.left.sourceKind, input.left.sourceId, input.left.sourcePath, input.left.sourceRoot, input.right.sourceKind, input.right.sourceId, input.right.sourcePath, input.right.sourceRoot, JSON.stringify(input.left.evidence), JSON.stringify(input.right.evidence), input.reason, timestamp, timestamp, timestamp);
+  return id;
+}
+function recordOntologyContradictionsForAttributeInTx(db, input) {
+  if (!tableExists3(db, "ontology_contradictions"))
+    return [];
+  const candidate = readClaim(db, input.agentId, input.attributeId);
+  if (candidate === null || candidate.kind === "constraint")
+    return [];
+  const rows = db.prepare(`${claimSelect()}
+			WHERE attr.agent_id = ? AND attr.aspect_id = ? AND attr.id != ?
+			  AND attr.status = 'active'
+			  AND COALESCE(asp.status, 'active') = 'active'
+			  AND COALESCE(e.status, 'active') = 'active'
+			  AND COALESCE(attr.group_key, 'general') = ?
+			  AND attr.claim_key = ?
+			  AND COALESCE(attr.kind, 'attribute') != 'constraint'`).all(input.agentId, candidate.aspectId, candidate.id, candidate.groupKey, candidate.claimKey);
+  const contradictionIds = [];
+  for (const row of rows) {
+    const other = claimFromRow(row);
+    if (other === null)
+      continue;
+    const detection = detectProspectiveContradictionRisk(candidate.content, other.content);
+    if (!detection.detected || detection.reason === null)
+      continue;
+    contradictionIds.push(insertOrReactivateContradiction(db, {
+      agentId: input.agentId,
+      entityId: candidate.entityId,
+      entityName: candidate.entityName,
+      aspectId: candidate.aspectId,
+      aspectName: candidate.aspectName,
+      groupKey: candidate.groupKey,
+      claimKey: candidate.claimKey,
+      ...canonicalPair(candidate, other),
+      reason: detection.reason
+    }));
+  }
+  return contradictionIds;
+}
+function contradictionScopeWhere(params) {
+  const where = ["c.agent_id = ?", "c.status = 'active'"];
+  const args = [params.agentId];
+  if (params.entityId !== undefined) {
+    where.push("c.entity_id = ?");
+    args.push(params.entityId);
+  }
+  if (params.aspectId !== undefined) {
+    where.push("c.aspect_id = ?");
+    args.push(params.aspectId);
+  }
+  if (params.groupKey !== undefined) {
+    where.push("c.group_key = ?");
+    args.push(params.groupKey);
+  }
+  if (params.claimKey !== undefined) {
+    where.push("c.claim_key = ?");
+    args.push(params.claimKey);
+  }
+  if (params.sourceId !== undefined) {
+    where.push("(c.left_source_id = ? OR c.right_source_id = ?)");
+    args.push(params.sourceId, params.sourceId);
+  }
+  return { where, args };
+}
+function reconcileOntologyContradictionsInTx(db, params) {
+  if (!tableExists3(db, "ontology_contradictions"))
+    return 0;
+  const scope = contradictionScopeWhere(params);
+  const rows = db.prepare(`${CONTRADICTION_SELECT}
+			WHERE ${scope.where.join(" AND ")}`).all(...scope.args);
+  let resolved = 0;
+  for (const row of rows) {
+    const left = readActiveClaim(db, params.agentId, row.left_attribute_id);
+    const right = readActiveClaim(db, params.agentId, row.right_attribute_id);
+    const stillContradictory = left !== null && right !== null && left.entityId === right.entityId && left.aspectId === right.aspectId && left.groupKey === right.groupKey && left.claimKey === right.claimKey && left.kind !== "constraint" && right.kind !== "constraint" && detectProspectiveContradictionRisk(left.content, right.content).detected;
+    if (stillContradictory)
+      continue;
+    const reason = left === null || right === null ? "one competing claim is no longer active" : "claims no longer conflict";
+    const timestamp = new Date().toISOString();
+    db.prepare(`UPDATE ontology_contradictions
+			 SET status = 'resolved', resolved_at = ?, resolution_reason = ?, updated_at = ?
+			 WHERE id = ? AND agent_id = ? AND status = 'active'`).run(timestamp, reason, timestamp, row.id, params.agentId);
+    resolved++;
+  }
+  return resolved;
+}
+function reconcileOntologyContradictions(accessor, params) {
+  return accessor.withWriteTx((db) => reconcileOntologyContradictionsInTx(db, params));
+}
+function listOntologyContradictions(accessor, params) {
+  const limit = Math.min(Math.max(params.limit ?? 50, 1), 200);
+  const offset = Math.max(params.offset ?? 0, 0);
+  reconcileOntologyContradictions(accessor, { agentId: params.agentId, sourceId: params.sourceId });
+  return accessor.withReadDb((db) => {
+    const where = ["c.agent_id = ?"];
+    const args = [params.agentId];
+    if (params.status !== "all") {
+      where.push("c.status = ?");
+      args.push(params.status ?? "active");
+    }
+    if (params.entityId !== undefined) {
+      where.push("c.entity_id = ?");
+      args.push(params.entityId);
+    }
+    if (params.entity !== undefined) {
+      where.push("LOWER(c.entity_name) = LOWER(?)");
+      args.push(params.entity);
+    }
+    if (params.aspectId !== undefined) {
+      where.push("c.aspect_id = ?");
+      args.push(params.aspectId);
+    }
+    if (params.groupKey !== undefined) {
+      where.push("c.group_key = ?");
+      args.push(params.groupKey);
+    }
+    if (params.claimKey !== undefined) {
+      where.push("c.claim_key = ?");
+      args.push(params.claimKey);
+    }
+    if (params.sourceId !== undefined) {
+      where.push("(c.left_source_id = ? OR c.right_source_id = ?)");
+      args.push(params.sourceId, params.sourceId);
+    }
+    const clause = where.join(" AND ");
+    const rows = db.prepare(`${CONTRADICTION_SELECT}
+				WHERE ${clause}
+				ORDER BY CASE WHEN c.status = 'active' THEN 0 ELSE 1 END, c.updated_at DESC
+				LIMIT ? OFFSET ?`).all(...args, limit, offset);
+    const count = db.prepare(`SELECT COUNT(*) AS count FROM ontology_contradictions c WHERE ${clause}`).get(...args);
+    return {
+      items: rows.map(rowToContradiction),
+      count: count?.count ?? rows.length,
+      limit,
+      offset
+    };
+  });
+}
+
 // ../../platform/daemon/src/ontology-link-evidence.ts
 class OntologyLinkEvidenceError extends Error {
   status;
@@ -45267,7 +45766,7 @@ function parseJsonRecord(value) {
   const parsed = JSON.parse(value);
   return isRecord3(parsed) ? parsed : {};
 }
-function parseJsonArray2(value) {
+function parseJsonArray3(value) {
   const parsed = JSON.parse(value);
   return Array.isArray(parsed) ? parsed : [];
 }
@@ -45286,7 +45785,7 @@ function toProposal(row) {
     payload: parseJsonRecord(row.payload),
     confidence: row.confidence,
     rationale: row.rationale,
-    evidence: parseJsonArray2(row.evidence),
+    evidence: parseJsonArray3(row.evidence),
     risk: row.risk,
     sourceKind: row.source_kind,
     sourceId: row.source_id,
@@ -45332,7 +45831,7 @@ function readStringArray(record5, key) {
 function unique2(values) {
   return [...new Set(values)];
 }
-function clamp01(value) {
+function clamp012(value) {
   if (typeof value !== "number" || !Number.isFinite(value))
     return 0;
   return Math.max(0, Math.min(1, value));
@@ -45379,7 +45878,7 @@ function insertProposalInTx(db, input, ts) {
 		 (id, agent_id, operation, status, payload, confidence, rationale,
 		  evidence, risk, source_kind, source_id, source_path, source_root,
 		  created_by, created_at, updated_at)
-		 VALUES (?, ?, ?, 'pending', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, agentId, operation, JSON.stringify(input.payload), clamp01(input.confidence), input.rationale?.trim() ?? "", JSON.stringify(evidence), input.risk ?? null, input.sourceKind ?? null, input.sourceId ?? null, input.sourcePath ?? null, input.sourceRoot ?? null, input.createdBy?.trim() || "operator", ts, ts);
+		 VALUES (?, ?, ?, 'pending', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, agentId, operation, JSON.stringify(input.payload), clamp012(input.confidence), input.rationale?.trim() ?? "", JSON.stringify(evidence), input.risk ?? null, input.sourceKind ?? null, input.sourceId ?? null, input.sourcePath ?? null, input.sourceRoot ?? null, input.createdBy?.trim() || "operator", ts, ts);
   return readBackInTx(db, id, agentId);
 }
 function proposalEvidenceRefs(proposal) {
@@ -45402,7 +45901,7 @@ function proposalEvidenceRefs(proposal) {
   return uniqueOntologyEvidenceRefs(refs);
 }
 function proposalAuditEvidence(proposal) {
-  return parseJsonArray2(proposal.evidence);
+  return parseJsonArray3(proposal.evidence);
 }
 function derivedMemorySourcesForProposal(proposal) {
   const sources = [];
@@ -45728,7 +46227,13 @@ function applyAddClaimValue(db, agentId, proposal, payload, writeCaps) {
 			   AND status = 'active'
 			 LIMIT 1`).get(aspectId, agentId, kind, normalized, groupKey, claimKey);
   if (existing) {
-    return { entityId, aspectId, attributeId: existing.id, deduped: true };
+    return {
+      entityId,
+      aspectId,
+      attributeId: existing.id,
+      deduped: true,
+      contradictionIds: recordOntologyContradictionsForAttributeInTx(db, { agentId, attributeId: existing.id })
+    };
   }
   if (writeCaps !== undefined) {
     const attrCount = db.prepare(`SELECT COUNT(*) AS c FROM entity_attributes
@@ -45739,8 +46244,8 @@ function applyAddClaimValue(db, agentId, proposal, payload, writeCaps) {
     }
   }
   const id = crypto.randomUUID();
-  const confidence = clamp01(readNumber(payload, "confidence") ?? proposal.confidence);
-  const importance = clamp01(readNumber(payload, "importance") ?? confidence);
+  const confidence = clamp012(readNumber(payload, "confidence") ?? proposal.confidence);
+  const importance = clamp012(readNumber(payload, "importance") ?? confidence);
   const reviewAfter = readReviewAfter(payload);
   const proposalEvidence = proposalAuditEvidence(proposal);
   db.prepare(`INSERT INTO entity_attributes
@@ -45762,7 +46267,14 @@ function applyAddClaimValue(db, agentId, proposal, payload, writeCaps) {
     reviewAfter,
     proposal
   });
-  return { entityId, aspectId, attributeId: id, memoryId, deduped: false };
+  return {
+    entityId,
+    aspectId,
+    attributeId: id,
+    memoryId,
+    deduped: false,
+    contradictionIds: recordOntologyContradictionsForAttributeInTx(db, { agentId, attributeId: id })
+  };
 }
 function applySetClaimValue(db, agentId, proposal, payload, writeCaps) {
   const entity = readString2(payload, "entity");
@@ -45799,7 +46311,8 @@ function applySetClaimValue(db, agentId, proposal, payload, writeCaps) {
       attributeId: existing.id,
       version: existing.version ?? 1,
       versionRootId: existing.version_root_id ?? existing.id,
-      deduped: true
+      deduped: true,
+      contradictionIds: []
     };
   }
   if (kind === "constraint" && active.length > 0 && !truthy(payload.force)) {
@@ -45817,8 +46330,8 @@ function applySetClaimValue(db, agentId, proposal, payload, writeCaps) {
   const version2 = previous === null ? 1 : Math.max(...slot.map((row) => row.version ?? 1)) + 1;
   const rootId = previous?.version_root_id ?? previous?.id ?? crypto.randomUUID();
   const id = version2 === 1 ? rootId : crypto.randomUUID();
-  const confidence = clamp01(readNumber(payload, "confidence") ?? proposal.confidence);
-  const importance = clamp01(readNumber(payload, "importance") ?? confidence);
+  const confidence = clamp012(readNumber(payload, "confidence") ?? proposal.confidence);
+  const importance = clamp012(readNumber(payload, "importance") ?? confidence);
   const reviewAfter = readReviewAfter(payload);
   db.prepare(`INSERT INTO entity_attributes
 		 (id, aspect_id, agent_id, kind, content, normalized_content,
@@ -45838,6 +46351,7 @@ function applySetClaimValue(db, agentId, proposal, payload, writeCaps) {
     reviewAfter,
     proposal
   });
+  const contradictionIds = recordOntologyContradictionsForAttributeInTx(db, { agentId, attributeId: id });
   if (active.length > 0) {
     db.prepare(`UPDATE entity_attributes
 			 SET status = 'superseded', superseded_by = ?, updated_at = datetime('now')
@@ -45861,7 +46375,8 @@ function applySetClaimValue(db, agentId, proposal, payload, writeCaps) {
     versionRootId: rootId,
     previousAttributeId: previous?.id ?? null,
     previousWasActive: previous?.status === "active",
-    supersededAttributeIds: active.map((row) => row.id)
+    supersededAttributeIds: active.map((row) => row.id),
+    contradictionIds
   };
 }
 function applySupersedeClaimValue(db, agentId, proposal, payload) {
@@ -46114,6 +46629,7 @@ function applyRestoreClaimVersion(db, agentId, proposal, payload) {
 		 SET status = 'active', superseded_by = NULL, archived_at = NULL, archived_by = NULL,
 		     archive_reason = NULL, proposal_id = ?, proposal_evidence = ?, updated_at = datetime('now')
 		 WHERE id = ? AND agent_id = ?`).run(proposal.id, JSON.stringify(proposalAuditEvidence(proposal)), attributeId, agentId);
+  recordOntologyContradictionsForAttributeInTx(db, { agentId, attributeId });
   return { attributeId, versionRootId: row.version_root_id ?? attributeId, restored: true };
 }
 function mergeEntityAspects(db, agentId, sourceId, targetId) {
@@ -46304,8 +46820,8 @@ function applyCreateLink(db, agentId, proposal, payload) {
   const sourceId = sourceIdSelector ? resolveEntityStrict(db, agentId, source).id : resolveOrCreateEntity(db, agentId, source, normalizeEntityType2(readString2(payload, "source_type")));
   const targetId = targetIdSelector ? resolveEntityStrict(db, agentId, target2).id : resolveOrCreateEntity(db, agentId, target2, normalizeEntityType2(readString2(payload, "target_type")));
   const reason = requireDependencyReason(dependencyType, readString2(payload, "reason") ?? proposal.rationale);
-  const strength = clamp01(readNumber(payload, "strength") ?? 0.5);
-  const confidence = clamp01(readNumber(payload, "confidence") ?? proposal.confidence);
+  const strength = clamp012(readNumber(payload, "strength") ?? 0.5);
+  const confidence = clamp012(readNumber(payload, "confidence") ?? proposal.confidence);
   const existing = db.prepare(`SELECT id, status FROM entity_dependencies
 			 WHERE source_entity_id = ? AND target_entity_id = ?
 			   AND dependency_type = ? AND agent_id = ?
@@ -46343,8 +46859,8 @@ function applyUpdateLink(db, agentId, proposal, payload) {
     throw new OntologyProposalError("Link not found", 404);
   const dependencyType = readString2(payload, "link_type") ? normalizeDependencyType(readString2(payload, "link_type")) : existing.dependency_type;
   const reason = requireDependencyReason(dependencyType, readString2(payload, "reason") ?? existing.reason ?? proposal.rationale);
-  const strength = clamp01(readNumber(payload, "strength") ?? existing.strength ?? 0.5);
-  const confidence = clamp01(readNumber(payload, "confidence") ?? existing.confidence ?? proposal.confidence);
+  const strength = clamp012(readNumber(payload, "strength") ?? existing.strength ?? 0.5);
+  const confidence = clamp012(readNumber(payload, "confidence") ?? existing.confidence ?? proposal.confidence);
   db.prepare(`UPDATE entity_dependencies
 		 SET dependency_type = ?, reason = ?, strength = ?, confidence = ?,
 		     source_id = COALESCE(?, source_id),
@@ -46400,7 +46916,7 @@ function applyCreateEntityAlias(db, agentId, proposal, payload) {
   if (canonicalAlias.length === 0)
     throw new OntologyProposalError("payload.alias is required", 400);
   const entity = resolveEntityStrict(db, agentId, entitySelector);
-  const confidence = clamp01(readNumber(payload, "confidence") ?? 1);
+  const confidence = clamp012(readNumber(payload, "confidence") ?? 1);
   const source = readString2(payload, "source");
   const id = crypto.randomUUID();
   db.prepare(`INSERT INTO entity_aliases
@@ -46424,58 +46940,62 @@ function applyArchiveEntityAlias(db, agentId, proposal, payload) {
   return { aliasId, entityId: entity.id, archived: true };
 }
 function applyOperation(db, proposal, actor, writeCaps) {
-  const payload = parseJsonRecord(proposal.payload);
-  if (proposal.operation === "create_entity")
-    return applyCreateEntity(db, proposal.agent_id, proposal, payload);
-  if (proposal.operation === "rename_entity")
-    return applyRenameEntity(db, proposal.agent_id, proposal, payload);
-  if (proposal.operation === "archive_entity")
-    return applyArchiveEntity(db, proposal.agent_id, proposal, payload, actor);
-  if (proposal.operation === "create_aspect")
-    return applyCreateAspect(db, proposal.agent_id, proposal, payload, writeCaps);
-  if (proposal.operation === "rename_aspect")
-    return applyRenameAspect(db, proposal.agent_id, proposal, payload);
-  if (proposal.operation === "archive_aspect")
-    return applyArchiveAspect(db, proposal.agent_id, proposal, payload, actor);
-  if (proposal.operation === "add_claim_value")
-    return applyAddClaimValue(db, proposal.agent_id, proposal, payload, writeCaps);
-  if (proposal.operation === "set_claim_value")
-    return applySetClaimValue(db, proposal.agent_id, proposal, payload, writeCaps);
-  if (proposal.operation === "merge_entities")
-    return applyMergeEntities(db, proposal.agent_id, payload);
-  if (proposal.operation === "merge_aspects")
-    return applyMergeAspects(db, proposal.agent_id, proposal, payload);
-  if (proposal.operation === "supersede_claim_value") {
-    return applySupersedeClaimValue(db, proposal.agent_id, proposal, payload);
-  }
-  if (proposal.operation === "archive_claim_value")
-    return applyArchiveClaimValue(db, proposal.agent_id, proposal, payload, actor);
-  if (proposal.operation === "restore_claim_version") {
-    return applyRestoreClaimVersion(db, proposal.agent_id, proposal, payload);
-  }
-  if (proposal.operation === "create_link")
-    return applyCreateLink(db, proposal.agent_id, proposal, payload);
-  if (proposal.operation === "update_link")
-    return applyUpdateLink(db, proposal.agent_id, proposal, payload);
-  if (proposal.operation === "archive_link")
-    return applyArchiveLink(db, proposal.agent_id, proposal, payload, actor);
-  if (proposal.operation === "create_policy")
-    return applyCreatePolicy(db, proposal.agent_id, proposal, payload);
-  if (proposal.operation === "create_action_type")
-    return applyCreateActionType(db, proposal.agent_id, proposal, payload);
-  if (proposal.operation === "create_interface")
-    return applyCreateInterface(db, proposal.agent_id, proposal, payload);
-  if (proposal.operation === "attach_interface")
-    return applyAttachInterface(db, proposal.agent_id, proposal, payload);
-  if (proposal.operation === "pin_entity")
-    return applyPinEntity(db, proposal.agent_id, proposal, payload);
-  if (proposal.operation === "unpin_entity")
-    return applyUnpinEntity(db, proposal.agent_id, proposal, payload);
-  if (proposal.operation === "create_entity_alias")
-    return applyCreateEntityAlias(db, proposal.agent_id, proposal, payload);
-  if (proposal.operation === "archive_entity_alias")
-    return applyArchiveEntityAlias(db, proposal.agent_id, proposal, payload);
-  throw new OntologyProposalError(`Unsupported ontology proposal operation: ${proposal.operation}`, 400);
+  try {
+    const payload = parseJsonRecord(proposal.payload);
+    if (proposal.operation === "create_entity")
+      return applyCreateEntity(db, proposal.agent_id, proposal, payload);
+    if (proposal.operation === "rename_entity")
+      return applyRenameEntity(db, proposal.agent_id, proposal, payload);
+    if (proposal.operation === "archive_entity")
+      return applyArchiveEntity(db, proposal.agent_id, proposal, payload, actor);
+    if (proposal.operation === "create_aspect")
+      return applyCreateAspect(db, proposal.agent_id, proposal, payload, writeCaps);
+    if (proposal.operation === "rename_aspect")
+      return applyRenameAspect(db, proposal.agent_id, proposal, payload);
+    if (proposal.operation === "archive_aspect")
+      return applyArchiveAspect(db, proposal.agent_id, proposal, payload, actor);
+    if (proposal.operation === "add_claim_value")
+      return applyAddClaimValue(db, proposal.agent_id, proposal, payload, writeCaps);
+    if (proposal.operation === "set_claim_value")
+      return applySetClaimValue(db, proposal.agent_id, proposal, payload, writeCaps);
+    if (proposal.operation === "merge_entities")
+      return applyMergeEntities(db, proposal.agent_id, payload);
+    if (proposal.operation === "merge_aspects")
+      return applyMergeAspects(db, proposal.agent_id, proposal, payload);
+    if (proposal.operation === "supersede_claim_value") {
+      return applySupersedeClaimValue(db, proposal.agent_id, proposal, payload);
+    }
+    if (proposal.operation === "archive_claim_value")
+      return applyArchiveClaimValue(db, proposal.agent_id, proposal, payload, actor);
+    if (proposal.operation === "restore_claim_version") {
+      return applyRestoreClaimVersion(db, proposal.agent_id, proposal, payload);
+    }
+    if (proposal.operation === "create_link")
+      return applyCreateLink(db, proposal.agent_id, proposal, payload);
+    if (proposal.operation === "update_link")
+      return applyUpdateLink(db, proposal.agent_id, proposal, payload);
+    if (proposal.operation === "archive_link")
+      return applyArchiveLink(db, proposal.agent_id, proposal, payload, actor);
+    if (proposal.operation === "create_policy")
+      return applyCreatePolicy(db, proposal.agent_id, proposal, payload);
+    if (proposal.operation === "create_action_type")
+      return applyCreateActionType(db, proposal.agent_id, proposal, payload);
+    if (proposal.operation === "create_interface")
+      return applyCreateInterface(db, proposal.agent_id, proposal, payload);
+    if (proposal.operation === "attach_interface")
+      return applyAttachInterface(db, proposal.agent_id, proposal, payload);
+    if (proposal.operation === "pin_entity")
+      return applyPinEntity(db, proposal.agent_id, proposal, payload);
+    if (proposal.operation === "unpin_entity")
+      return applyUnpinEntity(db, proposal.agent_id, proposal, payload);
+    if (proposal.operation === "create_entity_alias")
+      return applyCreateEntityAlias(db, proposal.agent_id, proposal, payload);
+    if (proposal.operation === "archive_entity_alias")
+      return applyArchiveEntityAlias(db, proposal.agent_id, proposal, payload);
+    throw new OntologyProposalError(`Unsupported ontology proposal operation: ${proposal.operation}`, 400);
+  } finally {
+    reconcileOntologyContradictionsInTx(db, { agentId: proposal.agent_id });
+  }
 }
 function createOntologyProposalsInTx(db, inputs) {
   if (inputs.length === 0)
@@ -46792,105 +47312,6 @@ function markAppliedInTx(db, proposal, actor, result) {
   return readBackInTx(db, proposal.id, proposal.agent_id);
 }
 
-// ../../platform/daemon/src/pipeline/antonyms.ts
-var NEGATION_TOKENS = new Set([
-  "not",
-  "no",
-  "never",
-  "cannot",
-  "cant",
-  "doesnt",
-  "dont",
-  "isnt",
-  "wasnt",
-  "wont",
-  "without"
-]);
-var PROSPECTIVE_ANTONYM_PAIRS = [
-  ["enabled", "disabled"],
-  ["allow", "deny"],
-  ["accept", "reject"],
-  ["always", "never"],
-  ["on", "off"],
-  ["true", "false"]
-];
-var ANTONYM_PAIRS = [
-  ["enabled", "disabled"],
-  ["allow", "deny"],
-  ["accept", "reject"],
-  ["always", "never"],
-  ["on", "off"],
-  ["true", "false"],
-  ["yes", "no"],
-  ["together", "apart"],
-  ["dating", "single"],
-  ["married", "divorced"],
-  ["friends", "strangers"],
-  ["close", "distant"],
-  ["love", "hate"],
-  ["like", "dislike"],
-  ["prefer", "avoid"],
-  ["enjoy", "dread"],
-  ["want", "refuse"],
-  ["start", "stop"],
-  ["begin", "end"],
-  ["open", "close"],
-  ["join", "leave"],
-  ["arrive", "depart"],
-  ["buy", "sell"],
-  ["alive", "dead"],
-  ["active", "inactive"],
-  ["positive", "negative"],
-  ["increase", "decrease"],
-  ["before", "after"]
-];
-var ANTONYM_SET = new Set(ANTONYM_PAIRS.flatMap(([a, b]) => [`${a}:${b}`, `${b}:${a}`]));
-function tokenize(text) {
-  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((token) => token.length >= 2);
-}
-function hasNegation(tokens) {
-  return tokens.some((token) => NEGATION_TOKENS.has(token));
-}
-function overlapCount(left, right) {
-  const rightSet = new Set(right);
-  let overlap = 0;
-  for (const token of left) {
-    if (rightSet.has(token))
-      overlap++;
-  }
-  return overlap;
-}
-function hasAntonymConflict(leftTokens, rightTokens, pairs = ANTONYM_PAIRS) {
-  for (const [a, b] of pairs) {
-    const leftHasA = leftTokens.has(a);
-    const leftHasB = leftTokens.has(b);
-    const rightHasA = rightTokens.has(a);
-    const rightHasB = rightTokens.has(b);
-    const leftExclusive = leftHasA !== leftHasB;
-    const rightExclusive = rightHasA !== rightHasB;
-    const opposite = leftHasA && rightHasB || leftHasB && rightHasA;
-    if (leftExclusive && rightExclusive && opposite) {
-      return true;
-    }
-  }
-  return false;
-}
-function detectProspectiveContradictionRisk(candidate, existing) {
-  const candidateTokens = tokenize(candidate);
-  const existingTokens = tokenize(existing);
-  const lexicalOverlap = overlapCount(candidateTokens, existingTokens);
-  if (candidateTokens.length === 0 || existingTokens.length === 0 || lexicalOverlap < 2) {
-    return { detected: false, lexicalOverlap, reason: null };
-  }
-  if (hasNegation(candidateTokens) !== hasNegation(existingTokens)) {
-    return { detected: true, lexicalOverlap, reason: "negation_mismatch" };
-  }
-  if (hasAntonymConflict(new Set(candidateTokens), new Set(existingTokens), PROSPECTIVE_ANTONYM_PAIRS)) {
-    return { detected: true, lexicalOverlap, reason: "antonym_conflict" };
-  }
-  return { detected: false, lexicalOverlap, reason: null };
-}
-
 // ../../platform/daemon/src/pipeline/dreaming-operation-contract.ts
 var text = exports_external.string().min(1);
 var score = exports_external.number().finite();
@@ -48049,6 +48470,29 @@ function createDreamingCapabilities(params) {
       }
       return result;
     }),
+    capability("list_contradictions", "List contradiction observations", "Read persisted, agent-scoped contradiction observations alongside competing claim evidence. Contradictions are advisory state, not a truth choice; use governed ontology operations for any correction.", true, exports_external.object({
+      agentId: exports_external.string().min(1),
+      entityId: exports_external.string().min(1).optional(),
+      aspectId: exports_external.string().min(1).optional(),
+      groupKey: exports_external.string().min(1).optional(),
+      claimKey: exports_external.string().min(1).optional(),
+      sourceId: exports_external.string().min(1).optional(),
+      status: exports_external.enum(["active", "resolved", "all"]).optional(),
+      ...pagination
+    }), async ({ agentId: scopeId, entityId: entityId2, aspectId: aspectId2, groupKey, claimKey: claimKey2, sourceId, status, limit, offset }) => ({
+      ok: true,
+      ...listOntologyContradictions(accessor, {
+        agentId: scopeId,
+        entityId: entityId2,
+        aspectId: aspectId2,
+        groupKey,
+        claimKey: claimKey2,
+        sourceId,
+        status,
+        limit,
+        offset
+      })
+    })),
     capability("runbook_read", "Read Dreaming runbook", "Read recent scoped pass outcomes, evidence windows, quarantines, and structured runbook notes.", true, exports_external.object({ limit: exports_external.number().finite().optional() }), async ({ limit }) => ({ ok: true, items: readDreamingRunbook(accessor, agentId, bounded(limit, 5, 20)) })),
     capability("runbook_write", "Write Dreaming runbook", "Before finishing a Dreaming pass, store one short structured note for future passes to review.", false, exports_external.object({
       summary: exports_external.string().trim().min(1).max(2000),

package/native-manifest.json

@@ -1,43 +1,43 @@
 {
   "schemaVersion": 1,
-  "version": "0.195.4",
+  "version": "0.196.0",
   "assets": [
     {
       "name": "signet-darwin-arm64",
       "platform": "darwin-arm64",
-      "sha256": "57278837f000e65847c63a61fa9d71b55b6bad3c4afdab39ebd66ab67353fc70",
-      "size": 124937632
+      "sha256": "415cd3b7853db4840af91bb64edad9d00a669926dac15a53019f18ad1ee76a38",
+      "size": 125020192
     },
     {
       "name": "signet-darwin-x64",
       "platform": "darwin-x64",
-      "sha256": "64eb4b70880511b6abc24e5f302415dd070ec6683819b67ba2a91c59a2d1ec7c",
-      "size": 129911360
+      "sha256": "97f4c5364b373ac02549864ef98882db0589e1effb957b46d71037d31f225caa",
+      "size": 129993280
     },
     {
       "name": "signet-linux-arm64",
       "platform": "linux-arm64",
-      "sha256": "57e42932a698bd6d41e370c793b29eb3e481ff0a80e8a2c6f2e9858649745ff6",
-      "size": 169487581
+      "sha256": "da4f4e7d82bb38a3a48d2b1cfa91854526a8dcfdce02d8a64bda4d610e7a2023",
+      "size": 169564354
     },
     {
       "name": "signet-linux-x64",
       "platform": "linux-x64",
-      "sha256": "8141b6d06946c153d6713d6cd230a4be19d450adf86364536ed3c57c8c009ed6",
-      "size": 171862163
+      "sha256": "52051d07b43bdec8c35be8747871fd246c2f4f7db096cb2b37b3a5a3605cf9cd",
+      "size": 171938936
     },
     {
       "name": "signet-win32-x64.exe",
       "platform": "win32-x64",
-      "sha256": "03844c6a35c263852538b19db8574ac68766185e912a28e8ba1fafb215456e84",
-      "size": 179988480
+      "sha256": "dd11feeada52f765f70ada430fa5dcb82a03b201e562f6816d8fa5068da5fae8",
+      "size": 180065280
     }
   ],
   "components": {
     "connectors": {
-      "url": "signet-connectors-0.195.4.tar.gz",
-      "sha256": "e4a02c5098124182f2a95fbe14b4cadbe9df60125da38d9cf7bf3c9173058184",
-      "size": 21669
+      "url": "signet-connectors-0.196.0.tar.gz",
+      "sha256": "74c3a39a0a88438eda1433dc26dd1041fc5d1f5ede1777ea474f402d53d46e78",
+      "size": 21666
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signetai",
-  "version": "0.195.4",
+  "version": "0.196.0",
   "description": "Signet native CLI installer wrapper",
   "type": "module",
   "bin": {
@@ -65,10 +65,10 @@
     "access": "public"
   },
   "optionalDependencies": {
-    "signetai-darwin-arm64": "https://github.com/Signet-AI/signetai/releases/download/v0.195.4/signetai-darwin-arm64-0.195.4.tgz",
-    "signetai-darwin-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.195.4/signetai-darwin-x64-0.195.4.tgz",
-    "signetai-linux-arm64": "https://github.com/Signet-AI/signetai/releases/download/v0.195.4/signetai-linux-arm64-0.195.4.tgz",
-    "signetai-linux-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.195.4/signetai-linux-x64-0.195.4.tgz",
-    "signetai-win32-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.195.4/signetai-win32-x64-0.195.4.tgz"
+    "signetai-darwin-arm64": "https://github.com/Signet-AI/signetai/releases/download/v0.196.0/signetai-darwin-arm64-0.196.0.tgz",
+    "signetai-darwin-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.196.0/signetai-darwin-x64-0.196.0.tgz",
+    "signetai-linux-arm64": "https://github.com/Signet-AI/signetai/releases/download/v0.196.0/signetai-linux-arm64-0.196.0.tgz",
+    "signetai-linux-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.196.0/signetai-linux-x64-0.196.0.tgz",
+    "signetai-win32-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.196.0/signetai-win32-x64-0.196.0.tgz"
   }
 }