@rallycry/conveyor-agent 7.3.4 → 7.3.6

package/dist/{chunk-TP5WEBQE.js → chunk-PC43BKMM.js}

@@ -641,8 +641,10 @@ var ModeController = class {
 // src/runner/lifecycle.ts
 var DEFAULT_LIFECYCLE_CONFIG = {
   idleTimeoutMs: 30 * 60 * 1e3,
+  dormantTimeoutMs: 60 * 60 * 1e3,
   heartbeatIntervalMs: 3e4,
-  tokenRefreshIntervalMs: 45 * 60 * 1e3
+  tokenRefreshIntervalMs: 45 * 60 * 1e3,
+  gitFlushIntervalMs: 2 * 60 * 1e3
 };
 var Lifecycle = class {
   config;
@@ -651,6 +653,8 @@ var Lifecycle = class {
   tokenRefreshTimer = null;
   idleTimer = null;
   idleCheckInterval = null;
+  dormantTimer = null;
+  gitFlushTimer = null;
   constructor(config, callbacks) {
     this.config = config;
     this.callbacks = callbacks;
@@ -682,6 +686,19 @@ var Lifecycle = class {
       this.tokenRefreshTimer = null;
     }
   }
+  // ── Periodic git flush ────────────────────────────────────────────
+  startGitFlush() {
+    this.stopGitFlush();
+    this.gitFlushTimer = setInterval(() => {
+      this.callbacks.onGitFlush();
+    }, this.config.gitFlushIntervalMs);
+  }
+  stopGitFlush() {
+    if (this.gitFlushTimer) {
+      clearInterval(this.gitFlushTimer);
+      this.gitFlushTimer = null;
+    }
+  }
   // ── Idle timer ─────────────────────────────────────────────────────
   startIdleTimer() {
     this.clearIdleTimers();
@@ -692,11 +709,34 @@ var Lifecycle = class {
   cancelIdleTimer() {
     this.clearIdleTimers();
   }
+  // ── Dormant timer ──────────────────────────────────────────────────
+  /** Start (or restart) the dormant timer.
+   *  @param overrideMs Optional custom delay in ms. When provided, the timer
+   *  fires after exactly that delay instead of `dormantTimeoutMs`. SessionRunner
+   *  uses this to enforce an *absolute* deadline across cycles: even if the
+   *  dormant wait is interrupted by an inbound message, the next iteration
+   *  passes the remaining time, so the agent shuts down at the original
+   *  deadline regardless of message volume. */
+  startDormantTimer(overrideMs) {
+    this.cancelDormantTimer();
+    const delay = Math.max(0, overrideMs ?? this.config.dormantTimeoutMs);
+    this.dormantTimer = setTimeout(() => {
+      this.callbacks.onDormantTimeout();
+    }, delay);
+  }
+  cancelDormantTimer() {
+    if (this.dormantTimer) {
+      clearTimeout(this.dormantTimer);
+      this.dormantTimer = null;
+    }
+  }
   // ── Cleanup ────────────────────────────────────────────────────────
   destroy() {
     this.stopHeartbeat();
     this.stopTokenRefresh();
+    this.stopGitFlush();
     this.clearIdleTimers();
+    this.cancelDormantTimer();
   }
   // ── Private ────────────────────────────────────────────────────────
   clearIdleTimers() {
@@ -1773,6 +1813,20 @@ function formatRepoRefs(repoRefs) {
   }
   return parts;
 }
+function formatReferenceProjects(referenceProjects) {
+  const parts = [];
+  parts.push(`
+## Reference Projects`);
+  parts.push(
+    `These sibling Conveyor projects have been shallow-cloned read-only into \`/workspaces/references/<slug>/\` for inspiration. You MAY grep/read them to compare approaches, but you MUST NOT modify them or commit anything from them into this task's repo.
+`
+  );
+  for (const ref of referenceProjects) {
+    const repo = ref.githubRepoOwner && ref.githubRepoName ? ` (${ref.githubRepoOwner}/${ref.githubRepoName})` : "";
+    parts.push(`- **${ref.name}**${repo} \u2014 \`/workspaces/references/${ref.slug}/\``);
+  }
+  return parts;
+}
 function formatProjectObjectives(objectives) {
   const parts = [];
   parts.push(`
@@ -2686,6 +2740,9 @@ ${truncatePlanForPrompt(context.plan)}`);
   if (context.repoRefs && context.repoRefs.length > 0) {
     parts.push(...formatRepoRefs(context.repoRefs));
   }
+  if (context.referenceProjects && context.referenceProjects.length > 0) {
+    parts.push(...formatReferenceProjects(context.referenceProjects));
+  }
   const tagSection = await resolveTaskTagContext(context, runnerMode);
   if (tagSection) parts.push(tagSection);
   if (runnerMode !== "task") {
@@ -6528,12 +6585,21 @@ var SessionRunner = class _SessionRunner {
   /** Defense-in-depth: set when the agent emits a "completed" event.
    *  Prevents the core loop from processing any further messages. */
   completedThisTurn = false;
+  /** Absolute deadline (ms epoch) at which the dormant idle wait must time
+   *  out. Set on the FIRST entry into dormant idle for a given completion
+   *  cycle and preserved across iterations so inbound critical messages
+   *  cannot extend the bound past the configured `dormantTimeoutMs`. Reset
+   *  to null when the agent transitions out of dormant idle (a wake actually
+   *  promotes it back to a working turn). */
+  dormantDeadline = null;
   taskContext = null;
   fullContext = null;
   queryBridge = null;
   inputResolver = null;
   pendingMessages = [];
   prNudgeCount = 0;
+  /** Guards overlapping runs of the periodic git flush. */
+  periodicFlushInFlight = false;
   constructor(config, callbacks) {
     this.config = config;
     this.callbacks = callbacks;
@@ -6552,7 +6618,17 @@ var SessionRunner = class _SessionRunner {
           resolver(null);
         }
       },
-      onTokenRefresh: () => void this.refreshGithubToken()
+      onDormantTimeout: () => {
+        process.stderr.write("[conveyor-agent] Dormant idle timeout reached, shutting down\n");
+        this.stopped = true;
+        if (this.inputResolver) {
+          const resolver = this.inputResolver;
+          this.inputResolver = null;
+          resolver(null);
+        }
+      },
+      onTokenRefresh: () => void this.refreshGithubToken(),
+      onGitFlush: () => void this.periodicGitFlush()
     });
   }
   get state() {
@@ -6578,6 +6654,7 @@ var SessionRunner = class _SessionRunner {
     this.wireConnectionCallbacks();
     this.lifecycle.startHeartbeat();
     this.lifecycle.startTokenRefresh();
+    this.lifecycle.startGitFlush();
     const { pendingMessages: serverMessages } = await this.connection.call("connectAgent", {
       sessionId: this.sessionId
     });
@@ -6667,16 +6744,8 @@ var SessionRunner = class _SessionRunner {
   async coreLoop() {
     while (!this.stopped) {
       if (this.completedThisTurn) {
-        process.stderr.write(
-          "[conveyor-agent] Completed \u2014 entering dormant idle (staying connected)\n"
-        );
-        this.pendingMessages.length = 0;
-        if (this._state !== "idle") await this.setState("idle");
-        const dormantMsg = await this.waitForMessage();
-        if (!dormantMsg) break;
-        process.stderr.write("[conveyor-agent] Received message while dormant, resuming\n");
-        this.completedThisTurn = false;
-        this.pendingMessages.unshift(dormantMsg);
+        const resumed = await this.handleDormantIdle();
+        if (!resumed) break;
         continue;
       }
       if (this._state === "idle") {
@@ -6730,6 +6799,41 @@ var SessionRunner = class _SessionRunner {
       }
     }
   }
+  /**
+   * Handle dormant-after-completed idle. Returns true if a critical message
+   * woke us (caller should `continue` the loop), false if we should break
+   * (stop signal or dormant timeout fired).
+   *
+   * The absolute deadline is set on first entry per completion cycle and
+   * preserved across re-entries: an inbound critical message cannot extend
+   * the bound past `dormantTimeoutMs`. Only a genuine wake (clearing
+   * `completedThisTurn`) resets the deadline so the next dormant entry
+   * starts a fresh window.
+   */
+  async handleDormantIdle() {
+    if (this.dormantDeadline === null) {
+      this.dormantDeadline = Date.now() + this.lifecycle.config.dormantTimeoutMs;
+      process.stderr.write(
+        "[conveyor-agent] Completed \u2014 entering dormant idle (staying connected)\n"
+      );
+    }
+    this.pendingMessages.length = 0;
+    if (this._state !== "idle") await this.setState("idle");
+    const remainingMs = Math.max(0, this.dormantDeadline - Date.now());
+    this.lifecycle.startDormantTimer(remainingMs);
+    const dormantMsg = await this.waitForMessage();
+    this.lifecycle.cancelDormantTimer();
+    if (!dormantMsg) return false;
+    const contentPreview = dormantMsg.content.length > 80 ? `${dormantMsg.content.slice(0, 80)}...` : dormantMsg.content;
+    process.stderr.write(
+      `[conveyor-agent] Received message while dormant, resuming: userId=${dormantMsg.userId}, source=${dormantMsg.source || "unknown"}, content="${contentPreview.replace(/\n/g, "\\n")}"
+`
+    );
+    this.completedThisTurn = false;
+    this.dormantDeadline = null;
+    this.pendingMessages.unshift(dormantMsg);
+    return true;
+  }
   // ── Initial mode execution ─────────────────────────────────────────
   /** Returns true if an initial query was executed, false otherwise. */
   async executeInitialMode() {
@@ -6783,6 +6887,38 @@ var SessionRunner = class _SessionRunner {
     }
   }
   // ── Stop / soft-stop ───────────────────────────────────────────────
+  /** Periodic best-effort WIP commit + push during normal agent execution.
+   *  Covers ungraceful pod termination (OOMKilled, node crash/eviction) where
+   *  the preStop hook + SIGTERM flush don't get a chance to run. No-ops on a
+   *  clean tree. Guarded so two ticks can't overlap. Never throws. */
+  async periodicGitFlush() {
+    if (this.periodicFlushInFlight || this.stopped) return;
+    this.periodicFlushInFlight = true;
+    try {
+      const result = await flushPendingChanges(this.config.workspaceDir, {
+        wipMessage: "WIP: periodic auto-commit",
+        refreshToken: async () => {
+          try {
+            const res = await this.connection.call("refreshGithubToken", {
+              sessionId: this.connection.sessionId
+            });
+            return res.token;
+          } catch {
+            return void 0;
+          }
+        }
+      });
+      if (result.hadWork) {
+        process.stderr.write(
+          `[conveyor-agent] Periodic git flush: committed=${result.committed} pushed=${result.pushed}
+`
+        );
+      }
+    } catch {
+    } finally {
+      this.periodicFlushInFlight = false;
+    }
+  }
   /** Best-effort WIP commit + push on shutdown so in-flight work isn't lost
    *  when a claudespace pod is killed. Must be called BEFORE stop() so the
    *  connection is still alive for token refresh. Never throws. */
@@ -6944,6 +7080,7 @@ var SessionRunner = class _SessionRunner {
         onEvent: (event) => {
           if (event.type === "completed") {
             this.completedThisTurn = true;
+            void this.connection.sendHeartbeat();
           }
           return this.callbacks.onEvent(event);
         }
@@ -7080,23 +7217,30 @@ var SessionRunner = class _SessionRunner {
   get finalState() {
     return this._finalState;
   }
-  logInitialization() {
-    const context = {
-      mode: this.mode.effectiveMode,
-      runnerMode: this.config.runnerMode ?? "task",
-      sessionId: this.sessionId,
-      // Task context
+  buildTaskContextSnapshot() {
+    return {
       isParentTask: this.fullContext?.isParentTask ?? false,
       status: this.taskContext?.status,
       taskTitle: this.fullContext?.title,
       hasExistingPR: !!this.fullContext?.githubPRUrl,
       hasExistingSession: !!this.fullContext?.claudeSessionId,
       chatHistoryLength: this.fullContext?.chatHistory?.length ?? 0,
-      tagIds: this.fullContext?.taskTagIds ?? [],
-      // Agent config
+      tagIds: this.fullContext?.taskTagIds ?? []
+    };
+  }
+  buildInitializationContext() {
+    return {
+      mode: this.mode.effectiveMode,
+      runnerMode: this.config.runnerMode ?? "task",
+      sessionId: this.sessionId,
+      ...this.buildTaskContextSnapshot(),
       model: this.taskContext?.model,
-      isAuto: this.config.isAuto ?? false
+      isAuto: this.config.isAuto ?? false,
+      subscriptionKeyLabel: process.env.CONVEYOR_SUBSCRIPTION_KEY_LABEL ?? null
     };
+  }
+  logInitialization() {
+    const context = this.buildInitializationContext();
     process.stderr.write(`[conveyor-agent] Initialized: ${JSON.stringify(context)}
 `);
     this.connection.sendEvent({ type: "session_manifest", ...context });
@@ -8586,15 +8730,38 @@ var ProjectRunner = class {
 import { readFile as readFile2 } from "fs/promises";
 import { join as join5 } from "path";
 var DEVCONTAINER_PATH = ".devcontainer/conveyor/devcontainer.json";
+var DEVCONTAINER_PORT_DENY_LIST = /* @__PURE__ */ new Set([5432, 6379, 9200]);
 async function loadForwardPorts(workspaceDir) {
   try {
     const raw = await readFile2(join5(workspaceDir, DEVCONTAINER_PATH), "utf-8");
     const parsed = JSON.parse(raw);
-    return parsed.forwardPorts ?? [];
+    const ports = (parsed.forwardPorts ?? []).filter(
+      (p) => typeof p === "number" && !DEVCONTAINER_PORT_DENY_LIST.has(p)
+    );
+    const attributes = {};
+    for (const [key, value] of Object.entries(parsed.portsAttributes ?? {})) {
+      if (!value || typeof value !== "object") continue;
+      const entry = {};
+      if (typeof value.label === "string") entry.label = value.label;
+      if (value.visibility === "public" || value.visibility === "private") {
+        entry.visibility = value.visibility;
+      }
+      attributes[key] = entry;
+    }
+    return { ports, attributes };
   } catch {
-    return [];
+    return { ports: [], attributes: {} };
   }
 }
+function buildSessionPreviewPorts(result) {
+  return result.ports.filter((port) => !DEVCONTAINER_PORT_DENY_LIST.has(port)).map((port) => {
+    const attr = result.attributes[String(port)];
+    const entry = { port };
+    if (attr?.label) entry.label = attr.label;
+    if (attr?.visibility) entry.visibility = attr.visibility;
+    return entry;
+  });
+}
 function loadConveyorConfig() {
   const envSetup = process.env.CONVEYOR_SETUP_COMMAND;
   const envStart = process.env.CONVEYOR_START_COMMAND;
@@ -8634,6 +8801,7 @@ export {
   runStartCommand,
   ProjectRunner,
   loadForwardPorts,
+  buildSessionPreviewPorts,
   loadConveyorConfig
 };
-//# sourceMappingURL=chunk-TP5WEBQE.js.map
+//# sourceMappingURL=chunk-PC43BKMM.js.map