vibe64 0.1.21

package/packages/vibe64-adapters/src/server/promptQuestionPolicy.js

@@ -0,0 +1,37 @@
+const QUESTION_BATCH_LIMIT = 3;
+
+function questionBatchLimitInstruction() {
+  return `Ask at most ${QUESTION_BATCH_LIMIT} questions at a time. If more uncertainty remains, ask the ${QUESTION_BATCH_LIMIT} highest-impact questions first.`;
+}
+
+function numberedQuestionFormatInstruction() {
+  return "When asking more than one question, format each question on its own line as `[1] Question text`, `[2] Question text`, and so on. Use the same numbered question text in the helper `message`.";
+}
+
+function questionPromptInstructions() {
+  return [
+    questionBatchLimitInstruction(),
+    numberedQuestionFormatInstruction()
+  ];
+}
+
+function questionPromptInstructionBullets() {
+  return questionPromptInstructions().map((instruction) => `- ${instruction}`);
+}
+
+function missingInformationPolicyInstruction() {
+  return [
+    "If required external service details, credentials, project URLs, API keys, provider choices, production-vs-local decisions, or runtime configuration are missing, ask concise questions before planning or implementing work that depends on them.",
+    questionBatchLimitInstruction(),
+    "Do not invent placeholder credentials, silently choose unrelated local substitutes, or proceed with fake integrations."
+  ].join(" ");
+}
+
+export {
+  QUESTION_BATCH_LIMIT,
+  missingInformationPolicyInstruction,
+  numberedQuestionFormatInstruction,
+  questionBatchLimitInstruction,
+  questionPromptInstructionBullets,
+  questionPromptInstructions
+};

package/packages/vibe64-adapters/src/server/promptRenderer.js

@@ -0,0 +1,480 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  VIBE64_STATE_DIR,
+  vibe64Error,
+  isMissingPathError,
+  isPlainObject,
+  normalizeText
+} from "@local/vibe64-core/server/core";
+import {
+  missingInformationPolicyInstruction
+} from "./promptQuestionPolicy.js";
+
+const DEFAULT_PROMPT_ID = "generic";
+const DEFAULT_SYSTEM_PROMPT_PACK_ROOT = fileURLToPath(new URL("./systemPrompts", import.meta.url));
+const PROMPT_OVERRIDES_DIR = "prompts";
+const PROMPT_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/u;
+const TEMPLATE_TOKEN_PATTERN = /\{\{([A-Za-z0-9_.-]+)\}\}/gu;
+const MANAGED_SERVICE_POLICY = [
+  "Use the Managed services section as the only source for Vibe64-managed database access.",
+  "Run the listed non-interactive client command directly from the worktree terminal: mysql or mariadb for MySQL-compatible services, and psql for PostgreSQL services.",
+  "When checking connectivity or inspecting schema from Codex, use `checkCommand`, use `command` with a real SQL statement, or pipe SQL to the client; do not run a bare interactive database client that waits for input.",
+  "When framework generators or CLIs ask for database connection tokens or flags, including commands such as `npx jskit ...`, pass the environment-variable references from `generatorTokenHints` instead of discovering replacement values.",
+  "Do not inspect Docker, Docker Compose, container names, runtime networks, localhost sockets, getent, mysqladmin, mariadb-admin, pg_isready, or host port probes for normal managed-service work.",
+  "If the listed client command cannot connect, report that the managed service is not ready or ask for the missing external detail; do not invent alternate credentials or infrastructure."
+].join(" ");
+const STATIC_CONTEXT_REFERENCE = "Use the Vibe64 session briefing already provided for adapter facts, adapter prompt context, managed services, managed service policy, and project config.";
+const STATIC_CONTEXT_REFERENCE_MODE = "reference";
+
+function assertPromptId(promptId) {
+  const normalizedPromptId = normalizeText(promptId);
+  if (!PROMPT_ID_PATTERN.test(normalizedPromptId)) {
+    throw vibe64Error(`Invalid Vibe64 prompt id: ${normalizedPromptId || "(empty)"}`, "vibe64_invalid_prompt_id");
+  }
+  return normalizedPromptId;
+}
+
+function stableValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(stableValue);
+  }
+  if (isPlainObject(value)) {
+    return Object.fromEntries(
+      Object.keys(value)
+        .sort((left, right) => left.localeCompare(right))
+        .map((key) => [key, stableValue(value[key])])
+    );
+  }
+  return value ?? null;
+}
+
+function stableJson(value) {
+  return JSON.stringify(stableValue(value), null, 2);
+}
+
+function staticContextMode(value = "") {
+  return normalizeText(value) === STATIC_CONTEXT_REFERENCE_MODE
+    ? STATIC_CONTEXT_REFERENCE_MODE
+    : "inline";
+}
+
+function promptTemplatePath(promptPackRoot, promptId) {
+  return path.join(promptPackRoot, `${assertPromptId(promptId)}.txt`);
+}
+
+function promptOverrideRoot(targetRoot = "") {
+  const normalizedTargetRoot = normalizeText(targetRoot);
+  return normalizedTargetRoot
+    ? path.join(path.resolve(normalizedTargetRoot), VIBE64_STATE_DIR, PROMPT_OVERRIDES_DIR)
+    : "";
+}
+
+function promptOverrideTemplatePath({
+  adapterId = "",
+  promptId = "",
+  targetRoot = ""
+} = {}) {
+  const overrideRoot = promptOverrideRoot(targetRoot);
+  const normalizedAdapterId = assertPromptId(adapterId);
+  return path.join(overrideRoot, normalizedAdapterId, `${assertPromptId(promptId)}.txt`);
+}
+
+function assertPromptPackRoot(promptPackRoot) {
+  const normalizedPromptPackRoot = normalizeText(promptPackRoot);
+  if (!normalizedPromptPackRoot) {
+    throw vibe64Error("Vibe64 prompt renderer requires a prompt pack root.", "vibe64_prompt_pack_root_missing");
+  }
+  return path.resolve(normalizedPromptPackRoot);
+}
+
+function optionalPromptPackRoot(promptPackRoot) {
+  if (promptPackRoot === false || promptPackRoot === null) {
+    return "";
+  }
+  return assertPromptPackRoot(promptPackRoot || DEFAULT_SYSTEM_PROMPT_PACK_ROOT);
+}
+
+async function readPromptTemplate(promptPackRoot, promptId) {
+  const requestedPromptId = assertPromptId(promptId || DEFAULT_PROMPT_ID);
+  try {
+    return await readFile(promptTemplatePath(promptPackRoot, requestedPromptId), "utf8");
+  } catch (error) {
+    if (!isMissingPathError(error) || requestedPromptId === DEFAULT_PROMPT_ID) {
+      throw error;
+    }
+    return readPromptTemplate(promptPackRoot, DEFAULT_PROMPT_ID);
+  }
+}
+
+async function readPromptOverrideTemplate(context) {
+  const targetRoot = context.session.targetRoot;
+  const adapterId = context.adapter.id;
+  if (!targetRoot || !adapterId) {
+    return null;
+  }
+  const filePath = promptOverrideTemplatePath({
+    adapterId,
+    promptId: context.action.promptId || DEFAULT_PROMPT_ID,
+    targetRoot
+  });
+  try {
+    return {
+      filePath,
+      template: await readFile(filePath, "utf8")
+    };
+  } catch (error) {
+    if (isMissingPathError(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+function promptContextForAction({
+  action = {},
+  config = {},
+  input = {},
+  session = {}
+} = {}) {
+  return normalizePromptContext({
+    action,
+    adapter: session.adapter,
+    config: config || session.config,
+    input,
+    session: sessionPromptContext(session)
+  });
+}
+
+function normalizePromptContext(context = {}) {
+  const adapterContext = context.adapter || context.session?.adapter;
+  const promptStaticContextMode = staticContextMode(
+    context.prompt?.staticContextMode ||
+    context.session?.promptStaticContextMode
+  );
+  return {
+    action: {
+      id: normalizeText(context.action?.id),
+      label: normalizeText(context.action?.label),
+      promptId: normalizeText(context.action?.promptId || context.action?.id),
+      type: normalizeText(context.action?.type)
+    },
+    adapter: {
+      commands: Array.isArray(adapterContext?.commands) ? adapterContext.commands : [],
+      detection: isPlainObject(adapterContext?.detection) ? adapterContext.detection : {},
+      facts: isPlainObject(adapterContext?.facts) ? adapterContext.facts : {},
+      id: normalizeText(adapterContext?.id),
+      label: normalizeText(adapterContext?.label),
+      managedServices: Array.isArray(adapterContext?.managedServices) ? adapterContext.managedServices : [],
+      promptContext: isPlainObject(adapterContext?.promptContext) ? adapterContext.promptContext : {}
+    },
+    config: isPlainObject(context.config) ? context.config : {},
+    input: context.input ?? {},
+    product: normalizeText(context.product || "vibe64"),
+    prompt: {
+      staticContextMode: promptStaticContextMode
+    },
+    session: {
+      artifactsRoot: normalizeText(context.session?.artifactsRoot),
+      completedSteps: Array.isArray(context.session?.completedSteps) ? context.session.completedSteps : [],
+      currentStep: normalizeText(context.session?.currentStep),
+      id: normalizeText(context.session?.id || context.session?.sessionId),
+      metadataRoot: normalizeText(context.session?.metadataRoot),
+      metadata: isPlainObject(context.session?.metadata) ? context.session.metadata : {},
+      sessionRoot: normalizeText(context.session?.sessionRoot),
+      stepMachine: isPlainObject(context.session?.stepMachine) ? context.session.stepMachine : null,
+      status: normalizeText(context.session?.status),
+      targetRoot: normalizeText(context.session?.targetRoot),
+      worktreePath: normalizeText(context.session?.metadata?.worktree_path || context.session?.worktree)
+    }
+  };
+}
+
+function sessionPromptContext(session = {}) {
+  return {
+    artifactsRoot: session.artifactsRoot,
+    completedSteps: session.completedSteps,
+    currentStepDefinition: session.currentStepDefinition,
+    currentStep: session.currentStep,
+    id: session.sessionId || session.id,
+    metadataRoot: session.metadataRoot,
+    metadata: session.metadata,
+    promptStaticContextMode: session.promptStaticContextMode,
+    sessionRoot: session.sessionRoot,
+    stepMachine: session.stepMachine,
+    status: session.status,
+    targetRoot: session.targetRoot,
+    worktree: session.worktree
+  };
+}
+
+function staticJsonReference(label = "") {
+  return {
+    vibe64SessionBriefingReference: normalizeText(label) || STATIC_CONTEXT_REFERENCE
+  };
+}
+
+function staticScalarReference(tokenName = "") {
+  return `See the Vibe64 session briefing for ${tokenName}.`;
+}
+
+function contextWithStaticReferences(context = {}) {
+  return {
+    ...context,
+    adapter: {
+      ...context.adapter,
+      commands: staticJsonReference("Adapter commands are in the Vibe64 session briefing."),
+      facts: staticJsonReference("Adapter project facts are in the Vibe64 session briefing."),
+      managedServices: staticJsonReference("Managed service connection details and policy are in the Vibe64 session briefing."),
+      promptContext: staticJsonReference("Adapter prompt context is in the Vibe64 session briefing.")
+    },
+    config: staticJsonReference("Project config is in the Vibe64 session briefing.")
+  };
+}
+
+function promptSessionBriefingReference() {
+  return [
+    "Session briefing:",
+    STATIC_CONTEXT_REFERENCE,
+    "Do not ask the user to restate those static setup details. If this prompt includes an Vibe64 session briefing above, treat that briefing as the source of truth for this Codex session."
+  ].join("\n");
+}
+
+function currentStepInputHelperBriefing() {
+  return [
+    "Vibe64 current-step input helper:",
+    "- When you need to update Vibe64 workflow state, call the helper command instead of writing Vibe64 artifacts directly.",
+    "- Command: node \"$VIBE64_CURRENT_STEP_INPUT_HELPER\"",
+    "- Pass one JSON object on stdin or with --json.",
+    "- Include `kind`, `stepId`, and `stepStatus` exactly for the current workflow state.",
+    "- The current values are in Action context as `session.currentStep` and `session.stepMachine.status`.",
+    "- Use `fields` for structured form values, `message` for questions to the user, and `text` for plain user responses.",
+    "- If the helper reports Reload state or a state mismatch, stop and ask the user to reload the current step."
+  ].join("\n");
+}
+
+function promptSessionBriefing(contextInput = {}) {
+  const context = normalizePromptContext(contextInput);
+  const codeIndexPath = normalizeText(context.session.metadata?.code_index_path);
+  const codeIndexPolicy = codeIndexPath
+    ? [
+      `Generated code index path: ${codeIndexPath}`,
+      "Read that generated code index before adding or reviewing helper-like code. Prefer existing helpers and structures from that index over redefining them."
+    ].join("\n")
+    : "If later session metadata includes `code_index_path`, read that generated code index before adding or reviewing helper-like code. Prefer existing helpers and structures from that index over redefining them.";
+  return [
+    "Vibe64 session briefing",
+    "",
+    "This briefing is sent once at the start of this Codex session. Keep using it for later Vibe64 prompts in the same session instead of asking for or rediscovering these static setup facts.",
+    "",
+    "Fixed session paths:",
+    `- session id: ${context.session.id}`,
+    `- target root: ${context.session.targetRoot}`,
+    `- worktree path: ${context.session.worktreePath}`,
+    `- artifacts root: ${context.session.artifactsRoot}`,
+    "",
+    "Adapter:",
+    `- id: ${context.adapter.id}`,
+    `- label: ${context.adapter.label}`,
+    "",
+    "Adapter project facts:",
+    stableJson(context.adapter.facts),
+    "",
+    "Adapter prompt context:",
+    stableJson(context.adapter.promptContext),
+    "",
+    "Managed services:",
+    stableJson(context.adapter.managedServices),
+    "",
+    "Managed service policy:",
+    MANAGED_SERVICE_POLICY,
+    "",
+    "Project config:",
+    stableJson(context.config),
+    "",
+    "Code index policy:",
+    codeIndexPolicy,
+    "",
+    currentStepInputHelperBriefing()
+  ].join("\n").trim();
+}
+
+function promptTemplateTokens(contextInput) {
+  const context = normalizePromptContext(contextInput);
+  const referenceStaticContext = context.prompt.staticContextMode === STATIC_CONTEXT_REFERENCE_MODE;
+  const jsonContext = referenceStaticContext ? contextWithStaticReferences(context) : context;
+  return {
+    "action.id": context.action.id,
+    "action.label": context.action.label,
+    "action.promptId": context.action.promptId,
+    "adapter.commands.json": referenceStaticContext
+      ? stableJson(staticJsonReference("Adapter commands are in the Vibe64 session briefing."))
+      : stableJson(context.adapter.commands),
+    "adapter.detection.json": stableJson(context.adapter.detection),
+    "adapter.facts.json": referenceStaticContext
+      ? stableJson(staticJsonReference("Adapter project facts are in the Vibe64 session briefing."))
+      : stableJson(context.adapter.facts),
+    "adapter.id": context.adapter.id,
+    "adapter.label": context.adapter.label,
+    "adapter.managedServices.json": referenceStaticContext
+      ? stableJson(staticJsonReference("Managed service connection details are in the Vibe64 session briefing."))
+      : stableJson(context.adapter.managedServices),
+    "adapter.promptContext.json": referenceStaticContext
+      ? stableJson(staticJsonReference("Adapter prompt context is in the Vibe64 session briefing."))
+      : stableJson(context.adapter.promptContext),
+    "adapter.runtimeContainers.json": stableJson([]),
+    "config.json": referenceStaticContext
+      ? stableJson(staticJsonReference("Project config is in the Vibe64 session briefing."))
+      : stableJson(context.config),
+    "context.json": stableJson(jsonContext),
+    "prompt.managedServicePolicy": referenceStaticContext
+      ? "Use the managed service policy from the Vibe64 session briefing."
+      : MANAGED_SERVICE_POLICY,
+    "prompt.currentStepInputHelperBriefing": currentStepInputHelperBriefing(),
+    "input.json": stableJson(context.input),
+    "prompt.missingInformationPolicy": missingInformationPolicyInstruction(),
+    "prompt.sessionBriefingReference": promptSessionBriefingReference(),
+    "product": context.product,
+    "session.artifactsRoot": context.session.artifactsRoot,
+    "session.completedSteps.json": stableJson(context.session.completedSteps),
+    "session.currentStep": context.session.currentStep,
+    "session.id": context.session.id,
+    "session.metadataRoot": context.session.metadataRoot,
+    "session.metadata.json": stableJson(context.session.metadata),
+    "session.sessionRoot": context.session.sessionRoot,
+    "session.stepMachine.json": stableJson(context.session.stepMachine),
+    "session.stepMachine.status": normalizeText(context.session.stepMachine?.status),
+    "session.status": context.session.status,
+    "session.targetRoot": context.session.targetRoot,
+    "session.worktreePath": context.session.worktreePath
+  };
+}
+
+function promptOverrideTokens(originalPrompt = "") {
+  return {
+    originalPrompt: String(originalPrompt || ""),
+    "prompt.original": String(originalPrompt || "")
+  };
+}
+
+function promptSystemStandardTokens(systemStandard = "") {
+  return {
+    "prompt.systemStandard": String(systemStandard || ""),
+    systemStandard: String(systemStandard || "")
+  };
+}
+
+function scalarPromptContextTokens(promptContext = {}) {
+  const entries = Object.entries(isPlainObject(promptContext) ? promptContext : {})
+    .filter(([, value]) => ["boolean", "number", "string"].includes(typeof value))
+    .map(([key, value]) => [`adapter.promptContext.${key}`, String(value)]);
+  return Object.fromEntries(entries);
+}
+
+function scalarPromptContextReferenceTokens(promptContext = {}) {
+  const entries = Object.keys(isPlainObject(promptContext) ? promptContext : {})
+    .sort((left, right) => left.localeCompare(right))
+    .map((key) => [`adapter.promptContext.${key}`, staticScalarReference(`adapter.promptContext.${key}`)]);
+  return Object.fromEntries(entries);
+}
+
+function renderPromptTemplate(template, context, extraTokens = {}) {
+  const normalizedContext = normalizePromptContext(context);
+  const promptContextTokens = normalizedContext.prompt.staticContextMode === STATIC_CONTEXT_REFERENCE_MODE
+    ? scalarPromptContextReferenceTokens(normalizedContext.adapter.promptContext)
+    : scalarPromptContextTokens(normalizedContext.adapter.promptContext);
+  const tokens = {
+    ...promptContextTokens,
+    ...promptTemplateTokens(normalizedContext),
+    ...extraTokens
+  };
+  return String(template || "").replace(TEMPLATE_TOKEN_PATTERN, (match, tokenName) => {
+    if (!Object.hasOwn(tokens, tokenName)) {
+      throw vibe64Error(`Unknown Vibe64 prompt token: ${tokenName}`, "vibe64_unknown_prompt_token");
+    }
+    return tokens[tokenName];
+  }).trim();
+}
+
+async function renderPromptWithOverrides({
+  context = {},
+  originalPrompt = "",
+  systemStandard = ""
+} = {}) {
+  const normalizedContext = normalizePromptContext(context);
+  const normalizedOriginalPrompt = String(originalPrompt || "");
+  const override = await readPromptOverrideTemplate(normalizedContext);
+  return {
+    originalPrompt: normalizedOriginalPrompt,
+    prompt: override
+      ? renderPromptTemplate(
+          override.template,
+          normalizedContext,
+          {
+            ...promptOverrideTokens(normalizedOriginalPrompt),
+            ...promptSystemStandardTokens(systemStandard)
+          }
+        )
+      : normalizedOriginalPrompt,
+    promptOverridePath: override?.filePath || ""
+  };
+}
+
+class PromptRenderer {
+  constructor({
+    promptPackRoot = "",
+    systemPromptPackRoot = DEFAULT_SYSTEM_PROMPT_PACK_ROOT
+  } = {}) {
+    this.promptPackRoot = assertPromptPackRoot(promptPackRoot);
+    this.systemPromptPackRoot = optionalPromptPackRoot(systemPromptPackRoot);
+  }
+
+  async renderSystemStandardPrompt(context) {
+    if (!this.systemPromptPackRoot) {
+      return "";
+    }
+    const template = await readPromptTemplate(this.systemPromptPackRoot, context.action.promptId || DEFAULT_PROMPT_ID);
+    return renderPromptTemplate(template, context);
+  }
+
+  async renderPrompt({
+    action,
+    config = {},
+    input = {},
+    session
+  } = {}) {
+    const context = promptContextForAction({
+      action,
+      config,
+      input,
+      session
+    });
+    const systemStandard = await this.renderSystemStandardPrompt(context);
+    const template = await readPromptTemplate(this.promptPackRoot, context.action.promptId || DEFAULT_PROMPT_ID);
+    const originalPrompt = renderPromptTemplate(
+      template,
+      context,
+      promptSystemStandardTokens(systemStandard)
+    );
+    const renderedPrompt = await renderPromptWithOverrides({
+      context,
+      originalPrompt,
+      systemStandard
+    });
+    return {
+      context,
+      ...renderedPrompt,
+      promptId: context.action.promptId,
+      systemStandard
+    };
+  }
+}
+
+export {
+  PromptRenderer,
+  promptContextForAction,
+  promptSessionBriefing,
+  renderPromptTemplate,
+  renderPromptWithOverrides
+};

package/packages/vibe64-adapters/src/server/systemPrompts/agent_conversation.txt

@@ -0,0 +1,45 @@
+Agent conversation
+
+Vibe64 interactive Codex conversation instructions.
+
+Session:
+- id: {{session.id}}
+- current step: {{session.currentStep}}
+- target root: {{session.targetRoot}}
+- worktree path: {{session.worktreePath}}
+- artifacts root: {{session.artifactsRoot}}
+
+Known session metadata:
+{{session.metadata.json}}
+
+{{prompt.sessionBriefingReference}}
+
+Action input:
+{{input.json}}
+
+Missing information policy:
+{{prompt.missingInformationPolicy}}
+
+Use `conversationRequest` from Action input as the user's latest request.
+
+This is an interactive conversation step. The user may send several requests, inspect the work, run the app, and steer you before moving to the next workflow step.
+
+General rules:
+- Work in the session worktree when file changes or project inspection are needed.
+- If the request can be answered without project inspection or file changes, do not read repository files, list directories, or inspect existing artifact files first.
+- Ask concise clarification questions when required. Use the Vibe64 step completion contract appended to this prompt when questions block progress or when your turn is complete.
+- Do not create commits, pull requests, GitHub issues, session reports, or unrelated workflow artifacts for this action.
+- Do not modify Vibe64 session internals or artifact files.
+
+Workflow-specific behavior:
+- If `session.currentStep` is `agent_conversation`, this is the General coding change-making step. Make the requested code or project changes directly, following the adapter and framework guidance. When you are done, report what changed, what you checked, and what remains unresolved. The user decides when to continue to validation.
+- If `session.currentStep` is `implementation_reviewed`, the user is reviewing the implemented work before slower checks. Make only the focused tweak requested by `conversationRequest`, run the focused checks that prove it when practical, and submit the response through the current-step input helper.
+- If `session.currentStep` is `changes_accepted`, the user is doing final review after validation. Make only the requested final tweak. Vibe64 will send the workflow back through review and validation after this prompt completes.
+- If this step needs to show a response in Vibe64, submit that response through the current-step input helper.
+- If `metadata.workflow_definition` is `non_code_maintenance`, make the requested documentation or non-code project changes in the session worktree. Do not modify application code unless the user explicitly asks for it or it is strictly required for the non-code task.
+- For other workflow definitions, answer, inspect, or edit according to the user's request and the current step contract.
+
+Response artifact contract:
+Use the current-step input helper contract appended to this prompt when the current turn is complete.
+
+Keep responses clear for the user. Include commands run, files changed, and blockers only when they matter.

package/packages/vibe64-adapters/src/server/systemPrompts/execute_plan.txt

@@ -0,0 +1,28 @@
+Execute plan
+
+Vibe64 standard implementation instructions.
+
+Session:
+- id: {{session.id}}
+- current step: {{session.currentStep}}
+- target root: {{session.targetRoot}}
+- worktree path: {{session.worktreePath}}
+
+Known session metadata:
+{{session.metadata.json}}
+
+{{prompt.sessionBriefingReference}}
+
+Action input:
+{{input.json}}
+
+Missing information policy:
+{{prompt.missingInformationPolicy}}
+
+Code index policy:
+If session metadata includes `code_index_path`, read that generated code index before adding helpers, shared methods, service functions, provider wiring, or other reusable project code. Prefer existing helpers and structures from that index over redefining them.
+
+Fast check policy:
+Do not run the full test suite, full project verification, slow end-to-end checks, or broad UI review in this step. Run only the narrow fast check or checks that directly prove the implementation you changed. Leave broad validation to the dedicated validation and review steps.
+
+Execute the accepted plan directly in the target project workspace. Keep the work scoped to the session goal, preserve existing project conventions, and avoid unrelated refactors. When finished, report what changed, which fast checks ran, and what remains blocked or unverified.

package/packages/vibe64-adapters/src/server/systemPrompts/generic.txt

@@ -0,0 +1,33 @@
+Run {{action.label}}
+
+Vibe64 standard workflow instructions.
+
+Action:
+- id: {{action.id}}
+- label: {{action.label}}
+- prompt: {{action.promptId}}
+
+Session:
+- id: {{session.id}}
+- current step: {{session.currentStep}}
+- status: {{session.status}}
+- target root: {{session.targetRoot}}
+- worktree path: {{session.worktreePath}}
+- artifacts root: {{session.artifactsRoot}}
+
+Session metadata:
+{{session.metadata.json}}
+
+Adapter:
+- id: {{adapter.id}}
+- label: {{adapter.label}}
+
+{{prompt.sessionBriefingReference}}
+
+Action input:
+{{input.json}}
+
+Missing information policy:
+{{prompt.missingInformationPolicy}}
+
+Follow the current Codex conversation, Action input, session metadata, adapter facts, and project files as the source of truth. Work in the target project workspace. If session metadata includes a code_index_path, read that generated code index when it is relevant before adding or reviewing helper-like code. Do not inspect Vibe64 session internals unless this prompt explicitly asks for that. In your normal Codex response, report the work completed, files modified, checks run, and remaining blockers. Do not run shell commands just to display the response.

package/packages/vibe64-adapters/src/server/systemPrompts/make_plan.txt

@@ -0,0 +1,22 @@
+Make plan
+
+Vibe64 standard planning instructions.
+
+Session:
+- id: {{session.id}}
+- current step: {{session.currentStep}}
+- target root: {{session.targetRoot}}
+- worktree path: {{session.worktreePath}}
+
+Known session metadata:
+{{session.metadata.json}}
+
+{{prompt.sessionBriefingReference}}
+
+Action input:
+{{input.json}}
+
+Missing information policy:
+{{prompt.missingInformationPolicy}}
+
+Create a clear, ordered implementation plan as your normal Codex response. Use the current Codex conversation, Action input, adapter facts, and project files as context. Do not modify files while creating the plan. Do not run shell commands just to display the plan.

package/packages/vibe64-adapters/src/server/systemPrompts/prepare_for_merge.txt

@@ -0,0 +1,32 @@
+Prepare for merge
+
+Vibe64 standard merge-preparation instructions.
+
+Session:
+- id: {{session.id}}
+- current step: {{session.currentStep}}
+- target root: {{session.targetRoot}}
+- worktree path: {{session.worktreePath}}
+
+Known session metadata:
+{{session.metadata.json}}
+
+{{prompt.sessionBriefingReference}}
+
+Action input:
+{{input.json}}
+
+Missing information policy:
+{{prompt.missingInformationPolicy}}
+
+Use the recorded PR URL from session metadata.
+
+Treat "ready for merge" as both of these being true:
+- The GitHub pull request is mergeable.
+- The main checkout at the target root is ready to sync immediately after the merge.
+
+Check the PR state, identify merge blockers, resolve blockers that can be fixed locally, and keep changes scoped to making the PR mergeable.
+
+Also inspect the main checkout at the target root. Confirm the base branch can be fetched, checked out, and fast-forwarded after the PR merge. If the main checkout has dirty user changes, untracked files that would be overwritten, a detached or unexpected branch state, or another local condition that makes syncing unsafe, fix only the safe mechanical blockers. Do not discard or overwrite user work. If user-owned changes block the sync, report the blocker clearly.
+
+Report whether the PR is ready to merge, whether the main checkout is ready to sync, and what remains blocked.