@askexenow/exe-os 0.9.364 → 0.9.367

package/dist/chunk-R4AROSYI.js

@@ -0,0 +1,496 @@
+import {
+  sessionScopeFilter
+} from "./chunk-QX33D4CH.js";
+
+// src/lib/verification-evidence.ts
+import { execFileSync } from "child_process";
+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;
+  }
+}
+
+// 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/shared/task-completion-gate.ts
+var COMPLETION_CLAIM_STATUSES = ["done", "needs_review", "closed"];
+function isCompletionClaim(status) {
+  const normalized = typeof status === "string" ? status.trim() : "";
+  return COMPLETION_CLAIM_STATUSES.includes(normalized);
+}
+var ok2 = { ok: true, code: "ok", message: "verified" };
+function assessAutomatedTaskCompletion(input) {
+  if (!isCompletionClaim(input.status)) return ok2;
+  if (!isSubstantiveCommit(input.substance)) {
+    return {
+      ok: false,
+      code: "commit_not_substantive",
+      message: "the matched commit changes no executable production source (comment-only, whitespace-only, docs-only or test-only diffs are not work)"
+    };
+  }
+  if (input.verificationArtifact !== void 0 && input.verificationArtifact !== null) {
+    return assessVerificationArtifact(input.verificationArtifact, input.context ?? {});
+  }
+  return ok2;
+}
+
+// src/lib/git-task-sweep.ts
+import { execSync } from "child_process";
+var DEFAULT_COMMIT_LIMIT = 50;
+var DEFAULT_STALE_MINUTES = 10;
+var AUTO_ESCALATE_THRESHOLD = 0.6;
+var EXACT_UUID_SCORE = 1;
+var TITLE_KEYWORD_SCORE = 0.5;
+var FILE_PATH_SCORE = 0.3;
+var MIN_KEYWORD_OVERLAP = 3;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "is",
+  "it",
+  "as",
+  "be",
+  "was",
+  "are",
+  "this",
+  "that",
+  "not",
+  "no",
+  "if",
+  "so",
+  "do",
+  "up"
+]);
+function extractKeywords(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length >= 3 && !STOP_WORDS.has(w));
+}
+function matchScore(task, commitMessage, changedFiles) {
+  if (task.id.length >= 8 && commitMessage.includes(task.id)) {
+    return EXACT_UUID_SCORE;
+  }
+  let score = 0;
+  const titleWords = extractKeywords(task.title);
+  const commitWords = new Set(extractKeywords(commitMessage));
+  const overlap = titleWords.filter((w) => commitWords.has(w));
+  if (overlap.length >= MIN_KEYWORD_OVERLAP) {
+    score += TITLE_KEYWORD_SCORE;
+  }
+  if (task.context && changedFiles.length > 0) {
+    const contextLower = task.context.toLowerCase();
+    const hasFileMatch = changedFiles.some(
+      (f) => contextLower.includes(f.toLowerCase())
+    );
+    if (hasFileMatch) {
+      score += FILE_PATH_SCORE;
+    }
+  }
+  return score;
+}
+function getRecentCommits(limit = DEFAULT_COMMIT_LIMIT) {
+  try {
+    const SEPARATOR = "<<SEP>>";
+    const output = execSync(
+      `git log --format="%h${SEPARATOR}%s${SEPARATOR}%aI" --name-only -n ${limit} -z`,
+      { encoding: "utf8", timeout: 1e4 }
+    );
+    const entries = output.split("\0").filter(Boolean);
+    const commits = [];
+    let current = null;
+    for (const entry of entries) {
+      if (entry.includes(SEPARATOR)) {
+        const lines = entry.split("\n");
+        const headerLine = lines[0];
+        const parts = headerLine.split(SEPARATOR);
+        if (parts.length >= 3) {
+          if (current) commits.push(current);
+          current = {
+            hash: parts[0],
+            message: parts[1],
+            files: lines.slice(1).filter(Boolean),
+            date: new Date(parts[2])
+          };
+        }
+      } else if (current) {
+        const files = entry.split("\n").filter(Boolean);
+        current.files.push(...files);
+      }
+    }
+    if (current) commits.push(current);
+    return commits;
+  } catch {
+    return [];
+  }
+}
+function pushUnpushedCommits() {
+  const run = (args) => execSync(`git ${args}`, { encoding: "utf8", timeout: 15e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
+  let branch;
+  try {
+    branch = run("rev-parse --abbrev-ref HEAD");
+  } catch {
+    return { branch: null, ahead: 0, pushed: false, status: "not_a_repo" };
+  }
+  if (!branch || branch === "HEAD") {
+    return { branch: null, ahead: 0, pushed: false, status: "no_branch" };
+  }
+  if (branch === "main" || branch === "master") {
+    return { branch, ahead: 0, pushed: false, status: "default_branch_skipped" };
+  }
+  let ahead = 0;
+  let hasUpstream = false;
+  try {
+    run("rev-parse --abbrev-ref --symbolic-full-name @{u}");
+    hasUpstream = true;
+    const count = run("rev-list --count @{u}..HEAD");
+    ahead = Number.parseInt(count, 10) || 0;
+  } catch {
+    hasUpstream = false;
+    for (const base of ["origin/main", "origin/master"]) {
+      try {
+        const count = run(`rev-list --count ${base}..HEAD`);
+        ahead = Number.parseInt(count, 10) || 0;
+        if (ahead > 0) break;
+      } catch {
+      }
+    }
+    if (ahead === 0) {
+      try {
+        const count = run("rev-list --count HEAD");
+        ahead = Number.parseInt(count, 10) || 0;
+      } catch {
+        ahead = 0;
+      }
+    }
+  }
+  if (ahead <= 0) {
+    return { branch, ahead: 0, pushed: false, status: "nothing_to_push" };
+  }
+  try {
+    if (hasUpstream) {
+      run("push");
+    } else {
+      run(`push --set-upstream origin ${branch}`);
+    }
+    return { branch, ahead, pushed: true, status: "pushed" };
+  } catch (err) {
+    return {
+      branch,
+      ahead,
+      pushed: false,
+      status: "push_failed",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function isStale(updatedAt, staleMinutes) {
+  const updated = new Date(updatedAt).getTime();
+  const threshold = Date.now() - staleMinutes * 6e4;
+  return updated < threshold;
+}
+function findBestMatch(task, commits) {
+  let best = null;
+  for (const commit of commits) {
+    const score = matchScore(task, commit.message, commit.files);
+    if (score >= AUTO_ESCALATE_THRESHOLD && (!best || score > best.score)) {
+      best = { commit, score };
+    }
+  }
+  return best;
+}
+async function sweepTasks(projectName, options = {}) {
+  const commitLimit = options.commitLimit ?? DEFAULT_COMMIT_LIMIT;
+  const staleMinutes = options.staleMinutes ?? DEFAULT_STALE_MINUTES;
+  const dryRun = options.dryRun ?? false;
+  const result = { escalated: [], rejected: [], unchanged: 0, errors: [] };
+  const substanceCache = /* @__PURE__ */ new Map();
+  const commitIsAdmissible = (hash) => {
+    if (!substanceCache.has(hash)) {
+      substanceCache.set(hash, measureCommitSubstance(hash, process.cwd()));
+    }
+    return assessAutomatedTaskCompletion({
+      status: "needs_review",
+      substance: substanceCache.get(hash) ?? null
+    }).ok;
+  };
+  const commits = getRecentCommits(commitLimit);
+  if (commits.length === 0) {
+    result.errors.push("No git commits found (not a git repo or empty history)");
+    return result;
+  }
+  let tasks;
+  try {
+    const { initStore } = await import("./lib/store.js");
+    await initStore();
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    const conditions = ["status = 'in_progress'"];
+    const args = [];
+    if (projectName) {
+      conditions.push("project_name = ?");
+      args.push(projectName);
+    }
+    const swScope = sessionScopeFilter();
+    if (swScope.sql) {
+      conditions.push("(session_scope IS NULL OR session_scope = ?)");
+      args.push(...swScope.args);
+    }
+    const queryResult = await client.execute({
+      sql: `SELECT id, title, assigned_to, project_name, status, updated_at, context
+            FROM tasks WHERE ${conditions.join(" AND ")}
+            ORDER BY updated_at ASC`,
+      args
+    });
+    tasks = queryResult.rows.map((r) => ({
+      id: String(r.id),
+      title: String(r.title),
+      assignedTo: String(r.assigned_to),
+      projectName: String(r.project_name),
+      status: String(r.status),
+      updatedAt: String(r.updated_at),
+      context: r.context ? String(r.context) : void 0
+    }));
+  } catch (err) {
+    result.errors.push(`DB query failed: ${err instanceof Error ? err.message : String(err)}`);
+    return result;
+  }
+  if (tasks.length === 0) {
+    return result;
+  }
+  for (const task of tasks) {
+    if (!isStale(task.updatedAt, staleMinutes)) {
+      result.unchanged++;
+      continue;
+    }
+    const match = findBestMatch(task, commits);
+    if (!match) {
+      result.unchanged++;
+      continue;
+    }
+    if (!commitIsAdmissible(match.commit.hash)) {
+      result.rejected.push({
+        taskId: task.id,
+        title: task.title,
+        matchedCommit: match.commit.hash,
+        score: match.score
+      });
+      result.unchanged++;
+      process.stderr.write(
+        `[git-sweep] Rejected task ${task.id} \u2192 commit ${match.commit.hash} (score: ${match.score.toFixed(2)}) \u2014 commit changes no executable production source
+`
+      );
+      continue;
+    }
+    if (!dryRun) {
+      try {
+        const { updateTaskStatus } = await import("./tasks-crud-ZU6RZDEZ.js");
+        await updateTaskStatus({
+          taskId: task.id,
+          status: "needs_review",
+          result: `Auto-escalated by git-sweep: matching commit ${match.commit.hash} found (score: ${match.score.toFixed(2)})`
+        });
+      } catch (err) {
+        result.errors.push(
+          `Failed to escalate task ${task.id}: ${err instanceof Error ? err.message : String(err)}`
+        );
+        continue;
+      }
+    }
+    result.escalated.push({
+      taskId: task.id,
+      title: task.title,
+      matchedCommit: match.commit.hash,
+      score: match.score
+    });
+    process.stderr.write(
+      `[git-sweep] ${dryRun ? "WOULD escalate" : "Escalated"} task ${task.id} \u2192 commit ${match.commit.hash} (score: ${match.score.toFixed(2)})
+`
+    );
+  }
+  return result;
+}
+
+export {
+  measureCommitSubstance,
+  assessAutomatedTaskCompletion,
+  extractKeywords,
+  matchScore,
+  getRecentCommits,
+  pushUnpushedCommits,
+  findBestMatch,
+  sweepTasks
+};

package/dist/{chunk-CE323JHD.js → chunk-RIECV7SR.js}

@@ -1,6 +1,6 @@
 import {
   EXE_AI_DIR
-} from "./chunk-EKOWJXHN.js";
+} from "./chunk-QMSEL5YS.js";
 import {
   enforcePrivateFileSync,
   ensurePrivateDirSync

package/dist/{chunk-IANRPLHA.js → chunk-RLDMUSRM.js}

@@ -2,14 +2,14 @@ import {
   connectEmbedDaemon,
   disconnectClient,
   embedViaClient
-} from "./chunk-FXPWMPU2.js";
+} from "./chunk-BNHAZ65R.js";
 import {
   EMBEDDING_DIM
 } from "./chunk-FXU7JOXK.js";
 import {
   MODELS_DIR,
   loadConfigSync
-} from "./chunk-EKOWJXHN.js";
+} from "./chunk-QMSEL5YS.js";
 
 // src/lib/embedder.ts
 var MAX_EMBED_CHARS = 24e3;

package/dist/{chunk-LYXICKAH.js → chunk-SBJV2PCU.js}

@@ -1,6 +1,6 @@
 import {
   resolveDataDir
-} from "./chunk-EKOWJXHN.js";
+} from "./chunk-QMSEL5YS.js";
 
 // src/lib/postinstall-failure.ts
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";

package/dist/{chunk-U6E3CLKI.js → chunk-SFKIZYKK.js}

@@ -1,15 +1,15 @@
 import {
   PLATFORM_PROCEDURE_TITLES
-} from "./chunk-ZACPAM2C.js";
+} from "./chunk-HHGOCBVQ.js";
 import {
   isGhostBehaviorRow
-} from "./chunk-5G46JZTE.js";
+} from "./chunk-WBKIU6UJ.js";
 import {
   getClient,
   getIdentity,
   listIdentities,
   updateIdentity
-} from "./chunk-KAF66DIP.js";
+} from "./chunk-HSBKV5LB.js";
 import {
   atomicWriteJsonSync
 } from "./chunk-HSGBZSCA.js";

package/dist/{chunk-7JR2IRBY.js → chunk-TCR7NBHD.js}

@@ -1,20 +1,20 @@
 import {
   isExeSession,
   strictSessionScopeFilter
-} from "./chunk-ZVZEYHWY.js";
+} from "./chunk-QX33D4CH.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-4FNUBXYO.js";
+} from "./chunk-UI3K73LD.js";
 import {
   getProjectName
-} from "./chunk-OPU3NYOO.js";
+} from "./chunk-W2IRQJ6R.js";
 import {
   DEFAULT_COORDINATOR_TEMPLATE_NAME,
   getCoordinatorName
-} from "./chunk-KAF66DIP.js";
+} from "./chunk-HSBKV5LB.js";
 import {
   loadConfigSync
-} from "./chunk-EKOWJXHN.js";
+} from "./chunk-QMSEL5YS.js";
 
 // src/lib/review-polling.ts
 import { execSync } from "child_process";
@@ -260,7 +260,7 @@ function createRealDeps(getClient) {
       });
     },
     createReviewForOrphan: async (task) => {
-      const { createReviewForCompletedTask } = await import("./tasks-review-P7JTBLWK.js");
+      const { createReviewForCompletedTask } = await import("./tasks-review-4F6PZZ3B.js");
       const cwd = process.cwd();
       await createReviewForCompletedTask(
         task,

package/dist/{chunk-DVPBCGC2.js → chunk-TJSTWACD.js}

@@ -10,7 +10,7 @@ import {
 import {
   createCRMWebhookHandler,
   parseTwentyWebhook
-} from "./chunk-TLBAZU3V.js";
+} from "./chunk-EDZ5URGR.js";
 import {
   WhatsAppAdapter
 } from "./chunk-WSOA3WMC.js";
@@ -42,7 +42,7 @@ import {
   retryWithBackoff,
   routeMessage,
   validateGatewayConfig
-} from "./chunk-TOLJH6XP.js";
+} from "./chunk-R3H3WW7H.js";
 import {
   OllamaProvider
 } from "./chunk-FWFFZGSC.js";