@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-workflow-ux-model.mjs

@@ -0,0 +1,205 @@
+function readOnlyWorkflowBoundary(extra) {
+  return {
+    writes: false,
+    state_directory_created: false,
+    sidecar_write: false,
+    source_write: false,
+    skill_execution: false,
+    command_execution: false,
+    runtime_action: false,
+    auto_execution: false,
+    external_network: false,
+    model_invocation: false,
+    platform_api: false,
+    git: false,
+    worktree: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+    shell_interception: false,
+    business_source_write: false,
+    source_merge: false,
+    ...extra,
+  };
+}
+
+export function workflowCockpitBoundaryAssertions() {
+  const boundary = readOnlyWorkflowBoundary({ workflow_cockpit_artifact: false });
+  delete boundary.source_write;
+  return boundary;
+}
+
+export function workflowCockpitPhase(intent, readiness, planLint) {
+  if (readiness.normalized_intent === 'unknown') return 'clarify';
+  if (planLint && planLint.execution_ready === false) return 'plan_lint';
+  if (intent === 'review') return 'review';
+  if (intent === 'completion' || intent === 'release') return 'closeout';
+  if (intent === 'debug') return 'verify';
+  if (planLint && planLint.execution_ready === true) return 'tdd_strategy';
+  if (intent === 'plan') return 'plan';
+  return 'plan_lint';
+}
+
+export function workflowCockpitRequiredEvidence(intent, planLint) {
+  const base = [];
+  if (!planLint) base.push('local plan file for Stage 86 plan lint when entering implementation');
+  if (intent === 'implementation') base.push('accepted plan', 'TDD or verification strategy', 'task-level acceptance');
+  if (intent === 'review') base.push('scoped diff or evidence', 'review severity focus', 'required-change criteria');
+  if (intent === 'completion' || intent === 'release') base.push('fresh syntax/check evidence', 'behavior smoke evidence', 'known unverified items');
+  if (intent === 'debug') base.push('minimal reproduction', 'root-cause hypothesis', 'targeted verification path');
+  if (intent === 'unknown') base.push('goal', 'scope', 'constraints', 'acceptance');
+  return [...new Set(base)];
+}
+
+export function workflowReceiptBoundaryAssertions() {
+  return readOnlyWorkflowBoundary({ workflow_receipt_artifact: false });
+}
+
+export function workflowCockpitSelfCheckSummary({ normalizedIntent, currentPhase, readiness, advice, planLint, blockedReasons, requiredEvidence }) {
+  const planLintStatus = planLint ? (planLint.execution_ready ? 'ready' : 'blocked') : 'not_provided';
+  const completionEvidenceRequired = normalizedIntent === 'completion' || normalizedIntent === 'release';
+  return {
+    summary_kind: 'workflow-cockpit-self-check',
+    profile_check: {
+      status: 'external_read_only_check',
+      recommended_commands: ['profile --show', 'profile --explain'],
+      writes: false,
+    },
+    entry_check: {
+      recommended_command: 'workflow --start --prompt <request> --json',
+      current_phase: currentPhase,
+      recommended_next_skill: readiness.route_summary.first_skill,
+    },
+    readiness_check: {
+      ready_to_start: readiness.ready_to_start,
+      required_gate_count: readiness.required_gate_kinds.length,
+      blocker_count: readiness.blocked_reasons.length,
+      readiness_digest: readiness.readiness_digest,
+    },
+    plan_check: {
+      status: planLintStatus,
+      source_file: planLint?.source_file || '',
+    },
+    completion_check: {
+      status: completionEvidenceRequired ? 'required_before_done_claim' : 'available_when_closing_out',
+      recommended_command: 'completion --readiness --from-file <local-completion-evidence-file> --json',
+      evidence_required_before_done: completionEvidenceRequired,
+    },
+    evidence_gap_count: blockedReasons.length,
+    required_evidence_count: requiredEvidence.length,
+    primary_advice: {
+      lane: advice.primary_lane,
+      command: advice.primary_recommendation.recommended_command,
+    },
+    next_manual_action: blockedReasons.length > 0 ? `Resolve cockpit blockers first: ${blockedReasons.slice(0, 3).join('; ')}` : `Enter ${readiness.route_summary.first_skill} with the required evidence preserved.`,
+    boundary: {
+      writes: false,
+      command_execution: false,
+      workflow_execution: false,
+      skill_execution: false,
+      subagent: false,
+      business_source_write: false,
+    },
+  };
+}
+
+export function buildWorkflowCockpitModel({ inputIntent, normalizedIntent, readiness, advice, planLint, tokenAdvice, learningAdvice, governanceAdvice }) {
+  const blockedReasons = [...new Set([
+    ...readiness.blocked_reasons,
+    ...(planLint && !planLint.execution_ready ? planLint.blocking_findings.map((item) => `plan_lint: ${item}`) : []),
+    ...(!planLint && ['implementation', 'plan'].includes(normalizedIntent) ? ['plan lint evidence not provided for implementation readiness cockpit'] : []),
+  ])];
+  const currentPhase = workflowCockpitPhase(normalizedIntent, readiness, planLint);
+  const requiredEvidence = workflowCockpitRequiredEvidence(normalizedIntent, planLint);
+  const selfCheckSummary = workflowCockpitSelfCheckSummary({ normalizedIntent, currentPhase, readiness, advice, planLint, blockedReasons, requiredEvidence });
+  const boundaryAssertions = workflowCockpitBoundaryAssertions();
+  const nextManualAction = selfCheckSummary.next_manual_action;
+  const cockpit = {
+    version: 1,
+    stage: 'Stage 87',
+    cockpit_kind: 'workflow-cockpit',
+    input_intent: inputIntent,
+    normalized_intent: normalizedIntent,
+    current_phase: currentPhase,
+    state_machine: ['clarify', 'plan', 'plan_lint', 'tdd_strategy', 'execute_task', 'review', 'verify', 'closeout'],
+    recommended_next_skill: readiness.route_summary.first_skill,
+    route_summary: readiness.route_summary,
+    readiness_summary: { ready_to_start: readiness.ready_to_start, required_gate_kinds: readiness.required_gate_kinds, blocked_reasons: readiness.blocked_reasons, readiness_digest: readiness.readiness_digest },
+    advice_summary: { primary_lane: advice.primary_lane, primary_command: advice.primary_recommendation.recommended_command, advice_digest: advice.advice_digest },
+    plan_lint_summary: planLint ? { status: planLint.execution_ready ? 'ready' : 'blocked', source_file: planLint.source_file, blocker_count: planLint.summary.blocker_count, warning_count: planLint.summary.warning_count, lint_digest: planLint.lint_digest } : { status: 'not_provided' },
+    token_hint: { recommended_profile: tokenAdvice.recommended_profile, recommended_command: tokenAdvice.command ? `tokens --advice --command ${tokenAdvice.command} --json` : `tokens --advice --intent ${tokenAdvice.intent} --json`, advice_digest: tokenAdvice.advice_digest },
+    learning_hint: { recommended_next_learning_step: learningAdvice.recommended_next_learning_step, recommended_command: learningAdvice.recommended_command, advice_digest: learningAdvice.advice_digest },
+    governance_hint: { recommended_next_governance_step: governanceAdvice.recommended_next_governance_step, recommended_command: governanceAdvice.recommended_command, advice_digest: governanceAdvice.advice_digest },
+    blocked_reasons: blockedReasons,
+    required_evidence: requiredEvidence,
+    self_check_summary: selfCheckSummary,
+    forbidden_actions: ['auto workflow execution', 'subagent dispatch without explicit permission', 'platform API calls', 'git push/merge/PR/tag', 'business source mutation from cockpit'],
+    next_manual_action: nextManualAction,
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  return { cockpit, blockedReasons, boundaryAssertions };
+}
+
+export function onboardingBriefBoundaryAssertions() {
+  return readOnlyWorkflowBoundary({ onboarding_brief_artifact: false });
+}
+
+export function onboardingBriefLines() {
+  return [
+    'Start every development task with a lightweight using-vibecoding workflow judgment.',
+    'Use workflow --start when you want one local read-only panel for route, receipt, readiness, and next action.',
+    'State a verification strategy before source edits; simple tasks stay lightweight.',
+    'Use workflow --sequence for TDD, plan execution, review, or closeout choreography.',
+    'Do not call subagents, git host actions, push, merge, PR, platform APIs, external models, or network without explicit user permission.',
+    'Do not claim completion without fresh verification evidence.',
+  ];
+}
+
+export function workflowSequenceBoundaryAssertions() {
+  return readOnlyWorkflowBoundary({ workflow_sequence_artifact: false });
+}
+
+export function workflowSequenceDefinition(intent) {
+  if (intent === 'review') {
+    return {
+      phase_order: ['scope-review-target', 'collect-evidence', 'review-blockers-first', 'classify-feedback', 'decide-fix-or-closeout'],
+      phase_entry_criteria: ['review target and diff/evidence are scoped', 'severity policy is known', 'verification expectations are explicit'],
+      phase_exit_evidence: ['blocking findings list or none', 'high-risk findings with file/evidence references', 'required-change decision for each finding'],
+      handoff_points: ['handoff to vibe-receiving-code-review when fixes are required', 'handoff to completion readiness when no blockers remain'],
+      stop_conditions: ['missing review target', 'unverified evidence', 'request to merge/push without explicit authorization'],
+    };
+  }
+  if (intent === 'completion' || intent === 'release') {
+    return {
+      phase_order: ['collect-fresh-verification', 'check-review-feedback', 'check-git-release-boundary', 'report-done-or-blocked'],
+      phase_entry_criteria: ['implementation or review work is claimed complete', 'verification path is known'],
+      phase_exit_evidence: ['fresh check output or manual verification evidence', 'known gaps stated', 'no implied commit/PR/push/release action'],
+      handoff_points: ['handoff to finishing branch only after verification evidence exists', 'handoff to user confirmation before git or platform action'],
+      stop_conditions: ['no fresh verification evidence', 'unresolved review feedback', 'missing user authorization for git/PR/release'],
+    };
+  }
+  if (intent === 'plan') {
+    return {
+      phase_order: ['load-plan', 'lint-plan', 'select-task-batch', 'state-verification-strategy', 'execute-task', 'task-level-acceptance', 'handoff-next-task'],
+      phase_entry_criteria: ['accepted local plan exists', 'plan lint is ready or known blockers are resolved', 'task dependencies are clear'],
+      phase_exit_evidence: ['task acceptance result', 'files touched or inspected', 'verification command/manual evidence', 'remaining tasks and risks'],
+      handoff_points: ['handoff after each task batch', 'handoff to review before completion claim'],
+      stop_conditions: ['plan lint blocker', 'unclear task ownership', 'missing verification strategy'],
+    };
+  }
+  return {
+    phase_order: ['state-verification-strategy', 'minimal-implementation', 'targeted-self-check', 'review-or-completion-readiness'],
+    phase_entry_criteria: ['goal, scope, and acceptance are clear', 'verification strategy is known before editing', 'risk boundary is explicit'],
+    phase_exit_evidence: ['changed files are bounded', 'targeted check output or manual evidence is recorded', 'remaining risk is stated'],
+    handoff_points: ['handoff to review for risky or non-trivial changes', 'handoff to completion readiness before claiming done'],
+    stop_conditions: ['unclear acceptance', 'test or check path unknown', 'request requires subagent/git/platform action without permission'],
+  };
+}

package/tools/vibe-runtime/runtime-workspace-boundary-text.mjs

@@ -0,0 +1,7 @@
+export function workspaceAllowedFollowupActions() {
+  return [
+    'source --patch-plan',
+    'source --sandbox-apply --confirm',
+    'source --apply-to-worktree --approval <file> --confirm after separate approval',
+  ];
+}

package/tools/vibe-runtime/runtime-workspace-isolation-command.mjs

@@ -0,0 +1,295 @@
+import crypto from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import {
+  emitReadonlyLocalJsonOutput,
+  readonlyLocalStatePresent,
+} from './runtime-readonly-local-json-output-envelope.mjs';
+import { workspaceAllowedFollowupActions } from './runtime-workspace-boundary-text.mjs';
+
+const workspaceStage = 'Stage 150';
+const workspaceDirectoryName = 'workspaces';
+const workspacePlanKind = 'workspace-isolation-plan';
+const workspaceCreateKind = 'workspace-isolation-contract';
+const workspaceCleanupKind = 'workspace-cleanup-plan';
+
+export function createRuntimeWorkspaceCommand(deps) {
+  const { ensureRoot } = deps;
+
+  function runWorkspace(options) {
+    ensureRoot(options.root);
+    const modes = [options.workspaceIsolatePlan, options.workspaceCreate, options.workspaceStatus, options.workspaceCleanupPlan].filter(Boolean);
+    if (modes.length !== 1) throw new Error('workspace requires exactly one mode: --isolate-plan, --create, --status, or --cleanup-plan');
+    if (options.profile && options.profile !== 'superpowers-parity') throw new Error('workspace --profile must be superpowers-parity when provided');
+
+    if (options.workspaceIsolatePlan) {
+      rejectWorkspaceFlags(options, { allowFromPlan: true });
+      const envelope = workspaceIsolationPlanEnvelope(options.root, options.fromPlan);
+      outputWorkspace(deps, options, envelope);
+      return;
+    }
+
+    if (options.workspaceStatus) {
+      rejectWorkspaceFlags(options, {});
+      const envelope = workspaceStatusEnvelope(options.root);
+      outputWorkspace(deps, options, envelope);
+      return;
+    }
+
+    if (options.workspaceCleanupPlan) {
+      rejectWorkspaceFlags(options, {});
+      const envelope = workspaceCleanupPlanEnvelope(options.root);
+      outputWorkspace(deps, options, envelope);
+      return;
+    }
+
+    if (!options.confirm) throw new Error('workspace --create requires --confirm');
+    rejectWorkspaceFlags(options, { allowFromPlan: true, allowConfirm: true });
+    const envelope = workspaceCreateEnvelope(options.root, options.fromPlan);
+    const files = writeWorkspaceContract(options.root, envelope.workspace_contract);
+    outputWorkspace(deps, options, { ...envelope, files });
+  }
+
+  return { runWorkspace };
+}
+
+function rejectWorkspaceFlags(options, allowances) {
+  if (!allowances.allowFromPlan && options.fromPlan) throw new Error('workspace mode does not accept --from-plan');
+  if (!allowances.allowConfirm && options.confirm) throw new Error('workspace mode does not accept --confirm');
+  if (options.write || options.dryRun || options.run || options.autoRun || options.dispatch || options.dispatchIntent || options.preflight || options.scan || options.once) {
+    throw new Error('workspace only accepts --from-plan where documented, --profile superpowers-parity, --confirm for create, --json, and --root');
+  }
+}
+
+function workspaceIsolationPlanEnvelope(root, planFile) {
+  const source = planFile ? readPlanSource(root, planFile) : null;
+  const contract = workspaceContractPayload(root, source, { writes: false, createdAt: new Date().toISOString() });
+  const plan = { ...contract, plan_kind: workspacePlanKind, workspace_contract_digest: digest(contract) };
+  return {
+    schema_version: 1,
+    command: 'workspace',
+    mode: workspacePlanKind,
+    ok: true,
+    state_present: readonlyLocalStatePresent(root),
+    workspace_isolation_plan: plan,
+    safety: { stage: workspaceStage, ...workspaceBoundary(false) },
+    quality: [],
+    action: 'workspace isolate-plan produced a local isolation contract preview only. No state, source, git, worktree, command, platform API, model, MCP, subagent, PR, push, or merge action occurred.',
+  };
+}
+
+function workspaceCreateEnvelope(root, planFile) {
+  const source = planFile ? readPlanSource(root, planFile) : null;
+  const createdAt = new Date().toISOString();
+  const contract = workspaceContractPayload(root, source, { writes: true, createdAt });
+  const payload = { ...contract, contract_kind: workspaceCreateKind, workspace_contract_digest: digest(contract) };
+  return {
+    schema_version: 1,
+    command: 'workspace',
+    mode: workspaceCreateKind,
+    ok: true,
+    state_present: readonlyLocalStatePresent(root),
+    workspace_contract: payload,
+    safety: { stage: workspaceStage, ...workspaceBoundary(true) },
+    quality: [],
+    action: 'workspace create wrote only a local workspace isolation contract under .vibecoding-state/workspaces. It did not create a git worktree, modify source, run commands, write git, commit, push, create PRs, call platform APIs, invoke models, MCP, or subagents.',
+  };
+}
+
+function workspaceStatusEnvelope(root) {
+  const records = listWorkspaceContracts(root);
+  return {
+    schema_version: 1,
+    command: 'workspace',
+    mode: 'workspace-isolation-status',
+    ok: true,
+    state_present: readonlyLocalStatePresent(root),
+    workspace_status: {
+      version: 1,
+      stage: workspaceStage,
+      status_kind: 'workspace-isolation-status',
+      contract_count: records.length,
+      contracts: records,
+      active_contracts: records.filter((item) => item.status === 'created-contract-only').length,
+      boundary_assertions: workspaceBoundary(false),
+      writes: false,
+      state_directory_created: false,
+      local_only: true,
+      deterministic: true,
+    },
+    safety: { stage: workspaceStage, ...workspaceBoundary(false) },
+    quality: [],
+    action: 'workspace status read local isolation contracts only. No state, source, git, worktree, command, platform API, model, MCP, subagent, PR, push, or merge action occurred.',
+  };
+}
+
+function workspaceCleanupPlanEnvelope(root) {
+  const records = listWorkspaceContracts(root);
+  const cleanup = {
+    version: 1,
+    stage: workspaceStage,
+    cleanup_kind: workspaceCleanupKind,
+    candidate_count: records.length,
+    cleanup_candidates: records.map((item) => ({
+      workspace_id: item.workspace_id,
+      contract_file: item.file,
+      cleanup_action: 'manual-remove-state-sidecar-after-review',
+      source_or_worktree_delete_authorized: false,
+    })),
+    boundary_assertions: workspaceBoundary(false),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  return {
+    schema_version: 1,
+    command: 'workspace',
+    mode: workspaceCleanupKind,
+    ok: true,
+    state_present: readonlyLocalStatePresent(root),
+    workspace_cleanup_plan: { ...cleanup, cleanup_plan_digest: digest(cleanup) },
+    safety: { stage: workspaceStage, ...workspaceBoundary(false) },
+    quality: [],
+    action: 'workspace cleanup-plan produced manual cleanup guidance only. It did not delete files, remove worktrees, run git, mutate source, or write state.',
+  };
+}
+
+function workspaceContractPayload(root, source, { writes, createdAt }) {
+  const workspaceId = workspaceIdFor(source, createdAt);
+  return {
+    version: 1,
+    stage: workspaceStage,
+    workspace_id: workspaceId,
+    automation_profile: 'superpowers-parity',
+    created_at: createdAt,
+    source_plan: source?.relative || '',
+    source_plan_digest: source?.digest || '',
+    isolation_policy: {
+      main_worktree_write_allowed: false,
+      isolated_workspace_required_for_source_write: true,
+      source_apply_requires_existing_source_gate: true,
+      task_commit_requires_later_commit_gate: true,
+      git_worktree_created_by_runtime: false,
+      git_commit_allowed: false,
+      push_allowed: false,
+      pr_allowed: false,
+      merge_allowed: false,
+    },
+    workspace_paths: {
+      contract_root: `${workspaceDirectoryName}/${workspaceId}`,
+      sidecar_file: `${workspaceDirectoryName}/${workspaceId}/${workspaceId}.workspace-isolation-contract.json`,
+      suggested_isolated_root_name: `.vibecoding-workspaces/${workspaceId}`,
+    },
+    allowed_followup: workspaceAllowedFollowupActions(),
+    forbidden_actions: ['main worktree source write', 'git worktree creation by this command', 'git add/commit/push', 'PR or merge', 'platform API call', 'model invocation', 'subagent invocation'],
+    boundary_assertions: workspaceBoundary(writes),
+    writes,
+    state_directory_created: writes,
+    local_only: true,
+    deterministic: true,
+  };
+}
+
+function writeWorkspaceContract(root, contract) {
+  const dir = path.join(root, '.vibecoding-state', workspaceDirectoryName, contract.workspace_id);
+  mkdirSync(dir, { recursive: true });
+  const file = `${contract.workspace_id}.workspace-isolation-contract.json`;
+  writeFileSync(path.join(dir, file), `${JSON.stringify(contract, null, 2)}\n`, 'utf8');
+  return { workspace_contract: `${workspaceDirectoryName}/${contract.workspace_id}/${file}` };
+}
+
+function listWorkspaceContracts(root) {
+  const base = path.join(root, '.vibecoding-state', workspaceDirectoryName);
+  if (!existsSync(base)) return [];
+  return readdirSync(base, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .flatMap((entry) => {
+      const dir = path.join(base, entry.name);
+      return readdirSync(dir)
+        .filter((name) => name.endsWith('.workspace-isolation-contract.json'))
+        .map((name) => readContractSummary(path.join(dir, name), `${workspaceDirectoryName}/${entry.name}/${name}`));
+    })
+    .filter(Boolean)
+    .sort((a, b) => String(a.file).localeCompare(String(b.file)));
+}
+
+function readContractSummary(file, relative) {
+  try {
+    const artifact = JSON.parse(readFileSync(file, 'utf8'));
+    return {
+      file: relative,
+      workspace_id: artifact.workspace_id || '',
+      status: artifact.writes ? 'created-contract-only' : 'planned',
+      source_plan: artifact.source_plan || '',
+      source_plan_digest: artifact.source_plan_digest || '',
+      git_worktree_created_by_runtime: artifact.isolation_policy?.git_worktree_created_by_runtime === true,
+      main_worktree_write_allowed: artifact.isolation_policy?.main_worktree_write_allowed === true,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function readPlanSource(root, planFile) {
+  const absolute = path.resolve(root, planFile);
+  const relative = path.relative(root, absolute).replaceAll(path.sep, '/');
+  if (relative.startsWith('..') || path.isAbsolute(relative)) throw new Error('workspace --from-plan must stay inside --root');
+  if (!existsSync(absolute)) throw new Error(`workspace plan file not found: ${relative}`);
+  const text = readFileSync(absolute, 'utf8');
+  return { relative, digest: crypto.createHash('sha256').update(text).digest('hex') };
+}
+
+function workspaceIdFor(source, createdAt) {
+  const seed = `${source?.digest || 'no-plan'}:${createdAt}`;
+  return `workspace-${crypto.createHash('sha256').update(seed).digest('hex').slice(0, 12)}`;
+}
+
+function workspaceBoundary(writes) {
+  return {
+    workspace_isolation_artifact: Boolean(writes),
+    state_directory_created: Boolean(writes),
+    source_write: false,
+    business_source_write: false,
+    main_worktree_write: false,
+    isolated_workspace_source_write: false,
+    command_execution: false,
+    test_execution: false,
+    git: false,
+    git_write: false,
+    git_worktree: false,
+    commit: false,
+    push: false,
+    pr: false,
+    merge: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+  };
+}
+
+function outputWorkspace(deps, options, envelope) {
+  emitReadonlyLocalJsonOutput({ deps, options, channel: 'workspace', envelope, print: printWorkspace });
+}
+
+function printWorkspace(envelope) {
+  console.log('Vibecoding Runtime Workspace Isolation');
+  console.log(`Mode: ${envelope.mode}; ok=${envelope.ok}`);
+  const detail = envelope.workspace_isolation_plan || envelope.workspace_contract || envelope.workspace_status || envelope.workspace_cleanup_plan;
+  if (detail?.workspace_id) console.log(`Workspace: ${detail.workspace_id}`);
+  if (detail?.contract_count !== undefined) console.log(`Contracts: ${detail.contract_count}`);
+  if (envelope.files?.workspace_contract) console.log(`Contract: ${envelope.files.workspace_contract}`);
+  console.log(`Action: ${envelope.action}`);
+}
+
+function digest(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+  if (value && typeof value === 'object') return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+  return JSON.stringify(value);
+}

package/tools/vibe-runtime/state-core-paths.mjs

@@ -0,0 +1,113 @@
+import path from 'node:path';
+import { stateDirectory } from './runtime-state-directory-model.mjs';
+export { stateDirectoryName } from './runtime-state-directory-model.mjs';
+
+export const workflowFileName = 'workflow.json';
+export const taskArtifactsDirectoryName = 'tasks';
+export const dispatchesDirectoryName = 'dispatches';
+export const dispatchClaimsDirectoryName = 'dispatch-claims';
+export const executionsDirectoryName = 'executions';
+export const executionCandidatesDirectoryName = 'execution-candidates';
+export const executionApprovalsDirectoryName = 'execution-approvals';
+export const autoRunLocksDirectoryName = 'auto-run-locks';
+export const recoveryPackagesDirectoryName = 'recovery-packages';
+export const recoveryClassificationsDirectoryName = 'recovery-classifications';
+export const recoveryRunsDirectoryName = 'recovery-runs';
+export const observabilityDirectoryName = 'observability';
+export const approvalLifecycleDirectoryName = 'approval-lifecycle';
+export const replyDraftsDirectoryName = 'reply-drafts';
+export const replyReviewsDirectoryName = 'reply-reviews';
+export const replyApprovalsDirectoryName = 'reply-approvals';
+export const replyOutboxDirectoryName = 'reply-outbox';
+export const replySendRunsDirectoryName = 'reply-send-runs';
+export const runtimeTracesDirectoryName = 'runtime-traces';
+export const governanceDirectoryName = 'governance';
+export const methodologyGatesDirectoryName = 'methodology-gates';
+
+export function workflowPath(root) {
+  return path.join(stateDirectory(root), workflowFileName);
+}
+
+export function artifactPath(root, fileName) {
+  return path.join(stateDirectory(root), fileName);
+}
+
+export function taskArtifactsDirectory(root) {
+  return path.join(stateDirectory(root), taskArtifactsDirectoryName);
+}
+
+export function dispatchesDirectory(root) {
+  return path.join(stateDirectory(root), dispatchesDirectoryName);
+}
+
+export function dispatchClaimsDirectory(root) {
+  return path.join(stateDirectory(root), dispatchClaimsDirectoryName);
+}
+
+export function executionsDirectory(root) {
+  return path.join(stateDirectory(root), executionsDirectoryName);
+}
+
+export function executionCandidatesDirectory(root) {
+  return path.join(stateDirectory(root), executionCandidatesDirectoryName);
+}
+
+export function executionApprovalsDirectory(root) {
+  return path.join(stateDirectory(root), executionApprovalsDirectoryName);
+}
+
+export function autoRunLocksDirectory(root) {
+  return path.join(stateDirectory(root), autoRunLocksDirectoryName);
+}
+
+export function recoveryPackagesDirectory(root) {
+  return path.join(stateDirectory(root), recoveryPackagesDirectoryName);
+}
+
+export function recoveryClassificationsDirectory(root) {
+  return path.join(stateDirectory(root), recoveryClassificationsDirectoryName);
+}
+
+export function recoveryRunsDirectory(root) {
+  return path.join(stateDirectory(root), recoveryRunsDirectoryName);
+}
+
+export function observabilityDirectory(root) {
+  return path.join(stateDirectory(root), observabilityDirectoryName);
+}
+
+export function approvalLifecycleDirectory(root) {
+  return path.join(stateDirectory(root), approvalLifecycleDirectoryName);
+}
+
+export function replyDraftsDirectory(root) {
+  return path.join(stateDirectory(root), replyDraftsDirectoryName);
+}
+
+export function replyReviewsDirectory(root) {
+  return path.join(stateDirectory(root), replyReviewsDirectoryName);
+}
+
+export function replyApprovalsDirectory(root) {
+  return path.join(stateDirectory(root), replyApprovalsDirectoryName);
+}
+
+export function replyOutboxDirectory(root) {
+  return path.join(stateDirectory(root), replyOutboxDirectoryName);
+}
+
+export function replySendRunsDirectory(root) {
+  return path.join(stateDirectory(root), replySendRunsDirectoryName);
+}
+
+export function runtimeTracesDirectory(root) {
+  return path.join(stateDirectory(root), runtimeTracesDirectoryName);
+}
+
+export function governanceDirectory(root) {
+  return path.join(stateDirectory(root), governanceDirectoryName);
+}
+
+export function methodologyGatesDirectory(root) {
+  return path.join(stateDirectory(root), methodologyGatesDirectoryName);
+}