forgedock 1.7.0 → 1.8.0

package/bin/engine/phases.mjs

@@ -116,6 +116,23 @@ async function commitsAhead(lane, branch, io) {
  */
 function has(blob, marker) { return blob.includes(marker); }
 
+/**
+ * The interactive workflow persists its conservative complexity decision in a
+ * FORGE:FAST_PATH comment. The engine must consume that decision too; otherwise
+ * its separate context/architect phases negate the documented trivial path.
+ * Only an exact TRIVIAL value is eligible to skip work, so malformed or absent
+ * annotations continue through the full pipeline.
+ */
+function complexityBand(comments) {
+  for (let i = comments.length - 1; i >= 0; i--) {
+    const body = comments[i];
+    if (!body?.includes("FORGE:FAST_PATH")) continue;
+    const match = body.match(/\*\*COMPLEXITY_BAND\*\*:\s*([A-Z_]+)/);
+    if (match) return match[1];
+  }
+  return null;
+}
+
 /**
  * Fetch the issue's live `state` (OPEN/CLOSED) and `labels` in one call.
  *
@@ -254,10 +271,13 @@ export const PHASES = [
     command: "work-on/build/context",
     entryCondition: (s) => s.committed.includes("investigate"),
     async reconcile(state, io) {
+      const markers = await issueMarkers(state.issue, io);
+      if (complexityBand(markers.comments) === "TRIVIAL") {
+        return { satisfied: true, outputs: { skipped: "trivial-complexity-band", phase: "context" } };
+      }
       // Idempotent resume: FORGE:CONTEXT:COMPLETE present → skip the LLM re-run.
       // Bare FORGE:CONTEXT matches a partial/interrupted annotation — require :COMPLETE.
-      const { blob } = await issueMarkers(state.issue, io);
-      return has(blob, PHASE_MARKERS.context.completionMarker) ? { satisfied: true } : { satisfied: false };
+      return has(markers.blob, PHASE_MARKERS.context.completionMarker) ? { satisfied: true } : { satisfied: false };
     },
     async detectOutcome(state, io) {
       const { blob } = await issueMarkers(state.issue, io);
@@ -271,10 +291,13 @@ export const PHASES = [
     command: "work-on/build/architect",
     entryCondition: (s) => s.committed.includes("context"),
     async reconcile(state, io) {
+      const markers = await issueMarkers(state.issue, io);
+      if (complexityBand(markers.comments) === "TRIVIAL") {
+        return { satisfied: true, outputs: { skipped: "trivial-complexity-band", phase: "architect" } };
+      }
       // Idempotent resume: FORGE:ARCHITECT:COMPLETE present → skip the LLM re-run.
       // Bare FORGE:ARCHITECT matches a partial/interrupted annotation — require :COMPLETE.
-      const { blob } = await issueMarkers(state.issue, io);
-      return has(blob, PHASE_MARKERS.architect.completionMarker) ? { satisfied: true } : { satisfied: false };
+      return has(markers.blob, PHASE_MARKERS.architect.completionMarker) ? { satisfied: true } : { satisfied: false };
     },
     async detectOutcome(state, io) {
       const { blob } = await issueMarkers(state.issue, io);
@@ -356,7 +379,7 @@ export const PHASES = [
       if (!pr) return { status: "failed", detail: "no PR created" };
       if (pr.merged) return { status: "committed", outputs: { pr: pr.number } };
       if (pr.needsHuman) return { status: "blocked", detail: "review escalated", outputs: { pr: pr.number } };
-      return { status: "failed", detail: "PR open, not merged" };
+      return { status: "failed", detail: "PR open, not merged", retryable: false };
     },
   },
   {
@@ -370,23 +393,9 @@ export const PHASES = [
     // phase table (closing the literal "remediate appears nowhere in the
     // engine" gap) and is fully unit-tested via `pickPhase`/`detectOutcome`.
     //
-    // KNOWN LIMITATION (documented, not fixed here — see forge#2379
-    // investigation "What We Found"): `review`'s `"blocked"` outcome (the
-    // needs-human escalation) causes `bin/engine.mjs`'s `runIssue()` to
-    // `terminate()` immediately, before `review` is ever added to
-    // `state.committed` — and the divergence guard just above that also
-    // pauses before any non-`close` phase once the issue carries
-    // `needs-human`. So a single continuous `runIssue()` walk cannot reach
-    // this phase's `entryCondition` today. In practice `remediate.md` is
-    // (correctly, per `work-on.md` Phase 0A.1) invoked as its own separate
-    // top-level entry point (`/work-on <pr> --remediate`), not as a
-    // continuation of the original run — this phase entry documents and
-    // tests the target state shape for a future run that reconstructs
-    // `committed`/`terminalReason` from live GitHub state (e.g. a dedicated
-    // remediation-run entry point) rather than from a fresh local run-log.
-    // Making that live wiring real is out of this issue's scope — it needs
-    // changes to `review`'s `"blocked"` contract and to `bin/tests/engine.test.mjs`,
-    // both outside this issue's declared file set.
+    // A blocked review is committed with terminalReason "needs-human" before
+    // the engine selects this phase, preserving the review verdict while
+    // handing the PR to remediation in the same run.
     id: "remediate",
     command: "work-on/remediate",
     entryCondition: (s) => s.committed.includes("review") && s.terminalReason === "needs-human",

package/bin/engine/resolve.mjs

@@ -94,7 +94,14 @@
  * @returns {ClassifiedInput}
  */
 export function classifyInputPattern(input) {
-  const trimmed = (input ?? "").trim();
+  // Orchestration control flags authorize or tune the dispatcher; they are not
+  // part of the issue-set predicate. Strip them here so a confirmed OpenCode
+  // fast path and the full shared resolver classify the same query.
+  const trimmed = String(input ?? "")
+    .replace(/(?:^|\s)(?:--auto|--confirm|--deep-plan)(?=\s|$)/gi, " ")
+    .replace(/(?:^|\s)--max-concurrent(?:=|\s+)[1-9]\d*(?=\s|$)/gi, " ")
+    .replace(/\s+/g, " ")
+    .trim();
   const tokens = trimmed.length > 0 ? trimmed.split(/\s+/) : [];
 
   // literal-numbers: every token is a bare integer or a (optionally

package/bin/engine/resolve.test.mjs

@@ -55,6 +55,11 @@ describe("classifyInputPattern — query patterns", () => {
     assert.equal(classifyInputPattern("fast-lane").kind, "query");
   });
 
+  it("ignores orchestration control flags when classifying the issue predicate", () => {
+    assert.equal(classifyInputPattern("fast-lane --auto --max-concurrent 4").pattern, "fast-lane");
+    assert.equal(classifyInputPattern("1 2 --confirm").kind, "literal");
+  });
+
   it("classifies priority:P0 / priority:P1 as a query (both label schemas, forge#2232)", () => {
     assert.equal(classifyInputPattern("priority:P0").pattern, "priority");
     assert.equal(classifyInputPattern("priority:P1").kind, "query");

package/bin/engine-cli.mjs

@@ -12,6 +12,7 @@ import { join } from "node:path";
 import { runIssue, DEFAULT_MAX_ATTEMPTS } from "./engine.mjs";
 import { makeProjector } from "./engine/projector.mjs";
 import { readLog, deriveState } from "./engine/runlog.mjs";
+import { assertOpenCodeNativeRuntime } from "./runner.mjs";
 
 /**
  * Workflow labels that mark an issue as "in the pipeline" (not yet terminal).
@@ -340,6 +341,7 @@ export function lastLocalRun(dir) {
 export async function runFromCli(argv, deps = {}) {
   const issue = parseInt(argv[0], 10);
   if (!Number.isInteger(issue)) throw new Error("usage: forgedock run-issue <issue-number> --lane <lane>");
+  assertOpenCodeNativeRuntime({ operation: "forgedock run-issue" });
   const lane = flag(argv, "--lane");
   if (!lane) throw new Error("--lane is required: e.g. --lane main or --lane staging. No default to prevent accidental production targeting.");
   const repo = flag(argv, "--repo");

package/bin/engine.mjs

@@ -331,7 +331,9 @@ export async function runIssue(opts) {
         // the same reason composes with that existing contract instead of
         // conflating "paused pending a human" with "dead". Deliberately does
         // NOT check `workflow:invalid`/CLOSED here — those are handled above.
-        if (snap.labels.includes("needs-human")) {
+        // A blocked review is deliberately handed to remediation in this same
+        // run. All other needs-human states remain paused for human action.
+        if (snap.labels.includes("needs-human") && phase.id !== "remediate") {
           const detail = `issue ${issue} carries needs-human — pausing before phase ${phase.id}`;
           return await terminate(state, "needs-human", detail);
         }
@@ -520,21 +522,24 @@ export async function runIssue(opts) {
       }
     }
 
+    const isRemediationHandoff = outcome.status === "blocked" &&
+      phase.id === "review" && (outcome.reason || "needs-human") === "needs-human";
     if (outcome.status === "blocked") {
       emitProgress({ event: "phase_exit", phase: phase.id, status: "blocked", detail: outcome.detail });
-      return await terminate(state, outcome.reason || "needs-human", outcome.detail);
+      if (!isRemediationHandoff)
+        return await terminate(state, outcome.reason || "needs-human", outcome.detail);
+    } else {
+      // committed
+      // forge#2321: only report a phase_exit if a matching phase_enter was
+      // actually emitted for this phase this iteration. A reconcile-satisfied
+      // phase (short-circuited above without ever entering the `else` branch)
+      // never "started" this run — emitting phase_exit for it produced a
+      // dangling exit with no preceding enter (bin/engine-cli.mjs prints
+      // "✓ phase X committed" with no prior "→ phase X started" line).
+      // Suppressing the unmatched exit is correct here rather than fabricating
+      // a synthetic phase_enter, since the phase's runner genuinely never ran.
+      if (phaseEntered) emitProgress({ event: "phase_exit", phase: phase.id, status: "committed" });
     }
-
-    // committed
-    // forge#2321: only report a phase_exit if a matching phase_enter was
-    // actually emitted for this phase this iteration. A reconcile-satisfied
-    // phase (short-circuited above without ever entering the `else` branch)
-    // never "started" this run — emitting phase_exit for it produced a
-    // dangling exit with no preceding enter (bin/engine-cli.mjs prints
-    // "✓ phase X committed" with no prior "→ phase X started" line).
-    // Suppressing the unmatched exit is correct here rather than fabricating
-    // a synthetic phase_enter, since the phase's runner genuinely never ran.
-    if (phaseEntered) emitProgress({ event: "phase_exit", phase: phase.id, status: "committed" });
     // forge#2377: `outcome.usage` is populated by runPhaseWithRetry() below
     // from the injected runner()'s (== bin/runner.mjs's runCommand()) return
     // value — null when the backend doesn't report usage (CLI backend today)
@@ -544,7 +549,10 @@ export async function runIssue(opts) {
     // owned by phase.detectOutcome() (bin/engine/phases.mjs).
     appendEvent(dir, issue, { event: "PHASE_COMMIT", phase: phase.id, outputs: outcome.outputs || {}, usage: outcome.usage ?? null });
     state = deriveState(readLog(dir, issue));
-    if (outcome.terminalReason) state.terminalReason = outcome.terminalReason;
+    const terminalReason = outcome.status === "blocked"
+      ? (outcome.reason || "needs-human")
+      : outcome.terminalReason;
+    if (terminalReason) state.terminalReason = terminalReason;
     await projector.writeState(issue, { ...state, lease: { by: agentId, until: now() + leaseTtlMs } });
 
     // forge#2379: the "investigate" phase reporting terminalReason "decomposed"
@@ -564,9 +572,10 @@ export async function runIssue(opts) {
     // is seen), phase.id is "decompose" — not "investigate" — so this
     // exemption does not apply and the normal terminate() path below fires,
     // ending the run for real.
-    const isDecomposeHandoff = phase.id === "investigate" && outcome.terminalReason === "decomposed";
-    if (outcome.terminalReason && TERMINAL_REASONS.includes(outcome.terminalReason) && !isDecomposeHandoff)
-      return await terminate(state, outcome.terminalReason);
+    const isDecomposeHandoff = phase.id === "investigate" && terminalReason === "decomposed";
+    if (terminalReason && TERMINAL_REASONS.includes(terminalReason) &&
+        !isDecomposeHandoff && !isRemediationHandoff)
+      return await terminate(state, terminalReason, outcome.detail);
     if (phase.isTerminalAfter && phase.isTerminalAfter(state))
       return await terminate(state, state.terminalReason || "merged");
   }

package/bin/forgedock.mjs

@@ -416,6 +416,40 @@ function getVersion() {
   }
 }
 
+/**
+ * Read the branch that owns the source currently being executed.
+ *
+ * This is deliberately best-effort: diagnostics should still identify the
+ * source path and version when the checkout has no readable branch ref.
+ *
+ * @param {string} [dir]
+ * @returns {string|null}
+ */
+function getGitBranch(dir = FORGE_HOME) {
+  try {
+    const branch = execFileSync(
+      "git",
+      ["rev-parse", "--abbrev-ref", "HEAD"],
+      { cwd: dir, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] },
+    ).trim();
+    return branch || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Describe the source path the current CLI process resolves from.
+ *
+ * @param {string|null} [branch]
+ * @returns {string}
+ */
+function formatSourceIdentity(branch = null) {
+  const version = getVersion() || "unknown";
+  const branchLabel = branch ? `, branch ${branch}` : "";
+  return `${FORGE_HOME} (v${version}${branchLabel})`;
+}
+
 /**
  * Compare two dotted version strings component-wise (numeric, not
  * lexicographic — "1.9.0" must compare as older than "1.10.0").
@@ -1330,11 +1364,51 @@ async function uninstall() {
   console.log("");
 }
 
-// Reinstall = relink commands + re-register the hook. Never the full
-// journey: update must not reach read/review, which could overwrite a
-// curated forge.yaml (and re-runs AI enrichment on every update). Also
-// idempotent, so it's the repair path for a configured repo whose
-// symlinks or hook registration got out of sync.
+// Reinstall = relink commands + re-register the hook + refresh an already
+// installed OpenCode adapter. Never the full journey: update must not reach
+// read/review, which could overwrite a curated forge.yaml (and re-runs AI
+// enrichment on every update). Also idempotent, so it's the repair path for a
+// configured repo whose symlinks, hook registration, or managed OpenCode files
+// got out of sync.
+async function refreshManagedOpenCodeAdapter() {
+  try {
+    const { getOpenCodeAdapterStatus, installOpenCodeAdapter } = await import("./opencode-adapter.mjs");
+    const status = await getOpenCodeAdapterStatus({ home: HOME, env: process.env });
+    if (!status.installed) return;
+
+    // npm/npx payloads must be persisted before the generated adapter points at
+    // them; git-clone installs are already stable and persistHome returns them
+    // unchanged.
+    const persisted = await persistHome(ctx());
+    const adapterForgeHome = persisted.forgeHome || FORGE_HOME;
+    if (adapterForgeHome === FORGE_HOME && isEphemeralCachePath(FORGE_HOME)) {
+      console.log(
+        `  ${YELLOW}OpenCode adapter refresh skipped: the current ForgeDock payload is ephemeral.${RESET}`,
+      );
+      return;
+    }
+
+    const result = await installOpenCodeAdapter({
+      forgeHome: adapterForgeHome,
+      home: HOME,
+      env: process.env,
+      includeExtras: status.manifest?.includeExtras === true,
+    });
+    console.log(
+      `  ${GREEN}Refreshed managed OpenCode adapter (${result.commandCount} commands, ${result.skillCount} skills).${RESET}`,
+    );
+    for (const warning of result.migration.warnings) {
+      console.log(`  ${YELLOW}OpenCode adapter warning: ${warning}${RESET}`);
+    }
+  } catch (error) {
+    // OpenCode refresh is best-effort, matching the existing update/relink
+    // behavior: a permissions or ownership problem must not block Claude users.
+    console.log(
+      `  ${YELLOW}Could not refresh the managed OpenCode adapter: ${error?.message || String(error)}${RESET}`,
+    );
+  }
+}
+
 async function relinkAndHint() {
   const c = ctx();
   const forged = await forge(c);
@@ -1343,9 +1417,10 @@ async function relinkAndHint() {
   // version-check path), so wiring it here covers "refreshed after every
   // successful update" without duplicating the call at each branch. Note:
   // this is NOT reached by install's already-managed-active short-circuit
-  // (that path calls statusScreen(), never relinkAndHint()) — see the
+  // (that path is also used by managed-active install) — see the
   // writeInstallReceipt() JSDoc in journey.mjs for the full picture.
   await writeInstallReceipt(c, { forged });
+  await refreshManagedOpenCodeAdapter();
   if (!existsSync(join(c.cwd, "forge.yaml"))) {
     const dim = (s) => (c.mode === "none" ? s : `\x1b[2m${s}\x1b[22m`);
     c.stdout.write("  " + dim("Configure this repo: npx forgedock init") + "\n");
@@ -1808,24 +1883,18 @@ async function update() {
     const separateGlobalInstall = findSeparateGlobalInstall();
     if (separateGlobalInstall) {
       console.log(
-        `  ${YELLOW}Note: this updates the git clone above. Your global npm install at ${separateGlobalInstall} was NOT touched.${RESET}`,
+        `  ${YELLOW}Note: this command resolves to the git clone above. Your global npm install at ${separateGlobalInstall} is NOT touched.${RESET}`,
       );
       console.log(
         `  ${YELLOW}Run 'npm update -g forgedock', or 'npx forgedock update' from outside a clone, to update it.${RESET}`,
       );
     }
     try {
-      const branch = execSync("git rev-parse --abbrev-ref HEAD", {
-        cwd: FORGE_HOME,
-        encoding: "utf-8",
-      }).trim();
+      const branch = getGitBranch();
+      const branchLabel = branch || "unknown branch";
+      console.log(`  Source: ${formatSourceIdentity(branch)}`);
 
-      // If on a non-main branch, switch to main for the update then restore.
-      // Detached HEAD ("HEAD") is treated as non-restorable — we leave on main
-      // after the update and warn the user.
-      const isDetached = branch === "HEAD";
-      const needsCheckout = branch !== "main";
-      if (needsCheckout) {
+      if (branch !== "main") {
         // Dirty-tree guard: refuse to move HEAD in this clone if there are
         // uncommitted TRACKED changes. Untracked files are intentionally
         // excluded (--untracked-files=no) so a clean checkout with stray
@@ -1837,7 +1906,7 @@ async function update() {
         ).trim();
         if (porcelain) {
           console.log(
-            `  ${YELLOW}Working tree has uncommitted changes on branch ${branch} — skipping git-based update.${RESET}`,
+            `  ${YELLOW}Working tree has uncommitted changes on branch ${branchLabel} — skipping git-based update.${RESET}`,
           );
 
           // forge#2460 — distinguish "developing on this checkout" from a
@@ -1882,16 +1951,13 @@ async function update() {
           return;
         }
 
-        if (isDetached) {
-          console.log(
-            `  ${YELLOW}Detached HEAD state — switching to main for update.${RESET}`,
-          );
-        } else {
-          console.log(
-            `  On branch ${CYAN}${branch}${RESET} — switching to ${CYAN}main${RESET} for update...`,
-          );
-        }
-        execFileSync("git", ["checkout", "main", "--quiet"], { cwd: FORGE_HOME });
+        console.log(
+          `  ${YELLOW}Source checkout is on ${branchLabel}, not main; skipping update to preserve this source.${RESET}`,
+        );
+        console.log(
+          `  Run 'npx forgedock update' from a main-branch checkout (or use 'npx forgedock@latest') to refresh ForgeDock.`,
+        );
+        return;
       }
 
       const before = execSync("git rev-parse HEAD", {
@@ -1914,20 +1980,6 @@ async function update() {
         printGitCloneChangelogSummary(before, after);
       }
       await relinkAndHint();
-
-      // Restore original branch after a successful update.
-      if (needsCheckout && !isDetached) {
-        try {
-          execFileSync("git", ["checkout", branch, "--quiet"], { cwd: FORGE_HOME });
-          console.log(
-            `  Restored branch ${CYAN}${branch}${RESET}.`,
-          );
-        } catch {
-          console.log(
-            `  ${YELLOW}⚠  Could not restore branch ${branch} — you are now on main.${RESET}`,
-          );
-        }
-      }
     } catch (err) {
       console.log(
         `  ${YELLOW}Cannot fast-forward — local changes exist. Skipping.${RESET}`,
@@ -2190,7 +2242,14 @@ async function doctor(fix = false) {
   console.log("");
 
   const { targetDir: TARGET_DIR } = detectInstallPaths();
-  console.log(`  Mode: global (~/.claude)`);
+  const isGitCloneInstall = existsSync(join(FORGE_HOME, ".git"));
+  const sourceBranch = isGitCloneInstall ? getGitBranch() : null;
+  console.log(
+    isGitCloneInstall
+      ? `  Mode: git clone at ${CYAN}${FORGE_HOME}${RESET}`
+      : `  Mode: global (~/.claude)`,
+  );
+  console.log(`  Source: ${formatSourceIdentity(sourceBranch)}`);
   console.log("");
 
   let failures = 0;
@@ -2357,6 +2416,16 @@ async function doctor(fix = false) {
                 broken++;
                 brokenLinks.push(rel);
                 symlinkOk = false;
+              } else {
+                try {
+                  // readlink() only validates the stored target. Opening the
+                  // link also catches platform-specific traversal failures.
+                  readFileSync(tgt);
+                } catch {
+                  broken++;
+                  brokenLinks.push(`${rel} (unreadable — link resolves but cannot be traversed)`);
+                  symlinkOk = false;
+                }
               }
             } else {
               // Regular file — copy-mode install (Windows without Developer Mode).
@@ -2717,7 +2786,6 @@ async function doctor(fix = false) {
   // absence that isn't a problem should not read as one.
   {
     try {
-      const isGitCloneInstall = existsSync(join(FORGE_HOME, ".git"));
       if (isGitCloneInstall) {
         pass("Persisted toolset home (~/.forge)", "skipped — git-clone install links directly from the clone");
       } else {
@@ -3208,6 +3276,7 @@ function help() {
  *   FORGEDOCK_BACKEND      Default backend ("cli"|"api"|"auto") when --backend is omitted.
  *   FORGEDOCK_MODEL        Default model id when --model is omitted.
  *   FORGEDOCK_CLI_TIMEOUT_MS  Wall-clock timeout (ms) for the cli backend invocation.
+ *                              Overrides forge.yaml pipeline.cli_timeout_minutes.
  *   FORGEDOCK_SHELL        Override the shell used by run_bash / the cli backend.
  *                          Defaults to bash when found (Git Bash / WSL on
  *                          Windows, /bin/bash on POSIX), falling back to the
@@ -3750,7 +3819,9 @@ switch (command) {
       }
     }
     if (existsSync(join(c.cwd, "forge.yaml")) && resolveState(c.cwd) === "managed-active") {
-      await statusScreen(c);
+      // A configured directory may still have missing commands after uninstall.
+      // Refresh managed files without re-running the configuration journey.
+      await relinkAndHint();
     } else {
       exitCode = await runJourney(c);
       // Record persistHome()'s outcome (set on c.persistHomeResult inside
@@ -3825,7 +3896,7 @@ switch (command) {
         includeExtras: restArgs.includes("--extras"),
       });
       process.stdout.write(
-        `Installed ${result.commandCount} OpenCode commands under ${result.configDir}.\n` +
+        `Installed ${result.commandCount} OpenCode commands and ${result.skillCount} skills under ${result.configDir}.\n` +
           "Restart OpenCode, then run /forge/work-on <issue>.\n",
       );
       if (result.migration.removedInstructionsFile || result.migration.removedConfigEntries > 0) {
@@ -3836,7 +3907,12 @@ switch (command) {
       for (const warning of result.migration.warnings) process.stderr.write(`Warning: ${warning}\n`);
     } else if (action === "status") {
       const result = await getOpenCodeAdapterStatus({ home: HOME });
-      if (!result.installed) {
+      if (result.legacy) {
+        process.stdout.write(
+          "A legacy ForgeDock OpenCode adapter is installed. Re-run: npx forgedock opencode install\n",
+        );
+        exitCode = 1;
+      } else if (!result.installed) {
         process.stdout.write(`OpenCode adapter is not installed under ${result.configDir}.\n`);
         exitCode = 1;
       } else if (!result.healthy) {
@@ -3847,7 +3923,7 @@ switch (command) {
         exitCode = 1;
       } else {
         process.stdout.write(
-          `OpenCode adapter is healthy (${result.manifest.commandCount} commands) under ${result.configDir}.\n`,
+          `OpenCode adapter is healthy (${result.manifest.commandCount} commands, ${result.manifest.skillCount ?? 0} skills) under ${result.configDir}.\n`,
         );
       }
     } else if (action === "uninstall") {