vibe64 0.1.21 → 0.1.22

package/node_modules/@local/vibe64-adapters/src/server/workflowCommandTerminal/worktreeDependencies.js

@@ -57,12 +57,11 @@ function createWorktreeScript({
   const quotedPrepareWorktreeScriptPath = shellQuote(normalizeText(prepareWorktreeScriptPath));
   const quotedTargetRoot = shellQuote(targetRoot);
   const quotedWorktreePath = shellQuote(worktreePath);
-  const workSource = normalizeText(session.metadata?.work_source) || "new_branch";
+  const workSource = normalizeText(session.metadata?.work_source) || "new_issue";
   const sourcePrNumber = normalizeText(session.metadata?.source_pr_number);
   const sourcePrHeadRef = normalizeText(session.metadata?.source_pr_head_ref);
   const sourcePrHeadRepo = normalizeText(session.metadata?.source_pr_head_repo);
-  const sourcePrUrl = normalizeText(session.metadata?.source_pr_url);
-  const requestedUpdateMode = normalizeText(session.metadata?.source_pr_update_mode);
+  const sourcePrHeadSha = normalizeText(session.metadata?.source_pr_head_sha);
   return [
     "set -e",
     `export VIBE64_TARGET_ROOT=${quotedTargetRoot}`,
@@ -92,8 +91,7 @@ function createWorktreeScript({
       `SOURCE_PR_NUMBER=${shellQuote(sourcePrNumber)}`,
       `SOURCE_PR_HEAD_REF=${shellQuote(sourcePrHeadRef)}`,
       `SOURCE_PR_HEAD_REPO=${shellQuote(sourcePrHeadRepo)}`,
-      `SOURCE_PR_URL=${shellQuote(sourcePrUrl)}`,
-      `REQUESTED_UPDATE_MODE=${shellQuote(requestedUpdateMode)}`,
+      `SOURCE_PR_HEAD_SHA=${shellQuote(sourcePrHeadSha)}`,
       "if [ -z \"$SOURCE_PR_NUMBER\" ]; then",
       "  printf '[studio] Existing PR metadata is incomplete. Abandon this session and start again.\\n' >&2",
       "  exit 1",
@@ -101,30 +99,19 @@ function createWorktreeScript({
       "PR_FETCH_REF=\"refs/remotes/vibe64/pr/$SOURCE_PR_NUMBER\"",
       "printf '[studio] Fetching PR #%s\\n' \"$SOURCE_PR_NUMBER\"",
       `git -C ${quotedTargetRoot} fetch origin "pull/$SOURCE_PR_NUMBER/head:$PR_FETCH_REF"`,
+      "FETCHED_PR_SHA=\"$(git -C " + quotedTargetRoot + " rev-parse --verify \"$PR_FETCH_REF\")\"",
+      "if [ -n \"$SOURCE_PR_HEAD_SHA\" ] && [ \"$FETCHED_PR_SHA\" != \"$SOURCE_PR_HEAD_SHA\" ]; then",
+      "  printf '[studio] Existing PR #%s moved from %s to %s. Start a new session from the updated PR.\\n' \"$SOURCE_PR_NUMBER\" \"$SOURCE_PR_HEAD_SHA\" \"$FETCHED_PR_SHA\" >&2",
+      "  exit 1",
+      "fi",
       `if git -C ${quotedTargetRoot} show-ref --verify --quiet ${quotedBranchRef}; then`,
       `  git -C ${quotedTargetRoot} worktree add ${quotedWorktreePath} ${quotedBranch}`,
       "else",
       `  git -C ${quotedTargetRoot} worktree add -b ${quotedBranch} ${quotedWorktreePath} "$PR_FETCH_REF"`,
       "fi",
       "prepare_vibe64_worktree",
-      "if [ \"$REQUESTED_UPDATE_MODE\" = \"direct\" ]; then",
-      "  if [ -z \"$SOURCE_PR_HEAD_REF\" ] || [ -z \"$SOURCE_PR_HEAD_REPO\" ]; then",
-      "    printf '[studio] Existing PR push target is incomplete; this session will create a replacement PR.\\n'",
-      `    ${recordCommandFactScript("source_pr_update_mode", "replacement")}`,
-      "    exit 0",
-      "  fi",
-      "  PR_HEAD_REMOTE=\"vibe64-pr-head\"",
-      `  git -C ${quotedWorktreePath} remote remove "$PR_HEAD_REMOTE" >/dev/null 2>&1 || true`,
-      `  git -C ${quotedWorktreePath} remote add "$PR_HEAD_REMOTE" "https://github.com/$SOURCE_PR_HEAD_REPO.git"`,
-      `  if git -C ${quotedWorktreePath} push --dry-run "$PR_HEAD_REMOTE" "HEAD:refs/heads/$SOURCE_PR_HEAD_REF"; then`,
-      "    printf '[studio] Existing PR can be updated directly.\\n'",
-      `    ${recordCommandFactScript("source_pr_update_mode", "direct")}`,
-      `    ${recordCommandFactScript("pr_url", "\"$SOURCE_PR_URL\"")}`,
-      "  else",
-      "    printf '[studio] Existing PR cannot be pushed directly; this session will create a replacement PR.\\n'",
-      `    ${recordCommandFactScript("source_pr_update_mode", "replacement")}`,
-      "  fi",
-      "fi",
+      "printf '[studio] Session branch will stack on existing PR branch %s/%s.\\n' \"$SOURCE_PR_HEAD_REPO\" \"$SOURCE_PR_HEAD_REF\"",
+      recordCommandFactScript("source_pr_update_mode", "stacked"),
       "exit 0"
     ] : []),
     `if git -C ${quotedTargetRoot} show-ref --verify --quiet ${quotedBranchRef}; then`,
@@ -154,9 +141,9 @@ async function createWorktreeTerminalSpec({
     readCurrentBranch(resolvedTargetRoot),
     readCurrentCommit(resolvedTargetRoot)
   ]);
-  const workSource = normalizeText(session.metadata?.work_source) || "new_branch";
+  const workSource = normalizeText(session.metadata?.work_source) || "new_issue";
   const metadataBaseBranch = workSource === "existing_pr"
-    ? normalizeText(session.metadata?.source_pr_base_ref) || baseBranch
+    ? normalizeText(session.metadata?.source_pr_head_ref) || baseBranch
     : baseBranch;
   const metadataBaseCommit = workSource === "existing_pr"
     ? normalizeText(session.metadata?.source_pr_head_sha) || baseCommit

package/node_modules/@local/vibe64-adapters/src/server/workflowSessionActions.js

@@ -12,6 +12,9 @@ import {
 const execFileAsync = promisify(execFile);
 const GITHUB_COMMAND_TIMEOUT_MS = 30_000;
 const GITHUB_OUTPUT_BUFFER_BYTES = 1024 * 1024;
+const ISSUE_BODY_ARTIFACT = "issue.md";
+const ISSUE_TITLE_ARTIFACT = "issue_title";
+const ISSUE_WORD_ARTIFACT = "issue_word";
 
 function commandOutput(error = {}) {
   return normalizeText(`${error.stdout || ""}\n${error.stderr || ""}`) ||
@@ -22,6 +25,20 @@ function normalizeGithubNumberOrUrl(value = "") {
   return normalizeText(value).replace(/^#/u, "");
 }
 
+function artifactText(value = "") {
+  const text = normalizeText(value);
+  return text ? `${text}\n` : "";
+}
+
+function issueWordFromGithubIssue(issue = {}, issueRef = "") {
+  const candidate = normalizeText(issue.title)
+    .split(/\s+/u)
+    .map((word) => word.replace(/[^A-Za-z0-9_-]+/gu, ""))
+    .find(Boolean);
+  const fallback = `issue${normalizeText(issue.number) || normalizeText(issueRef) || "selected"}`;
+  return normalizeText(candidate || fallback).slice(0, 24);
+}
+
 async function ghJson(targetRoot, args = []) {
   try {
     const result = await execFileAsync("gh", args, {
@@ -48,21 +65,33 @@ function repositoryNameWithOwner(repository = {}) {
     normalizeText(repository.url).replace(/^https:\/\/github\.com\//u, "");
 }
 
-function prCanUseDirectUpdate(pr = {}) {
-  if (normalizeText(pr.state).toUpperCase() !== "OPEN") {
-    return false;
-  }
-  if (!normalizeText(pr.headRefName) || !repositoryNameWithOwner(pr.headRepository)) {
-    return false;
-  }
-  return pr.isCrossRepository !== true || pr.maintainerCanModify === true;
+function prCanUseStackedBase(pr = {}) {
+  return normalizeText(pr.state).toUpperCase() === "OPEN" &&
+    normalizeText(pr.headRefName) &&
+    normalizeText(pr.headRefOid) &&
+    pr.isCrossRepository === false;
 }
 
-async function useNewBranchSessionAction() {
+async function useNewIssueSessionAction() {
   return adapterActionResult({
-    message: "Selected a new Vibe64 branch.",
+    message: "Starting fresh with a new GitHub issue.",
     metadata: {
-      work_source: "new_branch"
+      github_issue_mode: "create",
+      issue_source: "new",
+      work_anchor_type: "issue",
+      work_source: "new_issue"
+    }
+  });
+}
+
+async function useDescriptionSessionAction() {
+  return adapterActionResult({
+    message: "Starting from a plain work description.",
+    metadata: {
+      github_issue_mode: "skip",
+      issue_source: "none",
+      work_anchor_type: "description",
+      work_source: "description"
     }
   });
 }
@@ -93,7 +122,7 @@ async function useExistingIssueSessionAction({
     "view",
     issueRef,
     "--json",
-    "number,title,url,state"
+    "number,title,url,state,body"
   ]);
   if (result.ok === false) {
     return adapterActionResult({
@@ -109,13 +138,28 @@ async function useExistingIssueSessionAction({
       status: "blocked"
     });
   }
+  const title = normalizeText(issue.title);
+  const body = normalizeText(issue.body) || title;
+  const word = issueWordFromGithubIssue(issue, issueRef);
   return adapterActionResult({
-    message: `Selected GitHub issue #${issue.number}: ${normalizeText(issue.title)}`,
+    artifacts: {
+      [ISSUE_BODY_ARTIFACT]: artifactText(body),
+      [ISSUE_TITLE_ARTIFACT]: artifactText(title),
+      [ISSUE_WORD_ARTIFACT]: artifactText(word)
+    },
+    message: `Selected GitHub issue #${issue.number}: ${title}`,
     metadata: {
+      github_issue_mode: "reuse",
       issue_number: String(issue.number || ""),
       issue_source: "existing",
-      issue_title: normalizeText(issue.title),
-      issue_url: normalizeText(issue.url)
+      issue_title: title,
+      issue_url: normalizeText(issue.url),
+      work_anchor_number: String(issue.number || ""),
+      work_anchor_title: title,
+      work_anchor_type: "issue",
+      work_anchor_url: normalizeText(issue.url),
+      work_source: "existing_issue",
+      [ISSUE_WORD_ARTIFACT]: word
     }
   });
 }
@@ -165,10 +209,18 @@ async function useExistingPrSessionAction({
       status: "blocked"
     });
   }
-  const updateMode = prCanUseDirectUpdate(pr) ? "direct" : "replacement";
+  if (!prCanUseStackedBase(pr)) {
+    return adapterActionResult({
+      message: `GitHub PR #${pr.number || prRef} cannot be used as a stacked PR base because its head branch is not in this repository.`,
+      status: "blocked"
+    });
+  }
+  const title = normalizeText(pr.title);
   return adapterActionResult({
-    message: `Selected GitHub PR #${pr.number}: ${normalizeText(pr.title)}`,
+    message: `Selected GitHub PR #${pr.number}: ${title}`,
     metadata: {
+      github_issue_mode: "skip",
+      issue_source: "none",
       source_pr_base_ref: normalizeText(pr.baseRefName),
       source_pr_head_ref: normalizeText(pr.headRefName),
       source_pr_head_repo: repositoryNameWithOwner(pr.headRepository),
@@ -177,9 +229,13 @@ async function useExistingPrSessionAction({
       source_pr_maintainer_can_modify: pr.maintainerCanModify === true ? "yes" : "no",
       source_pr_number: String(pr.number || ""),
       source_pr_state: normalizeText(pr.state),
-      source_pr_title: normalizeText(pr.title),
-      source_pr_update_mode: updateMode,
+      source_pr_title: title,
+      source_pr_update_mode: "stacked",
       source_pr_url: normalizeText(pr.url),
+      work_anchor_number: String(pr.number || ""),
+      work_anchor_title: title,
+      work_anchor_type: "pull_request",
+      work_anchor_url: normalizeText(pr.url),
       work_source: "existing_pr"
     }
   });
@@ -187,9 +243,10 @@ async function useExistingPrSessionAction({
 
 const VIBE64_WORKFLOW_SESSION_ACTIONS = Object.freeze({
   skip_merge: skipMergeSessionAction,
+  use_description: useDescriptionSessionAction,
   use_existing_issue: useExistingIssueSessionAction,
   use_existing_pr: useExistingPrSessionAction,
-  use_new_branch: useNewBranchSessionAction
+  use_new_issue: useNewIssueSessionAction
 });
 
 async function runVibe64WorkflowSessionAction(actionId, context = {}) {

package/node_modules/@local/vibe64-core/src/server/terminalWebSocketRoutes.js

@@ -83,8 +83,11 @@ function registerTerminalWebSocketRoute(
         closeWithError(1011, String(error?.message || error || serviceUnavailableMessage));
         return;
       }
-      const sessionId = String(request.params?.sessionId || "");
-      const terminalSessionId = String(request.params?.terminalSessionId || "");
+      const routeParams = request.params || {};
+      const sessionId = String(routeParams.sessionId || "");
+      const terminalSessionId = String(routeParams.terminalSessionId || "");
+      const toolId = String(routeParams.toolId || "");
+      const jobId = String(routeParams.jobId || "");
 
       socket.on("message", async (rawMessage) => {
         try {
@@ -92,8 +95,10 @@ function registerTerminalWebSocketRoute(
           if (message?.type === "input") {
             const response = await write(service, {
               data: message.data,
+              jobId,
               sessionId,
-              terminalSessionId
+              terminalSessionId,
+              toolId
             });
             if (response?.ok === false) {
               sendSocketJson(socket, {
@@ -106,9 +111,11 @@ function registerTerminalWebSocketRoute(
           if (message?.type === "resize") {
             const response = await resize?.(service, {
               cols: message.cols,
+              jobId,
               rows: message.rows,
               sessionId,
-              terminalSessionId
+              terminalSessionId,
+              toolId
             });
             if (response?.ok === false) {
               sendSocketJson(socket, {
@@ -129,11 +136,13 @@ function registerTerminalWebSocketRoute(
       socket.on("error", closeSubscription);
 
       void Promise.resolve(subscribe(service, {
+        jobId,
         sessionId,
         subscriber: (message) => {
           sendSocketJson(socket, message);
         },
-        terminalSessionId
+        terminalSessionId,
+        toolId
       })).then((result) => {
         if (result?.ok === false) {
           closeWithError(1008, result.error || "Terminal session not found.");

package/node_modules/@local/vibe64-project/src/server/actions.js

@@ -5,6 +5,7 @@ import {
   projectTypeReadInputValidator
 } from "./inputSchemas.js";
 
+const ACTION_LIST_PROJECT_TOOLS = "feature.vibe64-project.tools.list";
 const ACTION_READ_PROJECT_TYPE = "feature.vibe64-project.project-type.read";
 const ACTION_SAVE_PROJECT_TYPE = "feature.vibe64-project.project-type.save";
 const ACTION_READ_PROJECT_CONFIG = "feature.vibe64-project.config.read";
@@ -12,6 +13,25 @@ const ACTION_READ_PROJECT_CONFIG_DEFAULTS = "feature.vibe64-project.config.defau
 const ACTION_SAVE_PROJECT_CONFIG = "feature.vibe64-project.config.save";
 
 const featureActions = Object.freeze([
+  {
+    id: ACTION_LIST_PROJECT_TOOLS,
+    version: 1,
+    kind: "query",
+    channels: ["api", "automation", "internal"],
+    surfaces: ["home"],
+    input: projectConfigReadInputValidator,
+    output: null,
+    idempotency: "none",
+    audit: {
+      actionName: ACTION_LIST_PROJECT_TOOLS
+    },
+    observability: {},
+    async execute(input, context, deps) {
+      void input;
+      void context;
+      return deps.featureService.listProjectTools();
+    }
+  },
   {
     id: ACTION_READ_PROJECT_TYPE,
     version: 1,
@@ -108,6 +128,7 @@ const featureActions = Object.freeze([
 ]);
 
 export {
+  ACTION_LIST_PROJECT_TOOLS,
   ACTION_READ_PROJECT_CONFIG,
   ACTION_READ_PROJECT_CONFIG_DEFAULTS,
   ACTION_READ_PROJECT_TYPE,

package/node_modules/@local/vibe64-project/src/server/registerRoutes.js

@@ -3,6 +3,7 @@ import {
   projectTypeInputValidator
 } from "./inputSchemas.js";
 import {
+  ACTION_LIST_PROJECT_TOOLS,
   ACTION_READ_PROJECT_CONFIG,
   ACTION_READ_PROJECT_CONFIG_DEFAULTS,
   ACTION_READ_PROJECT_TYPE,
@@ -25,6 +26,11 @@ function registerRoutes(
     tags: ["studio", "vibe64-project"]
   });
 
+  routes.actionRoute("GET", "/tools", {
+    actionId: ACTION_LIST_PROJECT_TOOLS,
+    summary: "List Vibe64 project tools."
+  });
+
   routes.actionRoute("GET", "/project-type", {
     actionId: ACTION_READ_PROJECT_TYPE,
     summary: "Read the Vibe64 project type."

package/node_modules/@local/vibe64-project/src/server/service.js

@@ -1,6 +1,9 @@
 import {
   Vibe64SessionRuntime
 } from "@local/vibe64-runtime/server/runtime";
+import {
+  createCoreProjectToolRegistry
+} from "@local/vibe64-runtime/server/coreProjectTools";
 import {
   createCoreWorkflowRegistry
 } from "@local/vibe64-runtime/server/registerCoreWorkflowModules";
@@ -138,11 +141,11 @@ function createService({
     };
   }
 
-  function configResponse({
-    adapter,
-    config,
-    projectType
-  } = {}) {
+function configResponse({
+  adapter,
+  config,
+  projectType
+} = {}) {
     return {
       ...config,
       adapter: {
@@ -153,6 +156,102 @@ function createService({
     };
   }
 
+  async function projectToolContext() {
+    const projectType = await readProjectTypeState();
+    if (!projectType.ready) {
+      return {
+        adapter: null,
+        baseBranch: "main",
+        config: null,
+        projectConfig: null,
+        projectMessage: projectType.message,
+        projectReady: false,
+        projectType,
+        targetRoot: resolvedTargetRoot
+      };
+    }
+
+    const adapter = await adapterRegistry.createAdapter(projectType.projectType);
+    const config = await readProjectConfigForAdapter(adapter, projectType);
+    const projectReady = config.ready === true;
+    return {
+      adapter,
+      baseBranch: "main",
+      config,
+      projectConfig: config,
+      projectMessage: projectReady
+        ? ""
+        : config.message || "Save Vibe64 project configuration before using project tools.",
+      projectReady,
+      projectType,
+      targetRoot: resolvedTargetRoot
+    };
+  }
+
+  async function createProjectToolRegistry(context = {}) {
+    const adapterTools = typeof context.adapter?.listProjectTools === "function"
+      ? await context.adapter.listProjectTools({
+          adapter: context.adapter,
+          config: context.config,
+          projectConfig: context.projectConfig,
+          projectType: context.projectType,
+          targetRoot: resolvedTargetRoot
+        })
+      : [];
+    const adapterToolModule = Array.isArray(adapterTools) && adapterTools.length
+      ? [{
+          id: `adapter.${context.adapter.id}`,
+          tools: adapterTools
+        }]
+      : [];
+    return createCoreProjectToolRegistry({
+      toolModules: adapterToolModule
+    });
+  }
+
+  function projectToolRunParameters(input = {}) {
+    const inputObject = input && typeof input === "object" && !Array.isArray(input) ? input : {};
+    const parameters = inputObject.parameters || inputObject.input || {};
+    return parameters && typeof parameters === "object" && !Array.isArray(parameters)
+      ? parameters
+      : {};
+  }
+
+  async function listProjectToolState() {
+    const context = await projectToolContext();
+    const registry = await createProjectToolRegistry(context);
+    return registry.listTools(context);
+  }
+
+  async function prepareProjectToolRunState(toolId = "", input = {}) {
+    const context = await projectToolContext();
+    const registry = await createProjectToolRegistry(context);
+    const run = await registry.resolveToolRun(toolId, {
+      context,
+      parameters: projectToolRunParameters(input)
+    });
+    if (run.type === "command" && run.spec?.ok === false) {
+      const error = new Error(run.spec.message || `${run.tool.label} cannot start.`);
+      error.code = "vibe64_project_tool_not_ready";
+      throw error;
+    }
+    if (run.type === "prompt" && !run.prompt) {
+      const error = new Error(`${run.tool.label} did not produce a prompt.`);
+      error.code = "vibe64_project_tool_not_ready";
+      throw error;
+    }
+    return {
+      ...run,
+      adapter: context.adapter
+        ? {
+            id: context.adapter.id,
+            label: context.adapter.label
+          }
+        : null,
+      targetRoot: resolvedTargetRoot
+    };
+  }
+
   async function readProjectConfigForAdapter(adapter, projectType) {
     const config = await projectConfigStore.readConfig(
       await projectConfigDefinition(adapter, projectType)
@@ -223,6 +322,8 @@ function createService({
   }
 
   return Object.freeze({
+    targetRoot: resolvedTargetRoot,
+
     async createRuntime() {
       return createRuntime();
     },
@@ -262,6 +363,24 @@ function createService({
       return projectConfigStore.environment();
     },
 
+    async listProjectTools() {
+      return projectResult(async () => {
+        return {
+          ok: true,
+          tools: await listProjectToolState()
+        };
+      });
+    },
+
+    async prepareProjectToolRun(toolId, input = {}) {
+      return projectResult(async () => {
+        return {
+          ok: true,
+          ...await prepareProjectToolRunState(toolId, input)
+        };
+      });
+    },
+
     async saveProjectType(input = {}) {
       return projectResult(async () => {
         return {
@@ -278,9 +397,7 @@ function createService({
           ok: true
         };
       });
-    },
-
-    targetRoot: resolvedTargetRoot
+    }
   });
 }
 

package/node_modules/@local/vibe64-runtime/src/server/coreProjectTools.js

@@ -0,0 +1,135 @@
+import {
+  configTextValue
+} from "@local/vibe64-adapters/server/configValues";
+import {
+  VIBE64_DEPLOY_PRODUCTION_COMMAND_CONFIG,
+  VIBE64_DEPLOY_STAGING_COMMAND_CONFIG
+} from "@local/vibe64-adapters/server/configStore";
+import {
+  projectSyncMainCheckoutTerminalSpec
+} from "@local/vibe64-adapters/server/workflowCommandTerminal/mergeSync";
+import {
+  normalizeText
+} from "@local/vibe64-core/server/core";
+import {
+  deepFreeze
+} from "@local/vibe64-core/server/deepFreeze";
+import {
+  createProjectToolRegistry,
+  registerProjectToolContributorModules
+} from "./projectToolRegistry.js";
+
+function projectConfigCommand(context = {}, fieldId = "") {
+  return configTextValue(context.config || context.projectConfig || {}, fieldId);
+}
+
+function projectToolsReady(context = {}) {
+  return context.projectReady !== false;
+}
+
+function projectToolsDisabledReason(context = {}) {
+  return normalizeText(context.projectMessage) || "Save Vibe64 project configuration before using project tools.";
+}
+
+function deployCommandDisabledReason(label = "", fieldId = "") {
+  return `Configure ${fieldId} before using ${label}.`;
+}
+
+function deployCommandTool({
+  configFieldId = "",
+  description = "",
+  id = "",
+  label = ""
+} = {}) {
+  return {
+    id,
+    label,
+    description,
+    type: "command",
+    parameters: [],
+    requiresConfirmation: true,
+    confirmationMessage: `${label} will run the saved deploy command against the main project checkout.`,
+    enabled: (context) => projectToolsReady(context) && Boolean(projectConfigCommand(context, configFieldId)),
+    disabledReason: (context) => {
+      if (!projectToolsReady(context)) {
+        return projectToolsDisabledReason(context);
+      }
+      return projectConfigCommand(context, configFieldId)
+        ? ""
+        : deployCommandDisabledReason(label, configFieldId);
+    },
+    async command(context = {}) {
+      const command = projectConfigCommand(context, configFieldId);
+      return {
+        args: [
+          "-lc",
+          command
+        ],
+        command: "bash",
+        commandPreview: command,
+        cwd: context.targetRoot,
+        ok: true
+      };
+    }
+  };
+}
+
+const coreProjectToolModule = deepFreeze({
+  id: "core",
+  tools: [
+    deployCommandTool({
+      configFieldId: VIBE64_DEPLOY_PRODUCTION_COMMAND_CONFIG,
+      description: "Run the configured production deployment command from the main project checkout.",
+      id: "push_to_production",
+      label: "Push to production"
+    }),
+    deployCommandTool({
+      configFieldId: VIBE64_DEPLOY_STAGING_COMMAND_CONFIG,
+      description: "Run the configured staging deployment command from the main project checkout.",
+      id: "push_to_staging",
+      label: "Push to staging"
+    }),
+    {
+      id: "sync_main_with_main",
+      label: "Sync main with main",
+      description: "Fetch, checkout, and fast-forward the main checkout from origin.",
+      type: "command",
+      parameters: [],
+      enabled: projectToolsReady,
+      disabledReason: (context) => projectToolsReady(context) ? "" : projectToolsDisabledReason(context),
+      async command(context = {}) {
+        return projectSyncMainCheckoutTerminalSpec({
+          baseBranch: normalizeText(context.baseBranch) || "main",
+          targetRoot: context.targetRoot
+        });
+      }
+    }
+  ]
+});
+
+const coreProjectToolModules = deepFreeze([
+  coreProjectToolModule
+]);
+
+function registerCoreProjectToolModules(registry) {
+  return registerProjectToolContributorModules(registry, {
+    toolModules: coreProjectToolModules
+  });
+}
+
+function createCoreProjectToolRegistry({
+  toolModules = []
+} = {}) {
+  const registry = createProjectToolRegistry();
+  registerCoreProjectToolModules(registry);
+  return registerProjectToolContributorModules(registry, {
+    toolModules
+  });
+}
+
+export {
+  coreProjectToolModule,
+  coreProjectToolModules,
+  createCoreProjectToolRegistry,
+  registerCoreProjectToolModules
+};

package/node_modules/@local/vibe64-runtime/src/server/index.js

@@ -1,14 +1,18 @@
 export * from "./currentStepInputHelperServer.js";
+export * from "./coreProjectTools.js";
+export * from "./projectToolRegistry.js";
 export * from "./registerCoreWorkflowModules.js";
 export * from "./runtime.js";
 export * from "./sessionDebugLog.js";
 export * from "./sessionDebugLogCore.js";
 export * from "./sessionStore.js";
+export * from "./sessionWorktreeState.js";
 export * from "./setupReadiness.js";
 export * from "./terminalFailureFixRequest.js";
 export * from "./workflow.js";
 export * from "./workflowArtifacts.js";
 export * from "./workflowConditions.js";
+export * from "./workflowDefinitionComposers.js";
 export * from "./workflowDefinitionBuilders.js";
 export * from "./workflowMachine.js";
 export * from "./workflowPresentation.js";