@askexenow/exe-os 0.9.367 → 0.9.368

package/dist/chunk-KZXMP6JG.js

@@ -0,0 +1,319 @@
+// src/lib/verification-evidence.ts
+import { execFileSync } from "child_process";
+
+// src/shared/verification-artifact.ts
+var ok = { ok: true, code: "ok", message: "verified" };
+function deny(code, message) {
+  return { ok: false, code, message };
+}
+var HEX_SHA = /^[0-9a-f]{7,64}$/i;
+var MIN_OBSERVATION_CHARS = 40;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function str(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function isSubstantiveCommit(substance) {
+  if (!isRecord(substance)) return false;
+  const added = num(substance.added);
+  const deleted = num(substance.deleted);
+  const substantive = num(substance.substantive_added);
+  const sourceFiles = num(substance.source_files);
+  if (added === null || deleted === null || substantive === null || sourceFiles === null) return false;
+  if (added < 0 || deleted < 0 || substantive < 0 || sourceFiles < 0) return false;
+  if (substantive > added) return false;
+  if (sourceFiles < 1) return false;
+  if (substantive < 1 && deleted < 1) return false;
+  return true;
+}
+function assessVerificationArtifact(raw, context = {}) {
+  if (raw === void 0 || raw === null || raw === "") {
+    return deny("artifact_missing", "closing requires a verification artifact showing the defect is absent");
+  }
+  let artifact = raw;
+  if (typeof raw === "string") {
+    try {
+      artifact = JSON.parse(raw);
+    } catch {
+      return deny("artifact_malformed", "verification artifact must be valid JSON");
+    }
+  }
+  if (!isRecord(artifact)) {
+    return deny("artifact_malformed", "verification artifact must be an object");
+  }
+  const kind = str(artifact.kind);
+  if (kind !== "regression_test" && kind !== "manual") {
+    return deny("artifact_unknown_kind", "verification artifact kind must be regression_test or manual");
+  }
+  if (!isSubstantiveCommit(artifact.substance)) {
+    return deny(
+      "commit_not_substantive",
+      "the fix commit changes no executable production source (comment-only, whitespace-only, or test-only diffs are not fixes)"
+    );
+  }
+  if (kind === "regression_test") {
+    const testId = str(artifact.test_id);
+    const fixCommit = str(artifact.fix_commit);
+    const parentCommit = str(artifact.parent_commit);
+    if (!testId || !HEX_SHA.test(fixCommit) || !HEX_SHA.test(parentCommit)) {
+      return deny("artifact_malformed", "regression_test requires test_id, fix_commit and parent_commit");
+    }
+    if (fixCommit.toLowerCase() === parentCommit.toLowerCase()) {
+      return deny("parent_equals_fix", "parent_commit must be the commit BEFORE the fix");
+    }
+    if (str(artifact.parent_result) !== "fail") {
+      return deny(
+        "test_did_not_fail_at_parent",
+        "the named test must FAIL at the parent commit \u2014 a test that already passed does not detect the defect"
+      );
+    }
+    if (str(artifact.fix_result) !== "pass") {
+      return deny("test_did_not_pass_at_fix", "the named test must PASS at the fix commit");
+    }
+    return ok;
+  }
+  const verifier = str(artifact.verifier);
+  if (!verifier) {
+    return deny("manual_verifier_missing", "manual verification requires a named verifier");
+  }
+  const authors = (context.authorIdentities ?? []).map((a) => str(a).toLowerCase()).filter(Boolean);
+  if (authors.includes(verifier.toLowerCase())) {
+    return deny(
+      "manual_verifier_is_author",
+      "manual verification must be attested by someone other than the bug's author or assignee"
+    );
+  }
+  if (!str(artifact.method)) {
+    return deny("artifact_malformed", "manual verification requires a method");
+  }
+  if (str(artifact.observation).length < MIN_OBSERVATION_CHARS) {
+    return deny(
+      "manual_observation_too_thin",
+      "manual verification requires an observation describing the defect's absence"
+    );
+  }
+  if (!HEX_SHA.test(str(artifact.fix_commit))) {
+    return deny("artifact_malformed", "manual verification requires a fix_commit");
+  }
+  return ok;
+}
+
+// src/lib/verification-evidence.ts
+var TEST_PATH = /(?:^|\/)(?:tests?|__tests__|__mocks__|e2e|fixtures)\//i;
+var TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$/i;
+var NON_SOURCE_FILE = /\.(?:md|mdx|txt|rst|adoc|snap|lock)$/i;
+var COMMENT_LINE = /^(?:\/\/|\/\*|\*\/|\*(?!\/)|#|--|<!--|-->)/;
+function isTestPath(path) {
+  return TEST_PATH.test(path) || TEST_FILE.test(path);
+}
+function isNonSourcePath(path) {
+  return NON_SOURCE_FILE.test(path);
+}
+function isCommentOrBlank(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return true;
+  return COMMENT_LINE.test(trimmed);
+}
+function measureUnifiedDiff(diff) {
+  let added = 0;
+  let deleted = 0;
+  let substantiveAdded = 0;
+  const sourceFiles = /* @__PURE__ */ new Set();
+  let currentPath = "";
+  let currentIsSource = false;
+  for (const line of diff.split(/\r?\n/)) {
+    if (line.startsWith("+++ ")) {
+      const path = line.slice(4).replace(/^b\//, "").trim();
+      currentPath = path === "/dev/null" ? "" : path;
+      currentIsSource = Boolean(currentPath) && !isTestPath(currentPath) && !isNonSourcePath(currentPath);
+      continue;
+    }
+    if (line.startsWith("--- ") || line.startsWith("diff ") || line.startsWith("index ") || line.startsWith("@@")) {
+      continue;
+    }
+    if (line.startsWith("+")) {
+      added += 1;
+      if (currentIsSource) {
+        const content = line.slice(1);
+        if (!isCommentOrBlank(content)) {
+          substantiveAdded += 1;
+          sourceFiles.add(currentPath);
+        }
+      }
+    } else if (line.startsWith("-")) {
+      deleted += 1;
+      if (currentIsSource) {
+        const content = line.slice(1);
+        if (!isCommentOrBlank(content)) sourceFiles.add(currentPath);
+      }
+    }
+  }
+  return {
+    added,
+    deleted,
+    substantive_added: substantiveAdded,
+    source_files: sourceFiles.size
+  };
+}
+function measureCommitSubstance(sha, cwd) {
+  if (!/^[0-9a-f]{7,64}$/i.test(sha)) return null;
+  try {
+    const diff = execFileSync(
+      "git",
+      ["show", "--format=", "--unified=0", "--no-color", sha],
+      { cwd, encoding: "utf8", timeout: 15e3, maxBuffer: 32 * 1024 * 1024 }
+    );
+    return measureUnifiedDiff(diff);
+  } catch {
+    return null;
+  }
+}
+function resolveParentCommit(sha, cwd) {
+  if (!/^[0-9a-f]{7,64}$/i.test(sha)) return null;
+  try {
+    const out = execFileSync("git", ["rev-parse", `${sha}^`], {
+      cwd,
+      encoding: "utf8",
+      timeout: 1e4
+    });
+    const parent = out.trim();
+    return /^[0-9a-f]{7,64}$/i.test(parent) ? parent : null;
+  } catch {
+    return null;
+  }
+}
+function fail(code, message) {
+  return { ok: false, code, message };
+}
+var PLACEHOLDER_VERIFIERS = /* @__PURE__ */ new Set([
+  "me",
+  "self",
+  "myself",
+  "i",
+  "agent",
+  "the agent",
+  "assistant",
+  "ai",
+  "bot",
+  "n/a",
+  "na",
+  "none",
+  "unknown",
+  "tbd",
+  "todo",
+  "system",
+  "automated",
+  "auto",
+  "claude",
+  "user",
+  "test",
+  "someone",
+  "team"
+]);
+var LOW_CONTENT_OBSERVATION = /^(?:it(?:'s| is)? |the bug (?:is|was) |this (?:is|was) )?(?:fixed|resolved|working|done|good|ok|verified|closed)\b/i;
+function resolveCommit(sha, cwd) {
+  if (!/^[0-9a-f]{7,64}$/i.test(sha)) return null;
+  try {
+    const out = execFileSync("git", ["rev-parse", "--verify", `${sha}^{commit}`], {
+      cwd,
+      encoding: "utf8",
+      timeout: 1e4
+    }).trim();
+    return /^[0-9a-f]{40}$/i.test(out) ? out : null;
+  } catch {
+    return null;
+  }
+}
+function buildVerificationArtifact(request, context = {}) {
+  const repo = request.repo_path;
+  if (!repo || !repo.trim()) {
+    return fail("repo_path_missing", "repo_path is required: the fix commit must be measured in the repository that contains it");
+  }
+  const fixCommit = resolveCommit(request.fix_commit ?? "", repo);
+  if (!fixCommit) {
+    return fail(
+      "fix_commit_unresolvable",
+      `fix_commit ${request.fix_commit} is not a commit in ${repo} \u2014 verification evidence cannot be measured, and will not be guessed`
+    );
+  }
+  const substance = measureCommitSubstance(fixCommit, repo);
+  if (!substance) {
+    return fail("commit_not_measurable", `git could not diff ${fixCommit} in ${repo}`);
+  }
+  let artifact;
+  if (request.kind === "regression_test") {
+    const parentCommit = resolveParentCommit(fixCommit, repo);
+    if (!parentCommit) {
+      return fail(
+        "parent_commit_unresolvable",
+        `could not resolve the first parent of ${fixCommit} \u2014 a regression_test artifact needs the tree WITHOUT the fix`
+      );
+    }
+    const testId = (request.test_id ?? "").trim();
+    if (!testId) return fail("artifact_malformed", "regression_test requires test_id (e.g. 'tests/foo.test.ts::rejects empty scope')");
+    const parentResult = (request.parent_result ?? "").trim();
+    const fixResult = (request.fix_result ?? "").trim();
+    if (parentResult !== "fail" && parentResult !== "pass" && parentResult !== "error") {
+      return fail("artifact_malformed", "parent_result must be the result you OBSERVED running the test at the parent commit: fail, pass or error");
+    }
+    if (fixResult !== "fail" && fixResult !== "pass" && fixResult !== "error") {
+      return fail("artifact_malformed", "fix_result must be the result you OBSERVED running the test at the fix commit: fail, pass or error");
+    }
+    const regression = {
+      kind: "regression_test",
+      test_id: testId,
+      fix_commit: fixCommit,
+      parent_commit: parentCommit,
+      parent_result: parentResult,
+      fix_result: fixResult,
+      substance
+    };
+    artifact = regression;
+  } else if (request.kind === "manual") {
+    const verifier = (request.verifier ?? "").trim();
+    if (!verifier) return fail("manual_verifier_missing", "manual verification requires a named verifier");
+    if (PLACEHOLDER_VERIFIERS.has(verifier.toLowerCase())) {
+      return fail(
+        "manual_verifier_placeholder",
+        `"${verifier}" is not an identity. Name the person or employee who reproduced the original defect and confirmed it is gone.`
+      );
+    }
+    const method = (request.method ?? "").trim();
+    if (!method) return fail("artifact_malformed", "manual verification requires a method someone else could repeat");
+    const observation = (request.observation ?? "").replace(/\s+/g, " ").trim();
+    if (LOW_CONTENT_OBSERVATION.test(observation)) {
+      return fail(
+        "manual_observation_too_thin",
+        "the observation must describe what you saw that shows the DEFECT IS ABSENT \u2014 not that the bug is 'fixed'"
+      );
+    }
+    if (observation.toLowerCase() === method.toLowerCase()) {
+      return fail("manual_observation_too_thin", "the observation must say what you saw, not repeat the method");
+    }
+    const manual = {
+      kind: "manual",
+      verifier,
+      method,
+      observation,
+      fix_commit: fixCommit,
+      substance
+    };
+    artifact = manual;
+  } else {
+    return fail("artifact_unknown_kind", "verification kind must be regression_test or manual");
+  }
+  const assessed = assessVerificationArtifact(artifact, context);
+  if (!assessed.ok) return fail(assessed.code, assessed.message);
+  return { ok: true, artifact, substance };
+}
+
+export {
+  isSubstantiveCommit,
+  assessVerificationArtifact,
+  measureCommitSubstance,
+  buildVerificationArtifact
+};

package/dist/{chunk-ZZ3JQM5I.js → chunk-LJWCK2DR.js}

@@ -2,7 +2,7 @@ import {
   dispatchTaskToEmployee,
   markTaskNotificationsRead,
   notifyTaskDone
-} from "./chunk-OISZ2I4X.js";
+} from "./chunk-NWE3CFX7.js";
 import {
   clearCurrentTask,
   writeCurrentTask
@@ -16,7 +16,7 @@ import {
   strictSessionScopeFilter,
   updateTaskStatus,
   writeNotification
-} from "./chunk-QX33D4CH.js";
+} from "./chunk-Y4AYNLXU.js";
 import {
   getAgentContext
 } from "./chunk-GJV3WDWM.js";
@@ -27,7 +27,7 @@ import {
   getClient,
   getCoordinatorName,
   isCoordinatorName
-} from "./chunk-HSBKV5LB.js";
+} from "./chunk-OBESOWFJ.js";
 
 // src/lib/tasks-chain.ts
 import path from "path";
@@ -62,7 +62,7 @@ async function cascadeUnblock(taskId, baseDir, now) {
   }
   if (unblockedRows.rows.length > 0 && !process.env.VITEST) {
     try {
-      const { dispatchTaskToEmployee: dispatchTaskToEmployee2 } = await import("./tasks-notify-767DRYAA.js");
+      const { dispatchTaskToEmployee: dispatchTaskToEmployee2 } = await import("./tasks-notify-7UVC3VGI.js");
       const dispatched = /* @__PURE__ */ new Set();
       for (const ur of unblockedRows.rows) {
         const assignee = String(ur.assigned_to);
@@ -87,7 +87,7 @@ async function cascadeUnblock(taskId, baseDir, now) {
       }
     } catch {
       try {
-        const { queueIntercom } = await import("./intercom-queue-IBOAVT2I.js");
+        const { queueIntercom } = await import("./intercom-queue-BZ4M3L4S.js");
         const dispatched = /* @__PURE__ */ new Set();
         for (const ur of unblockedRows.rows) {
           const assignee = String(ur.assigned_to);
@@ -285,7 +285,7 @@ async function updateTask(input) {
         try {
           process.stderr.write(`[tasks] EVENT: tmux delivery failed for reviewer="${reviewer}". Queueing for daemon delivery.
 `);
-          const { queueIntercom } = await import("./intercom-queue-IBOAVT2I.js");
+          const { queueIntercom } = await import("./intercom-queue-BZ4M3L4S.js");
           const { resolveExeSession } = await import("./lib/tmux-routing.js");
           const exeSession = row.session_scope ? String(row.session_scope) : resolveExeSession();
           if (exeSession) {
@@ -302,7 +302,7 @@ async function updateTask(input) {
         }
       }
       try {
-        const { pushNotifyAsync } = await import("./push-notifications-S2RYRXLF.js");
+        const { pushNotifyAsync } = await import("./push-notifications-DFSR6P7V.js");
         pushNotifyAsync({
           event: "review_ready",
           title: `Review ready: ${taskTitle.slice(0, 50)}`,
@@ -314,7 +314,7 @@ async function updateTask(input) {
     }
     if (!isCoordinator && isCompletionReviewTransition) {
       try {
-        const { pushNotifyAsync } = await import("./push-notifications-S2RYRXLF.js");
+        const { pushNotifyAsync } = await import("./push-notifications-DFSR6P7V.js");
         const event = input.status === "needs_review" ? "review_ready" : "task_complete";
         pushNotifyAsync({
           event,
@@ -329,7 +329,7 @@ async function updateTask(input) {
     await markTaskNotificationsRead(taskFile);
     if (isCompletionReviewTransition && !isCoordinator && row.reviewer) {
       try {
-        const { writeNotification: writeNotification2 } = await import("./notifications-S4GU22GF.js");
+        const { writeNotification: writeNotification2 } = await import("./notifications-LLCCHRYV.js");
         const reviewer = String(row.reviewer);
         await writeNotification2({
           agentId: reviewer,

package/dist/{chunk-WBKIU6UJ.js → chunk-MCXYNYZI.js}

@@ -3,13 +3,13 @@ import {
 } from "./chunk-VMJ2UH4S.js";
 import {
   vectorToSqlLiteral
-} from "./chunk-BQYQES2Z.js";
+} from "./chunk-ELY5WBZX.js";
 import {
   blobToVector
 } from "./chunk-OTVEIJUQ.js";
 import {
   getClient
-} from "./chunk-HSBKV5LB.js";
+} from "./chunk-OBESOWFJ.js";
 
 // src/lib/behaviors.ts
 import crypto from "crypto";
@@ -118,6 +118,33 @@ async function storeBehavior(opts) {
   });
   return id;
 }
+async function countActiveBehaviors(agentId, projectName) {
+  const client = getClient();
+  let currentDeviceId = null;
+  try {
+    const { loadDeviceId } = await import("./lib/license.js");
+    currentDeviceId = loadDeviceId() ?? null;
+  } catch {
+  }
+  const { offloadReadIfMain } = await import("./lib/database.js");
+  const result = await offloadReadIfMain(
+    client,
+    `SELECT count(*) AS total,
+            sum(CASE WHEN priority = 'p0' THEN 1 ELSE 0 END) AS p0
+          FROM behaviors
+          WHERE agent_id = ? AND active = 1
+            AND id IS NOT NULL AND trim(coalesce(content, '')) != ''
+            AND (project_name IS NULL OR project_name = ?)
+            AND (device_id IS NULL OR device_id = ?)`,
+    [agentId, projectName ?? "", currentDeviceId ?? ""],
+    true
+  );
+  const row = result.rows[0];
+  return {
+    total: Number(row?.total ?? 0),
+    p0: Number(row?.p0 ?? 0)
+  };
+}
 async function listBehaviors(agentId, projectName, limit = 30) {
   const client = getClient();
   let currentDeviceId = null;
@@ -329,6 +356,7 @@ export {
   isReflexBehavior,
   storeReflexBehavior,
   storeBehavior,
+  countActiveBehaviors,
   listBehaviors,
   listBehaviorsByDomain,
   listBehaviorsSince,

package/dist/{chunk-L2VZBPJJ.js → chunk-MWEIBVBS.js}

@@ -25,7 +25,10 @@ function normalizeState(value) {
     paused: raw.paused === true,
     pausedAt: typeof raw.pausedAt === "string" ? raw.pausedAt : null,
     intervalMs,
-    updatedAt
+    updatedAt,
+    // Optional and only present when actually set, so existing readers that
+    // compare whole state objects are unaffected by the new field.
+    ...typeof raw.pendingSliceAt === "string" && raw.pendingSliceAt !== "" ? { pendingSliceAt: raw.pendingSliceAt } : {}
   };
 }
 function readCloudSyncState(statePath = resolveCloudSyncStatePath()) {
@@ -85,6 +88,14 @@ function newestCloudSyncFailureFromHealthLog(healthLogPath) {
   }
   return null;
 }
+function hasPendingCloudSyncSlice(state, nowMs, intervalMs) {
+  const pendingSliceAt = state?.pendingSliceAt;
+  if (typeof pendingSliceAt !== "string" || pendingSliceAt === "") return false;
+  const pendingMs = Date.parse(pendingSliceAt);
+  if (!Number.isFinite(pendingMs)) return false;
+  const ageMs = nowMs - pendingMs;
+  return ageMs >= 0 && ageMs < (intervalMs > 0 ? intervalMs : DEFAULT_INTERVAL_MS);
+}
 function resolveCloudSyncStatus(options) {
   if (!options.cloudConfigured) return { status: "not-configured" };
   const nowMs = options.nowMs ?? Date.now();
@@ -142,5 +153,6 @@ export {
   resolveDaemonHealthLogPath,
   readCloudSyncState,
   writeCloudSyncState,
+  hasPendingCloudSyncSlice,
   resolveCloudSyncStatus
 };

package/dist/{chunk-GUOMZ3JM.js → chunk-MXP27XTP.js}

@@ -3,11 +3,11 @@ import {
 } from "./chunk-75H4R62K.js";
 import {
   initStore
-} from "./chunk-BQYQES2Z.js";
+} from "./chunk-ELY5WBZX.js";
 import {
   getClient,
   isInitialized
-} from "./chunk-HSBKV5LB.js";
+} from "./chunk-OBESOWFJ.js";
 
 // src/lib/schedules.ts
 import crypto from "crypto";

package/dist/{chunk-EDZ5URGR.js → chunk-N3CGSO3S.js}

@@ -1,6 +1,6 @@
 import {
   processCRMEvent
-} from "./chunk-YNPOELAN.js";
+} from "./chunk-LBWEAQ6Z.js";
 
 // src/gateway/adapters/crm-webhook.ts
 function parseTwentyWebhook(payload) {

package/dist/{chunk-QWDZNQXA.js → chunk-NNXPIJRB.js}

@@ -14,7 +14,7 @@ import {
   getEmployee,
   isCoordinatorRole,
   loadEmployeesSync
-} from "./chunk-HSBKV5LB.js";
+} from "./chunk-OBESOWFJ.js";
 import {
   EXE_AI_DIR
 } from "./chunk-QMSEL5YS.js";

package/dist/{chunk-OISZ2I4X.js → chunk-NWE3CFX7.js}

@@ -6,13 +6,13 @@ import {
   queryTaskRows,
   resolveExeSession,
   sendIntercom
-} from "./chunk-QX33D4CH.js";
+} from "./chunk-Y4AYNLXU.js";
 import {
   getTransport
 } from "./chunk-UXLO7VHX.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-UI3K73LD.js";
+} from "./chunk-BFL3UB77.js";
 import {
   releaseDispatchClaim,
   tryAcquireDispatchClaim
@@ -27,7 +27,7 @@ import {
   isCoordinatorName,
   isMultiInstance,
   shouldAutoInstance
-} from "./chunk-HSBKV5LB.js";
+} from "./chunk-OBESOWFJ.js";
 
 // src/lib/tasks-notify.ts
 var VERIFY_DELAY_MS = 1e4;
@@ -89,7 +89,7 @@ async function dispatchTaskToEmployee(input) {
   let crossProject = false;
   if (input.projectName) {
     try {
-      const { assertSessionScope } = await import("./session-scope-G4RVJJGR.js");
+      const { assertSessionScope } = await import("./session-scope-LXDW7LJJ.js");
       const check = assertSessionScope("dispatch_task", input.projectName);
       if (check.reason === "cross_session_denied") {
         crossProject = true;

package/dist/{chunk-HSBKV5LB.js → chunk-OBESOWFJ.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-5YEUPUV4.js";
 import {
   listBackups
-} from "./chunk-Y7OK5PJE.js";
+} from "./chunk-JDPV7W2L.js";
 import {
   isPostgresBackendEnabled
 } from "./chunk-YYB5PMTK.js";
@@ -1333,7 +1333,7 @@ async function migrateReflectionDedup(client) {
     "ALTER TABLE memory_reflections ADD COLUMN dedup_key TEXT",
     "migration add memory_reflections.dedup_key"
   );
-  const { reflectionDedupKey } = await import("./memory-reflection-3AI4JBV2.js");
+  const { reflectionDedupKey } = await import("./memory-reflection-5IJ6RE2J.js");
   const keyForRow = (row) => {
     let sources = [];
     try {
@@ -2346,7 +2346,7 @@ async function sweepExpiredSoftDeletedMemories(client, options = {}) {
   const purgeArchived = archDays !== void 0;
   const BATCH_SIZE = 2e3;
   const MAX_BATCHES = 500;
-  const { cleanupCardsForMemories, cleanupGraphLinksForMemories } = await import("./graph-rag-L5NV5YWD.js");
+  const { cleanupCardsForMemories, cleanupGraphLinksForMemories } = await import("./graph-rag-RLRQMY54.js");
   const softCutoff = `-${softDays} days`;
   const selectArgsBase = [softCutoff];
   let predicate = `status = 'deleted' AND COALESCE(deleted_at, timestamp) < datetime('now', ?)`;