@matthugh1/conductor-cli 0.1.0 → 0.2.2

package/dist/chunk-6AA726KG.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+
+// ../../src/core/runner-prompt.ts
+var AUTONOMOUS_WORKFLOW = `
+## Identity
+
+You are an autonomous implementation engineer spawned by Conductor's runner.
+When you need human input, use conductor_log_decision followed by
+conductor_await_decision \u2014 this blocks until the human responds in the
+Conductor panel. Work carefully and methodically.
+
+## Workflow (follow in order)
+
+### 1. Start your session
+
+Call conductor_session_brief with:
+- projectRoot: the project name given in your assignment below
+- deliverableId: the deliverable ID given in your assignment below
+- agentRole: "implementation-engineer"
+- agentType: "claude-code"
+
+Save the returned sessionId \u2014 pass it to every subsequent Conductor call.
+
+### 2. Read the brief and understand your assignment
+
+The session brief contains your deliverable title, description, and
+acceptance criteria. Read them carefully before writing any code.
+
+### 3. Branch from dev
+
+Run: git fetch origin && git checkout -b <branch-name> origin/dev
+
+Name the branch after the deliverable (e.g., feat/prompt-template).
+Branch from origin/dev (not main) so you pick up any prior autonomous
+work that has been merged to dev but not yet reviewed into main.
+Never use git checkout dev \u2014 use origin/dev directly to avoid worktree conflicts.
+Never branch from another feature branch.
+
+### 4. Mark your deliverable in-progress
+
+Call conductor_update_deliverable with status "in_progress".
+
+### 5. Do the work
+
+Implement the deliverable according to its acceptance criteria.
+After each meaningful chunk of work, call conductor_log_built with
+a plain English summary and the sessionId.
+
+### 6. Self-check before submitting
+
+Before creating a PR, run ALL of these checks:
+
+1. npx tsc --noEmit          (type check)
+2. npm run build              (build)
+3. npm test                   (tests)
+4. git status                 (working tree clean?)
+5. Review your own code for:
+   - No \`any\` type assertions
+   - No console.log in production code
+   - No large files (>200 lines of code)
+   - No large functions (>50 lines)
+   - No unused imports
+   - No secrets or .env files staged
+
+### 7. Retry on failure (up to 3 attempts)
+
+If any check fails:
+- Read the error output carefully
+- Fix the issue
+- Re-run the failing check
+- Repeat up to 3 total attempts per check
+
+If a check still fails after 3 attempts, go to the parking procedure (step 10).
+
+### 8. Create a PR and merge to dev
+
+When all checks pass:
+- git add the relevant files (never use git add -A)
+- git commit with a descriptive message
+- git push -u origin <branch-name>
+- gh pr create --title "<deliverable title>" --body "<summary>"
+- Save the PR URL \u2014 you need it for the completion report
+
+After the PR is created, merge your branch to dev so the next agent
+in the chain can build on your work without waiting for human review.
+Use a temporary local branch to avoid worktree checkout conflicts:
+
+  git fetch origin
+  git checkout -b _dev-merge origin/dev
+  git merge --no-ff <your-branch-name> -m "chore: merge <branch-name> to dev"
+  git push origin HEAD:dev
+  git checkout <your-branch-name>
+  git branch -D _dev-merge
+
+Never merge your own PR to main. Always merge to dev after creating the PR.
+
+### 9. Submit for review
+
+Call conductor_update_deliverable with:
+- status: "review"
+- completionReport with all check results and the prUrl
+
+Then call conductor_end_session with the sessionId.
+
+### 10. When you need a human decision
+
+If you hit a judgment call, ambiguous requirement, or blocker that needs human input:
+1. Call conductor_log_decision with the options and your reasoning.
+   This returns a decisionId.
+2. Call conductor_await_decision with that decisionId.
+   This blocks until the human approves in the Conductor panel (polls every
+   3 seconds, up to 5 minutes per call).
+3. If it returns "pending" (timeout), call conductor_await_decision again.
+   Keep calling until you get a resolution.
+4. Once resolved, read the chosenOption and continue your work accordingly.
+
+CRITICAL: You MUST call conductor_log_decision to create the decision.
+Do not just say "I need a decision" in text \u2014 the human cannot see your
+text output. The only way they know you need input is through the
+Conductor decision panel.
+
+### 11. Parking procedure (when truly stuck)
+
+If you cannot complete the work and waiting for a decision won't help:
+- Call conductor_update_deliverable with status "parked".
+- Call conductor_log_next describing what remains and why you stopped.
+- Call conductor_end_session with the sessionId.
+- Exit cleanly.
+
+## Rules
+
+- Follow all rules in CLAUDE.md (included above if present).
+- Never merge your own PR to main \u2014 only create it.
+- Always merge your branch to dev after creating the PR (see step 8).
+- Never make silent decisions \u2014 log every judgment call via conductor_log_decision.
+- If a subsequent deliverable exists in the same outcome, create a handoff
+  prompt via conductor_create_prompt before submitting for review.
+- Keep commits atomic and messages descriptive.
+- Do not install new dependencies without logging a decision.
+- Do not modify files outside the scope of your deliverable.
+- If you encounter merge conflicts, resolve them yourself.
+- Work within the existing code style and patterns.
+`.trim();
+var FREEFORM_TASK_WORKFLOW = `
+## Identity
+
+You are an agent spawned by Conductor's daemon to execute a task.
+When you need human input, use conductor_log_decision followed by
+conductor_await_decision \u2014 this blocks until the human responds in the
+Conductor panel. Work carefully and methodically.
+
+## Workflow
+
+1. Read the task description below carefully.
+2. Execute the task as described.
+3. If you hit a judgment call or blocker, log a decision via conductor_log_decision
+   and wait via conductor_await_decision. Do not proceed without resolution.
+4. When finished, report what you accomplished clearly.
+
+## Rules
+
+- Follow all rules in CLAUDE.md (included above if present).
+- Never make silent decisions \u2014 log every judgment call.
+- Work within the existing code style and patterns.
+- Do not install new dependencies without logging a decision.
+`.trim();
+function assembleAutonomousPrompt(ctx) {
+  const parts = [];
+  if (ctx.claudeMd.length > 0) {
+    parts.push("# Project Rules (CLAUDE.md)\n\n" + ctx.claudeMd);
+  }
+  parts.push("# Autonomous Runner Instructions\n\n" + AUTONOMOUS_WORKFLOW);
+  parts.push(
+    `# Your Assignment
+
+Project: ${ctx.projectName}
+Deliverable: ${ctx.item.title}
+Deliverable ID: ${ctx.item.entityId}
+Initiative: ${ctx.item.initiativeTitle ?? "unknown"}
+Priority: P${ctx.item.priority}
+Action: ${ctx.item.action}
+
+Start by calling conductor_session_brief with:
+- projectRoot: "${ctx.projectName}"
+- deliverableId: "${ctx.item.entityId}"
+- agentRole: "implementation-engineer"
+- agentType: "claude-code"`
+  );
+  return parts.join("\n\n---\n\n");
+}
+function assembleTaskPrompt(agent, task, claudeMd) {
+  const parts = [];
+  if (claudeMd.length > 0) {
+    parts.push("# Project Rules (CLAUDE.md)\n\n" + claudeMd);
+  }
+  if (agent.systemPrompt.length > 0) {
+    parts.push(
+      `# Agent: ${agent.name}
+
+## System Prompt
+
+` + agent.systemPrompt
+    );
+  }
+  if (task.deliverableId) {
+    parts.push("# Autonomous Runner Instructions\n\n" + AUTONOMOUS_WORKFLOW);
+  } else {
+    parts.push("# Task Instructions\n\n" + FREEFORM_TASK_WORKFLOW);
+  }
+  const assignmentLines = [
+    `# Your Assignment`,
+    ``,
+    `Task: ${task.title}`,
+    `Project: ${task.projectName}`
+  ];
+  if (task.deliverableId) {
+    assignmentLines.push(`Deliverable ID: ${task.deliverableId}`);
+    assignmentLines.push(``);
+    assignmentLines.push(`Start by calling conductor_session_brief with:`);
+    assignmentLines.push(`- projectRoot: "${task.projectName}"`);
+    assignmentLines.push(`- deliverableId: "${task.deliverableId}"`);
+    assignmentLines.push(`- agentRole: "implementation-engineer"`);
+    assignmentLines.push(`- agentType: "claude-code"`);
+  }
+  if (task.prompt.length > 0) {
+    assignmentLines.push(``);
+    assignmentLines.push(`## Task Details`);
+    assignmentLines.push(``);
+    assignmentLines.push(task.prompt);
+  }
+  parts.push(assignmentLines.join("\n"));
+  return parts.join("\n\n---\n\n");
+}
+
+export {
+  assembleAutonomousPrompt,
+  assembleTaskPrompt
+};

package/dist/{chunk-IHARLSA6.js → chunk-7S5HKGS5.js}

@@ -339,8 +339,9 @@ async function getConflictBranchesForWorkQueue(projectRoot, options) {
     }
   }
   const conflicts = [];
+  const SKIP_BRANCHES = /* @__PURE__ */ new Set(["dev", "develop", "staging"]);
   for (const name of namesToScan) {
-    if (name === defaultBranch) {
+    if (name === defaultBranch || SKIP_BRANCHES.has(name)) {
       continue;
     }
     let lastIso = "";

package/dist/{chunk-MJKFQIYA.js → chunk-B2WDTKD7.js}

@@ -4,18 +4,16 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
-import { homedir } from "os";
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
-var CONFIG_DIR = join(homedir(), ".conductor");
-var CONFIG_FILE = join(CONFIG_DIR, "config.json");
-var KEY_FILE = join(CONFIG_DIR, "api-key");
-function readConfig() {
-  if (!existsSync(CONFIG_FILE)) {
+function readConfig(projectRoot) {
+  const root = projectRoot ?? process.cwd();
+  const configFile = join(root, ".conductor", "config.json");
+  if (!existsSync(configFile)) {
     return {};
   }
   try {
-    const raw = readFileSync(CONFIG_FILE, "utf8");
+    const raw = readFileSync(configFile, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed !== null && typeof parsed === "object") {
       return parsed;
@@ -25,22 +23,21 @@ function readConfig() {
     return {};
   }
 }
-function writeConfig(config) {
-  mkdirSync(CONFIG_DIR, { recursive: true });
-  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", {
+function writeConfig(config, projectRoot) {
+  const root = projectRoot ?? process.cwd();
+  const dir = join(root, ".conductor");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "config.json"), JSON.stringify(config, null, 2) + "\n", {
     mode: 384
   });
 }
-function readApiKey() {
-  if (!existsSync(KEY_FILE)) {
-    return void 0;
-  }
-  try {
-    const key = readFileSync(KEY_FILE, "utf8").trim();
-    return key.length > 0 ? key : void 0;
-  } catch {
-    return void 0;
-  }
+function readApiKey(projectRoot) {
+  const config = readConfig(projectRoot);
+  return config.apiKey;
+}
+function readProjectId(projectRoot) {
+  const config = readConfig(projectRoot);
+  return config.projectId;
 }
 function getConfigEndpoint() {
   const candidates = [
@@ -130,6 +127,8 @@ async function ensureDatabaseUrl() {
 export {
   readConfig,
   writeConfig,
+  readApiKey,
+  readProjectId,
   getServerBaseUrl,
   fetchConfigFromServer,
   postToServer,

package/dist/{chunk-JZT526HU.js → chunk-KB2DTST2.js}

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  createNotification
+} from "./chunk-3MJBQK2F.js";
 import {
   runGit
 } from "./chunk-FAZ7FCZQ.js";
@@ -54,73 +57,6 @@ async function logGitActivity(input) {
   return rowToEvent(rows[0]);
 }
 
-// ../../src/core/notifications.ts
-var VALID_EVENT_TYPES = /* @__PURE__ */ new Set([
-  "gate_rejection",
-  "gate_bypassed",
-  "review_needed",
-  "handoff_needed",
-  "decision_pending",
-  "stale_session",
-  "abandoned_session",
-  "missing_checkin",
-  "orphan_work",
-  "stage_transition",
-  "watchdog_flag",
-  "stale_worktree",
-  "autonomous_flag_changed"
-]);
-var VALID_PRIORITIES = /* @__PURE__ */ new Set([
-  "info",
-  "warning",
-  "action_needed"
-]);
-var VALID_LINK_TYPES = /* @__PURE__ */ new Set([
-  "deliverable",
-  "decision",
-  "initiative",
-  "session"
-]);
-async function createNotification(params) {
-  if (!params.projectId || params.projectId.trim().length === 0) {
-    throw new Error("A project id is required to create a notification.");
-  }
-  if (!VALID_EVENT_TYPES.has(params.eventType)) {
-    throw new Error(
-      `Unknown event type "${params.eventType}". Expected one of: ${[...VALID_EVENT_TYPES].join(", ")}.`
-    );
-  }
-  if (!params.message || params.message.trim().length === 0) {
-    throw new Error("A notification needs a message.");
-  }
-  if (!VALID_PRIORITIES.has(params.priority)) {
-    throw new Error(
-      `Unknown priority "${params.priority}". Expected info, warning, or action_needed.`
-    );
-  }
-  if (params.linkType !== void 0 && !VALID_LINK_TYPES.has(params.linkType)) {
-    throw new Error(
-      `Unknown link type "${params.linkType}". Expected deliverable, decision, initiative, or session.`
-    );
-  }
-  const rows = await query(
-    `INSERT INTO notifications (project_id, event_type, message, priority, link_type, link_id, agent_type, agent_name)
-     VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
-     RETURNING id`,
-    [
-      params.projectId,
-      params.eventType,
-      params.message.trim(),
-      params.priority,
-      params.linkType ?? null,
-      params.linkId ?? null,
-      params.agentType ?? null,
-      params.agentName ?? null
-    ]
-  );
-  return rows[0].id;
-}
-
 // ../../src/core/worktree-manager.ts
 var STALE_DAYS = 7;
 var STALE_MS = STALE_DAYS * 24 * 60 * 60 * 1e3;
@@ -176,6 +112,11 @@ async function createWorktree(projectId, projectRoot, initiativeId, initiativeTi
       `A worktree already exists for "${initiativeTitle}" at ${existing.worktreePath}`
     );
   }
+  await query(
+    `DELETE FROM worktrees
+     WHERE project_id = $1 AND initiative_id = $2 AND status IN ('removed', 'merged')`,
+    [projectId, initiativeId]
+  );
   const slug = slugifyForBranch(initiativeTitle);
   const branchName = slug;
   const projectDir = path.basename(projectRoot);
@@ -217,8 +158,21 @@ async function createWorktree(projectId, projectRoot, initiativeId, initiativeTi
   return record;
 }
 async function listWorktrees(projectId, opts) {
-  const statusFilter = opts?.status;
-  const baseQuery = `
+  const conditions = ["w.project_id = $1"];
+  const params = [projectId];
+  let paramIndex = 2;
+  if (opts?.status) {
+    conditions.push(`w.status = $${paramIndex}`);
+    params.push(opts.status);
+    paramIndex++;
+  }
+  if (opts?.initiativeId) {
+    conditions.push(`w.initiative_id = $${paramIndex}`);
+    params.push(opts.initiativeId);
+    paramIndex++;
+  }
+  const rows = await query(
+    `
     SELECT w.*, i.title AS initiative_title,
       (
         SELECT d.title FROM deliverables d
@@ -229,18 +183,10 @@ async function listWorktrees(projectId, opts) {
       ) AS deliverable_title
     FROM worktrees w
     LEFT JOIN initiatives i ON i.id = w.initiative_id
-    WHERE w.project_id = $1
-  `;
-  if (statusFilter) {
-    const rows2 = await query(
-      `${baseQuery} AND w.status = $2 ORDER BY w.created_at DESC`,
-      [projectId, statusFilter]
-    );
-    return rows2.map(rowToWithInitiative);
-  }
-  const rows = await query(
-    `${baseQuery} ORDER BY w.created_at DESC`,
-    [projectId]
+    WHERE ${conditions.join(" AND ")}
+    ORDER BY w.created_at DESC
+    `,
+    params
   );
   return rows.map(rowToWithInitiative);
 }

package/dist/{cli-config-TDSTAXIA.js → cli-config-2ZDXUUQN.js}

@@ -4,14 +4,18 @@ import {
   fetchConfigFromServer,
   getServerBaseUrl,
   postToServer,
+  readApiKey,
   readConfig,
+  readProjectId,
   writeConfig
-} from "./chunk-MJKFQIYA.js";
+} from "./chunk-B2WDTKD7.js";
 export {
   ensureDatabaseUrl,
   fetchConfigFromServer,
   getServerBaseUrl,
   postToServer,
+  readApiKey,
   readConfig,
+  readProjectId,
   writeConfig
 };

package/dist/{cli-tasks-NW3BONXC.js → cli-tasks-NM5D5PIZ.js}

@@ -2,10 +2,11 @@
 import {
   logGitActivity,
   removeWorktree
-} from "./chunk-JZT526HU.js";
+} from "./chunk-KB2DTST2.js";
+import "./chunk-3MJBQK2F.js";
 import {
   getProjectPathById
-} from "./chunk-VYINBHPQ.js";
+} from "./chunk-6VMREHG4.js";
 import {
   runGit
 } from "./chunk-FAZ7FCZQ.js";