overlord-cli 0.2608172109.0 → 0.2608180913.0

package/dist/connectors/core/overlord-mission/reference/mcp.md

@@ -9,6 +9,6 @@
 - `overlord_record_work` (hosted MCP) and `ovld protocol record-work` (CLI) record already-completed chat work as a single review-column mission with a completed objective, file-change rationales, and the standard Gemini delivery summary — no `attach`/`deliver`. Hosted MCP requires `projectId` (it never chooses a project implicitly); the CLI resolves the project from the working directory or `--project-id`. The submission format is in [record-work.md](record-work.md). The route is `POST /api/protocol/record-work`.
 - `overlord_add_artifact` (hosted MCP) and `ovld protocol add-artifact` (CLI) create a mission artifact during a turn without delivering. Required: `missionId` / `--mission-id`, `type` / `--type`, `label` / `--label`, plus at least one of `contentText` / `--content-text`/`--content-text-file` or `externalUrl` / `--external-url`. Optional `sessionKey` / `--session-key` stamps session/objective provenance. Same service as REST `POST /api/missions/:id/artifacts`. The route is `POST /api/protocol/add-artifact`.
 - `overlord_update_artifact` (hosted MCP) and `ovld protocol update-artifact` (CLI) revise an existing mission artifact's label, Markdown content, and/or HTTP(S) URL in place. Required: `missionId` / `--mission-id`, `artifactId` / `--artifact-id`, `expectedRevision` / `--expected-revision`. Provide at least one editable field. No session key is required. Same service as REST `PATCH /api/missions/:id/artifacts/:artifactId`. The route is `POST /api/protocol/update-artifact`.
-- `overlord_create_mission` / `overlord_add_objectives` accept optional `autoAdvance` (boolean; default false). `overlord_update_objective` (`objectiveId` + `autoAdvance`) and `ovld protocol update-objective --objective-id <id> --auto-advance|--no-auto-advance` toggle it on an existing objective. The route is `POST /api/protocol/update-objective`.
+- `overlord_create_mission` / `overlord_add_objectives` accept optional `autoAdvance` (boolean; default false). `overlord_update_objective` (`objectiveId` plus optional `autoAdvance` and/or `instructionText`) and `ovld protocol update-objective --objective-id <id>` with `--auto-advance|--no-auto-advance` and/or `--instruction-text|--instruction-text-file` update an existing objective. Instruction text is editable only in `draft` or `future` state. The route is `POST /api/protocol/update-objective`.
 - Objective attachment tools follow the `<verb>_<noun>` MCP naming: `list_attachments`, `prepare_attachment_upload`, `finalize_attachment_upload`, `get_attachment_download_url`, `upload_attachment_file`. CLI commands use `attachment-*`. `mission_id` / `missionId` is optional for attachment calls when the objective or attachment id lets the server derive mission scope.
 - "Artifacts" may be published mid-turn with `add-artifact` / `overlord_add_artifact`, revised with `update-artifact` / `overlord_update_artifact`, or attached at `deliver` time (next_steps, test_results, migration, decision, note, url) — not user-uploaded files. Files attached by users live on objectives via the attachment tools above.

package/dist/connectors/core/scripts/overlord-mcp.mjs

@@ -198,17 +198,20 @@ const tools = [
   },
   {
     name: 'overlord_update_objective',
-    title: 'Update objective auto-advance',
+    title: 'Update objective',
     description:
-      'Turn auto-advance on or off for an existing objective so delivery can queue the next one.',
+      'Turn auto-advance on or off and/or edit instruction text on a draft or future objective.',
     inputSchema: objectSchema(
       {
-        objectiveId: stringProperty('Objective UUID.'),
+        objectiveId: stringProperty('Objective UUID or display id.'),
         autoAdvance: booleanProperty(
           'When true, Overlord queues the next objective after this one is delivered. When false, delivery waits for approval.'
+        ),
+        instructionText: stringProperty(
+          'Replacement instruction text. Allowed only when the objective is in draft or future state; blank clears the text in those states.'
         )
       },
-      ['objectiveId', 'autoAdvance']
+      ['objectiveId']
     )
   },
   {
@@ -436,10 +439,15 @@ function callOverlordTool(name, args) {
     });
   }
   if (name === 'overlord_update_objective') {
-    if (typeof args.autoAdvance !== 'boolean') throw new Error('autoAdvance must be a boolean');
+    const hasAutoAdvance = typeof args.autoAdvance === 'boolean';
+    const hasInstructionText = typeof args.instructionText === 'string';
+    if (!hasAutoAdvance && !hasInstructionText) {
+      throw new Error('Provide autoAdvance and/or instructionText');
+    }
     return runProtocol('update-objective', {
       'objective-id': requiredString(args, 'objectiveId'),
-      ...(args.autoAdvance ? { 'auto-advance': true } : { 'no-auto-advance': true })
+      ...(hasAutoAdvance ? (args.autoAdvance ? { 'auto-advance': true } : { 'no-auto-advance': true }) : {}),
+      ...(hasInstructionText ? { 'instruction-text': requiredString(args, 'instructionText') } : {})
     });
   }
   if (name === 'overlord_attach_session') {

package/dist/index.js

@@ -17452,6 +17452,41 @@ var init_latch_events = __esm({
   }
 });
 
+// ../packages/core/dist/service/latch-harness-ingest.js
+function encodedEventSize(event) {
+  return new TextEncoder().encode(JSON.stringify(event)).length;
+}
+function chunkLatchHarnessEventsForIngest({ events, from, maxBytes = HARNESS_EVENT_INGEST_MAX_BYTES }) {
+  if (events.length === 0)
+    return [];
+  const chunks = [];
+  let chunk = [];
+  let chunkFrom = from;
+  let used = 2;
+  for (const event of events) {
+    const size = encodedEventSize(event);
+    const extra = (chunk.length === 0 ? 0 : 1) + size;
+    if (chunk.length > 0 && used + extra > maxBytes) {
+      chunks.push({ events: chunk, from: chunkFrom });
+      chunkFrom += chunk.length;
+      chunk = [event];
+      used = 2 + size;
+      continue;
+    }
+    chunk.push(event);
+    used += extra;
+  }
+  chunks.push({ events: chunk, from: chunkFrom });
+  return chunks;
+}
+var HARNESS_EVENT_INGEST_MAX_BYTES;
+var init_latch_harness_ingest = __esm({
+  "../packages/core/dist/service/latch-harness-ingest.js"() {
+    "use strict";
+    HARNESS_EVENT_INGEST_MAX_BYTES = 64 * 1024;
+  }
+});
+
 // ../packages/core/dist/service/util.js
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
@@ -18917,7 +18952,7 @@ function withWorktreeFields(input, branch) {
     cycle: Number.isFinite(cycleMatch) && cycleMatch > 1 ? cycleMatch : 1
   };
 }
-function planMissionBranch(input) {
+function planSharedMissionBranch(input) {
   const baseBranch = canonicalMissionBranch(input.mission);
   const allRefs = refSet([...input.refs.local, ...input.refs.remote]);
   const mergedRefs = refSet(input.refs.merged);
@@ -18947,6 +18982,46 @@ function planMissionBranch(input) {
   }
   return { action: "new_cycle", ...withWorktreeFields(input, candidate), from: input.base };
 }
+function isolationParent(sharedBranch, allRefs, base) {
+  return allRefs.has(sharedBranch) ? sharedBranch : base;
+}
+function isolateDecision(input, shared) {
+  const key = sanitizeBranchName(input.isolation?.objectiveKey ?? "", "");
+  if (!key) return shared;
+  const allRefs = refSet([...input.refs.local, ...input.refs.remote]);
+  const mergedRefs = refSet(input.refs.merged);
+  const checkedOutRefs = refSet(input.refs.checkedOut ?? []);
+  const isolatedBase = sanitizeBranchName(`${shared.branch}-${key}`, shared.branch);
+  if (isolatedBase === shared.branch) return shared;
+  if (!allRefs.has(isolatedBase)) {
+    return {
+      action: "create",
+      ...withWorktreeFields(input, isolatedBase),
+      cycle: 1,
+      from: isolationParent(shared.branch, allRefs, input.base)
+    };
+  }
+  if (!mergedRefs.has(isolatedBase)) {
+    return { action: "reuse", ...withWorktreeFields(input, isolatedBase), cycle: 1 };
+  }
+  let cycle = Math.max(2, highestExistingCycle(isolatedBase, allRefs) + 1);
+  let candidate = `${isolatedBase}-${cycle}`;
+  while (allRefs.has(candidate) || checkedOutRefs.has(candidate) || mergedRefs.has(candidate)) {
+    cycle += 1;
+    candidate = `${isolatedBase}-${cycle}`;
+  }
+  return {
+    action: "new_cycle",
+    ...withWorktreeFields(input, candidate),
+    cycle,
+    from: isolationParent(shared.branch, allRefs, input.base)
+  };
+}
+function planMissionBranch(input) {
+  const shared = planSharedMissionBranch(input);
+  if (!input.isolation || input.overrideBranch) return shared;
+  return isolateDecision(input, shared);
+}
 var TITLE_SLUG_MAX;
 var init_branch_planning = __esm({
   "src/branch-planning.ts"() {
@@ -19195,6 +19270,48 @@ function resolveLaunchResourceKey({
   }
   return deriveProjectResourceKey({ directoryPath: options.workingDirectory });
 }
+function readString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+async function resolveProjectPrimaryResourceKey({
+  runtime,
+  mission
+}) {
+  const projectId = readString(mission.projectId);
+  if (!projectId) return DEFAULT_PRIMARY_RESOURCE_KEY;
+  try {
+    const resources = await runtime.backend.get(
+      `/api/projects/${encodeURIComponent(projectId)}/resources`
+    );
+    if (!Array.isArray(resources)) return DEFAULT_PRIMARY_RESOURCE_KEY;
+    const primary = resources.find((resource) => resource?.isPrimary === true);
+    return readString(primary?.resourceKey) || DEFAULT_PRIMARY_RESOURCE_KEY;
+  } catch {
+    return DEFAULT_PRIMARY_RESOURCE_KEY;
+  }
+}
+async function resolveBranchIsolation({
+  runtime,
+  mission,
+  options,
+  useWorktree
+}) {
+  if (!useWorktree) return null;
+  if (mission.allowParallelObjectives !== true) return null;
+  const objectiveId = readString(options.objectiveId);
+  if (!objectiveId) return null;
+  const objectives = Array.isArray(mission.objectives) ? mission.objectives : [];
+  const self = objectives.find((candidate) => readString(candidate.id) === objectiveId);
+  const objectiveKey = readString(self?.displayKey);
+  if (!self || !objectiveKey) return null;
+  const primaryResourceKey = await resolveProjectPrimaryResourceKey({ runtime, mission });
+  const canonical = (value) => readString(value) || primaryResourceKey;
+  const selfResourceKey = canonical(self.resourceKey);
+  const hasLiveSibling = objectives.some(
+    (candidate) => readString(candidate.id) !== objectiveId && PARALLEL_BLOCKING_OBJECTIVE_STATES.includes(readString(candidate.state)) && canonical(candidate.resourceKey) === selfResourceKey
+  );
+  return hasLiveSibling ? { objectiveKey } : null;
+}
 async function prepareMissionBranch({
   runtime,
   options
@@ -19221,6 +19338,7 @@ async function prepareMissionBranch({
   const overrideBranch = overrideFlag || missionOverrideBranch(mission);
   const projectSlug = await resolveMissionProjectSlug({ runtime, mission });
   const resourceKey = resolveLaunchResourceKey({ mission, options });
+  const isolation = await resolveBranchIsolation({ runtime, mission, options, useWorktree });
   const decision = planMissionBranch({
     mission: {
       title: typeof mission.title === "string" ? mission.title : "mission",
@@ -19232,8 +19350,10 @@ async function prepareMissionBranch({
     base,
     refs,
     worktreeRoot: resolveWorktreeRoot(),
-    overrideBranch
+    overrideBranch,
+    isolation
   });
+  const isolated = Boolean(isolation) && !overrideBranch;
   if (useWorktree) {
     ensureWorktree(gitRoot, decision);
     return {
@@ -19244,7 +19364,8 @@ async function prepareMissionBranch({
         worktreePath: decision.worktreePath,
         resourceKey,
         action: decision.action,
-        cycle: decision.cycle
+        cycle: decision.cycle,
+        isolated
       }
     };
   }
@@ -19257,15 +19378,19 @@ async function prepareMissionBranch({
       worktreePath: gitRoot,
       resourceKey,
       action: decision.action,
-      cycle: decision.cycle
+      cycle: decision.cycle,
+      isolated: false
     }
   };
 }
+var PARALLEL_BLOCKING_OBJECTIVE_STATES, DEFAULT_PRIMARY_RESOURCE_KEY;
 var init_branch_preparation = __esm({
   "src/branch-preparation.ts"() {
     "use strict";
     init_project_resource_key();
     init_branch_planning();
+    PARALLEL_BLOCKING_OBJECTIVE_STATES = ["launching", "executing", "pending_delivery"];
+    DEFAULT_PRIMARY_RESOURCE_KEY = "primary";
   }
 });
 
@@ -20673,7 +20798,7 @@ Subcommands:
   search-missions         Find missions by keyword, status, or project
   discuss-objective      Mark a draft objective as submitted (does not start execution)
   add-objectives         Append ordered objectives to an existing mission
-  update-objective       Set auto-advance on an existing objective
+  update-objective       Set auto-advance and/or instruction text on an objective
   create                 Create a draft mission without attaching
   prompt                 Create a mission and attach to it immediately
   record-work            Record completed-from-chat work as a review mission (no attach)
@@ -20798,12 +20923,17 @@ add-objectives:
 
 update-objective:
   Purpose:
-    Turn auto-advance on or off for an existing objective.
+    Turn auto-advance on or off and/or edit instruction text on an existing objective.
   Required:
     --objective-id <id>
-    --auto-advance or --no-auto-advance
+    At least one of:
+      --auto-advance or --no-auto-advance
+      --instruction-text <text> or --instruction-text-file <path|->
+  Rules:
+    Instruction text may be edited only when the objective is in draft or future state.
+    Blank instruction text is allowed in those states.
   Returns:
-    The updated objective JSON, including autoAdvance.
+    The updated objective JSON, including autoAdvance and instructionText.
 
 create:
   Purpose:
@@ -24241,14 +24371,20 @@ async function postLatchHarnessEventsAfterLaunch({
       from: 0
     });
     if (collected.events.length === 0) return;
-    await backend.post({
-      path: `/api/runner/requests/${requestId}/harness-events`,
-      body: {
-        providerSessionId,
-        events: collected.events,
-        from: collected.from
-      }
+    const chunks = chunkLatchHarnessEventsForIngest({
+      events: collected.events,
+      from: collected.from
     });
+    for (const chunk of chunks) {
+      await backend.post({
+        path: `/api/runner/requests/${requestId}/harness-events`,
+        body: {
+          providerSessionId,
+          events: chunk.events,
+          from: chunk.from
+        }
+      });
+    }
   } catch {
   }
 }
@@ -24258,6 +24394,7 @@ var init_commands = __esm({
     "use strict";
     init_dist2();
     init_latch_events();
+    init_latch_harness_ingest();
     init_project_metadata();
     init_local_target_mutation_runner();
     init_terminal_profile_types2();