hive-lite 0.1.3 → 0.1.7

package/src/lib/change.js

@@ -174,9 +174,15 @@ function scopeFromContext(root, context) {
     });
   }
   const scope = context.scope;
+  const selectedDirect = Array.isArray(context.writableScope) && context.writableScope.length > 0
+    ? context.writableScope
+    : (scope.writableDirect || []);
   return {
     readable: (scope.readable || []).slice(),
-    writableDirect: (scope.writableDirect || []).map(itemPattern).filter(Boolean),
+    readableReference: (scope.readableReference || []).slice(),
+    writableDirect: selectedDirect.map(itemPattern).filter(Boolean),
+    writableExisting: normalizePatternList(scope.writableExisting || [], { source: 'writable_existing' }),
+    writableCreatePatterns: normalizePatternList(scope.writableCreatePatterns || [], { source: 'writable_create_patterns' }),
     writableConditional: normalizePatternList(scope.writableConditional || [], { requiresReview: true }),
     writableBroadFallback: normalizePatternList(scope.writableBroadFallback || [], { requiresReview: true }),
     forbidden: (scope.forbidden || []).slice(),
@@ -190,6 +196,9 @@ function firstItemMatch(file, items) {
 
 function scopeCheck(root, files, context, map) {
   const filePaths = files.map((item) => item.path || item);
+  const referenceOnly = context && context.writePlan && Array.isArray(context.writePlan.referenceFiles)
+    ? context.writePlan.referenceFiles.map((item) => item.path || item.pattern).filter(Boolean)
+    : [];
   const matchedAreas = [];
   let scope = {
     readable: [],
@@ -236,6 +245,13 @@ function scopeCheck(root, files, context, map) {
       violations.push(`${file} matched doNotTouch ${forbidden}`);
       continue;
     }
+    const reference = firstPatternMatch(file, referenceOnly);
+    if (reference) {
+      matchedTiers.unmatched.push(file);
+      review.push(file);
+      reviewDetails.push(`${file} matched reference-only file ${reference}`);
+      continue;
+    }
     const direct = firstItemMatch(file, scope.writableDirect);
     if (direct) {
       matchedTiers.direct.push(file);
@@ -298,6 +314,63 @@ function validationPlanFromContextOrMap(context, map) {
   }] : [];
 }
 
+function evaluateWritePlanStatus(files, context) {
+  if (!context) {
+    return {
+      status: 'not_available',
+      contextMode: null,
+      blockingReasons: [],
+      selectedWritableDirect: [],
+      referenceOnlyTouched: [],
+      requiredWrites: [],
+      blockingWarnings: [],
+    };
+  }
+
+  const writePlan = context.writePlan || null;
+  const blockingWarnings = writePlan && Array.isArray(writePlan.blockingWarnings)
+    ? writePlan.blockingWarnings
+    : [];
+  const selectedWritableDirect = Array.isArray(context.writableScope) ? context.writableScope : [];
+  const changedPaths = files.map((item) => item.path || item);
+  const referenceFiles = writePlan && Array.isArray(writePlan.referenceFiles) ? writePlan.referenceFiles : [];
+  const referenceOnlyTouched = [];
+  for (const file of changedPaths) {
+    const reference = referenceFiles.find((item) => matchesPattern(file, item.path || item.pattern));
+    if (reference) {
+      referenceOnlyTouched.push({
+        path: file,
+        reference: reference.path || reference.pattern,
+        reason: reference.reason || '',
+      });
+    }
+  }
+
+  const blockingReasons = [];
+  if (context.mode && context.mode !== 'edit_context') {
+    blockingReasons.push(`context mode is ${context.mode}, not edit_context`);
+  }
+  for (const warning of blockingWarnings) {
+    blockingReasons.push(`${warning.code}: ${warning.message}`);
+  }
+  for (const item of referenceOnlyTouched) {
+    blockingReasons.push(`${item.path} touched reference-only file ${item.reference}`);
+  }
+  if (selectedWritableDirect.length === 0 && changedPaths.length > 0) {
+    blockingReasons.push('context has no selected Direct Writable scope');
+  }
+
+  return {
+    status: blockingReasons.length > 0 ? 'blocked' : 'clean',
+    contextMode: context.mode || null,
+    blockingReasons: [...new Set(blockingReasons)],
+    selectedWritableDirect,
+    referenceOnlyTouched,
+    requiredWrites: writePlan && Array.isArray(writePlan.hypotheses) ? writePlan.hypotheses : [],
+    blockingWarnings,
+  };
+}
+
 function createOrUpdateChange(cwd, options = {}) {
   const root = repoRoot(cwd);
   const map = loadProjectMap(root);
@@ -339,6 +412,7 @@ function createOrUpdateChange(cwd, options = {}) {
       text: diffText,
     },
     scope: scopeCheck(root, files, context, map),
+    writePlanStatus: evaluateWritePlanStatus(files, context),
     validation: {
       status: existing && existing.validation ? existing.validation.status : 'not_run',
       plan: validationPlanFromContextOrMap(context, map),

package/src/lib/context.js

@@ -40,6 +40,374 @@ function tokenize(value) {
   return [...new Set([...latin, ...cjk])];
 }
 
+function unique(values) {
+  return [...new Set((values || []).filter(Boolean))];
+}
+
+function looksLikeFilePattern(pattern) {
+  if (String(pattern || '').includes('*')) return false;
+  const base = path.basename(String(pattern || ''));
+  return /\.[A-Za-z0-9]+$/.test(base);
+}
+
+function isCreateCapablePattern(pattern) {
+  return !looksLikeFilePattern(pattern);
+}
+
+const IDENTITY_ALIASES = {
+  openai: ['openai', 'chatgpt', 'gpt'],
+  google: ['google', 'gemini'],
+  qwen: ['qwen', 'tongyi'],
+  wan: ['wan'],
+  aliyun: ['aliyun', 'ali'],
+  anthropic: ['anthropic', 'claude'],
+  azure: ['azure'],
+};
+
+function canonicalIdentity(value) {
+  const text = normalize(value);
+  if (!text) return null;
+  for (const [canonical, aliases] of Object.entries(IDENTITY_ALIASES)) {
+    if (aliases.includes(text)) return canonical;
+  }
+  return text;
+}
+
+function targetIdentityForIntent(intent) {
+  const tokens = tokenize(intent);
+  for (const token of tokens) {
+    const identity = canonicalIdentity(token);
+    if (identity && Object.prototype.hasOwnProperty.call(IDENTITY_ALIASES, identity)) return identity;
+  }
+  return null;
+}
+
+function peerIdentityFromPath(pattern) {
+  if (!looksLikeFilePattern(pattern)) return null;
+  const tokens = basenameTokens(pattern);
+  for (const token of tokens) {
+    const identity = canonicalIdentity(token);
+    if (identity && Object.prototype.hasOwnProperty.call(IDENTITY_ALIASES, identity)) return identity;
+  }
+  return null;
+}
+
+function identityMatches(left, right) {
+  if (!left || !right) return false;
+  return canonicalIdentity(left) === canonicalIdentity(right);
+}
+
+function intentTargetsAllPeers(intent) {
+  const text = normalize(intent);
+  return [
+    /\b(all|every|each)\b/,
+    /所有|全部|每个|统一|全量|全部/,
+  ].some((pattern) => pattern.test(text));
+}
+
+function arrayFrom(value) {
+  if (Array.isArray(value)) return value.map((item) => String(item || '')).filter(Boolean);
+  if (value == null || value === '') return [];
+  if (typeof value === 'object') return [];
+  return [String(value)];
+}
+
+function configuredArtifactFamilies(area) {
+  const raw = area && area.artifact_families ? area.artifact_families : null;
+  if (!raw) return [];
+  if (Array.isArray(raw)) {
+    return raw.map((item) => ({
+      id: item.id || item.name || '',
+      triggerTerms: [
+        ...arrayFrom(item.trigger_terms || item.triggerTerms),
+        ...arrayFrom(item.trigger_terms && item.trigger_terms.en),
+        ...arrayFrom(item.trigger_terms && item.trigger_terms.zh),
+      ],
+      createRequires: arrayFrom(item.create_requires || item.createRequires),
+      hooks: arrayFrom(item.hooks),
+      examples: arrayFrom(item.examples),
+    })).filter((item) => item.id);
+  }
+  return Object.entries(raw).map(([id, value]) => ({
+    id,
+    triggerTerms: [
+      ...arrayFrom(value && (value.trigger_terms || value.triggerTerms)),
+      ...arrayFrom(value && value.trigger_terms && value.trigger_terms.en),
+      ...arrayFrom(value && value.trigger_terms && value.trigger_terms.zh),
+    ],
+    createRequires: arrayFrom(value && (value.create_requires || value.createRequires)),
+    hooks: arrayFrom(value && value.hooks),
+    examples: arrayFrom(value && value.examples),
+  }));
+}
+
+function configuredArtifactFamilyForIntent(area, intent) {
+  const text = normalize(intent);
+  for (const family of configuredArtifactFamilies(area)) {
+    const terms = unique([
+      family.id,
+      ...family.triggerTerms,
+    ]).map(normalize).filter(Boolean);
+    if (terms.some((term) => text.includes(term))) return family;
+  }
+  return null;
+}
+
+function classifyArtifactFamily(intent, area) {
+  const configured = configuredArtifactFamilyForIntent(area, intent);
+  if (configured) return configured.id;
+  const text = normalize(intent);
+  if ([
+    /\b(provider|proxy|adapter|integration|connector|plugin)\b/,
+    /代理|提供商|适配器|集成|连接器|插件/,
+  ].some((pattern) => pattern.test(text))) return 'provider_proxy';
+  if ([
+    /\b(endpoint|controller|route|api)\b/,
+    /接口|端点|路由|控制器/,
+  ].some((pattern) => pattern.test(text))) return 'endpoint';
+  if ([
+    /\b(dto|request|response|payload)\b/,
+    /请求|响应|入参|出参/,
+  ].some((pattern) => pattern.test(text))) return 'dto';
+  if ([
+    /\b(migration|database|db|sql)\b/,
+    /数据库|迁移|表结构/,
+  ].some((pattern) => pattern.test(text))) return 'migration';
+  if ([
+    /\b(test|spec)\b/,
+    /测试|用例/,
+  ].some((pattern) => pattern.test(text))) return 'test';
+  if ([
+    /\b(component|page|view|ui)\b/,
+    /组件|页面|视图|界面/,
+  ].some((pattern) => pattern.test(text))) return 'component';
+  if ([
+    /\b(service)\b/,
+    /服务/,
+  ].some((pattern) => pattern.test(text))) return 'service';
+  return 'unknown';
+}
+
+function classifyIntentWrite(intent, area) {
+  const text = normalize(intent);
+  const createTerm = [
+    /\b(add|create|new|introduce|support|implement)\b/,
+    /新增|新建|创建|添加|接入|支持/,
+  ].some((pattern) => pattern.test(text));
+  const deleteTerm = [
+    /\b(delete|remove)\b/,
+    /删除|移除/,
+  ].some((pattern) => pattern.test(text));
+  const renameTerm = [
+    /\b(rename|move)\b/,
+    /重命名|改名|迁移/,
+  ].some((pattern) => pattern.test(text));
+  const targetAll = intentTargetsAllPeers(intent);
+  const artifactFamily = classifyArtifactFamily(intent, area);
+  const familyConfig = configuredArtifactFamilies(area).find((item) => item.id === artifactFamily) || null;
+  const targetIdentity = targetIdentityForIntent(intent);
+  let action = 'modify';
+  if (deleteTerm) action = 'delete';
+  else if (renameTerm) action = 'rename';
+  else if (createTerm && !targetAll) action = 'create';
+  return {
+    action,
+    artifactFamily,
+    targetIdentity,
+    operation: action === 'create' && artifactFamily === 'provider_proxy' ? 'create_file' : 'modify_existing_file',
+    required: true,
+    targetAll,
+    intentKind: action === 'create' ? `add_${artifactFamily}` : `${action}_${artifactFamily}`,
+    createRequires: familyConfig ? familyConfig.createRequires : [],
+    hooks: familyConfig ? familyConfig.hooks : [],
+    confidence: artifactFamily === 'unknown' ? 'low' : 'medium',
+  };
+}
+
+function directCapabilities(scope) {
+  const explicitItems = [
+    ...(scope.writableDirectItems || []),
+  ];
+  const items = explicitItems.length
+    ? explicitItems
+    : (scope.writableDirect || []).map((pattern) => ({ pattern, source: 'writable_direct' }));
+  const seen = new Set();
+  return items.map((item) => {
+    const pattern = item.pattern || item.path || item;
+    const createCapable = isCreateCapablePattern(pattern);
+    const configuredOperations = arrayFrom(item.operations);
+    const operations = configuredOperations.length
+      ? configuredOperations
+      : (createCapable ? ['update_existing', 'create_file'] : ['update_existing']);
+    const key = `${pattern}:${operations.join(',')}:${item.source || ''}:${item.artifact || ''}`;
+    if (seen.has(key)) return null;
+    seen.add(key);
+    return {
+      scope: pattern,
+      operations,
+      breadth: createCapable ? 'narrow_pattern' : 'exact',
+      reviewGated: false,
+      source: item.source || 'writable_direct',
+      artifact: item.artifact || null,
+      artifactFamily: item.artifactFamily || item.artifact_family || null,
+      intentKinds: arrayFrom(item.intentKinds || item.intent_kinds),
+      requiredWhen: arrayFrom(item.requiredWhen || item.required_when),
+      targetSlot: item.targetSlot || item.target_slot || null,
+      peerIdentity: canonicalIdentity(item.targetIdentity || item.target_identity || item.peerIdentity || item.peer_identity) || peerIdentityFromPath(pattern),
+    };
+  }).filter(Boolean);
+}
+
+function warning(code, message, data = {}) {
+  return {
+    code,
+    message,
+    blocking: data.blocking !== false,
+    ...data,
+  };
+}
+
+function buildReference(capability, reason) {
+  return {
+    path: capability.scope || capability.path,
+    role: capability.role || 'peer_example',
+    writable: false,
+    reason,
+    artifact: capability.artifact || null,
+    peerIdentity: capability.peerIdentity || null,
+  };
+}
+
+function artifactMatches(capability, artifact) {
+  if (!artifact) return false;
+  return capability.artifact === artifact || capability.artifactFamily === artifact;
+}
+
+function capabilityMatchesIntent(capability, hypothesis) {
+  if (!capability.intentKinds || capability.intentKinds.length === 0) return true;
+  return capability.intentKinds.includes(hypothesis.intentKind);
+}
+
+function buildWritePlan(scope, intent, area) {
+  const hypothesis = classifyIntentWrite(intent, area);
+  const capabilities = directCapabilities(scope);
+  const warnings = [];
+  const references = (scope.readableReference || []).map((item) => buildReference(
+    {
+      path: item.path,
+      role: item.role || 'reference',
+      artifact: item.artifact || null,
+      peerIdentity: canonicalIdentity(item.peerIdentity) || peerIdentityFromPath(item.path),
+    },
+    item.reason || 'readable reference from Project Map'
+  ));
+  let selected = capabilities.map((item) => item.scope);
+
+  if (hypothesis.operation === 'create_file' && hypothesis.artifactFamily === 'provider_proxy') {
+    const createCapabilities = capabilities.filter((item) => (
+      item.operations.includes('create_file') && capabilityMatchesIntent(item, hypothesis)
+    ));
+    const genericExistingCapabilities = capabilities.filter((item) => (
+      !item.peerIdentity && !item.operations.includes('create_file')
+    ));
+    const referencePeers = capabilities.filter((item) => (
+      item.peerIdentity
+      && hypothesis.targetIdentity
+      && !identityMatches(item.peerIdentity, hypothesis.targetIdentity)
+    ));
+    const selectedCreateCapabilities = hypothesis.createRequires.length
+      ? createCapabilities.filter((item) => hypothesis.createRequires.some((artifact) => artifactMatches(item, artifact)))
+      : createCapabilities;
+    const hookCapabilities = hypothesis.hooks.length
+      ? genericExistingCapabilities.filter((item) => hypothesis.hooks.some((artifact) => artifactMatches(item, artifact)))
+      : genericExistingCapabilities;
+
+    selected = selectedCreateCapabilities.length > 0
+      ? [...selectedCreateCapabilities, ...hookCapabilities].map((item) => item.scope)
+      : [];
+    for (const capability of referencePeers) {
+      references.push(buildReference(
+        capability,
+        `peer identity ${capability.peerIdentity} differs from target ${hypothesis.targetIdentity}; use as a reference example only`
+      ));
+    }
+
+    if (createCapabilities.length === 0) {
+      warnings.push(warning(
+        'MISSING_DIRECT_NEW_FILE_SCOPE',
+        'Intent appears to add a new peer provider/proxy artifact, but direct writable scope does not include a narrow create pattern.'
+      ));
+    }
+    for (const artifact of hypothesis.createRequires) {
+      if (!createCapabilities.some((item) => artifactMatches(item, artifact))) {
+        warnings.push(warning(
+          'MISSING_ARTIFACT_FAMILY_SCOPE',
+          `Intent requires provider/proxy artifact ${artifact}, but no direct create capability covers it.`,
+          { artifact }
+        ));
+      }
+    }
+    for (const artifact of hypothesis.hooks) {
+      if (!genericExistingCapabilities.some((item) => artifactMatches(item, artifact))) {
+        warnings.push(warning(
+          'MISSING_REQUIRED_HOOK_SCOPE',
+          `Intent requires provider/proxy hook ${artifact}, but no direct existing-file capability covers it.`,
+          { artifact }
+        ));
+      }
+    }
+    if (referencePeers.length > 0 && createCapabilities.length === 0) {
+      warnings.push(warning(
+        'DIRECT_ONLY_REFERENCE_PEERS',
+        'Direct writable scope only contains existing peer provider/proxy files for other identities; those are reference examples, not the target write files.'
+      ));
+    }
+    if (createCapabilities.length === 0 && (scope.writableBroadFallback || []).length > 0) {
+      warnings.push(warning(
+        'BROAD_FALLBACK_ONLY',
+        'Only broad fallback scope appears able to cover new provider/proxy files; broad fallback is review-gated and is not direct write permission.'
+      ));
+    }
+  } else if (
+    hypothesis.artifactFamily === 'provider_proxy'
+    && hypothesis.targetIdentity
+    && !hypothesis.targetAll
+  ) {
+    const targetMatches = capabilities.filter((item) => (
+      item.peerIdentity && identityMatches(item.peerIdentity, hypothesis.targetIdentity)
+    ));
+    const genericCapabilities = capabilities.filter((item) => (
+      !item.peerIdentity && !item.operations.includes('create_file')
+    ));
+    const referencePeers = capabilities.filter((item) => (
+      item.peerIdentity && !identityMatches(item.peerIdentity, hypothesis.targetIdentity)
+    ));
+    selected = unique([...targetMatches, ...genericCapabilities].map((item) => item.scope));
+    for (const capability of referencePeers) {
+      references.push(buildReference(
+        capability,
+        `peer identity ${capability.peerIdentity} differs from target ${hypothesis.targetIdentity}`
+      ));
+    }
+    if (targetMatches.length === 0 && referencePeers.length > 0) {
+      warnings.push(warning(
+        'TARGET_ENTITY_MISMATCH',
+        `Intent targets ${hypothesis.targetIdentity}, but direct writable peer files are for other identities.`
+      ));
+    }
+  }
+
+  selected = unique(selected);
+  return {
+    hypotheses: [hypothesis],
+    capabilities,
+    selectedWritableDirect: selected,
+    referenceFiles: references,
+    blockingWarnings: warnings.filter((item) => item.blocking !== false),
+    warnings,
+  };
+}
+
 function basenameTokens(file) {
   return tokenize(path.basename(file || '').replace(/([a-z])([A-Z])/g, '$1 $2'));
 }
@@ -734,10 +1102,22 @@ function reviewGatedNotices(scope) {
   return notices;
 }
 
-function contextMode(area, scope, validationPlan, relevant, decomposition = []) {
+function hasBlockingMapGapWarning(warnings = []) {
+  return warnings.some((warning) => warning.blocking === true || [
+    'MISSING_DIRECT_NEW_FILE_SCOPE',
+    'DIRECT_ONLY_REFERENCE_PEERS',
+    'BROAD_FALLBACK_ONLY',
+    'TARGET_ENTITY_MISMATCH',
+    'MISSING_ARTIFACT_FAMILY_SCOPE',
+    'MISSING_REQUIRED_HOOK_SCOPE',
+  ].includes(warning.code));
+}
+
+function contextMode(area, selectedWritableDirect, validationPlan, relevant, decomposition = [], warnings = []) {
   if (!area) return 'needs_map';
   if (decomposition.some((item) => item.blocking)) return 'needs_decomposition';
-  if (scope.writableDirect.length === 0) return 'discovery_context';
+  if (selectedWritableDirect.length === 0) return 'discovery_context';
+  if (hasBlockingMapGapWarning(warnings)) return 'discovery_context';
   if (relevant.length === 0 || !relevant.some((file) => file.source === 'project_map')) return 'discovery_context';
   if (validationPlan.length === 0) return 'discovery_context';
   return 'edit_context';
@@ -850,12 +1230,31 @@ function buildContextMarkdown(packet) {
       ...packet.phaseDependencyStatus.missingRequiredAcceptedPhases.map((item) => `- Missing required phase: ${item}`),
       '',
     ] : []),
+    ...(packet.writePlan ? [
+      '## Write Plan',
+      ...packet.writePlan.hypotheses.map((item) => `- ${item.action} ${item.artifactFamily}: ${item.operation}${item.targetIdentity ? ` for ${item.targetIdentity}` : ''}`),
+      ...(packet.writePlan.blockingWarnings.length
+        ? packet.writePlan.blockingWarnings.map((item) => `- Blocking: ${item.code}: ${item.message}`)
+        : ['- Coverage: direct writable scope covers the inferred write operation.']),
+      '',
+    ] : []),
+    ...(packet.writePlan && packet.writePlan.referenceFiles.length ? [
+      '## Reference Files',
+      ...packet.writePlan.referenceFiles.map((file) => `- ${file.path}: ${file.reason}`),
+      '',
+    ] : []),
     '## Relevant Files',
     ...packet.relevantFiles.map((file) => `- ${file.path} (${file.role || file.source}): ${file.reason}`),
     '',
     '## Writable Scope',
     ...(packet.writableScope.length ? packet.writableScope.map((item) => `- ${item}`) : ['- (none; this is not an edit permit)']),
     '',
+    '## Writable Existing Scope',
+    ...(packet.scope.writableExisting && packet.scope.writableExisting.length ? packet.scope.writableExisting.map((item) => `- ${patternDisplay(item)}`) : ['- (none configured)']),
+    '',
+    '## Writable Create Patterns',
+    ...(packet.scope.writableCreatePatterns && packet.scope.writableCreatePatterns.length ? packet.scope.writableCreatePatterns.map((item) => `- ${patternDisplay(item)}`) : ['- (none configured)']),
+    '',
     '## Conditional Writable Scope',
     ...(packet.scope.writableConditional.length ? packet.scope.writableConditional.map((item) => `- ${patternDisplay(item)}`) : ['- (none configured)']),
     '',
@@ -921,12 +1320,24 @@ function createContextPacket(root, intent, options = {}) {
   const candidateAreas = candidateAreasFromScored(scored);
   const scope = area ? normalizeAreaScope(root, area) : {
     readable: [],
+    readableReference: [],
     writableDirect: [],
+    writableDirectItems: [],
+    writableExisting: [],
+    writableCreatePatterns: [],
     writableConditional: [],
     writableBroadFallback: [],
     forbidden: [],
     quality: 'unknown',
   };
+  const writePlan = area ? buildWritePlan(scope, intent, area) : {
+    hypotheses: [],
+    capabilities: [],
+    selectedWritableDirect: [],
+    referenceFiles: [],
+    blockingWarnings: [],
+    warnings: [],
+  };
   const restrictGrepToReadable = area && (confidence === 'high' || findOptions.area) && scope.readable.length > 0;
   const grepFiles = grepHints(root, tokens, maxFiles, {
     allowedPatterns: restrictGrepToReadable ? scope.readable : [],
@@ -969,6 +1380,7 @@ function createContextPacket(root, intent, options = {}) {
     });
   } else {
     warnings.push(...scopeWarnings(scope));
+    warnings.push(...writePlan.warnings);
     if (relevant.length === 0 || !relevant.some((file) => file.source === 'project_map')) {
       warnings.push({
         code: 'MISSING_ENTRYPOINT',
@@ -996,7 +1408,7 @@ function createContextPacket(root, intent, options = {}) {
     constrainedAreaId,
   });
   const phaseSeeds = decomposition.length > 0 ? candidatePhaseSeeds(scored, intent) : [];
-  let mode = contextMode(area, scope, validationPlan, relevant, decomposition);
+  let mode = contextMode(area, writePlan.selectedWritableDirect, validationPlan, relevant, decomposition, warnings);
   if (missingSplitReference(phaseStatus) && mode === 'edit_context') mode = 'discovery_context';
   const actions = recommendedActions(mode, intent, id, phaseStatus);
   const packet = {
@@ -1034,7 +1446,8 @@ function createContextPacket(root, intent, options = {}) {
     phaseDependencyStatus: phaseStatus,
     relevantFiles: relevant,
     scope,
-    writableScope: scope.writableDirect.slice(),
+    writePlan,
+    writableScope: writePlan.selectedWritableDirect.slice(),
     readableScope: scope.readable.slice(),
     doNotTouch: scope.forbidden.slice(),
     validationPlan,
@@ -1076,6 +1489,7 @@ function createContextPacket(root, intent, options = {}) {
       })),
       validationQuality: validationPlan.length > 0 ? 'configured' : 'missing',
       warnings,
+      writePlan,
       reviewGated,
       decompositionSignals: decomposition,
       candidatePhaseSeeds: phaseSeeds,

package/src/lib/evidence.js

@@ -106,6 +106,13 @@ function evaluateEvidencePolicy(change, map) {
   let changeClass = 'unknown';
   let verdict = 'acceptable';
 
+  if (change.writePlanStatus && change.writePlanStatus.status === 'blocked') {
+    verdict = 'blocked';
+    missing.push('write_plan_clean');
+    required.push('write_plan_clean');
+    reasons.push(...(change.writePlanStatus.blockingReasons || []).map((item) => `Write plan blocked: ${item}`));
+  }
+
   if (change.scope.status === 'violation') {
     verdict = 'blocked';
     missing.push('scope_clean');

package/src/lib/health.js

@@ -69,7 +69,7 @@ function readYamlHealth(root, name, fallback, findings) {
       field: '',
       message: `.hive/map/${name} is missing.`,
       impact: 'Hive Lite cannot evaluate Project Map health.',
-      fix: 'Run hive-lite init or restore the missing map file.',
+      fix: 'Use $hive-lite-bootstrap for first-time or partial setup. If this repo already had a committed Project Map, restore the missing map file from git instead of rebuilding it silently.',
     });
     return { doc: fallback, valid: false };
   }