@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-6E25C4IA.js

@@ -0,0 +1,269 @@
+import {
+  extractRequestedVerification,
+  hasExplicitVerificationIntent
+} from "./chunk-NMVZ5YES.js";
+import {
+  NON_BLOCKING_QUALITY_GATE_SKIP_MARKERS
+} from "./chunk-QOFLUS24.js";
+import {
+  parseSimpleArtifactGoal
+} from "./chunk-QXBKIHY7.js";
+import {
+  classifyExplicitNoEdit
+} from "./chunk-PPHXX4W7.js";
+
+// src/core/loop/autoloop-gate-policy.ts
+var DEFAULT_AUTOLOOP_QUALITY_GATES_MODE = "fast";
+var NO_COMMANDS_DETECTED_REASON = "no verification commands detected for this project";
+function analyzeAutoloopTaskIntent(taskDescription) {
+  const explicitVerificationCommands = extractRequestedVerification(taskDescription);
+  return {
+    readOnlyAutoloopIntent: classifyExplicitNoEdit(taskDescription),
+    simpleArtifactGoal: parseSimpleArtifactGoal(taskDescription),
+    explicitVerificationCommands,
+    explicitVerificationIntent: hasExplicitVerificationIntent(taskDescription) || explicitVerificationCommands.length > 0
+  };
+}
+function formatUnsatisfiedInstallSuffix(unsatisfiedInstalls) {
+  if (unsatisfiedInstalls.length === 0) return "";
+  const installs = unsatisfiedInstalls.map((requirement) => `run ${requirement.installCommand}`);
+  return `; dependencies not installed: ${installs.join(", ")}`;
+}
+function suppressInferredQualityGatesForSimpleArtifact(intent, options) {
+  return !options.runQualityGates && intent.simpleArtifactGoal !== void 0 && !intent.explicitVerificationIntent;
+}
+function shouldAutoDetectAutoloopQualityGates(intent, options) {
+  return !options.disableQualityGates && !options.runQualityGates && !intent.readOnlyAutoloopIntent && !suppressInferredQualityGatesForSimpleArtifact(intent, options);
+}
+function resolveAutoloopGatePolicy(input) {
+  const { intent, options, corePatch, autoGates } = input;
+  const notes = [];
+  const suppressForSimpleArtifact = suppressInferredQualityGatesForSimpleArtifact(intent, options);
+  const detectedCommands = autoGates?.detectedCommands ?? [];
+  const unsatisfiedInstalls = autoGates?.unsatisfiedInstalls ?? [];
+  const installSuffix = formatUnsatisfiedInstallSuffix(unsatisfiedInstalls);
+  let runQualityGates = options.runQualityGates ?? false;
+  let qualityGatesMode = options.qualityGatesMode;
+  let statusReason;
+  if (shouldAutoDetectAutoloopQualityGates(intent, options)) {
+    if (autoGates?.enabled) {
+      runQualityGates = true;
+      qualityGatesMode = options.qualityGatesMode ?? input.defaultQualityGatesMode ?? autoGates.mode ?? DEFAULT_AUTOLOOP_QUALITY_GATES_MODE;
+      statusReason = "auto-enabled from detected verification commands";
+      notes.push({
+        tone: "info",
+        message: detectedCommands.length > 0 ? `Quality gates auto-enabled (detected verification commands: ${detectedCommands.join(", ")}${installSuffix})` : `Quality gates auto-enabled (detected verification commands${installSuffix})`
+      });
+    } else {
+      statusReason = NO_COMMANDS_DETECTED_REASON;
+      notes.push({
+        tone: "detail",
+        message: `Quality gates not auto-enabled (${NO_COMMANDS_DETECTED_REASON})`
+      });
+    }
+  } else if (intent.readOnlyAutoloopIntent && !options.disableQualityGates && !options.runQualityGates) {
+    runQualityGates = false;
+    statusReason = "explicit no-edit intent";
+    notes.push({
+      tone: "detail",
+      message: "Quality gates not auto-enabled (explicit no-edit intent)"
+    });
+  } else if (suppressForSimpleArtifact && !options.disableQualityGates) {
+    runQualityGates = false;
+    statusReason = "simple artifact task";
+    notes.push({
+      tone: "detail",
+      message: "Quality gates not auto-enabled (simple artifact task)"
+    });
+  } else if (options.disableQualityGates) {
+    runQualityGates = false;
+    statusReason = "explicit --autoloop-no-quality-gates";
+    notes.push({ tone: "detail", message: "Quality gates explicitly disabled" });
+  }
+  if (runQualityGates && !qualityGatesMode) {
+    qualityGatesMode = input.defaultQualityGatesMode ?? DEFAULT_AUTOLOOP_QUALITY_GATES_MODE;
+  }
+  let validationMode = options.validationMode ?? input.defaultValidationMode;
+  if (corePatch?.validationMode && options.validationMode === void 0) {
+    validationMode = corePatch.validationMode;
+  }
+  if (intent.simpleArtifactGoal !== void 0 && options.validationMode === void 0 && !intent.explicitVerificationIntent) {
+    validationMode = "none";
+  }
+  if (!options.disableQualityGates && intent.explicitVerificationIntent && intent.explicitVerificationCommands.length > 0) {
+    runQualityGates = true;
+    statusReason = "verification commands named in the task prompt";
+    if (!qualityGatesMode) {
+      qualityGatesMode = input.defaultQualityGatesMode ?? DEFAULT_AUTOLOOP_QUALITY_GATES_MODE;
+    }
+  }
+  const useAIJudge = options.useAIJudge ?? false;
+  if (validationMode === "deterministic" && !qualityGatesMode && runQualityGates) {
+    qualityGatesMode = "fast";
+    notes.push({
+      tone: "info",
+      message: 'Quality gates mode defaulted to "fast" for deterministic validation'
+    });
+  }
+  return {
+    runQualityGates,
+    qualityGatePolicy: runQualityGates ? "enabled" : options.disableQualityGates === true ? "explicitly_disabled" : "not_configured",
+    qualityGatesMode,
+    validationMode,
+    useAIJudge,
+    suppressInferredQualityGatesForSimpleArtifact: suppressForSimpleArtifact,
+    deterministicConflict: validationMode === "deterministic" && !runQualityGates,
+    stopOnUnconfirmableCompletion: options.disableQualityGates === true && intent.simpleArtifactGoal === void 0,
+    rediscoverQualityGates: shouldAutoDetectAutoloopQualityGates(intent, options) && !runQualityGates,
+    qualityGatesStatus: {
+      state: runQualityGates ? "on" : options.disableQualityGates === true ? "off" : "auto-off",
+      reason: statusReason ?? (runQualityGates ? "explicit --autoloop-quality-gates" : "quality gates not configured"),
+      detectedCommands,
+      ...autoGates?.notRunByMode?.length ? { notRunByMode: autoGates.notRunByMode } : {},
+      unsatisfiedInstalls
+    },
+    notes
+  };
+}
+function formatNotRunSuffix(mode, notRunByMode, hostGateCommands) {
+  const notRun = notRunByMode.filter((command) => !hostGateCommands.includes(command));
+  return notRun.length > 0 ? `; not run in ${mode} mode: ${notRun.join(", ")}` : "";
+}
+function formatAutoloopQualityGatesStatusLine(resolution, hostGateCommands = []) {
+  const status = resolution.qualityGatesStatus;
+  if (status.state !== "on") {
+    return `Quality gates: off (${status.reason})`;
+  }
+  const mode = resolution.qualityGatesMode ?? DEFAULT_AUTOLOOP_QUALITY_GATES_MODE;
+  const detected = status.detectedCommands.length > 0 ? `; detected: ${status.detectedCommands.join(", ")}` : "";
+  const notRun = formatNotRunSuffix(mode, status.notRunByMode ?? [], hostGateCommands);
+  const installs = formatUnsatisfiedInstallSuffix(status.unsatisfiedInstalls);
+  return `Quality gates: on (${mode}${detected}${notRun}${installs})`;
+}
+function formatRediscoveredQualityGatesLine(input) {
+  const detected = input.detectedCommands.length > 0 ? `: ${input.detectedCommands.join(", ")}` : "";
+  const notRun = formatNotRunSuffix(input.mode, input.notRunCommands ?? [], []);
+  return `Quality gates: on (${input.mode}; detected after iteration ${input.iteration}${detected}${notRun})`;
+}
+var NO_OP_WITH_PASSING_GATES_DETAIL = "no_op_with_passing_gates";
+var DUPLICATE_CHANGE_WITH_PASSING_GATES_DETAIL = "duplicate_change_with_passing_gates";
+var PASSING_GATES_RESCUABLE_TERMINATION_CODES = /* @__PURE__ */ new Set([
+  "no_op_loop",
+  "duplicate_change_loop"
+]);
+function iterationIsSubstantive(input) {
+  if (typeof input.completeness === "number" && input.completeness > 0) {
+    return true;
+  }
+  return (input.changedFiles?.length ?? 0) > 0;
+}
+function isNonBlockingGateSkip(gate) {
+  if (gate.unavailable === true) return true;
+  const details = (gate.details ?? "").toLowerCase();
+  return NON_BLOCKING_QUALITY_GATE_SKIP_MARKERS.some((marker) => details.includes(marker));
+}
+function iterationPassedAllEnabledChecks(iteration, enabled) {
+  if (!iteration.success) {
+    return false;
+  }
+  let executedPassingGate = false;
+  if (enabled.qualityGates) {
+    const gates = iteration.qualityGates;
+    if (!gates || gates.length === 0) {
+      return false;
+    }
+    for (const gate of gates) {
+      if (gate.skipped === true) {
+        if (isNonBlockingGateSkip(gate)) {
+          continue;
+        }
+        return false;
+      }
+      if (gate.passed) {
+        executedPassingGate = true;
+        continue;
+      }
+      if (gate.isRegression === false) {
+        continue;
+      }
+      return false;
+    }
+  }
+  if (enabled.customGates) {
+    const customGates = iteration.customGateResults;
+    if (!customGates || customGates.length === 0) {
+      return false;
+    }
+    for (const gate of customGates) {
+      if (gate.skipped === true) {
+        return false;
+      }
+      if (gate.passed) {
+        executedPassingGate = true;
+        continue;
+      }
+      if (gate.isRegression !== false) {
+        return false;
+      }
+    }
+  }
+  if (!executedPassingGate) {
+    return false;
+  }
+  if (iteration.requirements?.enabled && !iteration.requirements.passed) {
+    return false;
+  }
+  return true;
+}
+function findMostRecentSubstantiveIteration(iterations) {
+  for (let index = iterations.length - 1; index >= 0; index -= 1) {
+    const iteration = iterations[index];
+    if (iteration?.substantive) {
+      return iteration;
+    }
+  }
+  return void 0;
+}
+function priorIterationVerified(iterations, enabled) {
+  if (!enabled.qualityGates && !enabled.customGates) {
+    return false;
+  }
+  const latest = iterations.at(-1);
+  return latest?.substantive === true && iterationPassedAllEnabledChecks(latest, enabled);
+}
+function resolveNoOpWithPassingGatesTermination(input) {
+  if (input.noOpTerminationCode === null || !PASSING_GATES_RESCUABLE_TERMINATION_CODES.has(input.noOpTerminationCode)) {
+    return { kind: "failure" };
+  }
+  if (!input.enabled.qualityGates && !input.enabled.customGates) {
+    return { kind: "failure" };
+  }
+  const substantive = findMostRecentSubstantiveIteration(input.iterations);
+  if (!substantive || !iterationPassedAllEnabledChecks(substantive, input.enabled)) {
+    return { kind: "failure" };
+  }
+  const detail = input.noOpTerminationCode === "duplicate_change_loop" ? DUPLICATE_CHANGE_WITH_PASSING_GATES_DETAIL : NO_OP_WITH_PASSING_GATES_DETAIL;
+  return {
+    kind: "success",
+    reason: "deterministic_complete",
+    detail
+  };
+}
+
+export {
+  DEFAULT_AUTOLOOP_QUALITY_GATES_MODE,
+  analyzeAutoloopTaskIntent,
+  suppressInferredQualityGatesForSimpleArtifact,
+  shouldAutoDetectAutoloopQualityGates,
+  resolveAutoloopGatePolicy,
+  formatAutoloopQualityGatesStatusLine,
+  formatRediscoveredQualityGatesLine,
+  NO_OP_WITH_PASSING_GATES_DETAIL,
+  DUPLICATE_CHANGE_WITH_PASSING_GATES_DETAIL,
+  iterationIsSubstantive,
+  iterationPassedAllEnabledChecks,
+  findMostRecentSubstantiveIteration,
+  priorIterationVerified,
+  resolveNoOpWithPassingGatesTermination
+};
+//# sourceMappingURL=chunk-6E25C4IA.js.map

package/dist/chunk-6FIBNIQU.js

@@ -0,0 +1,73 @@
+import {
+  BUILD_AUTOLOOP_COMPLETION_SIGNAL,
+  BUILD_AUTOLOOP_QUALITY_GATES_MODE,
+  BUILD_AUTOLOOP_TIMEBOX,
+  BUILD_AUTOLOOP_TIMEBOX_MS,
+  BUILD_AUTOLOOP_VALIDATION,
+  readEnv,
+  readRawEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/orchestrator/autoloop-run-defaults.ts
+var DEFAULT_AUTOLOOP_VALIDATION_MODE = "heuristic";
+var DEFAULT_AUTOLOOP_TIMEBOX_MS = 36e5;
+var VALIDATION_MODES = ["heuristic", "none", "deterministic"];
+function isValidationMode(value) {
+  return value !== void 0 && VALIDATION_MODES.includes(value);
+}
+function resolveAutoloopValidationSelection(explicit, envRaw) {
+  if (isValidationMode(explicit ?? void 0)) {
+    return explicit;
+  }
+  const fromEnv = envRaw ?? readRawEnv(BUILD_AUTOLOOP_VALIDATION);
+  return isValidationMode(fromEnv) ? fromEnv : void 0;
+}
+function resolveAutoloopValidationMode(explicit, envRaw) {
+  return resolveAutoloopValidationSelection(explicit, envRaw) ?? DEFAULT_AUTOLOOP_VALIDATION_MODE;
+}
+var QUALITY_GATES_MODES = ["full", "safe", "fast"];
+function resolveAutoloopEnvQualityGatesMode() {
+  const raw = readRawEnv(BUILD_AUTOLOOP_QUALITY_GATES_MODE);
+  return QUALITY_GATES_MODES.includes(raw) ? raw : void 0;
+}
+function resolveAutoloopCompletionSignal(explicit) {
+  return explicit || readEnv(BUILD_AUTOLOOP_COMPLETION_SIGNAL).value || void 0;
+}
+function resolveAutoloopTimeboxMs(explicitMs) {
+  if (explicitMs != null && Number.isFinite(explicitMs) && explicitMs > 0) {
+    return explicitMs;
+  }
+  const rawValues = [readRawEnv(BUILD_AUTOLOOP_TIMEBOX_MS), readRawEnv(BUILD_AUTOLOOP_TIMEBOX)];
+  for (const raw of rawValues) {
+    if (raw === void 0 || raw === "") continue;
+    const fromEnv = Number(raw);
+    if (Number.isFinite(fromEnv) && fromEnv > 0) {
+      return fromEnv;
+    }
+  }
+  return DEFAULT_AUTOLOOP_TIMEBOX_MS;
+}
+var AUTOLOOP_TIMEBOX_ENV_MIN_PLAUSIBLE_MS = 6e4;
+function checkAutoloopTimeboxEnvUnit(rawEnvValue, envVarName = "BUILD_AUTOLOOP_TIMEBOX") {
+  if (rawEnvValue === void 0 || rawEnvValue === "") return null;
+  const parsed = Number(rawEnvValue);
+  if (!Number.isFinite(parsed) || parsed <= 0) return null;
+  if (parsed < AUTOLOOP_TIMEBOX_ENV_MIN_PLAUSIBLE_MS) {
+    const correctedMs = Math.round(parsed * 6e4);
+    return `Warning: ${envVarName}=${rawEnvValue} is less than 60 000 ms (1 minute). The env var is in milliseconds, not minutes. If you meant ${rawEnvValue} minutes, set ${envVarName}=${correctedMs}.`;
+  }
+  return null;
+}
+
+export {
+  DEFAULT_AUTOLOOP_VALIDATION_MODE,
+  DEFAULT_AUTOLOOP_TIMEBOX_MS,
+  resolveAutoloopValidationSelection,
+  resolveAutoloopValidationMode,
+  resolveAutoloopEnvQualityGatesMode,
+  resolveAutoloopCompletionSignal,
+  resolveAutoloopTimeboxMs,
+  AUTOLOOP_TIMEBOX_ENV_MIN_PLAUSIBLE_MS,
+  checkAutoloopTimeboxEnvUnit
+};
+//# sourceMappingURL=chunk-6FIBNIQU.js.map

package/dist/chunk-6G57FYBV.js

@@ -0,0 +1,189 @@
+import {
+  parseHumanOwnerId
+} from "./chunk-7KBEOPVB.js";
+
+// src/planning/coordination/lease.ts
+var DEFAULT_LEASE_TTL_MS = 15 * 60 * 1e3;
+var DEFAULT_GRACE_MS = 5 * 60 * 1e3;
+function isExpiryLive(expiresAtIso, nowIso) {
+  if (!expiresAtIso) return false;
+  const expiryMs = Date.parse(expiresAtIso);
+  const nowMs = Date.parse(nowIso);
+  if (Number.isNaN(expiryMs) || Number.isNaN(nowMs)) return false;
+  return expiryMs > nowMs;
+}
+function isWorkOwnershipLeaseLive(lease, nowIso) {
+  if (lease.expiresAt) {
+    return isExpiryLive(lease.expiresAt, nowIso);
+  }
+  const heartbeatMs = Date.parse(lease.lastHeartbeatAt);
+  const nowMs = Date.parse(nowIso);
+  if (Number.isNaN(heartbeatMs) || Number.isNaN(nowMs)) {
+    return false;
+  }
+  const effectiveGrace = lease.grace ?? DEFAULT_GRACE_MS;
+  return heartbeatMs + lease.ttlMs + effectiveGrace > nowMs;
+}
+
+// src/planning/work-ownership.ts
+var DEFAULT_WORK_OWNERSHIP_TTL_MS = 4 * 60 * 60 * 1e3;
+function parseLease(value) {
+  if (value == null || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const record = value;
+  const acquiredAt = typeof record.acquiredAt === "string" ? record.acquiredAt.trim() : "";
+  const lastHeartbeatAt = typeof record.lastHeartbeatAt === "string" ? record.lastHeartbeatAt.trim() : "";
+  const ttlMs = typeof record.ttlMs === "number" && Number.isFinite(record.ttlMs) && record.ttlMs > 0 ? record.ttlMs : void 0;
+  if (!acquiredAt || !lastHeartbeatAt || ttlMs === void 0) {
+    return void 0;
+  }
+  const lease = { acquiredAt, ttlMs, lastHeartbeatAt };
+  if (typeof record.expiresAt === "string" && record.expiresAt.trim()) {
+    lease.expiresAt = record.expiresAt.trim();
+  }
+  if (typeof record.grace === "number" && Number.isFinite(record.grace) && record.grace >= 0) {
+    lease.grace = record.grace;
+  }
+  return lease;
+}
+function parseWorkOwnership(value) {
+  if (value == null || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const record = value;
+  const id = typeof record.id === "string" ? record.id.trim() : "";
+  if (!id) {
+    return void 0;
+  }
+  if (record.kind === "human") {
+    return { kind: "human", id };
+  }
+  if (record.kind === "agent") {
+    const lease = parseLease(record.lease);
+    return lease ? { kind: "agent", id, lease } : { kind: "agent", id };
+  }
+  return void 0;
+}
+function projectWorkOwnership(ownership, assignee) {
+  const parsed = parseWorkOwnership(ownership);
+  if (parsed) {
+    return parsed;
+  }
+  const legacy = typeof assignee === "string" ? assignee.trim() : "";
+  return legacy ? { kind: "human", id: legacy } : null;
+}
+function legacyAssigneeValue(ownership, assignee) {
+  if (ownership) {
+    return ownership.id;
+  }
+  const stored = typeof assignee === "string" ? assignee.trim() : "";
+  return stored || null;
+}
+function isWorkOwnershipLive(ownership, nowIso) {
+  if (ownership.kind === "human") {
+    return true;
+  }
+  if (!ownership.lease) {
+    return true;
+  }
+  return isWorkOwnershipLeaseLive(ownership.lease, nowIso);
+}
+function ownershipForWrite(value) {
+  return parseWorkOwnership(value);
+}
+function normalizeClaimant(actor) {
+  if (actor.kind === "human") {
+    const id2 = parseHumanOwnerId(actor.id);
+    return id2 ? { kind: "human", id: id2 } : null;
+  }
+  const id = actor.id.trim();
+  if (!id) {
+    return null;
+  }
+  return {
+    kind: "agent",
+    id,
+    ...typeof actor.ttlMs === "number" && Number.isFinite(actor.ttlMs) && actor.ttlMs > 0 ? { ttlMs: actor.ttlMs } : {},
+    ...typeof actor.grace === "number" && Number.isFinite(actor.grace) && actor.grace >= 0 ? { grace: actor.grace } : {}
+  };
+}
+function sameWorkOwner(ownership, actor) {
+  const claimant = normalizeClaimant(actor);
+  if (!claimant) {
+    return false;
+  }
+  return ownership.kind === claimant.kind && ownership.id === claimant.id;
+}
+function buildOwnership(actor, nowIso, previous) {
+  if (actor.kind === "human") {
+    return { kind: "human", id: actor.id };
+  }
+  const ttlMs = actor.ttlMs ?? DEFAULT_WORK_OWNERSHIP_TTL_MS;
+  const sameAgent = previous?.kind === "agent" && previous.id === actor.id ? previous : null;
+  const lease = {
+    acquiredAt: sameAgent?.lease?.acquiredAt ?? nowIso,
+    ttlMs,
+    lastHeartbeatAt: nowIso
+  };
+  if (actor.grace !== void 0) {
+    lease.grace = actor.grace;
+  } else if (sameAgent?.lease?.grace !== void 0) {
+    lease.grace = sameAgent.lease.grace;
+  }
+  const nowMs = Date.parse(nowIso);
+  if (Number.isFinite(nowMs)) {
+    lease.expiresAt = new Date(nowMs + ttlMs).toISOString();
+  }
+  return { kind: "agent", id: actor.id, lease };
+}
+function claimWorkOwnership(current, actor, nowIso) {
+  const claimant = normalizeClaimant(actor);
+  if (!claimant) {
+    return { ok: false, reason: "invalid-actor" };
+  }
+  if (current && isWorkOwnershipLive(current, nowIso) && !sameWorkOwner(current, claimant)) {
+    return { ok: false, reason: "contended" };
+  }
+  return { ok: true, ownership: buildOwnership(claimant, nowIso, current) };
+}
+function releaseWorkOwnership(current, actor, _nowIso) {
+  const claimant = normalizeClaimant(actor);
+  if (!claimant) {
+    return { ok: false, reason: "invalid-actor" };
+  }
+  if (!current) {
+    return { ok: true, ownership: null };
+  }
+  if (!sameWorkOwner(current, claimant)) {
+    return { ok: false, reason: "not-owner" };
+  }
+  return { ok: true, ownership: null };
+}
+function transferWorkOwnership(current, from, to, nowIso) {
+  const source = normalizeClaimant(from);
+  const destination = normalizeClaimant(to);
+  if (!source || !destination) {
+    return { ok: false, reason: "invalid-actor" };
+  }
+  if (!current) {
+    return { ok: false, reason: "unassigned" };
+  }
+  if (!sameWorkOwner(current, source)) {
+    return { ok: false, reason: "not-owner" };
+  }
+  const previous = sameWorkOwner(current, destination) ? current : null;
+  return { ok: true, ownership: buildOwnership(destination, nowIso, previous) };
+}
+
+export {
+  isExpiryLive,
+  parseWorkOwnership,
+  projectWorkOwnership,
+  legacyAssigneeValue,
+  ownershipForWrite,
+  claimWorkOwnership,
+  releaseWorkOwnership,
+  transferWorkOwnership
+};
+//# sourceMappingURL=chunk-6G57FYBV.js.map