@rallycry/conveyor-agent 10.9.0 → 10.11.0

package/dist/cli.js

@@ -16,6 +16,7 @@ import {
   buildSessionPreviewPorts,
   cleanTerminalOutput,
   createServiceLogger,
+  defineTool,
   fetchBootstrap,
   findOnPath,
   inheritedEnv,
@@ -27,8 +28,9 @@ import {
   runSetupCommand,
   runStartCommand,
   sampleKeyUsage,
-  terminateProcessGroup
-} from "./chunk-H3OGNJS4.js";
+  terminateProcessGroup,
+  textResult
+} from "./chunk-KEKGEDN2.js";
 import "./chunk-7TQO4ZF4.js";
 
 // src/cli.ts
@@ -43,7 +45,7 @@ import { dirname } from "path";
 var POSTGRES_TIMEOUT_MS = 12e4;
 var FIREBASE_TIMEOUT_MS = 6e4;
 var FALLBACK_TIMEOUT_MS = 3e4;
-var DEFAULT_POLL_INTERVAL_MS = 1e3;
+var DEFAULT_SIDECAR_POLL_INTERVAL_MS = 1e3;
 var DEFAULT_PROBE_TIMEOUT_MS = 2e3;
 var POSTGRES_DEFAULT_PORT = 5432;
 var FIREBASE_DEFAULT_PORT = 9099;
@@ -187,7 +189,7 @@ async function waitForSidecars(opts = {}) {
     onLog = () => {
     },
     timeoutMs,
-    pollIntervalMs = DEFAULT_POLL_INTERVAL_MS,
+    pollIntervalMs = DEFAULT_SIDECAR_POLL_INTERVAL_MS,
     probe = defaultProbe,
     startLazy = true,
     signal
@@ -824,8 +826,277 @@ function resolveTuiAdapter(kind = "claude-code") {
   }
 }
 
+// src/tools/project-tools.ts
+import { z } from "zod";
+var CONTEXT_PATH_SHAPE = z.object({
+  type: z.enum(["rule", "doc", "file", "folder"]).describe("Link kind"),
+  path: z.string().min(1).max(500).describe("Repo-relative path"),
+  label: z.string().max(100).optional()
+});
+function errText(prefix, error) {
+  return textResult(`${prefix}: ${error instanceof Error ? error.message : "Unknown error"}`);
+}
+function buildListTagsTool(connection, projectId) {
+  return defineTool(
+    "list_tags",
+    "List this project's tags (id, name, color). Use the ids with update_tag.",
+    {},
+    async () => {
+      try {
+        const tags = await connection.call("listProjectTags", { projectId });
+        return textResult(JSON.stringify(tags, null, 2));
+      } catch (error) {
+        return errText("Failed to list tags", error);
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildCreateTagTool(connection, projectId) {
+  return defineTool(
+    "create_tag",
+    "Create a project tag. Include a crisp description and contextPaths (rule/doc/file/folder links agents auto-load when working on matching tasks). Fails if the name already exists.",
+    {
+      name: z.string().min(1).max(50),
+      color: z.string().regex(/^#[0-9a-fA-F]{6}$/).optional().describe("#RRGGBB (default gray)"),
+      description: z.string().max(500).optional(),
+      contextPaths: z.array(CONTEXT_PATH_SHAPE).max(20).optional()
+    },
+    async ({ name, color, description, contextPaths }) => {
+      try {
+        const result = await connection.call("createProjectTag", {
+          projectId,
+          name,
+          color,
+          description,
+          contextPaths
+        });
+        return textResult(`Tag created: ${result.id}`);
+      } catch (error) {
+        return errText("Failed to create tag", error);
+      }
+    }
+  );
+}
+function buildUpdateTagTool(connection, projectId) {
+  return defineTool(
+    "update_tag",
+    "Update a tag's name, color, description, or contextPaths. contextPaths is a FULL replacement \u2014 include existing links you want to keep. Verify paths exist in the repo first.",
+    {
+      tagId: z.string().describe("Tag id from list_tags"),
+      name: z.string().min(1).max(50).optional(),
+      color: z.string().regex(/^#[0-9a-fA-F]{6}$/).optional(),
+      description: z.string().max(500).optional(),
+      contextPaths: z.array(CONTEXT_PATH_SHAPE).max(20).optional()
+    },
+    async ({ tagId, name, color, description, contextPaths }) => {
+      try {
+        await connection.call("updateProjectTag", {
+          projectId,
+          tagId,
+          name,
+          color,
+          description,
+          contextPaths
+        });
+        return textResult(`Tag updated: ${tagId}`);
+      } catch (error) {
+        return errText("Failed to update tag", error);
+      }
+    }
+  );
+}
+function buildCreateSuggestionTool(connection, projectId) {
+  return defineTool(
+    "create_suggestion",
+    "File a project suggestion (idea/improvement for maintainers to review). Duplicates are AI-deduped into an existing suggestion with an upvote. Returns the suggestion id.",
+    {
+      title: z.string().min(1).describe("Short title"),
+      description: z.string().optional().describe("1-3 sentences: what should change and why"),
+      tag_names: z.array(z.string()).optional().describe("Tag names to categorize")
+    },
+    async ({ title, description, tag_names }) => {
+      try {
+        const result = await connection.call("createProjectSuggestion", {
+          projectId,
+          title,
+          description,
+          tagNames: tag_names
+        });
+        return textResult(
+          result.merged ? `Merged into existing suggestion ${result.mergedIntoId ?? result.id} (id: ${result.id})` : `Suggestion created: ${result.id}`
+        );
+      } catch (error) {
+        return errText("Failed to create suggestion", error);
+      }
+    }
+  );
+}
+function buildPostToProjectChatTool(connection, projectId) {
+  return defineTool(
+    "post_to_project_chat",
+    "Post a markdown message to the PROJECT chat \u2014 use once at the end of an audit for the summary the team reads.",
+    {
+      message: z.string().min(1).max(2e4)
+    },
+    async ({ message }) => {
+      try {
+        await connection.call("postToProjectChat", { projectId, content: message });
+        return textResult("Posted to project chat");
+      } catch (error) {
+        return errText("Failed to post to project chat", error);
+      }
+    }
+  );
+}
+function buildGetProjectTaskTool(connection, projectId) {
+  return defineTool(
+    "get_project_task",
+    "Fetch any task in the project by id or slug: title, description, plan, status, and metadata. The audit evidence trail starts here.",
+    {
+      taskId: z.string().describe("Task id or slug")
+    },
+    async ({ taskId }) => {
+      try {
+        const task = await connection.call("getProjectTask", { projectId, taskId });
+        return textResult(JSON.stringify(task, null, 2));
+      } catch (error) {
+        return errText("Failed to get task", error);
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildReadProjectTaskChatTool(connection, projectId) {
+  return defineTool(
+    "read_project_task_chat",
+    "Read any project task's chat messages (newest last). role 'user' rows are HUMAN turns; 'assistant'/'system' rows are agent posts and activity-log entries.",
+    {
+      taskId: z.string().describe("Task id or slug"),
+      limit: z.number().int().min(1).max(200).optional().describe("Messages to fetch (default 50)")
+    },
+    async ({ taskId, limit }) => {
+      try {
+        const chat = await connection.call("getProjectTaskChat", {
+          projectId,
+          taskId,
+          limit: limit ?? 50
+        });
+        return textResult(JSON.stringify(chat, null, 2));
+      } catch (error) {
+        return errText("Failed to read task chat", error);
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildGetProjectTaskLogsTool(connection, projectId) {
+  return defineTool(
+    "get_project_task_logs",
+    "Read any project task's persisted agent event stream (message / tool_use / turn_end / error / completed). Turn boundaries are turn_end events. Entries are truncated to ~2KB each; max 500 per call.",
+    {
+      taskId: z.string().describe("Task id or slug"),
+      limit: z.number().int().min(1).max(500).optional().describe("Entries to fetch (default 50)"),
+      source: z.enum(["agent", "application"]).optional().describe("Filter: 'agent' = model events (default useful for grading)")
+    },
+    async ({ taskId, limit, source }) => {
+      try {
+        const logs = await connection.call("getProjectTaskCli", {
+          projectId,
+          taskId,
+          limit: limit ?? 50,
+          source
+        });
+        return textResult(JSON.stringify(logs, null, 2));
+      } catch (error) {
+        return errText("Failed to get task logs", error);
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+var TURN_GRADE_SHAPE = z.object({
+  turnIndex: z.number().int().min(0),
+  phase: z.enum(["planning", "building", "human"]),
+  grade: z.enum(["correct", "neutral", "blunder"]),
+  reasoning: z.string(),
+  eventType: z.string().describe('e.g. "message", "tool_use", "human_message"'),
+  eventSummary: z.string().max(200).describe("\u2264120 chars of what happened this turn")
+});
+var HUMAN_EVAL_SHAPE = z.object({
+  messageIndex: z.number().int().min(0).describe("Index into the task's human messages, oldest first"),
+  rating: z.number().int().min(-1).max(1),
+  reasoning: z.string()
+});
+function buildReportTaskAuditResultTool(connection, projectId) {
+  return defineTool(
+    "report_task_audit_result",
+    "Persist one audited task's grades (call once per task after grading it). Pass error instead to mark the audit failed when the evidence is unusable.",
+    {
+      taskId: z.string().describe("The audited task's id (NOT slug)"),
+      summary: z.string().describe("3-6 sentences: what went well, what was wasted"),
+      turnGrades: z.array(TURN_GRADE_SHAPE),
+      planningAccuracy: z.number().min(0).max(1).nullable(),
+      buildingAccuracy: z.number().min(0).max(1).nullable(),
+      humanAccuracy: z.number().min(0).max(1).nullable(),
+      planningCorrect: z.number().int().min(0),
+      planningNeutral: z.number().int().min(0),
+      planningBlunder: z.number().int().min(0),
+      buildingCorrect: z.number().int().min(0),
+      buildingNeutral: z.number().int().min(0),
+      buildingBlunder: z.number().int().min(0),
+      humanCorrect: z.number().int().min(0),
+      humanNeutral: z.number().int().min(0),
+      humanBlunder: z.number().int().min(0),
+      humanEvaluations: z.array(HUMAN_EVAL_SHAPE).optional(),
+      suggestionIds: z.array(z.string()).describe("Suggestion ids filed for this task, or []"),
+      auditCostUsd: z.number().nullable(),
+      model: z.string().nullable().describe("The model you are running as"),
+      error: z.string().optional().describe("Set ONLY to mark this task's audit failed")
+    },
+    async (input) => {
+      try {
+        await connection.call("reportTaskAuditResult", {
+          projectId,
+          ...input,
+          humanEvaluations: input.humanEvaluations ?? []
+        });
+        return textResult(
+          input.error ? `Audit for ${input.taskId} marked failed` : `Audit result saved for ${input.taskId}`
+        );
+      } catch (error) {
+        return errText("Failed to report audit result", error);
+      }
+    }
+  );
+}
+function buildProjectTools(connection, projectId) {
+  return [
+    buildListTagsTool(connection, projectId),
+    buildCreateTagTool(connection, projectId),
+    buildUpdateTagTool(connection, projectId),
+    buildCreateSuggestionTool(connection, projectId),
+    buildPostToProjectChatTool(connection, projectId),
+    buildGetProjectTaskTool(connection, projectId),
+    buildReadProjectTaskChatTool(connection, projectId),
+    buildGetProjectTaskLogsTool(connection, projectId),
+    buildReportTaskAuditResultTool(connection, projectId)
+  ];
+}
+
 // src/runner/adhoc-session-runner.ts
 var ADHOC_SYSTEM_NOTE = "You are running in an ad-hoc Conveyor scratch pod \u2014 an interactive terminal on the project's repository checked out at its default branch. There is no task or plan; help the human with whatever they ask directly.";
+var HEADLESS_SYSTEM_NOTE = "You are running a HEADLESS Conveyor session on the project's repository \u2014 your instructions were auto-submitted as the first message. Work them to completion autonomously and never wait for user input; a human may attach to this terminal to watch or interject, but none is required.";
+function resolveInitialPrompt(env = process.env) {
+  const b64 = env.CONVEYOR_INITIAL_PROMPT_B64;
+  if (!b64) return null;
+  try {
+    const decoded = Buffer.from(b64, "base64").toString("utf8").trim();
+    return decoded.length > 0 ? decoded : null;
+  } catch {
+    return null;
+  }
+}
 function resolveAdhocTui(env) {
   const raw = env.CONVEYOR_TUI ?? "claude-code";
   if (TUI_KINDS.includes(raw)) return raw;
@@ -839,24 +1110,29 @@ function buildAdhocPtyBridge(connection) {
     onResize: (handler) => connection.onPtyResize(handler)
   };
 }
-function buildAdhocQueryOptions(workspaceDir, model, abortController, session, env = process.env) {
+function buildAdhocQueryOptions(workspaceDir, model, abortController, session, env = process.env, headless) {
+  const systemNote = headless ? HEADLESS_SYSTEM_NOTE : ADHOC_SYSTEM_NOTE;
   return {
     model,
-    systemPrompt: { type: "preset", preset: "claude_code", append: ADHOC_SYSTEM_NOTE },
-    appendSystemPrompt: ADHOC_SYSTEM_NOTE,
+    systemPrompt: { type: "preset", preset: "claude_code", append: systemNote },
+    appendSystemPrompt: systemNote,
     cwd: workspaceDir,
-    // Human-driven interactive shell — no plan-mode gating, no Conveyor tools.
+    // Human-driven interactive shell — no plan-mode gating. (Headless audit
+    // runs keep the same bypass: they must finish with no one at the terminal.)
     permissionMode: "bypassPermissions",
     allowDangerouslySkipPermissions: true,
     tools: { type: "preset", preset: "claude_code" },
-    // Browser automation only — the baked playwright-mcp when present.
     mcpServers: (() => {
       const playwright = resolvePlaywrightMcpServer(env);
-      return playwright ? { playwright } : {};
+      return {
+        ...playwright ? { playwright } : {},
+        ...headless?.conveyorMcpServer ? { conveyor: headless.conveyorMcpServer } : {}
+      };
     })(),
     settingSources: ["user", "project"],
-    // Empty box, unsubmitted: the human types the first prompt themselves.
-    promptDelivery: "prefill",
+    // Interactive: empty box, unsubmitted — the human types the first prompt.
+    // Headless: paste + submit the server-assembled instructions immediately.
+    promptDelivery: headless ? "submit" : "prefill",
     abortController,
     ...session?.sessionId ? { sessionId: session.sessionId } : {},
     ...session?.resume ? { resume: session.resume } : {}
@@ -958,15 +1234,34 @@ var AdhocSessionRunner = class {
   async runInteractiveTui() {
     const model = this.config.model ?? process.env.CONVEYOR_AGENT_MODEL ?? process.env.CONVEYOR_ADHOC_MODEL ?? DEFAULT_SONNET_MODEL;
     const session = resolveSessionStart(this.config.workspaceId, this.config.workspaceDir);
+    const initialPrompt = this.config.initialPrompt ?? null;
+    const headless = initialPrompt ? {
+      initialPrompt,
+      conveyorMcpServer: this.harness.createMcpServer({
+        name: "conveyor",
+        tools: buildProjectTools(this.connection, this.config.projectId)
+      })
+    } : void 0;
     const options = buildAdhocQueryOptions(
       this.config.workspaceDir,
       model,
       this.abortController,
-      session
+      session,
+      process.env,
+      headless
     );
+    let promptMarked = false;
     try {
-      for await (const event of this.harness.executeQuery({ prompt: "", options })) {
+      for await (const event of this.harness.executeQuery({
+        prompt: initialPrompt ?? "",
+        options
+      })) {
         if (this.stopped) break;
+        if (initialPrompt && !promptMarked) {
+          promptMarked = true;
+          void this.connection.call("markInitialPromptSubmitted", { sessionId: this.config.connection.sessionId }).catch(() => {
+          });
+        }
         if (event.type === "result" && event.subtype === "error") {
           throw new Error(event.errors.join("\n"));
         }
@@ -1173,7 +1468,6 @@ var ReviewChildSupervisor = class {
 // src/runner/session-child.ts
 import { spawn as nodeSpawn2 } from "child_process";
 var logger3 = createServiceLogger("SessionChild");
-var KILL_WAIT_MS2 = 5e3;
 function buildSpawnedChildEnv(baseEnv, data) {
   const env = { ...baseEnv };
   env.CONVEYOR_TASK_TOKEN = data.sessionJwt;
@@ -1283,7 +1577,7 @@ var SessionChildSupervisor = class {
         } catch {
         }
         resolve();
-      }, KILL_WAIT_MS2);
+      }, KILL_WAIT_MS);
       timer.unref();
       child.once("exit", () => {
         clearTimeout(timer);
@@ -1577,6 +1871,9 @@ if (!CONVEYOR_TASK_ID && projectIdentity && CONVEYOR_MODE === "adhoc") {
       projectId: projectIdentity.projectId,
       workspaceId: projectIdentity.workspaceId,
       workspaceDir: CONVEYOR_WORKSPACE,
+      // Headless sessions: un-submitted audit instructions from the bundle.
+      // Resolved ONLY here — spawned same-pod tabs must not inherit them.
+      initialPrompt: resolveInitialPrompt(process.env),
       ...process.env.CLAUDESPACE_NAME ? { lifecycle: { idleTimeoutMs: 60 * 60 * 1e3 } } : {}
     },
     {