@jskit-ai/jskit-cli 0.2.79 → 0.2.81

package/src/server/sessionRuntime/prompts/new_issue.md

@@ -0,0 +1,31 @@
+Create a GitHub issue from this user request:
+
+{{user_input}}
+
+First inspect the local app enough to understand the request in context. Use package.json, config, .jskit metadata, routes, packages, and any saved app blueprint when available. Classify the current app state as empty, non_jskit_repo, partial_jskit_app, or jskit_app before assuming ordinary feature work is possible.
+
+Draft an implementation-ready issue, not a broad product essay.
+
+Preserve these JSKIT boundaries:
+
+- If the app is empty or a partial JSKIT app, the issue should be about bootstrap or recovery before feature implementation.
+- If platform choices are still provisional, make the issue resolve those choices before installing tenancy-sensitive packages.
+- Do not ask the developer to redesign standard JSKIT package-owned workflows from scratch. Treat selected package workflows as defaults unless the request asks for overrides, restrictions, or custom additions.
+- For persisted app-owned data, prefer generated/package ownership over direct hand-built persistence. A new ordinary table should usually become a server CRUD-owned entity before CRUD UI or route work.
+- For non-CRUD app pages, prefer the JSKIT UI generator when it fits.
+- Keep direct knex or low-level runtime work exceptional and explicitly justified.
+- Do not include workflow bookkeeping such as old workboards in the issue body. JSKIT session state and receipts are the workflow tracker.
+
+Ask concise clarifying questions if the request is not specific enough to produce a useful implementation issue. Ask only for details that materially change the ticket.
+
+When the issue is ready, output only the final issue title and body surrounded by these exact markers:
+
+[issue_title]
+<short issue title>
+[/issue_title]
+
+[issue_text]
+<issue body in Markdown, without repeating the title as a heading>
+[/issue_text]
+
+The issue should be concrete, scoped, and implementation-ready. Include acceptance criteria when they are useful.

package/src/server/sessionRuntime/prompts/plan_issue.md

@@ -0,0 +1,50 @@
+Create an implementation plan for JSKIT session {{session_id}}.
+
+GitHub issue: {{issue_url}}
+Issue number: {{issue_number}}
+Issue title: {{issue_title}}
+Issue body file: {{issue_file}}
+Issue title file: {{issue_title_file}}
+Plan file to create: {{plan_file}}
+Worktree: {{worktree}}
+
+Read the issue and inspect the local app before planning. Use the issue files, package.json, .jskit metadata, config, packages, routes, generated references, package docs, and any saved app blueprint when available.
+
+Start by identifying the app state and the implementation lane:
+
+- empty, non_jskit_repo, partial_jskit_app, or jskit_app
+- package install
+- generator scaffolding
+- custom local code
+- a combination of those
+
+Planning rules:
+
+- Keep the plan scoped to the issue. Avoid "while I am here" work.
+- Prefer vertical slices that produce visible or end-to-end progress.
+- If the work is too broad to review confidently, split it into clear chunks.
+- Make generator decisions concrete. Name the exact `jskit` commands to run when a generator or package install applies.
+- For non-CRUD route page work, plan to check `jskit show ui-generator --details` and `jskit list-placements` before hand-writing pages or placement entries.
+- For CRUD work, plan server ownership first. Name the `jskit generate crud-server-generator scaffold ...` command before any CRUD UI plan.
+- For CRUD-owned tables, plan around the real database table shape. Do not plan a separate hand-written migration for a table that `crud-server-generator` will own.
+- Every persisted app-owned table should have generated/package CRUD ownership unless there is a narrow explicit exception.
+- Do not hand-build CRUD routes, CRUD endpoints, or CRUD page trees before the server CRUD package and shared resource file exist.
+- `feature-server-generator` is for non-CRUD workflows and orchestration, not ordinary persisted entity tables.
+- Keep runtime, UI, and data concerns separated.
+- Keep direct knex exceptional and minimal. Prefer internal json-rest-api seams outside generated CRUD packages and explicit weird-custom feature lanes.
+- For package-owned baseline workflows, plan to install and verify the baseline before inventing custom code around it.
+- For user-facing UI, include Material/Vuetify quality expectations and a Playwright verification path.
+- If login is required for UI verification, plan for a development-only auth bootstrap path instead of live external auth.
+- Do not create or update the old `.jskit/WORKBOARD.md` workflow. JSKIT session state, receipts, issue text, plan file, transcript, and commits are the tracker.
+
+If setup values are needed, ask plainly using exact env var or option names. For example: DB_NAME, DB_USER, DB_PASSWORD, DB_HOST, DB_PORT, AUTH_SUPABASE_URL, AUTH_SUPABASE_PUBLISHABLE_KEY, APP_PUBLIC_URL.
+
+If the issue is not clear enough to plan safely, ask the user concise follow-up questions first.
+
+When the plan is ready, output only the final plan surrounded by these exact markers:
+
+[plan]
+<implementation plan in Markdown>
+[/plan]
+
+Keep the plan concrete and implementation-oriented. Include the likely files or areas to touch, ordered steps, generator commands to consider, review expectations, and checks that should be run.

package/src/server/sessionRuntime/prompts/pr_failure.md

@@ -0,0 +1,28 @@
+The JSKIT session PR operation failed.
+
+Session:
+
+{{session_id}}
+
+Worktree:
+
+{{worktree}}
+
+Failure output:
+
+{{doctor_output}}
+
+Diagnose the failure and fix only what is required in this worktree.
+
+Check for:
+
+- missing or wrong GitHub remote
+- missing GitHub auth
+- branch push failure
+- PR body/title issue
+- stale local git state
+- rejected merge or failing required checks
+
+Use repository-portable repairs only. Do not hard-code local paths or credentials. Do not create a parallel manual workflow around the JSKIT session.
+
+Do not push, open a PR, merge, or remove the worktree unless JSKIT Studio or the JSKIT session step explicitly instructs it. Report root cause, changed files, commands run, and remaining risk.

package/src/server/sessionRuntime/prompts/review_changes.md

@@ -0,0 +1,43 @@
+Review changes for session {{session_id}}.
+
+Changed files from the latest commit:
+
+{{changed_files}}
+
+Review the committed changes and fix important issues in this worktree when the fix is clear and scoped.
+
+Use four passes:
+
+1. Deslop review
+   - repeated functions or duplicated local helpers
+   - helpers reimplemented locally when a kernel/runtime seam already exists
+   - placeholder, fake-complete, or vague UI/copy/code structure
+   - dead code, unused props/imports, TODO-shaped gaps, or accidental abstractions
+   - missing loading, empty, error, permission, or ownership states
+   - broken flows, missing route wiring, missing migrations, or stale generated metadata
+   - surface or entity ownership mistakes: public, user, workspace, workspace_user
+2. JSKIT review
+   - existing helper/runtime seam available?
+   - should this have been a package install, generator step, or scaffold extension instead of hand code?
+   - if a generator existed, was the exact `jskit` command used or was the gap documented?
+   - for CRUD work, was `crud-server-generator scaffold` used before CRUD UI or CRUD route hand-coding?
+   - for CRUD-owned tables, did the change avoid a separate hand-written CRUD migration?
+   - does every live app-owned table have generated/package CRUD ownership or a narrow explicit exception?
+   - is direct app-owned knex usage limited to generated CRUD packages or explicit weird-custom feature lanes?
+   - are surface, route, ownership, package metadata, and migration choices aligned with JSKIT conventions?
+3. UI standards review
+   - user-facing screens follow Material Design and Vuetify best practices
+   - list screens have clear hierarchy, actions, density, empty states, and table/list patterns
+   - view and edit/new screens have clear grouping, labels, helper text, validation, spacing, and action placement
+   - responsive layout, loading, disabled, success, and error states are coherent
+   - improve weak screens before sign-off when the fix is scoped
+4. Verification review
+   - run the smallest relevant verification commands for the changed scope
+   - any changed user-facing UI should be exercised with Playwright when possible
+   - UI verification should normally be recorded through `jskit app verify-ui`
+   - if login is required, use the chosen local test-auth path instead of live external auth
+   - if there is no usable local auth bootstrap path, record it as a blocking testability gap
+
+Do not create commits, branches, pull requests, merges, or worktree cleanup yourself. JSKIT session owns those steps.
+
+When finished, report findings ordered by severity, fixes made, changed files, checks run, and anything still unverified. If there are no important findings, say so explicitly and list residual risk.

package/src/server/sessionRuntime/prompts/user_check.md

@@ -0,0 +1,13 @@
+User check for session {{session_id}}.
+
+The code should already be built or runnable according to the implementation instructions.
+
+Ask the user to test the changed behavior in the app and report whether it works as intended. Be specific about the user-visible behavior, route, command, or workflow to inspect.
+
+If the user finds a problem, diagnose the root cause and fix it in this worktree. Keep the fix scoped. Reuse JSKIT helpers, generated seams, and package workflows where they apply.
+
+If the behavior works, tell the user to run:
+
+jskit session {{session_id}} step --user-check passed
+
+Do not commit, push, create a PR, merge, or clean up the worktree yourself. JSKIT session owns those steps.

package/src/server/sessionRuntime/responses.js

@@ -0,0 +1,442 @@
+import { mkdir, readdir } from "node:fs/promises";
+import path from "node:path";
+import {
+  SESSION_STATUS,
+  STEP_DEFINITION_BY_ID,
+  STEP_DEFINITIONS,
+  STEP_IDS,
+  STEP_LABEL_BY_ID
+} from "./constants.js";
+import {
+  fileExists,
+  normalizeText,
+  readTextIfExists,
+  readTrimmedFile,
+  timestampForReceipt,
+  writeTextFile
+} from "./io.js";
+import {
+  pathsForExistingSession
+} from "./paths.js";
+import {
+  hasWorktree
+} from "./worktrees.js";
+
+function createError({
+  code,
+  message,
+  repairCommand = ""
+}) {
+  return Object.freeze({
+    code: normalizeText(code),
+    message: normalizeText(message),
+    repairCommand: normalizeText(repairCommand)
+  });
+}
+
+function createPrecondition({
+  id,
+  ok,
+  message
+}) {
+  return Object.freeze({
+    id: normalizeText(id),
+    ok: ok === true,
+    message: normalizeText(message)
+  });
+}
+
+const LEGACY_CURRENT_STEP_ID_ALIASES = Object.freeze({
+  implementation_changes_detected: "implementation_changes_accepted",
+  review_changes_detected: "review_changes_accepted"
+});
+
+const LEGACY_COMPLETED_STEP_ID_ALIASES = Object.freeze({
+  implementation_changes_detected: Object.freeze(["implementation_changes_accepted"]),
+  review_changes_detected: Object.freeze(["review_changes_accepted", "review_changes_committed"])
+});
+
+const LEGACY_RECEIPT_STEP_ID_ALIASES = Object.freeze({
+  implementation_changes_detected: "implementation_changes_accepted",
+  review_changes_detected: "review_changes_committed"
+});
+
+function normalizeStepId(stepId) {
+  const normalized = normalizeText(stepId);
+  return LEGACY_CURRENT_STEP_ID_ALIASES[normalized] || normalized;
+}
+
+function completedStepIdsForReceipt(stepId) {
+  const normalized = normalizeText(stepId);
+  return LEGACY_COMPLETED_STEP_ID_ALIASES[normalized] || [normalized];
+}
+
+function receiptStepId(stepId) {
+  const normalized = normalizeText(stepId);
+  return LEGACY_RECEIPT_STEP_ID_ALIASES[normalized] || normalizeStepId(normalized);
+}
+
+function stepIndex(stepId) {
+  return STEP_IDS.indexOf(normalizeStepId(stepId));
+}
+
+function normalizeKnownStepIds(stepIds = []) {
+  return Array.from(
+    new Set(
+      stepIds
+        .flatMap((stepId) => completedStepIdsForReceipt(stepId))
+        .map((stepId) => normalizeText(stepId))
+        .filter((stepId) => STEP_IDS.includes(stepId))
+    )
+  ).sort((left, right) => STEP_IDS.indexOf(left) - STEP_IDS.indexOf(right));
+}
+
+function stepCanExposeStoredPrompt(stepId) {
+  const step = STEP_DEFINITION_BY_ID[normalizeStepId(stepId)];
+  return Boolean(step?.codex || step?.kind === "human_input");
+}
+
+const PROMPT_ARTIFACT_BY_STEP_ID = Object.freeze({
+  issue_drafted: "issue_draft.md",
+  plan_made: "plan_request.md",
+  user_check_completed: "user_check.md"
+});
+
+async function readPromptForStep(paths, stepId) {
+  if (!stepCanExposeStoredPrompt(stepId)) {
+    return "";
+  }
+  const promptArtifact = PROMPT_ARTIFACT_BY_STEP_ID[normalizeStepId(stepId)];
+  if (promptArtifact) {
+    const prompt = await readTextIfExists(path.join(paths.sessionRoot, "prompts", promptArtifact));
+    if (prompt) {
+      return prompt;
+    }
+  }
+  return readTextIfExists(path.join(paths.sessionRoot, "prompt.md"));
+}
+
+async function readCompletedSteps(sessionRoot) {
+  const stepsRoot = path.join(sessionRoot, "steps");
+  try {
+    const entries = await readdir(stepsRoot, { withFileTypes: true });
+    return normalizeKnownStepIds(entries
+      .filter((entry) => entry.isFile())
+      .map((entry) => entry.name));
+  } catch {
+    return [];
+  }
+}
+
+async function readReceiptSteps(paths) {
+  const stepsRoot = path.join(paths.sessionRoot, "steps");
+  try {
+    const entries = await readdir(stepsRoot, { withFileTypes: true });
+    const knownStepRows = new Map();
+    const unknownStepRows = [];
+    entries
+      .filter((entry) => entry.isFile())
+      .map((entry) => entry.name)
+      .forEach((receiptName) => {
+        const stepId = receiptStepId(receiptName);
+        if (STEP_IDS.includes(stepId)) {
+          if (!knownStepRows.has(stepId) || receiptName === stepId) {
+            knownStepRows.set(stepId, {
+              receiptName,
+              stepId
+            });
+          }
+          return;
+        }
+        unknownStepRows.push({
+          receiptName,
+          stepId
+        });
+      });
+
+    const stepRows = [...knownStepRows.values(), ...unknownStepRows]
+      .sort((left, right) => {
+        const leftIndex = stepIndex(left.stepId);
+        const rightIndex = stepIndex(right.stepId);
+        if (leftIndex >= 0 && rightIndex >= 0) {
+          return leftIndex - rightIndex;
+        }
+        if (leftIndex >= 0) {
+          return -1;
+        }
+        if (rightIndex >= 0) {
+          return 1;
+        }
+        return left.stepId.localeCompare(right.stepId);
+      });
+
+    return Promise.all(stepRows.map(async ({ receiptName, stepId }) => ({
+      label: STEP_LABEL_BY_ID[stepId] || stepId,
+      receipt: (await readTextIfExists(path.join(stepsRoot, receiptName))).trim(),
+      stepId
+    })));
+  } catch {
+    return [];
+  }
+}
+
+function resolveNextStep(completedSteps = []) {
+  const completed = new Set(completedSteps);
+  return STEP_IDS.find((stepId) => !completed.has(stepId)) || "";
+}
+
+function cloneContractValue(value) {
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => cloneContractValue(entry));
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [key, cloneContractValue(entry)])
+  );
+}
+
+function publicStepDefinition(step, index) {
+  return {
+    description: step.description,
+    id: step.id,
+    index,
+    input: cloneContractValue(step.input),
+    kind: step.kind,
+    label: step.label,
+    utilityActions: cloneContractValue(step.utilityActions || [])
+  };
+}
+
+function buildStepDefinitions() {
+  return STEP_DEFINITIONS.map((step, index) => publicStepDefinition(step, index));
+}
+
+function buildCurrentStepAction(stepId) {
+  const step = STEP_DEFINITION_BY_ID[stepId];
+  if (!step) {
+    return null;
+  }
+  return {
+    buttonLabel: step.buttonLabel,
+    description: step.description,
+    index: STEP_IDS.indexOf(step.id),
+    input: cloneContractValue(step.input),
+    kind: step.kind,
+    stepId: step.id,
+    utilityActions: cloneContractValue(step.utilityActions || [])
+  };
+}
+
+function buildCodexHandoff(stepId) {
+  const step = STEP_DEFINITION_BY_ID[stepId];
+  return step?.codex ? cloneContractValue(step.codex) : null;
+}
+
+async function readSessionArtifacts(paths) {
+  const [status, rawCurrentStep, issueUrl, prUrl, issueText, issueTitle, planText, codexThreadId] = await Promise.all([
+    readTrimmedFile(path.join(paths.sessionRoot, "status")),
+    readTrimmedFile(path.join(paths.sessionRoot, "current_step")),
+    readTrimmedFile(path.join(paths.sessionRoot, "issue_url")),
+    readTrimmedFile(path.join(paths.sessionRoot, "pr_url")),
+    readTextIfExists(path.join(paths.sessionRoot, "issue.md")),
+    readTrimmedFile(path.join(paths.sessionRoot, "issue_title")),
+    readTextIfExists(path.join(paths.sessionRoot, "plan.md")),
+    readTrimmedFile(path.join(paths.sessionRoot, "codex_thread_id"))
+  ]);
+  const currentStep = normalizeStepId(rawCurrentStep);
+  const worktreeReady = await hasWorktree(paths);
+  let completedSteps = await readCompletedSteps(paths.sessionRoot);
+  const worktreeRemovalCompleted = completedSteps.includes("pr_merged") ||
+    completedSteps.includes("worktree_removed");
+  const worktreeReceiptInvalid = !worktreeReady &&
+    completedSteps.includes("worktree_created") &&
+    !worktreeRemovalCompleted &&
+    status !== SESSION_STATUS.FINISHED &&
+    status !== SESSION_STATUS.ABANDONED;
+  if (worktreeReceiptInvalid) {
+    completedSteps = completedSteps.filter((stepId) => !["worktree_created", "dependencies_installed"].includes(stepId));
+  }
+  const nextStep = resolveNextStep(completedSteps);
+  const currentStepIndex = stepIndex(currentStep);
+  const nextStepIndex = stepIndex(nextStep);
+  const effectiveCurrentStep = nextStep &&
+    (completedSteps.includes(currentStep) || currentStepIndex < 0 || currentStepIndex > nextStepIndex)
+    ? nextStep
+    : currentStep || nextStep;
+  const prompt = await readPromptForStep(paths, effectiveCurrentStep);
+
+  return {
+    codexThreadId,
+    completedSteps,
+    currentStep: effectiveCurrentStep,
+    issueTitle,
+    issueText: issueText.trim(),
+    issueUrl,
+    nextStep,
+    prUrl,
+    planText: planText.trim(),
+    prompt: prompt.trim(),
+    status: status || SESSION_STATUS.PENDING,
+    worktreeReady
+  };
+}
+
+function buildNextCommand(sessionId, stepId) {
+  if (!stepId) {
+    return "";
+  }
+  const template = STEP_DEFINITION_BY_ID[stepId]?.nextCommandTemplate || "jskit session {{session_id}} step";
+  return template.replaceAll("{{session_id}}", sessionId);
+}
+
+async function buildSessionResponse(paths, {
+  codex = undefined,
+  ok = true,
+  errors = [],
+  preconditions = [],
+  prompt = undefined,
+  status = undefined
+} = {}) {
+  const responsePaths = paths.sessionId ? await pathsForExistingSession(paths) : paths;
+  const artifacts = responsePaths.sessionRoot ? await readSessionArtifacts(responsePaths) : {};
+  const resolvedStatus = status || artifacts.status || (ok ? SESSION_STATUS.PENDING : SESSION_STATUS.BLOCKED);
+  const currentStep = artifacts.currentStep || artifacts.nextStep || "";
+  const responsePrompt = typeof prompt === "string"
+    ? prompt
+    : stepCanExposeStoredPrompt(currentStep) ? artifacts.prompt || "" : "";
+
+  return {
+    ok: ok === true,
+    sessionId: paths.sessionId || "",
+    status: resolvedStatus,
+    currentStep,
+    completedSteps: artifacts.completedSteps || [],
+    stepDefinitions: buildStepDefinitions(),
+    currentStepAction: buildCurrentStepAction(currentStep),
+    codex: codex === undefined ? buildCodexHandoff(currentStep) : cloneContractValue(codex),
+    prompt: responsePrompt,
+    nextCommand: buildNextCommand(paths.sessionId || "", currentStep),
+    issueUrl: artifacts.issueUrl || "",
+    issueTitle: artifacts.issueTitle || "",
+    issueText: artifacts.issueText || "",
+    planText: artifacts.planText || "",
+    prUrl: artifacts.prUrl || "",
+    preconditions,
+    errors,
+    archive: responsePaths.archive || (resolvedStatus === SESSION_STATUS.FINISHED ? "completed" : resolvedStatus === SESSION_STATUS.ABANDONED ? "abandoned" : "active"),
+    sessionRoot: responsePaths.sessionRoot || "",
+    worktree: paths.worktree || "",
+    worktreeReady: artifacts.worktreeReady === true,
+    branch: paths.branch || "",
+    codexThreadId: artifacts.codexThreadId || ""
+  };
+}
+
+function buildSessionErrorResponse({
+  targetRoot = process.cwd(),
+  sessionId = "",
+  code,
+  message,
+  repairCommand = "",
+  status = SESSION_STATUS.BLOCKED,
+  preconditions = [],
+  errors = undefined
+} = {}) {
+  const normalizedTargetRoot = path.resolve(normalizeText(targetRoot) || process.cwd());
+  const errorList = Array.isArray(errors)
+    ? errors
+    : [
+        createError({
+          code,
+          message,
+          repairCommand
+        })
+      ];
+
+  return {
+    ok: false,
+    sessionId: normalizeText(sessionId),
+    status,
+    currentStep: "",
+    completedSteps: [],
+    stepDefinitions: buildStepDefinitions(),
+    currentStepAction: null,
+    codex: null,
+    prompt: "",
+    nextCommand: "",
+    issueTitle: "",
+    issueText: "",
+    planText: "",
+    issueUrl: "",
+    prUrl: "",
+    preconditions,
+    errors: errorList,
+    archive: "",
+    sessionRoot: "",
+    worktree: "",
+    worktreeReady: false,
+    branch: "",
+    codexThreadId: "",
+    targetRoot: normalizedTargetRoot
+  };
+}
+
+async function markStatus(paths, status) {
+  await writeTextFile(path.join(paths.sessionRoot, "status"), status);
+}
+
+async function markCurrentStep(paths, stepId) {
+  await writeTextFile(path.join(paths.sessionRoot, "current_step"), stepId);
+}
+
+async function writeReceipt(paths, stepId, message) {
+  await mkdir(path.join(paths.sessionRoot, "steps"), { recursive: true });
+  await writeTextFile(
+    path.join(paths.sessionRoot, "steps", stepId),
+    `${timestampForReceipt()}\n${normalizeText(message) || STEP_LABEL_BY_ID[stepId] || stepId}`
+  );
+  const completedSteps = await readCompletedSteps(paths.sessionRoot);
+  await markCurrentStep(paths, resolveNextStep(completedSteps));
+}
+
+async function failSession(paths, {
+  code,
+  message,
+  repairCommand = "",
+  preconditions = [],
+  status = SESSION_STATUS.BLOCKED,
+  prompt = ""
+}) {
+  if (paths.sessionRoot && await fileExists(paths.sessionRoot)) {
+    await markStatus(paths, status);
+  }
+  return buildSessionResponse(paths, {
+    ok: false,
+    status,
+    prompt,
+    preconditions,
+    errors: [
+      createError({
+        code,
+        message,
+        repairCommand
+      })
+    ]
+  });
+}
+
+export {
+  buildSessionErrorResponse,
+  buildSessionResponse,
+  buildStepDefinitions,
+  createError,
+  createPrecondition,
+  failSession,
+  markCurrentStep,
+  markStatus,
+  readReceiptSteps,
+  readSessionArtifacts,
+  writeReceipt
+};

package/src/server/sessionRuntime/worktrees.js

@@ -0,0 +1,31 @@
+import path from "node:path";
+import {
+  runGit
+} from "./io.js";
+
+function parseGitWorktreeList(output = "") {
+  return String(output || "")
+    .split(/\r?\n/u)
+    .filter((line) => line.startsWith("worktree "))
+    .map((line) => path.resolve(line.slice("worktree ".length).trim()))
+    .filter(Boolean);
+}
+
+async function hasWorktree(paths = {}) {
+  if (!paths.targetRoot || !paths.worktree) {
+    return false;
+  }
+  const result = await runGit(paths.targetRoot, ["worktree", "list", "--porcelain"], {
+    timeout: 10000
+  });
+  if (!result.ok) {
+    return false;
+  }
+  const expectedWorktree = path.resolve(paths.worktree);
+  return parseGitWorktreeList(result.stdout).includes(expectedWorktree);
+}
+
+export {
+  hasWorktree,
+  parseGitWorktreeList
+};