opencode-missions 0.1.0

package/dist/index.js

@@ -0,0 +1,1414 @@
+// @bun
+// src/index.ts
+import { tool } from "@opencode-ai/plugin";
+import path3 from "path";
+
+// src/droid-missions/prompts.ts
+function buildWorkerPrompt(input) {
+  const { state, feature, missionDir, message } = input;
+  const extraMessage = message ? `
+## Orchestrator Message
+
+${message}
+` : "";
+  return `You are executing one OpenCode mission feature.
+
+## Mission
+
+- Mission ID: ${state.missionId}
+- Title: ${state.title}
+- Goal: ${state.goal}
+- Mission directory: ${missionDir}
+- Working directory: ${state.workingDirectory}
+
+## Assigned Feature
+
+- Feature ID: ${feature.id}
+- Skill: ${feature.skillName}
+- Milestone: ${feature.milestone}
+- Description: ${feature.description}
+- Expected behavior: ${feature.expectedBehavior}
+- Preconditions: ${feature.preconditions.join("; ") || "none"}
+- Verification steps: ${feature.verificationSteps.join("; ") || "none"}
+- Fulfills: ${feature.fulfills.join("; ") || "none"}
+${extraMessage}
+## Required Completion Contract
+
+1. Inspect the mission artifacts before editing.
+2. Implement only this feature unless verification requires a tiny local adjustment.
+3. Run the verification steps or the closest available checks.
+4. Finish by calling droid_mission_end_feature with:
+   - missionId: "${state.missionId}"
+   - featureId: "${feature.id}"
+   - successState: "success", "partial", or "failure"
+   - a structured handoff containing salientSummary, whatWasImplemented, whatWasLeftUndone, verification.commandsRun, and discoveredIssues.
+
+Do not mark unrelated features complete.`;
+}
+function buildCompactionContext(input) {
+  const current = input.features.find((feature) => feature.id === input.state.activeFeatureId);
+  const counts = input.features.reduce((acc, feature) => {
+    acc[feature.status] += 1;
+    return acc;
+  }, { pending: 0, in_progress: 0, completed: 0, cancelled: 0 });
+  return `OpenCode mission ${input.state.missionId} is ${input.state.status}. Feature counts: ${JSON.stringify(counts)}. Active feature: ${current?.id ?? "none"}. Use mission tools for state changes.`;
+}
+function buildResumePrompt(input) {
+  return `Continue where you left off on OpenCode mission feature "${input.feature.id}".
+
+Mission directory: ${input.missionDir}
+Working directory: ${input.state.workingDirectory}
+
+Before continuing:
+1. Check current repo state and modified files.
+2. Review existing work for this feature.
+3. Continue the same feature; do not start from scratch.
+4. Finish by calling droid_mission_end_feature with missionId "${input.state.missionId}" and featureId "${input.feature.id}".`;
+}
+
+// src/droid-missions/runner.ts
+function nowIso(now) {
+  return now ?? new Date().toISOString();
+}
+function extractSessionId(response) {
+  if (response && typeof response === "object") {
+    const record = response;
+    if (typeof record.id === "string")
+      return record.id;
+    if (record.data && typeof record.data === "object") {
+      const data = record.data;
+      if (typeof data.id === "string")
+        return data.id;
+    }
+    if (record.session && typeof record.session === "object") {
+      const session = record.session;
+      if (typeof session.id === "string")
+        return session.id;
+    }
+  }
+  throw new Error("OpenCode did not return a worker session id");
+}
+function allFeaturesCompleted(features) {
+  return features.length > 0 && features.every((feature) => feature.status === "completed" || feature.status === "cancelled");
+}
+function progressType(successState) {
+  return successState === "success" ? "worker_completed" : "worker_failed";
+}
+function validationFeature(milestone, kind) {
+  const id = kind === "scrutiny" ? `scrutiny-validator-${milestone}` : `user-testing-validator-${milestone}`;
+  return {
+    id,
+    description: kind === "scrutiny" ? `Validate milestone ${milestone} for correctness, regressions, and test adequacy.` : `Validate milestone ${milestone} through user-facing workflow checks.`,
+    skillName: kind === "scrutiny" ? "scrutiny-validator" : "user-testing-validator",
+    milestone,
+    preconditions: [`implementation milestone ${milestone} completed`],
+    expectedBehavior: kind === "scrutiny" ? "The completed milestone satisfies its contract and does not regress existing behavior." : "The completed milestone works from the user workflow perspective.",
+    verificationSteps: kind === "scrutiny" ? ["review feature handoffs", "run relevant automated checks"] : ["exercise the milestone workflow", "record manual observations"],
+    fulfills: [`milestone:${milestone}:validation`],
+    status: "pending",
+    isValidation: true,
+    validatesMilestone: milestone,
+    validationKind: kind
+  };
+}
+function agentForFeature(feature) {
+  if (feature.skillName === "scrutiny-validator") {
+    return "droid-mission-scrutiny-validator";
+  }
+  if (feature.skillName === "user-testing-validator") {
+    return "droid-mission-user-testing-validator";
+  }
+  return "droid-mission-worker";
+}
+function hasUnfinishedWork(value) {
+  const trimmed = value.trim();
+  return trimmed !== "" && trimmed.toLowerCase() !== "none";
+}
+function isValidationFeature(feature) {
+  return feature.isValidation === true || feature.skillName === "scrutiny-validator" || feature.skillName === "user-testing-validator";
+}
+function countSentences(text) {
+  const normalized = text.replace(/\s+/g, " ").trim().replace(/[.!?]+\s*$/, "");
+  if (!normalized)
+    return 0;
+  return normalized.split(/[.!?]+\s+/).filter(Boolean).length;
+}
+function assertHandoffContract(args) {
+  const summary = args.handoff.salientSummary.trim();
+  if (summary.length < 20 || summary.length > 750 || summary.includes(`
+`) || countSentences(summary) < 1 || countSentences(summary) > 6) {
+    throw new Error("handoff.salientSummary must be 20-750 characters and 1-6 sentences with no newlines");
+  }
+  if (args.handoff.whatWasImplemented.trim().length < 50) {
+    throw new Error("handoff.whatWasImplemented must be at least 50 characters");
+  }
+  for (const command of args.handoff.verification.commandsRun) {
+    if (!command.command.trim())
+      throw new Error("verification command is required");
+    if (!Number.isFinite(command.exitCode))
+      throw new Error("verification exitCode must be numeric");
+    if (!command.observation.trim())
+      throw new Error("verification observation is required");
+  }
+  if (!Array.isArray(args.handoff.tests.added)) {
+    throw new Error("handoff.tests.added must be an array");
+  }
+  if (!args.handoff.tests.coverage.trim()) {
+    throw new Error("handoff.tests.coverage is required");
+  }
+  for (const issue of args.handoff.discoveredIssues) {
+    if (!issue.description.trim())
+      throw new Error("discovered issue description is required");
+    if (!["blocking", "non_blocking", "suggestion"].includes(issue.severity)) {
+      throw new Error("discovered issue severity is invalid");
+    }
+  }
+}
+
+class MissionRunner {
+  store;
+  client;
+  constructor(store, client) {
+    this.store = store;
+    this.client = client;
+  }
+  async startMission(args) {
+    const firstStarted = {};
+    const maxIterations = 100;
+    for (let iteration = 0;iteration < maxIterations; iteration++) {
+      const at = nowIso(args.now);
+      const state = await this.store.readState(args.missionId);
+      const features = await this.store.readFeatures(args.missionId);
+      if (state.status === "paused") {
+        const pausedFeature = features.find((candidate) => candidate.status === "in_progress");
+        const pausedIndex = pausedFeature ? features.findIndex((feature2) => feature2.id === pausedFeature.id) : -1;
+        const firstPendingIndex = features.findIndex((feature2) => feature2.status === "pending");
+        if (pausedFeature && firstPendingIndex !== -1 && pausedIndex !== -1 && firstPendingIndex < pausedIndex) {
+          pausedFeature.status = "pending";
+          pausedFeature.workerSessionId = undefined;
+          pausedFeature.startedAt = undefined;
+          state.status = "running";
+          state.pauseReason = undefined;
+          state.activeFeatureId = undefined;
+          state.activeWorkerSessionId = undefined;
+          state.updatedAt = at;
+          await this.store.writeFeatureRecords(args.missionId, features);
+          await this.store.writeState(state);
+          continue;
+        }
+        if (pausedFeature && args.restartFeature) {
+          pausedFeature.status = "pending";
+          pausedFeature.workerSessionId = undefined;
+          pausedFeature.startedAt = undefined;
+          state.status = "running";
+          state.pauseReason = undefined;
+          state.activeFeatureId = undefined;
+          state.activeWorkerSessionId = undefined;
+          state.updatedAt = at;
+          await this.store.writeFeatureRecords(args.missionId, features);
+          await this.store.writeState(state);
+          continue;
+        }
+        if (pausedFeature && (args.resumeWorkerSessionId === undefined || pausedFeature.workerSessionId === args.resumeWorkerSessionId)) {
+          await this.resumeWorker({
+            missionId: args.missionId,
+            state,
+            feature: pausedFeature,
+            workerSessionId: pausedFeature.workerSessionId,
+            now: at
+          });
+          if (!firstStarted.featureId) {
+            firstStarted.featureId = pausedFeature.id;
+            firstStarted.workerSessionId = pausedFeature.workerSessionId;
+          }
+          continue;
+        }
+        return {
+          started: false,
+          completed: false,
+          missionId: args.missionId,
+          blockedReason: "paused",
+          systemMessage: state.pauseReason ?? "Mission is paused."
+        };
+      }
+      const unresolved = await this.getUnresolvedHandoffItems(args.missionId);
+      if (unresolved.length > 0) {
+        state.status = "orchestrator_turn";
+        state.updatedAt = at;
+        await this.store.writeState(state);
+        return {
+          started: false,
+          completed: false,
+          missionId: args.missionId,
+          blockedReason: "unresolved_handoff",
+          systemMessage: `Mission has ${unresolved.length} unresolved handoff item(s). Update mission artifacts or dismiss them before continuing.`
+        };
+      }
+      const validationInserted = this.injectEligibleMilestoneValidators(features);
+      if (validationInserted.length > 0) {
+        await this.store.writeFeatureRecords(args.missionId, features);
+        await this.store.appendProgress(args.missionId, {
+          type: "milestone_validation_triggered",
+          at,
+          missionId: args.missionId,
+          summary: "Validation queued for terminal milestone",
+          details: { validationInserted }
+        });
+        continue;
+      }
+      if (allFeaturesCompleted(features)) {
+        const validationBlockers = await this.getValidationStateBlockers(args.missionId);
+        if (validationBlockers.length > 0) {
+          state.status = "orchestrator_turn";
+          state.updatedAt = at;
+          await this.store.writeState(state);
+          return {
+            started: false,
+            completed: false,
+            missionId: args.missionId,
+            blockedReason: "validation_state",
+            systemMessage: `Mission validation-state has ${validationBlockers.length} unresolved assertion(s).`
+          };
+        }
+        state.status = "completed";
+        state.completedAt = state.completedAt ?? at;
+        state.updatedAt = at;
+        state.activeFeatureId = undefined;
+        state.activeWorkerSessionId = undefined;
+        await this.store.writeState(state);
+        await this.store.appendProgress(args.missionId, {
+          type: "mission_completed",
+          at,
+          missionId: args.missionId,
+          summary: "All mission features are complete"
+        });
+        return {
+          started: false,
+          completed: true,
+          missionId: args.missionId,
+          systemMessage: "Mission completed."
+        };
+      }
+      const inProgress = features.find((candidate) => candidate.status === "in_progress");
+      if (inProgress) {
+        return {
+          started: firstStarted.featureId !== undefined,
+          completed: false,
+          missionId: args.missionId,
+          featureId: inProgress.id,
+          workerSessionId: inProgress.workerSessionId,
+          blockedReason: "worker_in_progress",
+          systemMessage: `Feature "${inProgress.id}" is already in progress in worker session "${inProgress.workerSessionId ?? "unknown"}".`
+        };
+      }
+      const feature = features.find((candidate) => candidate.status === "pending");
+      if (!feature) {
+        state.status = features.length === 0 ? "awaiting_input" : "orchestrator_turn";
+        state.updatedAt = at;
+        await this.store.writeState(state);
+        return {
+          started: false,
+          completed: false,
+          missionId: args.missionId,
+          systemMessage: features.length === 0 ? "Mission has no features yet." : "No pending features are available."
+        };
+      }
+      if (!this.client.session?.create || !this.client.session.prompt) {
+        throw new Error("OpenCode session client is unavailable");
+      }
+      const createResponse = await this.client.session.create({
+        body: {
+          parentID: args.parentSessionId,
+          title: `${state.title}: ${feature.id}`
+        },
+        query: {
+          directory: state.workingDirectory
+        }
+      });
+      const workerSessionId = extractSessionId(createResponse);
+      if (!firstStarted.featureId) {
+        firstStarted.featureId = feature.id;
+        firstStarted.workerSessionId = workerSessionId;
+      }
+      feature.status = "in_progress";
+      feature.workerSessionId = workerSessionId;
+      feature.startedAt = at;
+      state.status = "running";
+      state.updatedAt = at;
+      state.activeFeatureId = feature.id;
+      state.activeWorkerSessionId = workerSessionId;
+      state.lastMessage = args.message;
+      await this.store.writeFeatureRecords(args.missionId, features);
+      await this.store.writeState(state);
+      await this.store.appendProgress(args.missionId, {
+        type: "worker_selected_feature",
+        at,
+        missionId: args.missionId,
+        featureId: feature.id,
+        workerSessionId,
+        summary: feature.description
+      });
+      await this.store.appendProgress(args.missionId, {
+        type: "worker_started",
+        at,
+        missionId: args.missionId,
+        featureId: feature.id,
+        workerSessionId,
+        summary: feature.description
+      });
+      try {
+        await this.client.session.prompt({
+          path: { id: workerSessionId },
+          query: { directory: state.workingDirectory },
+          body: {
+            agent: agentForFeature(feature),
+            parts: [
+              {
+                type: "text",
+                text: buildWorkerPrompt({
+                  state,
+                  feature,
+                  missionDir: this.store.missionDir(args.missionId),
+                  message: args.message
+                })
+              }
+            ],
+            tools: {
+              droid_mission_end_feature: true,
+              droid_mission_status: true,
+              droid_mission_write_artifact: true
+            }
+          }
+        });
+      } catch (error) {
+        feature.status = "pending";
+        feature.workerSessionId = undefined;
+        feature.startedAt = undefined;
+        state.status = "orchestrator_turn";
+        state.activeFeatureId = undefined;
+        state.activeWorkerSessionId = undefined;
+        state.updatedAt = nowIso();
+        await this.store.writeFeatureRecords(args.missionId, features);
+        await this.store.writeState(state);
+        await this.store.appendProgress(args.missionId, {
+          type: "worker_failed",
+          at: state.updatedAt,
+          missionId: args.missionId,
+          featureId: feature.id,
+          workerSessionId,
+          summary: error instanceof Error ? error.message : String(error)
+        });
+        throw error;
+      }
+    }
+    throw new Error(`Mission run loop exceeded ${maxIterations} iterations`);
+  }
+  async endFeatureRun(args) {
+    const at = nowIso(args.now);
+    const state = await this.store.readState(args.missionId);
+    const features = await this.store.readFeatures(args.missionId);
+    const feature = features.find((candidate) => candidate.id === args.featureId);
+    if (!feature) {
+      throw new Error(`Unknown feature: ${args.featureId}`);
+    }
+    if (feature.status !== "in_progress") {
+      throw new Error(`Feature "${feature.id}" is not in progress`);
+    }
+    if (feature.workerSessionId && args.workerSessionId && feature.workerSessionId !== args.workerSessionId) {
+      throw new Error(`Worker "${args.workerSessionId}" does not own feature "${feature.id}"`);
+    }
+    if (state.activeFeatureId && state.activeFeatureId !== feature.id && state.activeWorkerSessionId === args.workerSessionId) {
+      throw new Error(`Worker "${args.workerSessionId}" is not assigned to feature "${feature.id}"`);
+    }
+    if (args.successState === "success" && args.validatorsPassed !== true) {
+      throw new Error('validatorsPassed must be true when successState is "success"');
+    }
+    if (args.commitId && !args.repoPath) {
+      throw new Error("repoPath is required when commitId is provided");
+    }
+    if (args.codeChanged && (!args.commitId || !args.repoPath)) {
+      throw new Error("commitId and repoPath are required when codeChanged is true");
+    }
+    assertHandoffContract(args);
+    feature.workerSessionId = args.workerSessionId ?? feature.workerSessionId;
+    feature.completedAt = at;
+    feature.status = args.successState === "success" ? "completed" : "pending";
+    const hasHandoffIssues = args.handoff.discoveredIssues.length > 0 || hasUnfinishedWork(args.handoff.whatWasLeftUndone);
+    const forceReturnToOrchestrator = args.returnToOrchestrator === true || isValidationFeature(feature);
+    state.status = args.successState === "success" && !hasHandoffIssues && !forceReturnToOrchestrator ? "running" : "orchestrator_turn";
+    state.updatedAt = at;
+    state.activeFeatureId = state.activeFeatureId === feature.id ? undefined : state.activeFeatureId;
+    state.activeWorkerSessionId = state.activeWorkerSessionId === feature.workerSessionId ? undefined : state.activeWorkerSessionId;
+    if (args.successState === "success") {
+      const currentIndex = features.findIndex((candidate) => candidate.id === feature.id);
+      if (currentIndex >= 0) {
+        const [completedFeature] = features.splice(currentIndex, 1);
+        if (completedFeature)
+          features.push(completedFeature);
+      }
+    }
+    const storedHandoff = await this.store.appendHandoff(args.missionId, {
+      featureId: feature.id,
+      workerSessionId: feature.workerSessionId,
+      successState: args.successState,
+      returnToOrchestrator: forceReturnToOrchestrator || hasHandoffIssues,
+      validatorsPassed: args.validatorsPassed,
+      commitId: args.commitId,
+      repoPath: args.repoPath,
+      handoff: args.handoff,
+      now: at
+    });
+    const validationInserted = args.successState === "success" ? this.injectMilestoneValidators(features, feature) : [];
+    if (validationInserted.length > 0) {
+      await this.store.appendProgress(args.missionId, {
+        type: "milestone_validation_triggered",
+        at,
+        missionId: args.missionId,
+        featureId: feature.id,
+        summary: `Validation queued for milestone ${feature.milestone}`,
+        details: { validationInserted }
+      });
+    }
+    await this.store.writeFeatureRecords(args.missionId, features);
+    await this.store.writeState(state);
+    await this.store.appendProgress(args.missionId, {
+      type: progressType(args.successState),
+      at,
+      missionId: args.missionId,
+      featureId: feature.id,
+      workerSessionId: feature.workerSessionId,
+      summary: args.handoff.salientSummary,
+      details: {
+        returnToOrchestrator: args.returnToOrchestrator ?? hasHandoffIssues,
+        validationFeature: isValidationFeature(feature),
+        validatorsPassed: args.validatorsPassed,
+        commitId: args.commitId,
+        repoPath: args.repoPath,
+        handoffFile: storedHandoff.handoffFile
+      }
+    });
+    return { feature, validationInserted };
+  }
+  async pauseMission(missionId, reason, now) {
+    const at = nowIso(now);
+    const state = await this.store.readState(missionId);
+    state.status = "paused";
+    state.pauseReason = reason ?? "Paused by mission tool";
+    state.updatedAt = at;
+    await this.store.writeState(state);
+    await this.store.appendProgress(missionId, {
+      type: "mission_paused",
+      at,
+      missionId,
+      summary: state.pauseReason
+    });
+    if (state.activeWorkerSessionId && this.client.session?.abort) {
+      await this.client.session.abort({ path: { id: state.activeWorkerSessionId } });
+    }
+    return state;
+  }
+  async resumeWorker(args) {
+    if (!this.client.session?.prompt) {
+      throw new Error("OpenCode session client is unavailable");
+    }
+    if (!args.workerSessionId) {
+      throw new Error(`Cannot resume feature "${args.feature.id}" without a worker session id`);
+    }
+    args.state.status = "running";
+    args.state.pauseReason = undefined;
+    args.state.activeFeatureId = args.feature.id;
+    args.state.activeWorkerSessionId = args.workerSessionId;
+    args.state.updatedAt = args.now;
+    await this.store.writeState(args.state);
+    await this.store.appendProgress(args.missionId, {
+      type: "mission_resumed",
+      at: args.now,
+      missionId: args.missionId,
+      featureId: args.feature.id,
+      workerSessionId: args.workerSessionId,
+      summary: "Resumed paused worker session"
+    });
+    await this.client.session.prompt({
+      path: { id: args.workerSessionId },
+      query: { directory: args.state.workingDirectory },
+      body: {
+        agent: agentForFeature(args.feature),
+        parts: [
+          {
+            type: "text",
+            text: buildResumePrompt({
+              state: args.state,
+              feature: args.feature,
+              missionDir: this.store.missionDir(args.missionId)
+            })
+          }
+        ],
+        tools: {
+          droid_mission_end_feature: true,
+          droid_mission_status: true,
+          droid_mission_write_artifact: true
+        }
+      }
+    });
+  }
+  async completeMission(missionId, now) {
+    const at = nowIso(now);
+    const features = await this.store.readFeatures(missionId);
+    const validationInserted = this.injectEligibleMilestoneValidators(features);
+    if (validationInserted.length > 0) {
+      await this.store.writeFeatureRecords(missionId, features);
+      await this.store.appendProgress(missionId, {
+        type: "milestone_validation_triggered",
+        at,
+        missionId,
+        summary: "Validation queued before manual mission completion",
+        details: { validationInserted }
+      });
+    }
+    const incomplete = features.filter((feature) => feature.status !== "completed" && feature.status !== "cancelled");
+    if (incomplete.length > 0) {
+      throw new Error(`Cannot complete mission with incomplete features: ${incomplete.map((feature) => feature.id).join(", ")}`);
+    }
+    const unresolved = await this.getUnresolvedHandoffItems(missionId);
+    if (unresolved.length > 0) {
+      throw new Error(`Cannot complete mission with unresolved handoff items: ${unresolved.join("; ")}`);
+    }
+    const validationBlockers = await this.getValidationStateBlockers(missionId);
+    if (validationBlockers.length > 0) {
+      throw new Error(`Cannot complete mission with unresolved validation-state assertions: ${validationBlockers.join("; ")}`);
+    }
+    const state = await this.store.readState(missionId);
+    state.status = "completed";
+    state.completedAt = at;
+    state.updatedAt = at;
+    state.activeFeatureId = undefined;
+    state.activeWorkerSessionId = undefined;
+    await this.store.writeState(state);
+    await this.store.appendProgress(missionId, {
+      type: "mission_completed",
+      at,
+      missionId,
+      summary: "Mission manually completed"
+    });
+    return state;
+  }
+  injectMilestoneValidators(features, completedFeature) {
+    if (isValidationFeature(completedFeature))
+      return [];
+    return this.injectValidatorsForMilestone(features, completedFeature.milestone);
+  }
+  injectEligibleMilestoneValidators(features) {
+    const inserted = [];
+    const milestones = new Set(features.filter((feature) => !isValidationFeature(feature)).map((feature) => feature.milestone).filter(Boolean));
+    for (const milestone of milestones) {
+      inserted.push(...this.injectValidatorsForMilestone(features, milestone));
+    }
+    return inserted;
+  }
+  injectValidatorsForMilestone(features, milestone) {
+    if (features.some((feature) => isValidationFeature(feature) && feature.validatesMilestone === milestone)) {
+      return [];
+    }
+    const implementationFeatures = features.filter((feature) => feature.milestone === milestone && !isValidationFeature(feature));
+    const shouldValidate = implementationFeatures.length > 0 && implementationFeatures.every((feature) => feature.status === "completed" || feature.status === "cancelled") && implementationFeatures.some((feature) => feature.status === "completed");
+    if (!shouldValidate)
+      return [];
+    const validators = [
+      validationFeature(milestone, "scrutiny"),
+      validationFeature(milestone, "user-testing")
+    ];
+    features.splice(0, 0, ...validators);
+    return validators.map((feature) => feature.id);
+  }
+  async getUnresolvedHandoffItems(missionId) {
+    const handoffs = await this.store.readHandoffs(missionId);
+    const progress = await this.store.readProgress(missionId);
+    return handoffs.filter((handoff) => {
+      if (handoff.dismissedAt)
+        return false;
+      const handoffTime = new Date(handoff.createdAt).getTime();
+      return !progress.some((entry) => {
+        const clearsHandoff = entry.type === "features_written" || entry.type === "artifact_written" && entry.summary === "mission.md";
+        if (!clearsHandoff) {
+          return false;
+        }
+        return new Date(entry.at).getTime() > handoffTime;
+      });
+    }).flatMap((handoff) => [
+      ...handoff.discoveredIssues.map((issue) => `${handoff.id}: discovered issue: ${issue.description}`),
+      ...hasUnfinishedWork(handoff.whatWasLeftUndone) ? [`${handoff.id}: unfinished work: ${handoff.whatWasLeftUndone}`] : []
+    ]);
+  }
+  async getValidationStateBlockers(missionId) {
+    const validationState = await this.store.readValidationState(missionId);
+    const blockers = [];
+    const visit = (value, trail, assertionContext) => {
+      if (!value || typeof value !== "object")
+        return;
+      for (const [key, child] of Object.entries(value)) {
+        const nextTrail = [...trail, key];
+        const inAssertionContext = assertionContext || key === "assertions" || key === "validationAssertions";
+        if (typeof child === "string") {
+          const normalized = child.toLowerCase();
+          const isStatusKey = key === "status" || key === "state";
+          if ((inAssertionContext || isStatusKey) && normalized !== "passed") {
+            blockers.push(`${nextTrail.join(".")}: ${child}`);
+          }
+          continue;
+        }
+        visit(child, nextTrail, inAssertionContext);
+      }
+    };
+    visit(validationState, [], false);
+    return blockers;
+  }
+}
+
+// src/droid-missions/store.ts
+import {
+  mkdir,
+  readdir,
+  readFile,
+  rename,
+  rm,
+  stat,
+  writeFile
+} from "fs/promises";
+import path2 from "path";
+
+// src/droid-missions/paths.ts
+import path from "path";
+var STORAGE_DIR = path.join(".opencode", "droid-missions");
+var MISSIONS_DIR = "missions";
+function missionStorageRoot(projectRoot) {
+  return path.join(projectRoot, STORAGE_DIR);
+}
+function missionsRoot(projectRoot) {
+  return path.join(missionStorageRoot(projectRoot), MISSIONS_DIR);
+}
+function sanitizeMissionId(input) {
+  const value = input.trim();
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(value)) {
+    throw new Error("Invalid mission id. Use 1-128 letters, numbers, dots, underscores, or hyphens.");
+  }
+  return value;
+}
+function createMissionId(title, now) {
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "mission";
+  const stamp = new Date(now).getTime().toString(36);
+  return sanitizeMissionId(`${slug}-${stamp}`);
+}
+function missionDir(projectRoot, missionId) {
+  return path.join(missionsRoot(projectRoot), sanitizeMissionId(missionId));
+}
+function toMissionRelativePath(relativePath) {
+  const normalized = relativePath.replaceAll("\\", "/").replace(/^\/+/, "");
+  if (normalized === "" || normalized.startsWith("../") || normalized.includes("/../") || normalized === "..") {
+    throw new Error(`Invalid mission artifact path: ${relativePath}`);
+  }
+  return path.posix.normalize(normalized);
+}
+function assertInside(parent, child) {
+  const resolvedParent = path.resolve(parent);
+  const resolvedChild = path.resolve(child);
+  if (resolvedChild !== resolvedParent && !resolvedChild.startsWith(resolvedParent + path.sep)) {
+    throw new Error(`Path escapes mission directory: ${child}`);
+  }
+}
+function isMissionSystemFile(relativePath) {
+  const systemFiles = new Set([
+    "state.json",
+    "features.json",
+    "progress_log.jsonl",
+    "handoffs.jsonl",
+    "worker-transcripts.jsonl",
+    "working_directory.txt"
+  ]);
+  return systemFiles.has(toMissionRelativePath(relativePath));
+}
+
+// src/droid-missions/validation.ts
+var systemManagedFeatureFields = new Set([
+  "status",
+  "workerSessionId",
+  "startedAt",
+  "completedAt",
+  "isValidation",
+  "validatesMilestone",
+  "validationKind"
+]);
+var allowedArtifactFiles = new Set([
+  "mission.md",
+  "AGENTS.md",
+  "validation-contract.md",
+  "validation-state.json",
+  "services.yaml",
+  "init.sh",
+  "model-settings.json",
+  "runtime-custom-models.json"
+]);
+function assertRecord(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+}
+function readString(record, key) {
+  const value = record[key];
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`Feature field "${key}" must be a non-empty string`);
+  }
+  return value.trim();
+}
+function readStringArray(record, key) {
+  const value = record[key];
+  if (value === undefined)
+    return [];
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new Error(`Feature field "${key}" must be an array of strings`);
+  }
+  return value.map((item) => item.trim()).filter(Boolean);
+}
+function validateFeaturePlans(inputs, skillNames) {
+  const ids = new Set;
+  return inputs.map((input, index) => {
+    assertRecord(input, `Feature ${index + 1}`);
+    for (const key of Object.keys(input)) {
+      if (systemManagedFeatureFields.has(key)) {
+        throw new Error(`Feature "${String(input.id ?? index + 1)}" includes system-managed field "${key}"`);
+      }
+    }
+    const id = readString(input, "id");
+    if (!/^[a-z0-9][a-z0-9._-]{0,127}$/i.test(id)) {
+      throw new Error(`Invalid feature id: ${id}`);
+    }
+    if (ids.has(id)) {
+      throw new Error(`Duplicate feature id: ${id}`);
+    }
+    ids.add(id);
+    const skillName = readString(input, "skillName");
+    if (!skillNames.has(skillName)) {
+      throw new Error(`Missing mission skill "${skillName}" for feature "${id}"`);
+    }
+    const feature = {
+      id,
+      description: readString(input, "description"),
+      skillName,
+      milestone: readString(input, "milestone"),
+      preconditions: readStringArray(input, "preconditions"),
+      expectedBehavior: readString(input, "expectedBehavior"),
+      verificationSteps: readStringArray(input, "verificationSteps"),
+      fulfills: readStringArray(input, "fulfills")
+    };
+    return {
+      ...feature,
+      preconditions: feature.preconditions ?? [],
+      verificationSteps: feature.verificationSteps ?? [],
+      fulfills: feature.fulfills ?? [],
+      status: "pending"
+    };
+  });
+}
+function validateArtifactPath(relativePath) {
+  const normalized = toMissionRelativePath(relativePath);
+  if (isMissionSystemFile(normalized)) {
+    throw new Error(`Cannot write system-managed mission file: ${normalized}`);
+  }
+  if (allowedArtifactFiles.has(normalized)) {
+    return normalized;
+  }
+  if (normalized.startsWith("skills/") && normalized.endsWith("/SKILL.md") && normalized.split("/").length === 3) {
+    return normalized;
+  }
+  if (normalized.startsWith("library/") && normalized.length > "library/".length) {
+    return normalized;
+  }
+  if (normalized.startsWith("scripts/") && normalized.length > "scripts/".length) {
+    return normalized;
+  }
+  throw new Error(`Invalid mission artifact path: ${relativePath}`);
+}
+
+// src/droid-missions/store.ts
+var DEFAULT_IMPLEMENTATION_SKILL = `---
+name: implementation
+description: Implement one mission feature, verify it, and report the result through the mission completion tool.
+---
+
+Work only on the assigned feature. Use the mission files as the source of truth. When finished, call the mission completion tool with a structured handoff.
+`;
+var DEFAULT_SCRUTINY_SKILL = `---
+name: scrutiny-validator
+description: Validate a completed mission milestone for correctness, regressions, and missing tests.
+---
+
+Review the milestone implementation against the validation contract and feature handoffs. Record verification commands and call the mission completion tool.
+`;
+var DEFAULT_USER_TESTING_SKILL = `---
+name: user-testing-validator
+description: Validate a completed mission milestone from the expected user workflow.
+---
+
+Exercise the milestone as a user would. Capture manual checks, issues, and confidence in the mission completion tool.
+`;
+function nowIso2(now) {
+  return now ?? new Date().toISOString();
+}
+async function pathExists(filePath) {
+  try {
+    await stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeJson(filePath, value) {
+  await mkdir(path2.dirname(filePath), { recursive: true });
+  const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(tempPath, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+  await rename(tempPath, filePath);
+}
+async function readJson(filePath) {
+  return JSON.parse(await readFile(filePath, "utf8"));
+}
+async function readJsonl(filePath) {
+  if (!await pathExists(filePath))
+    return [];
+  const content = await readFile(filePath, "utf8");
+  return content.split(`
+`).map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+}
+async function appendJsonl(filePath, value) {
+  await mkdir(path2.dirname(filePath), { recursive: true });
+  await writeFile(filePath, `${JSON.stringify(value)}
+`, {
+    encoding: "utf8",
+    flag: "a"
+  });
+}
+function missionAgentsFile(title) {
+  return `# OpenCode mission mode: ${title}
+
+This directory is managed by the OpenCode mission plugin.
+
+- The mission state files are system-managed. Use the mission tools instead of direct edits.
+- The orchestrator owns decomposition, artifacts, ordering, and validation.
+- Workers own exactly one feature at a time and must finish with a structured handoff.
+- Validation features are created automatically when implementation for a milestone is complete.
+`;
+}
+function missionMarkdown(args, missionId, createdAt) {
+  return `# ${args.title}
+
+Mission ID: ${missionId}
+Created: ${createdAt}
+
+## Goal
+
+${args.goal}
+
+## Operating Model
+
+Plan artifacts, write feature slices, run one worker per feature, then complete milestone validation before declaring the mission done.
+`;
+}
+function handoffId(featureId, at) {
+  return `${featureId}-${at.replace(/[^a-z0-9]/gi, "").slice(0, 20)}`;
+}
+
+class MissionStore {
+  projectRoot;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  storageRoot() {
+    return missionStorageRoot(this.projectRoot);
+  }
+  missionsRoot() {
+    return missionsRoot(this.projectRoot);
+  }
+  missionDir(missionId) {
+    return missionDir(this.projectRoot, missionId);
+  }
+  async createMission(args) {
+    const createdAt = nowIso2(args.now);
+    const missionId = args.missionId ? sanitizeMissionId(args.missionId) : createMissionId(args.title, createdAt);
+    const dir = this.missionDir(missionId);
+    if (await pathExists(dir)) {
+      throw new Error(`Mission already exists: ${missionId}`);
+    }
+    await mkdir(path2.join(dir, "skills", "implementation"), { recursive: true });
+    await mkdir(path2.join(dir, "skills", "scrutiny-validator"), {
+      recursive: true
+    });
+    await mkdir(path2.join(dir, "skills", "user-testing-validator"), {
+      recursive: true
+    });
+    await mkdir(path2.join(dir, "library"), { recursive: true });
+    await mkdir(path2.join(dir, "scripts"), { recursive: true });
+    await mkdir(path2.join(dir, "handoffs"), { recursive: true });
+    const state = {
+      missionId,
+      title: args.title,
+      goal: args.goal,
+      status: "awaiting_input",
+      workingDirectory: args.workingDirectory ?? this.projectRoot,
+      createdAt,
+      updatedAt: createdAt
+    };
+    await writeFile(path2.join(dir, "mission.md"), missionMarkdown(args, missionId, createdAt));
+    await writeFile(path2.join(dir, "working_directory.txt"), `${state.workingDirectory}
+`);
+    await writeFile(path2.join(dir, "AGENTS.md"), missionAgentsFile(args.title));
+    await writeFile(path2.join(dir, "skills", "implementation", "SKILL.md"), DEFAULT_IMPLEMENTATION_SKILL);
+    await writeFile(path2.join(dir, "skills", "scrutiny-validator", "SKILL.md"), DEFAULT_SCRUTINY_SKILL);
+    await writeFile(path2.join(dir, "skills", "user-testing-validator", "SKILL.md"), DEFAULT_USER_TESTING_SKILL);
+    await writeJson(path2.join(dir, "state.json"), state);
+    await writeJson(path2.join(dir, "features.json"), []);
+    await writeFile(path2.join(dir, "progress_log.jsonl"), "");
+    await writeFile(path2.join(dir, "handoffs.jsonl"), "");
+    await writeFile(path2.join(dir, "worker-transcripts.jsonl"), "");
+    await writeJson(path2.join(dir, "validation-state.json"), {
+      missionId,
+      milestones: {}
+    });
+    await this.appendProgress(missionId, {
+      type: "mission_accepted",
+      at: createdAt,
+      missionId,
+      summary: args.title
+    });
+    return { dir, state, features: [] };
+  }
+  async removeMission(missionId) {
+    await rm(this.missionDir(missionId), { recursive: true, force: true });
+  }
+  async listMissions() {
+    if (!await pathExists(this.missionsRoot()))
+      return [];
+    const entries = await readdir(this.missionsRoot(), { withFileTypes: true });
+    const states = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      try {
+        states.push(await this.readState(entry.name));
+      } catch {}
+    }
+    return states.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  }
+  async readState(missionId) {
+    return readJson(path2.join(this.missionDir(missionId), "state.json"));
+  }
+  async writeState(state) {
+    await writeJson(path2.join(this.missionDir(state.missionId), "state.json"), state);
+  }
+  async readFeatures(missionId) {
+    return readJson(path2.join(this.missionDir(missionId), "features.json"));
+  }
+  async writeFeatureRecords(missionId, features) {
+    await writeJson(path2.join(this.missionDir(missionId), "features.json"), features);
+  }
+  async writeFeatures(missionId, inputs) {
+    const skillNames = await this.listMissionSkills(missionId);
+    const features = validateFeaturePlans(inputs, skillNames);
+    await this.writeFeatureRecords(missionId, features);
+    const state = await this.readState(missionId);
+    state.status = "orchestrator_turn";
+    state.updatedAt = nowIso2();
+    await this.writeState(state);
+    await this.appendProgress(missionId, {
+      type: "features_written",
+      at: state.updatedAt,
+      missionId,
+      summary: `${features.length} features written`
+    });
+    return features;
+  }
+  async listMissionSkills(missionId) {
+    const skillsDir = path2.join(this.missionDir(missionId), "skills");
+    const skills = new Set;
+    if (!await pathExists(skillsDir))
+      return skills;
+    for (const entry of await readdir(skillsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory())
+        continue;
+      if (await pathExists(path2.join(skillsDir, entry.name, "SKILL.md"))) {
+        skills.add(entry.name);
+      }
+    }
+    return skills;
+  }
+  async writeArtifact(missionId, args) {
+    const relativePath = validateArtifactPath(args.relativePath);
+    const dir = this.missionDir(missionId);
+    const target = path2.join(dir, relativePath);
+    assertInside(dir, target);
+    await mkdir(path2.dirname(target), { recursive: true });
+    await writeFile(target, args.content, "utf8");
+    await this.appendProgress(missionId, {
+      type: "artifact_written",
+      at: nowIso2(),
+      missionId,
+      summary: relativePath
+    });
+    return target;
+  }
+  async readProgress(missionId) {
+    return readJsonl(path2.join(this.missionDir(missionId), "progress_log.jsonl"));
+  }
+  async appendProgress(missionId, entry) {
+    await appendJsonl(path2.join(this.missionDir(missionId), "progress_log.jsonl"), entry);
+  }
+  async readHandoffs(missionId) {
+    return readJsonl(path2.join(this.missionDir(missionId), "handoffs.jsonl"));
+  }
+  async writeHandoffs(missionId, handoffs) {
+    await writeFile(path2.join(this.missionDir(missionId), "handoffs.jsonl"), handoffs.map((handoff) => JSON.stringify(handoff)).join(`
+`) + (handoffs.length ? `
+` : ""), "utf8");
+  }
+  async appendHandoff(missionId, args) {
+    const createdAt = nowIso2(args.now);
+    const id = handoffId(args.featureId, createdAt);
+    const handoffFile = path2.join(this.missionDir(missionId), "handoffs", `${id}.json`);
+    const stored = {
+      id,
+      missionId,
+      featureId: args.featureId,
+      workerSessionId: args.workerSessionId,
+      successState: args.successState,
+      returnToOrchestrator: args.returnToOrchestrator,
+      validatorsPassed: args.validatorsPassed,
+      commitId: args.commitId,
+      repoPath: args.repoPath,
+      handoffFile,
+      createdAt,
+      ...args.handoff
+    };
+    await writeJson(handoffFile, stored);
+    await this.appendTranscriptSkeleton(missionId, {
+      workerSessionId: args.workerSessionId,
+      featureId: args.featureId,
+      milestone: undefined,
+      skeleton: `Feature ${args.featureId} completed via OpenCode worker ${args.workerSessionId ?? "unknown"}.
+
+Summary: ${args.handoff.salientSummary}
+
+Commands:
+${args.handoff.verification.commandsRun.map((command) => `- ${command.command} (exit ${command.exitCode}): ${command.observation}`).join(`
+`)}`,
+      createdAt
+    });
+    await appendJsonl(path2.join(this.missionDir(missionId), "handoffs.jsonl"), stored);
+    return stored;
+  }
+  async appendTranscriptSkeleton(missionId, args) {
+    await appendJsonl(path2.join(this.missionDir(missionId), "worker-transcripts.jsonl"), {
+      timestamp: args.createdAt ?? nowIso2(),
+      workerSessionId: args.workerSessionId,
+      featureId: args.featureId,
+      milestone: args.milestone,
+      skeleton: args.skeleton
+    });
+  }
+  async readValidationState(missionId) {
+    return readJson(path2.join(this.missionDir(missionId), "validation-state.json"));
+  }
+  async dismissHandoffItems(missionId, dismissals, now) {
+    const at = nowIso2(now);
+    const reasons = new Map(dismissals.map((item) => [item.id, item.reason]));
+    const handoffs = (await this.readHandoffs(missionId)).map((handoff) => {
+      const reason = reasons.get(handoff.id);
+      if (!reason)
+        return handoff;
+      return {
+        ...handoff,
+        dismissedAt: at,
+        dismissalReason: reason
+      };
+    });
+    await this.writeHandoffs(missionId, handoffs);
+    await this.appendProgress(missionId, {
+      type: "handoff_items_dismissed",
+      at,
+      missionId,
+      summary: `${dismissals.length} handoff items dismissed`
+    });
+    return handoffs;
+  }
+  async snapshot(missionId) {
+    return {
+      dir: this.missionDir(missionId),
+      state: await this.readState(missionId),
+      features: await this.readFeatures(missionId),
+      handoffs: await this.readHandoffs(missionId),
+      progress: await this.readProgress(missionId)
+    };
+  }
+}
+
+// src/index.ts
+function jsonResult(value) {
+  return JSON.stringify(value, null, 2);
+}
+function projectRootFrom(input) {
+  return input.worktree || input.directory;
+}
+function isProtectedMissionPath(projectRoot, filePath) {
+  const resolved = path3.resolve(filePath);
+  const missionRoot = path3.join(path3.resolve(projectRoot), ".opencode", "droid-missions", "missions");
+  if (!resolved.startsWith(missionRoot + path3.sep))
+    return false;
+  return [
+    "state.json",
+    "features.json",
+    "progress_log.jsonl",
+    "handoffs.jsonl",
+    "worker-transcripts.jsonl",
+    "working_directory.txt"
+  ].includes(path3.basename(resolved));
+}
+function normalizeToolPath(args) {
+  const candidate = args.filePath ?? args.path ?? args.file ?? args.target;
+  return typeof candidate === "string" ? candidate : undefined;
+}
+function normalizeSuccessState(value) {
+  if (value === "success" || value === "partial" || value === "failure") {
+    return value;
+  }
+  throw new Error(`Invalid success state: ${value}`);
+}
+var z = tool.schema;
+var verificationCommandSchema = z.object({
+  command: z.string(),
+  exitCode: z.number(),
+  observation: z.string()
+});
+var interactiveCheckSchema = z.object({
+  action: z.string(),
+  observed: z.string()
+});
+var testCaseSchema = z.object({
+  name: z.string(),
+  verifies: z.string()
+});
+var testFileSchema = z.object({
+  file: z.string(),
+  cases: z.array(testCaseSchema)
+});
+var discoveredIssueSchema = z.object({
+  severity: z.enum(["blocking", "non_blocking", "suggestion"]),
+  description: z.string(),
+  suggestedFix: z.string().optional()
+});
+var skillDeviationSchema = z.object({
+  step: z.string(),
+  whatIDidInstead: z.string(),
+  why: z.string()
+});
+var skillFeedbackSchema = z.object({
+  followedProcedure: z.boolean(),
+  deviations: z.array(skillDeviationSchema),
+  suggestedChanges: z.array(z.string()).optional()
+});
+var handoffSchema = z.object({
+  salientSummary: z.string(),
+  whatWasImplemented: z.string(),
+  whatWasLeftUndone: z.string(),
+  verification: z.object({
+    commandsRun: z.array(verificationCommandSchema),
+    interactiveChecks: z.array(interactiveCheckSchema).optional()
+  }),
+  tests: z.object({
+    added: z.array(testFileSchema),
+    updated: z.array(z.string()).optional(),
+    coverage: z.string()
+  }),
+  discoveredIssues: z.array(discoveredIssueSchema),
+  skillFeedback: skillFeedbackSchema.optional()
+});
+function normalizeHandoff(value) {
+  const parsed = handoffSchema.safeParse(value);
+  if (!parsed.success) {
+    throw new Error(`Invalid handoff schema: ${parsed.error.message}`);
+  }
+  return parsed.data;
+}
+var DroidMissionsPlugin = async (ctx) => {
+  const projectRoot = projectRootFrom(ctx);
+  const store = new MissionStore(projectRoot);
+  const runner = new MissionRunner(store, ctx.client);
+  return {
+    tool: {
+      droid_mission_create: tool({
+        description: "Create a self-contained OpenCode mission workspace and initialize mission artifacts.",
+        args: {
+          missionId: tool.schema.string().optional(),
+          title: tool.schema.string(),
+          goal: tool.schema.string(),
+          workingDirectory: tool.schema.string().optional()
+        },
+        async execute(args, context) {
+          const mission = await store.createMission({
+            missionId: args.missionId,
+            title: args.title,
+            goal: args.goal,
+            workingDirectory: args.workingDirectory ?? context.directory
+          });
+          return jsonResult(mission);
+        }
+      }),
+      droid_mission_write_artifact: tool({
+        description: "Write an allowed mission artifact such as mission.md, AGENTS.md, validation contract, service file, script, library doc, or skill.",
+        args: {
+          missionId: tool.schema.string(),
+          relativePath: tool.schema.string(),
+          content: tool.schema.string()
+        },
+        async execute(args) {
+          const filePath = await store.writeArtifact(args.missionId, {
+            relativePath: args.relativePath,
+            content: args.content
+          });
+          return jsonResult({ filePath });
+        }
+      }),
+      droid_mission_write_features: tool({
+        description: "Replace the mission feature plan. Feature plans may not include system-managed runtime fields.",
+        args: {
+          missionId: tool.schema.string(),
+          features: tool.schema.array(tool.schema.any())
+        },
+        async execute(args) {
+          const features = await store.writeFeatures(args.missionId, args.features);
+          return jsonResult({ features });
+        }
+      }),
+      droid_mission_start: tool({
+        description: "Run the next pending mission feature in an OpenCode child session and wait for the worker prompt to return.",
+        args: {
+          missionId: tool.schema.string(),
+          message: tool.schema.string().optional(),
+          resumeWorkerSessionId: tool.schema.string().optional(),
+          restartFeature: tool.schema.boolean().optional()
+        },
+        async execute(args, context) {
+          return jsonResult(await runner.startMission({
+            missionId: args.missionId,
+            parentSessionId: context.sessionID,
+            message: args.message,
+            resumeWorkerSessionId: args.resumeWorkerSessionId,
+            restartFeature: args.restartFeature
+          }));
+        }
+      }),
+      droid_mission_end_feature: tool({
+        description: "Finish the active mission feature with a structured handoff and success, partial, or failure state.",
+        args: {
+          missionId: tool.schema.string(),
+          featureId: tool.schema.string(),
+          successState: tool.schema.enum(["success", "partial", "failure"]),
+          returnToOrchestrator: tool.schema.boolean().optional(),
+          validatorsPassed: tool.schema.boolean().optional(),
+          codeChanged: tool.schema.boolean().optional(),
+          commitId: tool.schema.string().optional(),
+          repoPath: tool.schema.string().optional(),
+          handoff: handoffSchema
+        },
+        async execute(args, context) {
+          return jsonResult(await runner.endFeatureRun({
+            missionId: args.missionId,
+            featureId: args.featureId,
+            workerSessionId: context.sessionID,
+            successState: normalizeSuccessState(args.successState),
+            returnToOrchestrator: args.returnToOrchestrator,
+            validatorsPassed: args.validatorsPassed,
+            codeChanged: args.codeChanged,
+            commitId: args.commitId,
+            repoPath: args.repoPath,
+            handoff: normalizeHandoff(args.handoff)
+          }));
+        }
+      }),
+      droid_mission_pause: tool({
+        description: "Pause a mission and abort the active OpenCode worker session if present.",
+        args: {
+          missionId: tool.schema.string(),
+          reason: tool.schema.string().optional()
+        },
+        async execute(args) {
+          return jsonResult(await runner.pauseMission(args.missionId, args.reason));
+        }
+      }),
+      droid_mission_status: tool({
+        description: "Read a complete mission snapshot: state, features, handoffs, and progress.",
+        args: {
+          missionId: tool.schema.string()
+        },
+        async execute(args) {
+          return jsonResult(await store.snapshot(args.missionId));
+        }
+      }),
+      droid_mission_complete: tool({
+        description: "Mark a mission completed after every feature and validation feature is complete.",
+        args: {
+          missionId: tool.schema.string()
+        },
+        async execute(args) {
+          return jsonResult(await runner.completeMission(args.missionId));
+        }
+      }),
+      droid_mission_dismiss_handoff_items: tool({
+        description: "Dismiss handoff items by stored handoff id with explicit reasons.",
+        args: {
+          missionId: tool.schema.string(),
+          dismissals: tool.schema.array(tool.schema.object({
+            id: tool.schema.string(),
+            reason: tool.schema.string()
+          }))
+        },
+        async execute(args) {
+          return jsonResult(await store.dismissHandoffItems(args.missionId, args.dismissals));
+        }
+      }),
+      droid_mission_list: tool({
+        description: "List all project-local OpenCode missions.",
+        args: {},
+        async execute() {
+          return jsonResult({ missions: await store.listMissions() });
+        }
+      })
+    },
+    async "tool.execute.before"(input, output) {
+      if (!["write", "edit", "apply_patch", "patch", "multiedit"].includes(input.tool) || !output.args || typeof output.args !== "object") {
+        return;
+      }
+      const filePath = normalizeToolPath(output.args);
+      if (filePath && isProtectedMissionPath(projectRoot, filePath)) {
+        throw new Error("Use droid_mission tools instead of direct edits to mission system files.");
+      }
+      const serializedArgs = JSON.stringify(output.args);
+      if (serializedArgs.includes(".opencode/droid-missions/missions/") && /state\.json|features\.json|progress_log\.jsonl|handoffs\.jsonl/.test(serializedArgs)) {
+        throw new Error("Use droid_mission tools instead of patching mission system files.");
+      }
+    },
+    async "shell.env"(input, output) {
+      const root = input.cwd.startsWith(projectRoot) ? projectRoot : input.cwd;
+      output.env.OPENCODE_DROID_MISSIONS_ROOT = path3.join(root, ".opencode", "droid-missions");
+    },
+    async "experimental.session.compacting"(_input, output) {
+      const missions = await store.listMissions();
+      const active = missions.find((mission) => mission.status !== "completed" && mission.status !== "paused");
+      if (!active)
+        return;
+      const features = await store.readFeatures(active.missionId);
+      output.context.push(buildCompactionContext({ state: active, features }));
+    }
+  };
+};
+var src_default = DroidMissionsPlugin;
+export {
+  src_default as default,
+  DroidMissionsPlugin
+};