@michaelxwb/code-flow 0.6.0 → 0.6.2

package/src/core/code-flow/scripts/cf_spec_gate.py

@@ -10,9 +10,11 @@ import json
 from pathlib import Path
 import re
 import sys
+import time
 from typing import IO, Mapping, Optional, Sequence
 
 from cf_spec_context import Decision, RuleBinding, RuleStageStatus, SpecBinding, SpecContext, load_context
+from cf_core import phase_timing
 
 
 @dataclass(frozen=True)
@@ -55,7 +57,7 @@ def _waiver_issue(decision: Optional[Decision], now: datetime) -> Optional[str]:
     return "waiver_expired" if expires <= now else None
 
 
-def _evidence_issue(rule: RuleBinding, status: RuleStageStatus) -> Optional[str]:
+def _evidence_issue(rule: RuleBinding, status: RuleStageStatus, diff_sha256: Optional[str]) -> Optional[str]:
     if not status.evidence:
         return "evidence_missing"
     for evidence in status.evidence:
@@ -63,17 +65,20 @@ def _evidence_issue(rule: RuleBinding, status: RuleStageStatus) -> Optional[str]
             continue
         if evidence.get("rule_text_sha256") != rule.text_sha256:
             continue
+        evidence_diff = evidence.get("diff_sha256")
+        if evidence_diff is not None and diff_sha256 is not None and evidence_diff != diff_sha256:
+            continue
         result_hash = evidence.get("result_sha256")
         if isinstance(result_hash, str) and result_hash:
             return None
     return "stale_evidence"
 
 
-def _status_issue(rule: RuleBinding, status: RuleStageStatus, now: datetime) -> Optional[str]:
+def _status_issue(rule: RuleBinding, status: RuleStageStatus, now: datetime, diff_sha256: Optional[str]) -> Optional[str]:
     if status.status == "applied":
         return None
     if status.status == "verified":
-        return _evidence_issue(rule, status)
+        return _evidence_issue(rule, status, diff_sha256)
     if status.status == "not_applicable":
         return None if _decision_valid(status.decision) else "decision_invalid"
     if status.status == "waived":
@@ -81,7 +86,9 @@ def _status_issue(rule: RuleBinding, status: RuleStageStatus, now: datetime) ->
     return status.status
 
 
-def _binding_issues(binding: SpecBinding, stage: str, now: datetime) -> tuple[list[GateIssue], list[GateIssue]]:
+def _binding_issues(
+    binding: SpecBinding, stage: str, now: datetime, diff_sha256: Optional[str]
+) -> tuple[list[GateIssue], list[GateIssue]]:
     errors: list[GateIssue] = []
     warnings: list[GateIssue] = []
     for rule in binding.rules:
@@ -90,7 +97,7 @@ def _binding_issues(binding: SpecBinding, stage: str, now: datetime) -> tuple[li
             continue
         if rule.enforcement == "advisory" and status.status == "pending":
             continue
-        code = "missing_spec" if binding.status == "missing" else _status_issue(rule, status, now)
+        code = "missing_spec" if binding.status == "missing" else _status_issue(rule, status, now, diff_sha256)
         if code is None:
             continue
         issue = GateIssue(code, binding.spec_id, rule.ref, stage, f"{binding.spec_id}#{rule.ref}: {code}")
@@ -105,13 +112,14 @@ def validate_stage(
     artifact: str = "",
     task_id: str = "",
     now: Optional[datetime] = None,
+    diff_sha256: Optional[str] = None,
 ) -> GateResult:
     del artifact, task_id
     current = now or datetime.now(timezone.utc)
     errors: list[GateIssue] = []
     warnings: list[GateIssue] = []
     for binding in context.bindings:
-        binding_errors, binding_warnings = _binding_issues(binding, stage, current)
+        binding_errors, binding_warnings = _binding_issues(binding, stage, current, diff_sha256)
         errors.extend(binding_errors)
         warnings.extend(binding_warnings)
     refs = tuple(sorted({f"{item.spec_id}#{item.rule_ref}" for item in (*errors, *warnings)}))
@@ -206,13 +214,21 @@ def _parser() -> argparse.ArgumentParser:
 
 
 def main(argv: Optional[Sequence[str]] = None, stdout: IO[str] = sys.stdout) -> int:
+    started = time.monotonic()
     try:
         args = _parser().parse_args(argv)
+        phase_started = time.monotonic()
         context = load_context(str(Path(args.task_dir) / "spec-context.yml"))
+        phase_timing("gate.load_context", phase_started)
+        phase_started = time.monotonic()
         result = validate_stage(context, args.stage, task_id=args.task)
+        phase_timing("gate.validate_stage", phase_started)
         if args.stage == "plan" and args.artifact:
+            phase_started = time.monotonic()
             result = _merge_results(result, validate_plan_coverage(context, args.artifact))
+            phase_timing("gate.validate_plan", phase_started)
         stdout.write(json.dumps(result_to_data(result), ensure_ascii=False))
+        phase_timing("gate.total", started)
         return 0 if result.decision == "pass" else 3
     except Exception as exc:
         sys.stderr.write(f"cf_spec_gate error: {exc}\n")

package/src/core/code-flow/scripts/cf_spec_metadata.py

@@ -10,7 +10,6 @@ from pathlib import Path
 import re
 from typing import Mapping, Optional
 
-import yaml
 
 
 ALLOWED_STAGES = frozenset(("prd", "design", "plan", "code", "review"))
@@ -20,6 +19,8 @@ _ID_RE = re.compile(r"^[a-z0-9]+(?:-[a-z0-9]+)*$")
 _RULE_ID_RE = re.compile(r"^RULE-[a-z0-9]+(?:-[a-z0-9]+)*-\d{3}$")
 _EXPLICIT_RULE_RE = re.compile(r"^\[(RULE-[a-z0-9-]+-\d{3})\]\s+(.+)$")
 _FRONTMATTER_RE = re.compile(r"\A---[ \t]*\r?\n(.*?)\r?\n---[ \t]*(?:\r?\n|$)", re.DOTALL)
+_FRONTMATTER_OPEN_RE = re.compile(br"---[ \t]*\r?\n")
+_FRONTMATTER_CLOSE_RE = re.compile(br"---[ \t]*(?:\r?\n)?")
 _SECTION_RE = re.compile(r"^##\s+(Rules|Anti-Patterns|Patterns|Examples)\s*$")
 _H2_RE = re.compile(r"^##\s+")
 _BULLET_RE = re.compile(r"^\s*-\s+(.+\S|\S)\s*$")
@@ -63,6 +64,13 @@ class SpecRule:
     line: int
 
 
+@dataclass(frozen=True)
+class SpecHeader:
+    id: str
+    stages: tuple[str, ...]
+    enforcement: str
+
+
 @dataclass(frozen=True)
 class SpecMetadata:
     id: str
@@ -116,6 +124,11 @@ def _split_frontmatter(content: str, path: str) -> tuple[Mapping[str, object], s
     if not match:
         raise SpecMetadataError(path, "frontmatter", 1, "缺失或未闭合 YAML frontmatter")
     raw = match.group(1)
+    return _parse_frontmatter(raw, path), raw, content[match.end():]
+
+
+def _parse_frontmatter(raw: str, path: str) -> Mapping[str, object]:
+    import yaml
     try:
         loaded = yaml.safe_load(raw) or {}
     except yaml.YAMLError as exc:
@@ -126,7 +139,7 @@ def _split_frontmatter(content: str, path: str) -> tuple[Mapping[str, object], s
         raise SpecMetadataError(path, "frontmatter", 2, "顶层必须是 mapping")
     if not all(isinstance(key, str) for key in loaded):
         raise SpecMetadataError(path, "frontmatter", 2, "所有顶层 key 必须是字符串")
-    return loaded, raw, content[match.end():]
+    return loaded
 
 
 def _required_string(meta: Mapping[str, object], key: str, path: str, raw: str) -> str:
@@ -149,6 +162,46 @@ def _validate_stages(meta: Mapping[str, object], path: str, raw: str) -> tuple[s
     return stages
 
 
+def _spec_header(meta: Mapping[str, object], raw: str, path: str) -> SpecHeader:
+    spec_id = _required_string(meta, "id", path, raw)
+    if not _ID_RE.fullmatch(spec_id):
+        raise SpecMetadataError(path, "id", _field_line(raw, "id"), "必须是 kebab-case")
+    stages = _validate_stages(meta, path, raw)
+    enforcement = _required_string(meta, "enforcement", path, raw)
+    if enforcement not in ALLOWED_ENFORCEMENT:
+        line = _field_line(raw, "enforcement")
+        raise SpecMetadataError(path, "enforcement", line, f"必须是 {sorted(ALLOWED_ENFORCEMENT)}")
+    return SpecHeader(spec_id, stages, enforcement)
+
+
+def _read_frontmatter(path: str) -> str:
+    lines: list[bytes] = []
+    try:
+        with Path(path).open("rb") as source:
+            if not _FRONTMATTER_OPEN_RE.fullmatch(source.readline()):
+                raise SpecMetadataError(path, "frontmatter", 1, "缺失或未闭合 YAML frontmatter")
+            for line in source:
+                if _FRONTMATTER_CLOSE_RE.fullmatch(line):
+                    break
+                lines.append(line)
+            else:
+                raise SpecMetadataError(path, "frontmatter", 1, "缺失或未闭合 YAML frontmatter")
+    except OSError as exc:
+        raise SpecMetadataError(path, "file", 1, f"读取失败: {exc}") from exc
+    raw = b"".join(lines)
+    try:
+        return raw.decode("utf-8")
+    except UnicodeDecodeError as exc:
+        line = raw[:exc.start].count(b"\n") + 2
+        raise SpecMetadataError(path, "encoding", line, f"必须是 UTF-8: {exc}") from exc
+
+
+def load_spec_header(path: str) -> SpecHeader:
+    """Load only routing fields, stopping at the frontmatter delimiter."""
+    raw = _read_frontmatter(path)
+    return _spec_header(_parse_frontmatter(raw, path), raw, path)
+
+
 def _validate_checks(meta: Mapping[str, object], path: str, raw: str) -> tuple[Mapping[str, object], ...]:
     value = meta.get("checks", [])
     if not isinstance(value, list) or not all(isinstance(item, dict) for item in value):
@@ -265,15 +318,8 @@ def _validate_links(
 
 def parse_spec_metadata(content: str, path: str = "<memory>", raw_bytes: Optional[bytes] = None) -> SpecMetadata:
     meta, raw_frontmatter, body = _split_frontmatter(content, path)
-    spec_id = _required_string(meta, "id", path, raw_frontmatter)
-    if not _ID_RE.fullmatch(spec_id):
-        raise SpecMetadataError(path, "id", _field_line(raw_frontmatter, "id"), "必须是 kebab-case")
+    header = _spec_header(meta, raw_frontmatter, path)
     description = _required_string(meta, "description", path, raw_frontmatter)
-    stages = _validate_stages(meta, path, raw_frontmatter)
-    enforcement = _required_string(meta, "enforcement", path, raw_frontmatter)
-    if enforcement not in ALLOWED_ENFORCEMENT:
-        line = _field_line(raw_frontmatter, "enforcement")
-        raise SpecMetadataError(path, "enforcement", line, f"必须是 {sorted(ALLOWED_ENFORCEMENT)}")
     owner = meta.get("owner")
     if owner is not None and (not isinstance(owner, str) or not owner.strip()):
         raise SpecMetadataError(path, "owner", _field_line(raw_frontmatter, "owner"), "必须是非空字符串")
@@ -289,7 +335,10 @@ def parse_spec_metadata(content: str, path: str = "<memory>", raw_bytes: Optiona
         metadata_sha256=_sha256(_canonical_json(meta, path, "frontmatter", 1)),
         rules_sha256=_sha256(_canonical_json(required_rules, path, "rules", 1)),
     )
-    return SpecMetadata(spec_id, description, stages, enforcement, owner, checks, verifiers, rules, hashes, path)
+    return SpecMetadata(
+        header.id, description, header.stages, header.enforcement,
+        owner, checks, verifiers, rules, hashes, path,
+    )
 
 
 def load_spec_metadata(path: str) -> SpecMetadata:

package/src/core/code-flow/scripts/cf_spec_resolver.py

@@ -8,9 +8,14 @@ import fnmatch
 from pathlib import Path
 from typing import Mapping, Optional, Sequence
 
-import yaml
-
-from cf_spec_metadata import ALLOWED_STAGES, SpecMetadata, SpecRule, load_spec_metadata
+from cf_spec_metadata import (
+    ALLOWED_STAGES,
+    SpecHeader,
+    SpecMetadata,
+    SpecRule,
+    load_spec_header,
+    load_spec_metadata,
+)
 
 
 SCOPE_PRIORITY = {"global": 1, "path": 2, "task": 3}
@@ -44,6 +49,16 @@ class SpecCandidate:
         return sum(rule.enforcement == "required" for rule in self.metadata.rules)
 
 
+@dataclass(frozen=True)
+class SpecCandidateHeader:
+    spec_id: str
+    path: str
+    scope: str
+    priority: int
+    matched_paths: tuple[str, ...]
+    enforcement: str
+
+
 @dataclass(frozen=True)
 class ResolvedRule:
     ref: str
@@ -93,6 +108,7 @@ def _fingerprint(path: Path, field: str) -> tuple[int, int]:
 
 
 def _load_config(root: str) -> Mapping[str, object]:
+    import yaml
     path = Path(root) / ".code-flow" / "config.yml"
     if not path.is_file():
         raise SpecResolutionError(str(path), "config", "缺失 config.yml")
@@ -180,6 +196,36 @@ def _candidate_for(
     return SpecCandidate(metadata.id, relative, scope, SCOPE_PRIORITY[scope], matched, metadata)
 
 
+def _candidate_header_for(
+    path: Path,
+    spec_root: Path,
+    mapping: Mapping[str, object],
+    config_path: str,
+    stage: str,
+    paths: Sequence[str],
+) -> Optional[SpecCandidateHeader]:
+    relative = path.relative_to(spec_root).as_posix()
+    header: SpecHeader = load_spec_header(str(path))
+    if stage not in header.stages:
+        return None
+    domain = relative.split("/", 1)[0]
+    config = _domain_config(mapping, domain, config_path)
+    patterns = _patterns(config, f"path_mapping.{domain}.patterns", config_path)
+    scope, matched = _candidate_scope(relative, patterns, paths)
+    return SpecCandidateHeader(
+        header.id, relative, scope, SCOPE_PRIORITY[scope], matched, header.enforcement
+    )
+
+
+def _spec_paths(spec_root: Path, excluded: set[str]) -> tuple[Path, ...]:
+    result: list[Path] = []
+    for path in sorted(spec_root.rglob("*.md")):
+        relative = path.relative_to(spec_root).as_posix()
+        if path.name != "_map.md" and not relative.startswith("_session/") and relative not in excluded:
+            result.append(path)
+    return tuple(result)
+
+
 def resolve_candidates(root: str, stage: str, paths: Sequence[str]) -> tuple[SpecCandidate, ...]:
     if stage not in ALLOWED_STAGES:
         raise SpecResolutionError(root, "stage", f"不支持 stage: {stage!r}")
@@ -193,10 +239,7 @@ def resolve_candidates(root: str, stage: str, paths: Sequence[str]) -> tuple[Spe
         raise SpecResolutionError(str(spec_root), "specs", "缺失 specs 目录")
     candidates: list[SpecCandidate] = []
     ids: dict[str, str] = {}
-    for path in sorted(spec_root.rglob("*.md")):
-        relative = path.relative_to(spec_root).as_posix()
-        if path.name == "_map.md" or relative.startswith("_session/") or relative in excluded:
-            continue
+    for path in _spec_paths(spec_root, excluded):
         candidate = _candidate_for(path, spec_root, mapping, config_path, stage, normalized_paths)
         if candidate is None:
             continue
@@ -208,6 +251,34 @@ def resolve_candidates(root: str, stage: str, paths: Sequence[str]) -> tuple[Spe
     return tuple(sorted(candidates, key=lambda item: (-item.priority, item.path)))
 
 
+def resolve_candidate_headers(
+    root: str, stage: str, paths: Sequence[str]
+) -> tuple[SpecCandidateHeader, ...]:
+    """Resolve candidates from routing frontmatter without parsing bodies or hashes."""
+    if stage not in ALLOWED_STAGES:
+        raise SpecResolutionError(root, "stage", f"不支持 stage: {stage!r}")
+    normalized_paths = tuple(path.replace("\\", "/") for path in paths)
+    config = _load_config(root)
+    config_path = str(Path(root) / ".code-flow" / "config.yml")
+    mapping = _path_mapping(config, config_path)
+    excluded = _non_injectable(mapping, config_path)
+    spec_root = Path(root) / ".code-flow" / "specs"
+    if not spec_root.is_dir():
+        raise SpecResolutionError(str(spec_root), "specs", "缺失 specs 目录")
+    candidates: list[SpecCandidateHeader] = []
+    ids: dict[str, str] = {}
+    for path in _spec_paths(spec_root, excluded):
+        candidate = _candidate_header_for(path, spec_root, mapping, config_path, stage, normalized_paths)
+        if candidate is None:
+            continue
+        if candidate.spec_id in ids:
+            detail = f"重复 id {candidate.spec_id}: {ids[candidate.spec_id]}, {candidate.path}"
+            raise SpecResolutionError(str(spec_root), "spec_id", detail)
+        ids[candidate.spec_id] = candidate.path
+        candidates.append(candidate)
+    return tuple(sorted(candidates, key=lambda item: (-item.priority, item.path)))
+
+
 def _effective_enforcement(candidate: SpecCandidate, rule: SpecRule) -> str:
     if candidate.metadata.enforcement == "advisory" and rule.enforcement == "required":
         return "advisory"

package/src/core/code-flow/scripts/cf_spec_router.py

@@ -8,19 +8,31 @@ import json
 import os
 from pathlib import Path
 import tempfile
-from typing import Mapping, Sequence
-
-from cf_core import assemble_context, build_effective_mapping, build_spec_catalog, load_config, parse_spec_frontmatter
+from typing import Mapping, Optional, Sequence
+
+from cf_core import (
+    assemble_context,
+    build_effective_mapping,
+    build_spec_catalog,
+    compress_content,
+    load_config,
+    parse_spec_frontmatter,
+    resolve_compress,
+)
 from cf_spec_context import ContextError, load_active_task, load_context
 from cf_spec_resolver import resolve_candidates
 from cf_spec_session import context_sha256, project_task_session
 
 
+_PROJECTION_CACHE_PATH = ".code-flow/.task-projection-state.json"
+
+
 @dataclass(frozen=True)
 class RouteResult:
     mode: str
     text: str
     specs: tuple[str, ...]
+    context_sha256: Optional[str] = None
 
 
 class RouterError(ValueError):
@@ -43,6 +55,77 @@ def _task_file(task_dir: Path, task_id: str) -> Path:
     return matches[0]
 
 
+def _projection_cache_path(root: str) -> Path:
+    return Path(root) / _PROJECTION_CACHE_PATH
+
+
+def _load_projection_cache(root: str) -> Mapping[str, object]:
+    try:
+        value = json.loads(_projection_cache_path(root).read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError):
+        return {}
+    return value if isinstance(value, dict) else {}
+
+
+def _cached_projection(
+    root: str, task_dir: Path, task_id: str, current_hash: str
+) -> Optional[tuple[str, bool]]:
+    cache = _load_projection_cache(root)
+    if (
+        cache.get("version") != 1
+        or cache.get("task_id") != task_id
+        or cache.get("context_sha256") != current_hash
+        or not isinstance(cache.get("task_file"), str)
+        or not isinstance(cache.get("text"), str)
+        or not isinstance(cache.get("truncated"), bool)
+    ):
+        return None
+    task_file = Path(str(cache["task_file"]))
+    if task_file.parent != task_dir or not task_file.is_file():
+        return None
+    try:
+        directory_mtime = task_dir.stat().st_mtime_ns
+        task_mtime = task_file.stat().st_mtime_ns
+    except OSError:
+        return None
+    if cache.get("task_dir_mtime_ns") != directory_mtime or cache.get("task_mtime_ns") != task_mtime:
+        return None
+    return str(cache["text"]), bool(cache["truncated"])
+
+
+def _save_projection_cache(
+    root: str,
+    task_dir: Path,
+    task_file: Path,
+    task_id: str,
+    current_hash: str,
+    text: str,
+    truncated: bool,
+) -> None:
+    try:
+        payload = {
+            "version": 1,
+            "task_id": task_id,
+            "context_sha256": current_hash,
+            "task_file": str(task_file),
+            "task_dir_mtime_ns": task_dir.stat().st_mtime_ns,
+            "task_mtime_ns": task_file.stat().st_mtime_ns,
+            "text": text,
+            "truncated": truncated,
+        }
+        path = _projection_cache_path(root)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        temporary = path.with_name(f".{path.name}.{os.getpid()}.tmp")
+        temporary.write_text(json.dumps(payload, ensure_ascii=False), encoding="utf-8")
+        os.replace(temporary, path)
+    except (OSError, TypeError, UnicodeError):
+        if "temporary" in locals() and temporary.exists():
+            try:
+                temporary.unlink()
+            except OSError:
+                pass
+
+
 def _active_route(root: str) -> RouteResult:
     try:
         active = load_active_task(root)
@@ -52,15 +135,27 @@ def _active_route(root: str) -> RouteResult:
         raise RouterError("invalid_active_task", str(exc)) from exc
     current_hash = context_sha256(context)
     if current_hash != active.context_sha256:
-        raise RouterError("active_context_drift", "active marker Context hash does not match")
-    projection = project_task_session(context, str(_task_file(task_dir, active.task_id)), active.task_id)
-    if projection.truncated:
+        raise RouterError(
+            "active_context_drift",
+            "active marker Context hash does not match; run `cf-spec doctor` (resync) to re-sync the marker before continuing",
+        )
+    cached = _cached_projection(root, task_dir, active.task_id, current_hash)
+    if cached is None:
+        task_file = _task_file(task_dir, active.task_id)
+        projection = project_task_session(context, str(task_file), active.task_id)
+        _save_projection_cache(
+            root, task_dir, task_file, active.task_id, current_hash, projection.text, projection.truncated
+        )
+        text, truncated = projection.text, projection.truncated
+    else:
+        text, truncated = cached
+    if truncated:
         raise RouterError("task_projection_truncated", "split the TASK before coding")
     refs = tuple(binding.spec_id for binding in context.bindings)
-    return RouteResult("task", projection.text, refs)
+    return RouteResult("task", text, refs, current_hash)
 
 
-def _read_candidates(root: str, paths: Sequence[str]) -> RouteResult:
+def _read_candidates(root: str, paths: Sequence[str], compress: bool = True) -> RouteResult:
     try:
         candidates = resolve_candidates(root, "code", tuple(paths))
     except ValueError as exc:
@@ -74,7 +169,8 @@ def _read_candidates(root: str, paths: Sequence[str]) -> RouteResult:
             raise RouterError("spec_read_failed", f"{candidate.path}: {exc}") from exc
         unused_frontmatter, content = parse_spec_frontmatter(raw)
         del unused_frontmatter
-        specs.append({"path": candidate.path, "content": content.strip(), "tier": 1})
+        final_content = compress_content(content.strip()) if compress else content.strip()
+        specs.append({"path": candidate.path, "content": final_content, "tier": 1})
     text = assemble_context(specs, "## Active Specs (path-mapped)") if specs else ""
     return RouteResult("path", text, tuple(item.path for item in candidates))
 
@@ -141,5 +237,6 @@ def route_prompt(root: str, paths: Sequence[str], session_id: str) -> RouteResul
     if not config:
         return RouteResult("none", "", ())
     if paths:
-        return _read_candidates(root, paths)
+        quality = config.get("quality_loop")
+        return _read_candidates(root, paths, resolve_compress(quality if isinstance(quality, dict) else {}))
     return _catalog_route(root, session_id, config)

package/src/core/code-flow/scripts/cf_spec_session.py

@@ -5,16 +5,13 @@ from __future__ import annotations
 
 import argparse
 from dataclasses import dataclass
-import hashlib
 import json
 from pathlib import Path
 import re
 import sys
 from typing import IO, Mapping, Optional, Sequence
 
-import yaml
-
-from cf_spec_context import RuleBinding, SpecContext, context_to_data, load_context
+from cf_spec_context import RuleBinding, SpecContext, context_sha256, load_context
 
 
 @dataclass(frozen=True)
@@ -25,9 +22,8 @@ class SessionProjection:
     truncated: bool
 
 
-def context_sha256(context: SpecContext) -> str:
-    data = yaml.safe_dump(context_to_data(context), sort_keys=True, allow_unicode=True).encode()
-    return hashlib.sha256(data).hexdigest()
+# context_sha256 is defined next to the identity projection in cf_spec_context
+# and re-exported here for callers that import the session module.
 
 
 def _task_section(text: str, task_id: str) -> str:
@@ -70,7 +66,7 @@ def _rule_line(ref: str, rule: RuleBinding, compact: bool = False) -> str:
 
 
 def project_task_session(
-    context: SpecContext, task_file: str, task_id: str, max_chars: int = 4000
+    context: SpecContext, task_file: str, task_id: str, max_chars: int = 12000
 ) -> SessionProjection:
     section = _task_section(Path(task_file).read_text(encoding="utf-8"), task_id)
     refs = _refs(section)
@@ -100,7 +96,7 @@ def _parser() -> argparse.ArgumentParser:
     parser.add_argument("--task-file", required=True)
     parser.add_argument("--task", required=True)
     parser.add_argument("--output", required=True)
-    parser.add_argument("--budget", type=int, default=4000)
+    parser.add_argument("--budget", type=int, default=12000)
     parser.add_argument("--json", action="store_true")
     return parser