project-tiny-context-harness 0.8.17 → 0.12.0

package/assets/skills/long-task-workflow/references/source-authoring.md

@@ -1,123 +0,0 @@
-# Source-Bound Draft Input Reference
-
-Read this alongside `contract-authoring.md` when raw, mixed, attachment-heavy or incomplete inputs need Source-quality repair while the same Contract Draft is being mapped. Inputs enter the Draft immediately; this reference is neither an earlier Source-authoring phase nor a standalone intermediary planning stage or second lifecycle.
-
-## Objective and boundary
-
-Preserve every material user, product, technical, visual and acceptance constraint from the initial/revised proposal and supplied resources. Add only traceable necessary derivations, defensible delegated choices and evidence-backed repository facts. Make the real Source understandable without the original conversation before Preflight/Compile, while allowing Draft decomposition and repository binding to proceed incrementally.
-
-Do not create an intermediary planning schema, CLI, Preflight, Compile, Receipt, cache, authority, state or internal Source-authoring stage. Contract YAML cannot become the sole owner of a choice or missing semantic. Do not let current implementation silently redefine intent. A pre-existing planning or proposal document is simply one possible input.
-
-## Input inventory
-
-1. Assign every proposal, selected design resource, screenshot, document, diagram, table and other attachment a stable input ID.
-2. Inspect all pages/frames/screens/tables/visible states; never silently sample a multi-part artifact. Every non-empty line in a declared Markdown Source file must ultimately belong to exactly one Material Source Item, one keyed and reasoned non-authoritative `ty-source-background:start/end` block, or the one validated `design-resource-handoff-v1` formal block.
-3. Classify each input as user instruction, product requirement, technical constraint, existing proposal, selected target, repository/Context evidence, constraint, inspiration or background. Background is a closed grammar: `markdown-structure` contains only text-free anchors or horizontal rules, and `provenance` contains only `ty-source-provenance input=<key> mode=<direct|derived|delegated|evidence-backed> [source=<key>] [sha256=<64-lowercase-hex>]` comments; non-direct modes require `source`. Text-bearing headings, free-form provenance and explanatory prose are material or unclassified even when intended as non-authoritative; background must never hide a qualifier, requirement, acceptance fact, architecture meaning, design meaning or other delivery authority.
-4. For visual resources, preserve selection basis, classification (`exact-target`, `constraint` or `inspiration`), stable resource/surface/control/state/target keys, declared platform/viewport/mode/state/content applicability, source profile/canonical entry/dependency set, provider/project/run/entry provenance and immutable digest/snapshot, plus typed locators. A mutable link, metadata-only response, partial file set or prose locator is incomplete. Unselected candidates authorize no fidelity.
-5. Record incorporated meaning and every unreadable, conflicting or intentionally unused part. Higher authority and user-stated precedence win; unresolved conflicts remain decisions.
-
-## Preference and research gate
-
-Before comparative research or a material product, technical, architecture or provider selection, identify decision-changing criteria such as fidelity versus cost, delivery speed, reliability/support, privacy/compliance, lock-in/control, operational burden, platform scope and extensibility.
-
-Infer preferences only from user words, Source, Context or controlling constraints. If an unknown preference would materially change research or recommendation, ask one concise targeted clarification before proceeding. Do not impose a questionnaire, re-ask known preferences or pause for minor reversible choices with the same defensible recommendation.
-
-Use current primary/authoritative evidence for changing external facts. Record source, scope and retrieval date. Preference clarification authorizes plan meaning, not payment, contracting, deployment/publication, destructive production mutation, permission grants, sensitive-data transmission or required legal/security/human approval; those remain typed external confirmations.
-
-## Working strategies, not phases
-
-Choose locally as needed while revising the same Draft; do not expose these as lifecycle stages or ask the user to choose:
-
-- **refinement:** preserve and complete a substantially developed proposal;
-- **synthesis:** build coherent Source from a goal plus mixed inputs;
-- **hybrid:** use one proposal as backbone and fill gaps from other inputs.
-
-A short request is sufficient when roles, goal and reference authority are recoverable. Reuse an authorized writable proposal as the real Source. If the delivery exists only in conversation, materialize exactly one project-native Markdown Source according to repository convention. Do not create a parallel planning artifact.
-
-## Semantic authoring
-
-For every material item, preserve one origin:
-
-- `direct`: stated by user or controlling input, with all qualifiers;
-- `derived`: unavoidable for completeness/falsifiability, identifies `Derived From`, states why necessary and changes no user capability, business rule or scope;
-- `delegated`: a defensible choice requested by instructions to synthesize/refine/use judgment, records `Delegated By`, preference/evidence basis and exact added meaning;
-- `evidence-backed`: repository/Context fact with exact source and no promotion of incidental code shape to product intent;
-- `decision_required`: conflicting authority, explicitly user-reserved choice, missing material preference or no defensible recommendation.
-
-High impact or several options is not itself a reason to pause when criteria support one recommendation. Keep real high-risk actions as external confirmations. Never introduce a requirement for the first time only inside acceptance criteria.
-
-## Structure and stable keys
-
-Use stable semantic lowercase-kebab keys and Markdown anchors where practical. Preserve keys when wording changes but meaning does not; never renumber for ordering or reuse a retired key for new meaning.
-
-Define vertical Outcomes only when observable results are independently decidable and later verifiable. Do not split by response length, frontend/backend layer, module count, agent capacity or desired parallelism; do not merge distinct results merely for brevity.
-
-Use only applicable semantic types:
-
-- result/Outcome;
-- Requirement (`REQ`);
-- user-visible Control (`CTRL`);
-- technical obligation (`OBL`);
-- explicitly non-completing meaning (`NCOMP`);
-- acceptance scenario (`AC`);
-- global non-goal/constraint and forbidden shortcut;
-- risk with exact Fact, Affected Outcome, Basis and Consequence;
-- external confirmation (`EXT`);
-- genuine decision (`DEC`);
-- advisory implementation hint (`HINT`), which is not a material requirement.
-
-## Non-UI semantic completeness
-
-For every non-UI delivery, the authoring default is the finest independently decidable semantic Fact supported by direct Source, necessary logical derivation, explicit delegation or evidence-backed preservation. Do not stop at prose paragraphs, Requirements, Product Controls, user stories, broad acceptance scenarios, an `all-states`/`all-errors` catalogue or whatever fields current code happens to expose.
-
-Before implementation and formal Compile:
-
-1. Inventory every material request fragment, attachment, controlling Context unit, canonical schema/specification, selected external constraint, repository-preservation source and delegated instruction with stable identity, digest, disposition and basis. Ordinary Material Source is `non_ui_material` and must contribute Fact lineage. A validated design handoff may classify its independently closed visual facts as `ui_design`; `supporting_only` and `excluded_by_scope` need exact rationale/basis and cannot hide a requirement.
-2. Explicitly disposition every standard semantic family for every Outcome and add custom families discovered from Source/repository/domain structure. The standard floor covers goal/scope/glossary; actors/roles/tenants/entitlements; business rules/calculations; data; operations/workflows/state/time; validation/output/error/API/protocol/event/job; persistence/cache/search/transactions/consistency/concurrency/idempotency; fault/retry/degradation/recovery/backup; configuration/flags/secrets; compatibility/migration/rollout; performance/capacity/cost/reliability/SLO; security/privacy/safety/compliance; observability/deployment/operations; integrations/notification/file/media/localization/commercial; hardware; AI/ML; architecture ownership/boundaries/debt.
-3. Give every applicable outcome, actor, policy, entity/field/relation, operation, state/transition, interface/message/job, store/index/transaction/cache, configuration/migration/deployment/dependency, security/privacy boundary, SLO/signal/alert/runbook, device/AI/custom unit a stable subject/relation/population identity. Preserve hierarchy, owner, cardinality, causality, ordering, producer/consumer, source-of-truth and dependency relations. Static/dynamic populations need exact universe/partition/enumeration/exclusion identity.
-4. Disposition every standard and custom condition axis. Enumerate each atomic applicable value and exact combination across actors/roles/tenants/jurisdictions/environments/regions/platforms/versions/features/configuration/entitlements/permissions/consent/sessions/states/input/boundary/data volume/locale/time/concurrency/repetition/dependency health/connectivity/failure/retry/consistency/freshness/migration/rollout/topology/threat/mode. Continuous domains use explicit ranges/boundaries; invariance/equivalence may share execution only while retaining distinct Fact identity and verdict. No aggregate, representative, pairwise or default-path substitute.
-5. Disposition every standard and custom atomic property per unit and condition. One specified cell creates one Fact with typed value semantics, exact Source locator/digest, owner, quantifier, observation boundary, sensitivity and provenance. Every N/A/exclusion names exact affected identities, basis and rationale; `decision_required`, `unavailable`, unreadable or conflicting meaning remains blocking.
-6. Expand every Fact into all required proof methods—exact/schema/decision-table/formula/invariant/transition/sequence/durable roundtrip/boundary/external effect/population/concurrency/idempotency/fault/recovery/migration/compatibility/performance/capacity/security/privacy/audit/observability/deployment/structure or custom TCB method. Freeze comparator, parameters, tolerance/mask, Oracle identity/capability, environment, observer and protected-value policy. Reach the furthest independently failing boundary; request issuance, parser success, self-reported success, artifact existence or a nearer proxy does not prove downstream persistence/effect/recovery.
-7. Embed one complete `semantic-fact-manifest-v1` in declared Source. Its Inspector Census and collection counts/identity digests prove deterministic complete generation with no truncation or sampling. Require `Expected Semantic Facts = Source Indexed Facts`; later Contract authoring requires exact Fact and Fact×method projection. Values remain in Source/Context; Contract receives identities, located digests and comparison authority only.
-
-This expansion cannot invent a real product/legal/security/commercial/safety choice. A defensible delegated choice must first become traceable Material Source; an unsupported or user-reserved choice remains a blocker or typed External Confirmation. The named Inspector/Oracle is an explicit trusted-computing boundary, and custom extensions are mandatory when the standard catalog cannot observe the domain.
-
-## UI and control completeness
-
-For each in-scope surface, record purpose, entry/exit/navigation, regions/overlays and included Control keys. For every real material interactive Control, close every canonical field independently:
-
-`surface`, `region`, `location`, `control type`, `label/content`, `user task`, `visibility`, `availability`, `trigger`, `input`, `validation`, `default`, `interaction`, `navigation/result`, `loading`, `empty`, `success`, `failure`, `recovery`, `permission`, `feedback` and `accessibility`.
-
-For each field record concrete `specified` meaning, an explicit justified `not_applicable` statement, or blocking `unresolved`; omission is not non-applicability. Also preserve every material cross-Control and system relation—including shared state, ordering/dependency, mutual exclusion, navigation, permission, recovery, validation and feedback chains—and explicitly close the Outcome as `not_applicable` only when no such relation exists. Each specified or not-applicable fact, including relation closure, must name its actual target, atomic condition/input/state dimensions and Given/When journey applicability.
-
-Do not invent controls for a non-interface delivery. A coarse frame or configured design system does not supply unshown states. Selected design resources and product/technical Source remain parallel: visuals cannot invent business/data/permission/algorithmic rules.
-
-For every selected exact/constraint target, preserve the declared platform/viewport/mode/state/content conditions and identify which surface and Control keys it governs. A formal Web/App handoff also preserves its canonical Fact-manifest identity, frozen Inspector/Census and the exact handoff projection of condition axes/combinations, subject hierarchy, subject-local variations, atomic properties, Fact Cells/Facts, proof obligations, Oracles/environments, design-system lineage, assets and blockers. Product Controls and eight UI/UX dimensions are semantic/roll-up owners, not the Fact ceiling. Do not collapse a component instance or Anatomy Part into its family, several states into `all-states`, several conditions into one label, or several property/method obligations into one broad visual claim. Canonical resources retain exact values; Source and Contract retain stable Fact identities and located-digest/comparison authority rather than copied CSS.
-
-Before Compile, confirm the formal handoff already proves `Expected Fact Universe = Canonical Resource Facts = Handoff Indexed Facts`, including explicit N/A/exclusion basis and non-sampling/non-truncation. Each covered Fact has all property-required verification methods, and each exact target condition has full-target layout and pixel Facts. Separately record any design-resource acceptance blocker supplied by the Source, including its exact Source items, verification methods and non-empty runtime-observation `required_capabilities`. Do not weaken a physical-device, sensor, camera, orientation, haptic, assistive-technology, pixel-density, safe-area or other target-local need into a generic browser/runtime label merely because the proxy is available. File identity, hashes, provider/export success, registry membership, Census counts and preflight are integrity/input-closure facts only; they do not state that a production owner, real-user journey or rendered interaction conforms.
-
-## Acceptance and risk
-
-Each AC has exactly one Given/When/Then scenario, names the REQ/CTRL/OBL/NCOMP meaning it accepts and introduces no undeclared product semantics. Keep representative/sample/framework checks distinct from full-population claims and partial delivery distinct from completion.
-
-Use the Runtime's exact risk Fact names when marking risk. Data migration is `data_migration`; a weakly observable critical path is separate `critical_user_path` and `weak_observability` facts; preserve `multi_repository_change` in Source so Contract compilation can reject unsupported delivery honestly.
-
-## Preflight/Compile convergence audit
-
-Before Preflight/Compile confirm:
-
-1. Every material original statement and qualifier is preserved.
-2. Every supplied input is incorporated or has an explicit unreadable/unused/conflict disposition, and every non-empty Source line is owned by a Material Item, closed-grammar structure/provenance background block or validated formal block.
-3. Distinct requirements and independently decidable Outcomes were not collapsed.
-4. Every real Control has all 22 canonical fields closed as specified, justified not applicable or unresolved; every material cross-Control/shared-state/navigation/permission/recovery relation is specified or the Outcome explicitly declares that no such relation exists.
-5. Every REQ, specified/not-applicable CTRL field and Control relation has exact applicability plus acceptance, external confirmation, decision or explicit exception; unresolved coverage blocks.
-6. Derived/delegated/evidence-backed items have traceable basis and no hidden product expansion.
-7. Non-goals, forbidden shortcuts, risks and recovery are concrete.
-8. No unsupported number, threshold, metric or external claim appears.
-9. Selected design resources retain stable identity and exact declared coverage; formal Web/App handoffs retain manifest-backed atomic Fact/proof universes with no aggregate, sampled or truncated coverage; candidates remain non-authoritative.
-10. Every material UI Fact and Control can be mapped to a production target/owner, real-user entry journey and independently attributable acceptance route, while every declared design blocker has an explicit machine or target-blocking external-confirmation disposition. Removing one from scope requires an explicit Source revision; Contract prose cannot waive it.
-11. The Source is self-contained enough to own every mapped Draft semantic and names every still-required external artifact.
-12. At least one marked `technical_obligation` carries `aspect=architecture`, preserves the selected owner/dependency/debt conclusion, and maps to an independently falsifiable architecture obligation rather than only a Result Claim.
-13. The one `semantic-fact-manifest-v1` exactly inventories all material non-UI inputs and complete standard/custom family, unit/relation/population, condition, property, Fact and proof-obligation universes; every ordinary Material Source Item contributes exact Fact lineage, all generation collections have complete count/digest closure, and no aggregate/sample/ungrounded N/A/unresolved row is hidden.
-
-Complete non-rendering `ty-source-item:start/end` markers in the real Markdown Source without rewriting direct text, wrap only recognized Markdown structure or structured provenance in uniquely keyed and reasoned `ty-source-background:start/end` blocks, retain at most one schema-valid `design-resource-handoff-v1` formal block, and finish the corresponding Contract mapping in the same loop. Unclassified text, arbitrary prose inside background, a background block used to hide material meaning, unresolved Control coverage or missing applicability blocks Preflight/Compile. Neither markers nor this audit delay opening the Draft.

package/assets/tools/validate_context.py

@@ -1,442 +0,0 @@
-#!/usr/bin/env python3
-"""Standalone Minimal Context validator installed with the portable profile."""
-
-from pathlib import Path, PureWindowsPath
-import json
-import re
-import subprocess
-import sys
-
-try:
-    import tomllib
-except ImportError:  # Python 3.10 compatibility; Node is already required by ty-context.
-    tomllib = None
-
-
-ROOT = Path.cwd().resolve()
-CONTEXT_ROOT = ROOT / "project_context"
-
-GLOBAL_CHECKS = [
-    ("project goal", ["project goal", "项目目标", "目标"]),
-    ("boundaries", ["non-goals", "boundaries", "非目标", "边界"]),
-    ("design rationale", ["design rationale", "设计思路", "设计原因"]),
-    ("architecture context", ["architecture context", "架构上下文", "architecture.md"]),
-    ("verification entry points", ["verification entry", "验证入口", "测试入口"]),
-    ("current state", ["current state", "当前状态"]),
-    ("next safe action", ["next safe action", "下一步安全动作"]),
-    ("context index", ["context index", "module index", "上下文索引", "模块索引"]),
-]
-
-ARCHITECTURE_CHECKS = [
-    ("system boundary", ["system boundary", "系统边界", "边界"]),
-    ("component map", ["component map", "组件", "模块关系"]),
-    ("data or control flow", ["data / control flow", "data flow", "control flow", "数据流", "控制流"]),
-    ("design rationale", ["design rationale", "设计思路", "设计原因"]),
-    ("verification implications", ["verification implications", "验证影响", "验证入口"]),
-]
-
-VALID_ROLES = {
-    "global",
-    "architecture",
-    "area",
-    "domain",
-    "subdomain",
-    "foundation",
-    "archive",
-    "contract",
-    "verification",
-    "deployment",
-    "implementation-index",
-    "decision-rationale",
-}
-ROLE_ALIASES = {
-    "implementation_index": "implementation-index",
-    "decision_rationale": "decision-rationale",
-}
-READ_POLICIES = {"default", "always", "optional", "on-demand", "never-default"}
-TOP_LEVEL_FIELDS = {"areas", "context"}
-AREA_FIELDS = {"id", "root", "context", "kind", "default", "forbidden_runtime_dependencies"}
-CONTEXT_FIELDS = {"path", "role", "read_when", "read_policy", "triggers", "default_children"}
-CONFIG_CANDIDATES = [
-    ".agent/config.yaml",
-    ".codex/config.yaml",
-    ".harness/config.yaml",
-    ".claude/config.yaml",
-    ".cursor/config.yaml",
-    ".cline/config.yaml",
-    ".roo/config.yaml",
-    ".gemini/config.yaml",
-]
-FAKE_VERIFICATION_PATTERNS = [
-    re.compile(r"\btests?\s+(?:pass(?:ed|es)?|green)\b", re.I),
-    re.compile(r"\bverified\b", re.I),
-    re.compile(r"\bdeployed\s+successfully\b", re.I),
-    re.compile(r"\bvalidation\s+passed\b", re.I),
-    re.compile(r"测试(?:已)?通过"),
-    re.compile(r"验证(?:已)?通过"),
-    re.compile(r"部署(?:已)?成功"),
-]
-PLACEHOLDER = re.compile(r"^(?:todo|tbd|placeholder|coming soon|待补充|占位|暂无)[.!。…\s-]*$", re.I)
-
-
-def has_any(text, terms):
-    lower = text.lower()
-    return any(term.lower() in lower for term in terms)
-
-
-def normalize_role(value):
-    role = ROLE_ALIASES.get(value.strip().lower(), value.strip().lower())
-    return role if role in VALID_ROLES else None
-
-
-def normalize_context_path(value):
-    return value.replace("\\", "/").removeprefix("./")
-
-
-def parse_front_matter(text):
-    lines = text.splitlines()
-    if not lines or lines[0].strip() != "---":
-        return {}
-    result = {}
-    for line in lines[1:]:
-        if line.strip() == "---":
-            return result
-        match = re.match(r"^([A-Za-z0-9_-]+):\s*(.+?)\s*$", line.strip())
-        if match:
-            result[match.group(1)] = match.group(2).strip().strip("\"'")
-    return result
-
-
-def table_lines(content, table):
-    return [
-        index
-        for index, line in enumerate(content.splitlines(), start=1)
-        if line.strip() == f"[[{table}]]"
-    ]
-
-
-def parse_manifest(path, errors):
-    content = path.read_text(encoding="utf-8")
-    try:
-        parsed = parse_toml(content)
-    except (ValueError, RuntimeError) as error:
-        errors.append(f"project_context/context.toml is not valid TOML: {error}")
-        return {"areas": [], "context": []}
-    for key in parsed:
-        if key not in TOP_LEVEL_FIELDS:
-            errors.append(f"project_context/context.toml has unknown top-level field {key}")
-    manifest = {}
-    for table, allowed in (("areas", AREA_FIELDS), ("context", CONTEXT_FIELDS)):
-        entries = parsed.get(table, [])
-        if not isinstance(entries, list) or any(not isinstance(entry, dict) for entry in entries):
-            errors.append(f"project_context/context.toml field [[{table}]] must be an array of TOML tables")
-            entries = []
-        lines = table_lines(content, table)
-        manifest[table] = []
-        for index, raw in enumerate(entries):
-            entry = dict(raw)
-            entry["line"] = lines[index] if index < len(lines) else 1
-            for key in raw:
-                if key not in allowed:
-                    errors.append(f"project_context/context.toml line {entry['line']} has unknown field {key}")
-            manifest[table].append(entry)
-    return manifest
-
-
-def parse_toml(content):
-    if tomllib is not None:
-        try:
-            return tomllib.loads(content)
-        except tomllib.TOMLDecodeError as error:
-            raise ValueError(str(error)) from error
-    script = "import('smol-toml').then(({parse})=>{let s='';process.stdin.setEncoding('utf8');process.stdin.on('data',c=>s+=c);process.stdin.on('end',()=>process.stdout.write(JSON.stringify(parse(s))))}).catch(e=>{console.error(e.message);process.exit(1)})"
-    result = subprocess.run(
-        ["node", "--input-type=module", "--eval", script],
-        input=content,
-        text=True,
-        capture_output=True,
-        cwd=ROOT,
-        check=False,
-    )
-    if result.returncode != 0:
-        raise RuntimeError(f"formal TOML parser unavailable: {result.stderr.strip()}")
-    return json.loads(result.stdout)
-
-
-def required_string(entry, key, errors):
-    value = entry.get(key)
-    if not isinstance(value, str) or not value.strip():
-        errors.append(f"project_context/context.toml line {entry['line']} must include non-empty string field {key}")
-        return None
-    return value
-
-
-def optional_string(entry, key, errors):
-    value = entry.get(key)
-    if value is None:
-        return None
-    if not isinstance(value, str) or not value.strip():
-        errors.append(f"project_context/context.toml line {entry['line']} field {key} must be a non-empty string")
-        return None
-    return value
-
-
-def string_array(entry, key, errors):
-    value = entry.get(key, [])
-    if not isinstance(value, list) or any(not isinstance(item, str) or not item.strip() for item in value):
-        errors.append(f"project_context/context.toml line {entry['line']} {key} must be an array of non-empty strings")
-        return []
-    if len(value) != len(set(value)):
-        errors.append(f"project_context/context.toml line {entry['line']} {key} must not contain duplicates")
-    return value
-
-
-def is_relative_to(target, root):
-    try:
-        target.relative_to(root)
-        return True
-    except ValueError:
-        return False
-
-
-def safe_manifest_path(raw, allowed_root, label, expected, errors):
-    normalized = raw.replace("\\", "/")
-    if Path(raw).is_absolute() or PureWindowsPath(raw).is_absolute() or ".." in normalized.split("/"):
-        errors.append(f"project_context/context.toml {label} path must be relative and must not contain '..': {raw}")
-        return None
-    target = ROOT.joinpath(*normalized.split("/"))
-    if not target.exists():
-        errors.append(f"project_context/context.toml references missing {expected}: {normalized}")
-        return None
-    resolved_root = allowed_root.resolve()
-    resolved_target = target.resolve()
-    if not is_relative_to(resolved_target, resolved_root):
-        errors.append(f"project_context/context.toml {label} resolves outside its allowed root: {raw}")
-        return None
-    if expected == "context file" and not resolved_target.is_file():
-        errors.append(f"project_context/context.toml {label} must reference a regular file: {raw}")
-        return None
-    if expected == "area root" and not resolved_target.is_dir():
-        errors.append(f"project_context/context.toml {label} must reference a directory: {raw}")
-        return None
-    return resolved_target
-
-
-def validate_manifest(errors):
-    manifest_path = CONTEXT_ROOT / "context.toml"
-    roles = {}
-    policies = {}
-    if not manifest_path.exists():
-        if schema_requires_manifest():
-            errors.append("missing project_context/context.toml; run ty-context upgrade to create the Schema v4 Context graph manifest")
-        return roles, policies
-    manifest = parse_manifest(manifest_path, errors)
-    areas = manifest["areas"]
-    contexts = manifest["context"]
-    if not areas:
-        errors.append("project_context/context.toml must declare at least one [[areas]] entry")
-    defaults = [entry for entry in areas if entry.get("default") is True]
-    if areas and len(defaults) != 1:
-        errors.append(f"project_context/context.toml must mark exactly one [[areas]] entry with default = true; found {len(defaults)}")
-    area_ids = set()
-    registered_paths = set()
-
-    for area in areas:
-        area_id = required_string(area, "id", errors)
-        area_root = required_string(area, "root", errors)
-        context_path = required_string(area, "context", errors)
-        optional_string(area, "kind", errors)
-        if "default" in area and not isinstance(area["default"], bool):
-            errors.append(f"project_context/context.toml line {area['line']} default must be a boolean")
-        string_array(area, "forbidden_runtime_dependencies", errors)
-        if area_id:
-            if area_id in area_ids:
-                errors.append(f"project_context/context.toml has duplicate area id: {area_id}")
-            area_ids.add(area_id)
-        if area_root:
-            safe_manifest_path(area_root, ROOT, f"area {area_id or area['line']} root", "area root", errors)
-        if context_path:
-            register_context_path(context_path, "area", None, f"area {area_id or area['line']}", registered_paths, roles, policies, errors)
-
-    for entry in contexts:
-        context_path = required_string(entry, "path", errors)
-        raw_role = required_string(entry, "role", errors)
-        optional_string(entry, "read_when", errors)
-        read_policy = optional_string(entry, "read_policy", errors)
-        string_array(entry, "triggers", errors)
-        string_array(entry, "default_children", errors)
-        role = normalize_role(raw_role) if raw_role else None
-        if raw_role and role is None:
-            errors.append(f"project_context/context.toml line {entry['line']} has unsupported context role: {raw_role}")
-        if read_policy and read_policy not in READ_POLICIES:
-            errors.append(f"project_context/context.toml line {entry['line']} has unsupported read_policy: {read_policy}")
-        if context_path and role:
-            register_context_path(context_path, role, read_policy, f"context {context_path}", registered_paths, roles, policies, errors)
-
-    for entry in contexts:
-        for child in entry.get("default_children", []):
-            normalized = normalize_context_path(child)
-            if normalized not in registered_paths:
-                errors.append(f"project_context/context.toml line {entry['line']} default_children references unregistered Context path: {child}")
-    return roles, policies
-
-
-def register_context_path(raw, role, read_policy, label, registered, roles, policies, errors):
-    normalized = normalize_context_path(raw)
-    if normalized in registered:
-        errors.append(f"project_context/context.toml has duplicate Context path: {normalized}")
-        return
-    registered.add(normalized)
-    if not normalized.startswith("project_context/") or not normalized.endswith(".md"):
-        errors.append(f"project_context/context.toml {label} must reference a markdown file under project_context/: {raw}")
-        return
-    if safe_manifest_path(raw, CONTEXT_ROOT, label, "context file", errors) is None:
-        return
-    roles[normalized] = role
-    if read_policy:
-        policies[normalized] = read_policy
-
-
-def schema_requires_manifest():
-    schema_version = "4"
-    for candidate in CONFIG_CANDIDATES:
-        path = ROOT / candidate
-        if not path.exists():
-            continue
-        match = re.search(r'schema_version:\s*["\']?([^"\'\s]+)', path.read_text(encoding="utf-8"))
-        if match:
-            schema_version = match.group(1)
-            break
-    try:
-        return int(schema_version.split(".", 1)[0]) >= 4
-    except ValueError:
-        return True
-
-
-def validate_checks(rel, text, checks, errors):
-    for label, terms in checks:
-        if not has_any(text, terms):
-            errors.append(f"{rel} must include {label}")
-
-
-def section_bodies(text):
-    headings = list(re.finditer(r"^(#{2,6})\s+(.+?)\s*$", text, re.M))
-    for index, match in enumerate(headings):
-        end = headings[index + 1].start() if index + 1 < len(headings) else len(text)
-        yield match.group(2), text[match.end():end].strip()
-
-
-def validate_no_fake_verification(rel, text, errors):
-    for heading, body in section_bodies(text):
-        if not re.search(r"verification|tests?|deployment|验证|测试|部署", heading, re.I):
-            continue
-        if any(pattern.search(body) for pattern in FAKE_VERIFICATION_PATTERNS):
-            errors.append(f"{rel} must list verification entry points, not claim tests were already executed")
-            return
-
-
-def validate_minimum_recoverability(rel, text, errors):
-    if not re.search(r"^#\s+\S.+$", text, re.M):
-        errors.append(f"{rel} must contain a non-empty level-one title")
-    body = re.sub(r"^---\s*\n[\s\S]*?\n---\s*\n?", "", text, count=1)
-    facts = []
-    for line in body.splitlines():
-        value = line.strip()
-        if not value or value.startswith(("#", "```", "<!--")):
-            continue
-        value = re.sub(r"^[-*+>]\s*", "", value).strip()
-        if len(value) >= 8 and not PLACEHOLDER.fullmatch(value):
-            facts.append(value)
-    if not facts:
-        errors.append(f"{rel} must contain at least one concrete fact paragraph and cannot be only TODO or placeholder text")
-
-
-def validate_role_recoverability(rel, text, role, errors):
-    if role == "verification" and not re.search(r"`[^`\r\n]+`|(?:npm|pnpm|yarn|make|node|python|pytest|cargo|go)\s+\S+|(?:^|\s)(?:\./|[\w.-]+/)[\w./-]+", text, re.I | re.M):
-        errors.append(f"{rel} verification Context must contain a command, repository path or repeatable entry point")
-    if role == "implementation-index":
-        candidates = [match.group(1) for match in re.finditer(r"`([^`]+)`", text) if ("/" in match.group(1) or "\\" in match.group(1)) and " " not in match.group(1)]
-        if not any(repository_path_exists(candidate) for candidate in candidates):
-            errors.append(f"{rel} implementation-index Context must contain at least one existing repository path")
-    if role == "contract" and not re.search(r"producer|consumer|input|output|schema|compatibility|constraint|must|shall|禁止|必须|输入|输出|兼容", text, re.I):
-        errors.append(f"{rel} contract Context must state at least one constraint or input/output semantic")
-    if role == "decision-rationale":
-        has_decision = re.search(r"^##\s+(?:(?:Decision|Current Design Choice|Design Choice)(?:\b|\s|$)|决定(?:\s|$)|当前设计选择(?:\s|$))", text, re.I | re.M)
-        has_reason = re.search(r"^##\s+(?:(?:Reason|Rationale|Why)(?:\b|\s|$)|原因(?:\s|$)|理由(?:\s|$)|为什么(?:\s|$))", text, re.I | re.M)
-        if not has_decision or not has_reason:
-            errors.append(f"{rel} decision-rationale Context must contain both a Decision and a Reason")
-
-
-def repository_path_exists(candidate):
-    clean = candidate.rstrip(".:,;").replace("\\", "/")
-    if Path(clean).is_absolute() or PureWindowsPath(clean).is_absolute() or ".." in clean.split("/"):
-        return False
-    target = ROOT.joinpath(*clean.split("/"))
-    return target.exists() and is_relative_to(target.resolve(), ROOT)
-
-
-def validate_context_file(rel, text, role, errors):
-    validate_no_fake_verification(rel, text, errors)
-    validate_minimum_recoverability(rel, text, errors)
-    if role:
-        validate_role_recoverability(rel, text, role, errors)
-
-
-def main():
-    errors = []
-    warnings = []
-    global_path = CONTEXT_ROOT / "global.md"
-    architecture_path = CONTEXT_ROOT / "architecture.md"
-    if not global_path.exists():
-        errors.append("missing project_context/global.md")
-    else:
-        text = global_path.read_text(encoding="utf-8")
-        validate_checks("project_context/global.md", text, GLOBAL_CHECKS, errors)
-        validate_context_file("project_context/global.md", text, "global", errors)
-    if not architecture_path.exists():
-        errors.append("missing project_context/architecture.md")
-    else:
-        text = architecture_path.read_text(encoding="utf-8")
-        validate_checks("project_context/architecture.md", text, ARCHITECTURE_CHECKS, errors)
-        validate_context_file("project_context/architecture.md", text, "architecture", errors)
-
-    manifest_roles, manifest_policies = validate_manifest(errors)
-    checked = 0
-    context_files = sorted(CONTEXT_ROOT.rglob("*.md")) if CONTEXT_ROOT.exists() else []
-    for path in context_files:
-        rel = path.relative_to(ROOT).as_posix()
-        if rel in {"project_context/global.md", "project_context/architecture.md"}:
-            continue
-        text = path.read_text(encoding="utf-8")
-        front_matter = parse_front_matter(text)
-        declared_role = front_matter.get("context_role")
-        front_role = normalize_role(declared_role) if declared_role else None
-        if declared_role and front_role is None:
-            errors.append(f"{rel} has unsupported context_role: {declared_role}")
-        front_policy = front_matter.get("read_policy")
-        if front_policy and front_policy not in READ_POLICIES:
-            errors.append(f"{rel} has unsupported read_policy: {front_policy}")
-        manifest_role = manifest_roles.get(rel)
-        manifest_policy = manifest_policies.get(rel)
-        if manifest_role and front_role and manifest_role != front_role:
-            errors.append(f"{rel} front matter context_role {front_role} does not match manifest role {manifest_role}")
-        if manifest_policy and front_policy and manifest_policy != front_policy:
-            errors.append(f"{rel} front matter read_policy {front_policy} does not match manifest read_policy {manifest_policy}")
-        if not manifest_role:
-            warnings.append(f"{rel} is an unregistered Context Markdown file; add it to project_context/context.toml or move it out of project_context/**")
-        role = manifest_role or front_role
-        validate_context_file(rel, text, role, errors)
-        checked += 1
-
-    for warning in warnings:
-        print(f"warning: {warning}", file=sys.stderr)
-    if errors:
-        for error in errors:
-            print(f"error: {error}", file=sys.stderr)
-        return 1
-    print(f"Context OK: {2 + checked} context file(s)")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/dist/commands/check-modularity.d.ts

@@ -1 +0,0 @@
-export declare function checkModularity(args: string[]): Promise<void>;