@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-entry-summary-model.mjs

@@ -0,0 +1,343 @@
+export function entryRuntimeSummaryBoundaryAssertions() {
+  return {
+    entry_runtime_summary_artifact: false,
+    writes: false,
+    state_directory_created: false,
+    sidecar_write: false,
+    source_write: false,
+    prompt_write: false,
+    prompt_mutation: false,
+    template_mutation: false,
+    skill_mutation: false,
+    hook_registration: false,
+    command_execution: false,
+    check_execution: false,
+    test_execution: false,
+    verification_execution: false,
+    workflow_execution: false,
+    skill_execution: false,
+    runtime_action: false,
+    auto_execution: false,
+    repair_execution: false,
+    shell_interception: false,
+    output_mutation: false,
+    dynamic_tool_execution: false,
+    embeddings: false,
+    remote_config: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+    git: false,
+    git_write: false,
+    commit: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}
+
+export function learningAdviceIntentForWorkflowIntent(intent) {
+  const normalized = String(intent || '').trim().toLowerCase();
+  if (normalized === 'debug') return 'failure-fix';
+  if (normalized === 'review' || normalized === 'review-feedback') return 'review';
+  if (normalized === 'context') return 'repeated-workflow';
+  if (normalized === 'skill') return 'project-constraint';
+  return 'preference';
+}
+
+export function buildEntryRuntimeSummaryEnvelopeModel({
+  prompt = '',
+  inputIntent = '',
+  workflowStartEnvelope,
+  tokenSaviorBudgetEnvelope,
+  learningAdviceEnvelope,
+  digestObject,
+} = {}) {
+  const start = workflowStartEnvelope.workflow_start || {};
+  const budget = tokenSaviorBudgetEnvelope.token_savior_budget || {};
+  const advice = learningAdviceEnvelope.learning_advice || {};
+  const boundaryAssertions = entryRuntimeSummaryBoundaryAssertions();
+  const sourceBindings = {
+    workflow_start_digest: start.start_digest || '',
+    token_savior_budget_digest: budget.budget_digest || '',
+    learning_advice_digest: advice.advice_digest || '',
+  };
+  const summary = {
+    version: 1,
+    stage: 'Stage 145',
+    summary_kind: 'entry-runtime-summary',
+    prompt: String(prompt || '').trim(),
+    input_intent: String(inputIntent || '').trim(),
+    normalized_intent: start.normalized_intent || '',
+    source_bindings: sourceBindings,
+    entry_decision: {
+      classification: start.entry_summary?.entry_classification || 'unknown',
+      state_gap_is_expected: Boolean(start.entry_summary?.state_gap_is_expected),
+      selected_skill: start.receipt_summary?.selected_skill || '',
+      recommended_next_skill: start.cockpit_summary?.recommended_next_skill || '',
+      first_user_decision: start.entry_summary?.first_user_decision || start.next_manual_action || '',
+      readiness_blocker_count: start.entry_summary?.readiness_blocker_count ?? (start.blocked_reasons || []).length,
+    },
+    workflow_discipline: {
+      protocol_layer: start.workflow_discipline_summary?.protocol_layer || '',
+      default_context: start.workflow_discipline_summary?.context_policy?.default_context || '',
+      full_skill_injection: start.workflow_discipline_summary?.context_policy?.full_skill_injection === true,
+      skill_execution_claimed: start.workflow_discipline_summary?.visible_claims?.skill_execution_claimed === true,
+      workflow_execution_claimed: start.workflow_discipline_summary?.visible_claims?.workflow_execution_claimed === true,
+      command_execution_claimed: start.workflow_discipline_summary?.visible_claims?.command_execution_claimed === true,
+      subagent_dispatch_claimed: start.workflow_discipline_summary?.visible_claims?.subagent_dispatch_claimed === true,
+      git_write_claimed: start.workflow_discipline_summary?.visible_claims?.git_write_claimed === true,
+      discipline_digest: start.workflow_discipline_summary?.discipline_digest || '',
+    },
+    token_budget: {
+      recommended_profile: budget.recommended_profile || '',
+      max_context_tokens: budget.context_budget?.max_context_tokens || 0,
+      skills_to_surface: compactSkillItems(budget.skills_to_surface),
+      skills_to_defer: compactSkillItems(budget.skills_to_defer),
+      commands_to_surface: compactCommandItems(budget.commands_to_surface),
+    },
+    learning_advice: {
+      intent: advice.intent || '',
+      recommended_next_learning_step: advice.recommended_next_learning_step || '',
+      recommended_command: advice.recommended_command || '',
+      manual_action: advice.manual_action || '',
+      promotion_target: advice.promotion_boundary?.promotion_target || '',
+      automatic_promotion: advice.promotion_boundary?.automatic_promotion === true,
+    },
+    context_load_plan: contextLoadPlan(start, budget, advice),
+    defer_policy: deferPolicy(start, budget),
+    surface_now: surfaceNow(start, budget, advice),
+    defer_until_needed: deferUntilNeeded(start, budget),
+    next_manual_action: nextManualAction(start, budget, advice),
+    forbidden_actions: forbiddenActions(start),
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = entryRuntimeSummaryInvariants(summary);
+  const withInvariants = {
+    ...summary,
+    ok: invariants.pass,
+    entry_runtime_summary_invariants: invariants,
+  };
+  return {
+    mode: 'entry-runtime-summary',
+    ok: invariants.pass,
+    state_present: Boolean(workflowStartEnvelope.state_present || tokenSaviorBudgetEnvelope.state_present || learningAdviceEnvelope.state_present),
+    entry_runtime_summary: {
+      ...withInvariants,
+      summary_digest: digestObject(entryRuntimeSummaryDigestPayload(withInvariants)),
+    },
+    source_envelopes: sourceBindings,
+    safety: { stage: 'Stage 145', ...boundaryAssertions },
+    quality: invariants.findings,
+    action: 'entry runtime summary was computed read-only from workflow start, token savior budget, and learning advice envelopes. It only recommends visible context, deferred context, learning follow-up, and the next manual action; no state directory, sidecar, command, check, test, workflow skill execution, runtime action, source write, git, commit, push, PR, merge, platform API, external network, model, MCP, subagent, worktree, or business source write occurred.',
+  };
+}
+
+export function entryRuntimeSummaryDigestPayload(summary) {
+  return {
+    stage: summary.stage,
+    summary_kind: summary.summary_kind,
+    prompt: summary.prompt,
+    input_intent: summary.input_intent,
+    normalized_intent: summary.normalized_intent,
+    source_bindings: summary.source_bindings,
+    entry_decision: summary.entry_decision,
+    workflow_discipline: summary.workflow_discipline,
+    token_budget: summary.token_budget,
+    learning_advice: summary.learning_advice,
+    context_load_plan: summary.context_load_plan,
+    defer_policy: summary.defer_policy,
+    surface_now: summary.surface_now,
+    defer_until_needed: summary.defer_until_needed,
+    next_manual_action: summary.next_manual_action,
+    forbidden_actions: summary.forbidden_actions,
+    boundary_assertions: summary.boundary_assertions,
+    entry_runtime_summary_invariants: summary.entry_runtime_summary_invariants,
+  };
+}
+
+export function entryRuntimeSummaryInvariants(summary) {
+  const boundary = summary.boundary_assertions || {};
+  const unsafeBoundaries = Object.entries(boundary)
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const missingForbidden = Object.keys(entryRuntimeSummaryBoundaryAssertions())
+    .filter((key) => boundary[key] !== false);
+  const executableCommands = (summary.token_budget?.commands_to_surface || [])
+    .filter((item) => item.preview_only !== true || containsExecutablePreviewCommand(item.command))
+    .map((item) => item.id || item.command);
+  const findings = [
+    ...(summary.stage === 'Stage 145' ? [] : ['stage must be Stage 145']),
+    ...(summary.summary_kind === 'entry-runtime-summary' ? [] : ['summary_kind must be entry-runtime-summary']),
+    ...(summary.source_bindings?.workflow_start_digest ? [] : ['workflow_start_digest is required']),
+    ...(summary.source_bindings?.token_savior_budget_digest ? [] : ['token_savior_budget_digest is required']),
+    ...(summary.source_bindings?.learning_advice_digest ? [] : ['learning_advice_digest is required']),
+    ...(summary.entry_decision?.selected_skill ? [] : ['entry_decision.selected_skill is required']),
+    ...(summary.workflow_discipline?.protocol_layer ? [] : ['workflow_discipline.protocol_layer is required']),
+    ...(summary.workflow_discipline?.default_context === 'tiny_context' ? [] : ['workflow_discipline.default_context must be tiny_context']),
+    ...(summary.workflow_discipline?.full_skill_injection === false ? [] : ['workflow_discipline.full_skill_injection must remain false']),
+    ...(summary.workflow_discipline?.skill_execution_claimed === false ? [] : ['workflow_discipline.skill_execution_claimed must remain false']),
+    ...(summary.workflow_discipline?.workflow_execution_claimed === false ? [] : ['workflow_discipline.workflow_execution_claimed must remain false']),
+    ...(summary.workflow_discipline?.command_execution_claimed === false ? [] : ['workflow_discipline.command_execution_claimed must remain false']),
+    ...(summary.workflow_discipline?.subagent_dispatch_claimed === false ? [] : ['workflow_discipline.subagent_dispatch_claimed must remain false']),
+    ...(summary.workflow_discipline?.git_write_claimed === false ? [] : ['workflow_discipline.git_write_claimed must remain false']),
+    ...(summary.token_budget?.recommended_profile ? [] : ['token_budget.recommended_profile is required']),
+    ...(summary.learning_advice?.recommended_next_learning_step ? [] : ['learning_advice.recommended_next_learning_step is required']),
+    ...(summary.learning_advice?.automatic_promotion === false ? [] : ['learning_advice.automatic_promotion must remain false']),
+    ...(summary.context_load_plan?.plan_kind === 'entry-context-load-plan' ? [] : ['context_load_plan.plan_kind must be entry-context-load-plan']),
+    ...(Array.isArray(summary.context_load_plan?.load_order) && summary.context_load_plan.load_order.length >= 3 ? [] : ['context_load_plan.load_order must include workflow, token, and learning summary steps']),
+    ...(summary.context_load_plan?.full_skill_text_loaded === false ? [] : ['context_load_plan.full_skill_text_loaded must remain false']),
+    ...(summary.defer_policy?.policy_kind === 'entry-context-defer-policy' ? [] : ['defer_policy.policy_kind must be entry-context-defer-policy']),
+    ...(Array.isArray(summary.defer_policy?.expansion_triggers) && summary.defer_policy.expansion_triggers.length > 0 ? [] : ['defer_policy.expansion_triggers must not be empty']),
+    ...(summary.defer_policy?.hidden_discard === false ? [] : ['defer_policy.hidden_discard must remain false']),
+    ...(summary.defer_policy?.prompt_mutation === false ? [] : ['defer_policy.prompt_mutation must remain false']),
+    ...(Array.isArray(summary.surface_now) && summary.surface_now.length >= 3 ? [] : ['surface_now must include workflow, token, and learning items']),
+    ...(Array.isArray(summary.defer_until_needed) && summary.defer_until_needed.length > 0 ? [] : ['defer_until_needed must not be empty']),
+    ...(summary.next_manual_action ? [] : ['next_manual_action is required']),
+    ...unsafeBoundaries.map((key) => `boundary assertion must remain false: ${key}`),
+    ...missingForbidden.map((key) => `forbidden boundary missing or not false: ${key}`),
+    ...executableCommands.map((id) => `commands_to_surface must remain preview-only and non-executing: ${id}`),
+  ];
+  return {
+    pass: findings.length === 0,
+    checked: ['source_envelope_bindings', 'workflow_entry_decision', 'workflow_discipline_summary', 'token_budget_visibility', 'context_load_plan', 'defer_policy', 'learning_advice_boundary', 'surface_defer_split', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+function compactSkillItems(items = []) {
+  return items.map((item) => ({
+    skill: item.skill || item.id || '',
+    reason: item.reason || item.default || '',
+  })).filter((item) => item.skill);
+}
+
+function compactCommandItems(items = []) {
+  return items.map((item) => ({
+    id: item.id || '',
+    command: item.command || item.preview || '',
+    preview_only: item.preview_only !== false,
+  })).filter((item) => item.id || item.command);
+}
+
+function containsExecutablePreviewCommand(command = '') {
+  const value = String(command || '').toLowerCase();
+  const optionTokens = ['confirm', 'run', 'once', 'auto-run'].map((name) => `-${'-'}${name}`);
+  return optionTokens.some((token) => value.includes(token))
+    || /\bgit\s+(commit|push|merge|tag)\b|\bgh\s+pr\b/i.test(value);
+}
+
+function contextLoadPlan(start, budget, advice) {
+  const contextBudget = budget.context_budget || {};
+  const surfacedSkills = compactSkillItems(budget.skills_to_surface);
+  const commandPreviews = compactCommandItems(budget.commands_to_surface);
+  return {
+    plan_kind: 'entry-context-load-plan',
+    recommended_profile: budget.recommended_profile || '',
+    max_context_tokens: contextBudget.max_context_tokens || 0,
+    full_skill_text_loaded: false,
+    raw_evidence_loaded: false,
+    command_previews_executable: false,
+    load_order: [
+      contextLoadStep('workflow-entry-decision', 'workflow_start', 'selected skill, route summary, blocker counts, and first manual decision', contextBudget.entry_instruction_tokens || 0, start.entry_summary?.first_user_decision || start.next_manual_action || ''),
+      contextLoadStep('token-budget-summary', 'token_savior_budget', 'profile, token caps, surfaced skills, deferred skills, and preview commands', contextBudget.contract_summary_tokens || 0, contextBudget.target || ''),
+      contextLoadStep('learning-advice-summary', 'learning_advice', 'learning next step, manual promotion boundary, and candidate follow-up command', contextBudget.evidence_summary_tokens || 0, advice.manual_action || advice.recommended_next_learning_step || ''),
+    ],
+    skill_summaries: surfacedSkills.map((item) => ({
+      skill: item.skill,
+      load_mode: 'summary_only',
+      reason: item.reason,
+    })),
+    evidence_summaries: [
+      {
+        id: 'workflow-readiness-blockers',
+        load_mode: 'count_and_reason_only',
+        reason: `readiness_blocker_count=${start.entry_summary?.readiness_blocker_count ?? (start.blocked_reasons || []).length}`,
+      },
+      {
+        id: 'state-gap-summary',
+        load_mode: 'summary_only',
+        reason: start.entry_summary?.state_gap_is_expected ? 'state gap is expected for this entry' : 'state gap may require explicit follow-up evidence',
+      },
+    ],
+    command_previews: commandPreviews,
+  };
+}
+
+function contextLoadStep(id, source, load, tokenLimit, reason) {
+  return { id, source, load, token_limit: tokenLimit, reason };
+}
+
+function deferPolicy(start, budget) {
+  const deferred = deferUntilNeeded(start, budget);
+  return {
+    policy_kind: 'entry-context-defer-policy',
+    default_rule: 'Load compact summaries first; expand raw context only when a concrete blocker or selected workflow step requires it.',
+    hidden_discard: false,
+    prompt_mutation: false,
+    automatic_compaction: false,
+    deferred_items: deferred,
+    expansion_triggers: [
+      { id: 'selected-skill-execution-needed', load: 'full selected skill text and its handoff requirements', condition: 'after the user or agent commits to executing the selected workflow step' },
+      { id: 'evidence-blocker-needs-inspection', load: 'specific local evidence artifact or raw command excerpt', condition: 'when blocker text cannot be resolved from summary fields' },
+      { id: 'review-or-closeout-boundary', load: 'broader completion, review, or closeout context', condition: 'when normalized intent is review, completion, closeout, or regression' },
+    ],
+    never_defer: ['explicit user instruction boundaries', 'safety and permission constraints', 'current command output needed to prove validation status'],
+  };
+}
+
+function surfaceNow(start, budget, advice) {
+  const selectedSkill = start.receipt_summary?.selected_skill || start.cockpit_summary?.recommended_next_skill || '';
+  return [
+    { id: 'workflow-entry-decision', value: selectedSkill, reason: start.entry_summary?.first_user_decision || start.next_manual_action || '' },
+    { id: 'token-budget-profile', value: budget.recommended_profile || '', reason: `Expose at most ${budget.context_budget?.max_context_tokens || 0} context tokens before expanding deferred workflow text.` },
+    { id: 'learning-advice-summary', value: advice.recommended_next_learning_step || '', reason: advice.manual_action || '' },
+  ];
+}
+
+function deferUntilNeeded(start, budget) {
+  const deferredSkills = compactSkillItems(budget.skills_to_defer).map((item) => ({
+    id: `defer-${item.skill}`,
+    value: item.skill,
+    reason: item.reason,
+  }));
+  return [
+    ...deferredSkills,
+    {
+      id: 'full-workflow-state-or-artifacts',
+      value: 'full workflow state, evidence bundle, and raw command output',
+      reason: start.entry_summary?.entry_classification === 'planning_needed'
+        ? 'New planning entry should confirm goal, scope, acceptance, and validation before loading full evidence context.'
+        : 'Load only when readiness blockers require concrete evidence inspection.',
+    },
+  ];
+}
+
+function nextManualAction(start, budget, advice) {
+  const entryAction = start.next_manual_action || start.entry_summary?.first_user_decision || '';
+  const profile = budget.recommended_profile ? `Use ${budget.recommended_profile} context budget first.` : '';
+  const learning = advice.recommended_next_learning_step ? `Learning follow-up: ${advice.recommended_next_learning_step}.` : '';
+  return [entryAction, profile, learning].filter(Boolean).join(' ');
+}
+
+function forbiddenActions(start) {
+  return [...new Set([
+    ...(start.forbidden_actions || []),
+    'auto workflow execution',
+    'automatic learning promotion',
+    'full skill text injection before entry summary requires it',
+    'command execution from entry summary previews',
+    'subagent dispatch without explicit permission',
+    'git write, commit, push, PR, merge, or tag',
+  ])];
+}