Lacunar Code

Lacunar Code is a computation paradigm where systems are defined by intentional absence (lacunae) inside a semantic graph, rather than complete instruction sets. Execution is the emergent resolution or traversal of incomplete structure, mediated by constraint satisfaction, resonance, and AI-driven inference rather than deterministic control flow.

WHY THIS MATTERS

• Traditional software assumes completeness first, execution second; Lacunar Code inverts this: incompleteness is the operating condition
• It reframes bugs, TODOs, and missing logic as first-class structural signals, not failures
• It aligns computation with modern AI systems that already operate in partial specification + probabilistic completion regimes
• It enables a shift from:
• writing procedures → shaping possibility fields
• debugging logic → curating incompleteness
• It suggests a new software class: systems that are stable precisely because they are incomplete but structurally constrained

This is a draft review map for task-specific detail pages. Treat it as speculative context routing, not as validated research.

NODES

• /concepts/lacunar-code/details/authority-and-consent.txt :: Authority, Consent, and Delegated Resolution -- Defines who may resolve, activate, promote, bypass, or retire a lacuna and how scoped or revoked authority changes graph eligibility
• /concepts/lacunar-code/details/completion-validity.txt :: Validity Conditions for Semantic Completion -- Defines the obligations that distinguish a structurally plausible proposal from a completion that may participate in execution
• /concepts/lacunar-code/details/intent-resolution-overlays.txt :: Intent Graphs, Resolution Overlays, and Invalidation -- Separates durable declarations of desired structure from provisional execution structure and defines how contextual resolutions are composed, promoted, revoked, and reopened
• /concepts/lacunar-code/details/lacuna-state-machine.txt :: Lifecycle and Topological State of a Lacuna -- Defines a lacuna as a persistent graph object whose operational state is derived from relationships, events, and unmet conditions
• /concepts/lacunar-code/details/minimum-viable-path.txt :: Minimum Viable Path Selection -- Defines execution as selection of the smallest justified subgraph capable of satisfying a bounded intent
• /concepts/lacunar-code/details/nonresolution-policy.txt :: Policies for Preserving or Refusing a Lacuna -- Defines conditions under which absence should remain visible because completion would conceal missing evidence, authority, consent, or value judgment
• /concepts/lacunar-code/details/runtime-observability.txt :: Observability, Counterfactual Debugging, and Replay -- Defines path-level traces, structural failure classification, counterfactual queries, and reproducible replay for incomplete execution
• /concepts/lacunar-code/details/settling-and-termination.txt :: Semantic Settling, Convergence, and Termination -- Defines settling as a bounded fixed-point process and distinguishes successful convergence from localized stuckness, exhaustion, oscillation, divergence, and deadlock

EDGES

• authority-and-consent -> completion-validity (refines): Authority and consent are independent validity obligations rather than preferences in candidate ranking
• authority-and-consent -> intent-resolution-overlays (constrains): Overlay activation, promotion, and continued validity depend on scoped and revocable authority
• authority-and-consent -> nonresolution-policy (prerequisite): The runtime cannot decide whether to proceed, defer, refuse, or escalate without knowing the applicable delegation and consent scope
• completion-validity -> intent-resolution-overlays (application): Validated candidates enter contextual overlays instead of silently replacing durable declarations
• completion-validity -> minimum-viable-path (constrains): A path is admissible only when its mandatory nodes, edges, effects, and completions satisfy their applicable obligations
• completion-validity -> runtime-observability (application): Debugging requires access to the obligations and structural witnesses that accepted or rejected each candidate
• intent-resolution-overlays -> lacuna-state-machine (refines): Overlay activation, invalidation, and deletion explain how a lacuna moves between validated, activated, invalidated, and eligible states
• intent-resolution-overlays -> minimum-viable-path (prerequisite): Path selection operates over durable intent plus the compatible provisional structure available in the current context
• intent-resolution-overlays -> runtime-observability (prerequisite): Traces and replay must distinguish durable intent from provisional generated structure and preserve overlay composition
• lacuna-state-machine -> minimum-viable-path (prerequisite): Path construction must know which gaps are eligible, blocked, protected, proposed, bypassable, or already activated
• minimum-viable-path -> settling-and-termination (prerequisite): Convergence and failure conditions must be evaluated over a bounded active subgraph rather than the entire semantic field
• nonresolution-policy -> lacuna-state-machine (refines): Nonresolution policy gives operational meaning to blocked, deferred, bypassed, rejected, and persistently unresolved states
• nonresolution-policy -> minimum-viable-path (constrains): Path selection must avoid protected gaps and may use bypasses only when they preserve the active intent
• runtime-observability -> nonresolution-policy (adjacent): Refusal and deferral are trustworthy only when the system can identify the missing evidence, permission, resource, or safety condition
• settling-and-termination -> lacuna-state-machine (refines): Termination outcomes determine whether remaining lacunae are settled around, blocked, deferred, bypassed, or still active
• settling-and-termination -> runtime-observability (application): Execution traces must distinguish genuine convergence from localized stuckness, exhaustion, oscillation, divergence, deadlock, and false quiescence

Operating Logic

Lacunar Code systems operate as partial semantic graphs:

1. Specification phase (intent deposition)

• Developers define:
• intent nodes
• partial transformations
• constraints
• Missing logic is explicitly declared as lacuna

1. Graph formation

• Code is represented as a directed constraint graph
• Nodes may be:
• fully specified
• partially specified
• completely absent (lacuna nodes)

1. Execution as traversal

• “Running” the system means:
• traversing graph paths
• selecting valid constraint-satisfying routes
• activating minimal subgraphs

1. AI-mediated completion

• AI acts as:
• gap resolver
• topology completer
• resonance matcher
• It proposes:
• missing nodes
• missing edges
• viable execution paths

1. Semantic settling

• System behavior emerges when:
• constraint satisfaction converges
• attractor states stabilize
• Execution is thus a relaxation process in a structured field

Key inversion:

Code does not run. The graph settles.

Pattern Language

Choice: Represent missing logic as structured objects, not nulls.

Missing function execution.

Boundary Conditions

Key boundaries include Risks and Failure Modes.

1. Explicit Lacuna Modeling

• Choice: Represent missing logic as structured objects, not nulls
• Why it matters: Prevents hidden assumptions and silent failures
• What to do:
• Lacuna { intent, constraints, state, confidence }
• store unresolved nodes in graph
• What to avoid:
• null/undefined fallbacks
• implicit TODO comments as “meaning”

2. Graph as Execution Medium

• Choice: Replace call stacks with traversal
• Why it matters: Enables global reasoning and emergent execution
• What to do:
• execute via path selection in graph
• allow multiple valid execution trajectories
• What to avoid:
• linear control flow as core model
• hidden branching inside nodes

3. Separation of Structure and Resolution

• Choice: Distinguish intent graph from completed graph
• Why it matters: Preserves incompleteness safely
• What to do:
• immutable “intent graph”
• overlay “resolved execution graph”
• What to avoid:
• overwriting original intent during AI completion

4. Resonance-Based Matching

• Choice: Use embeddings / structural similarity instead of exact matches
• Why it matters: Enables cross-domain synthesis and flexible completion
• What to do:
• hybrid search: graph constraints + vector similarity
• rank completion candidates by structural fit
• What to avoid:
• pure keyword or schema matching

5. AI as Structural Resolver (not generator)

• Choice: AI fills gaps rather than writing full programs
• Why it matters: Maintains graph coherence and prevents uncontrolled generation
• What to do:
• propose minimal completion sets
• reject incoherent expansions
• What to avoid:
• free-form code generation detached from graph state

6. Execution Gating via Coherence

• Choice: Require full-path validity before activation
• Why it matters: Prevents partial or unsafe execution
• What to do:
• validate end-to-end constraint satisfaction
• What to avoid:
• speculative execution from incomplete paths

7. Persistence of Incompleteness

• Choice: Allow unresolved lacunae to remain active artifacts
• Why it matters: Incompleteness is a system signal, not waste
• What to do:
• log inactive lacuna states with reasons
• What to avoid:
• garbage collection of “unimplemented” structure

EXAMPLES AND SCENARIOS

• Missing function execution
• A node exists with intent + constraints, but no implementation
• AI resolves it into a compatible transformation at runtime

• Graph traversal instead of API calls
• Request = pathfinding problem across semantic nodes

• Partial system that still runs
• System executes via fallback routes through lacuna nodes

• Intent → completion pipeline
• “Make this true” expands into graph traversal + minimal diff resolution

• Self-expanding graph
• Missing edges spawn candidate nodes based on structural similarity

• Execution as equilibrium
• System behaves like a field settling into a stable configuration

Structural Primitives

• Node (Partial Transform): A computation unit that may be incomplete or undefined internally
• Edge (Intent Link): A constraint or transformation relation, not a strict call dependency
• Graph / Semantic Field: The primary substrate where computation lives
• Lacuna: Explicitly represented absence (missing node, edge, or transformation)

Semantic Primitives

• Intent Node (::intent): Attractor defining “what should be true.”
• Attractor State: Stable configuration satisfying constraints
• Constraint Field: Rules that govern which completions are valid
• Semantic Completion Path: A valid traversal that resolves or bypasses lacunae

Inference Primitives

• Resolution Operator: AI/runtime mechanism that fills or routes around lacunae
• Semantic Similarity / Resonance: Matching mechanism replacing exact symbolic binding
• MVP Path (Minimum Viable Path): Smallest coherent traversal through incomplete structure

HOW THE CONCEPT WORKS

Lacunar Code systems operate as partial semantic graphs:

1. Specification phase (intent deposition)

• Developers define:
• intent nodes
• partial transformations
• constraints
• Missing logic is explicitly declared as lacuna

1. Graph formation

• Code is represented as a directed constraint graph
• Nodes may be:
• fully specified
• partially specified
• completely absent (lacuna nodes)

1. Execution as traversal

• “Running” the system means:
• traversing graph paths
• selecting valid constraint-satisfying routes
• activating minimal subgraphs

1. AI-mediated completion

• AI acts as:
• gap resolver
• topology completer
• resonance matcher
• It proposes:
• missing nodes
• missing edges
• viable execution paths

1. Semantic settling

• System behavior emerges when:
• constraint satisfaction converges
• attractor states stabilize
• Execution is thus a relaxation process in a structured field

Key inversion:

Code does not run. The graph settles.

• Lacuna-native IDE
• Code editor where missing logic is visual, indexable, and AI-completable
• Graph execution runtime
• Replace microservices orchestration with traversal engine
• AI gap compiler
• Converts partial specs into runnable systems
• Intent-first backend framework
• APIs defined as attractors + constraints, not endpoints
• Self-healing software systems
• Production systems that evolve by filling lacunae dynamically
• Knowledge graph computation engines
• “Codebase as evolving semantic ecosystem”

• Constraint-based programming
• Graph-native execution systems
• Dataflow and reactive programming
• AI program synthesis
• Vector-symbolic architectures
• Morphogenetic computation
• Attractor networks / dynamical systems
• Partial evaluation and staged computation
• Knowledge graph reasoning systems
• Intent-driven development (IDD)
• Emergent software systems
• “Code as topology” / semantic execution graphs

• Formal semantics of absence-as-computation
• Type systems for structured voids (lacuna types)
• Graph-native execution engines vs call-stack models
• AI-driven semantic completion compilers
• Constraint-field computation and attractor dynamics
• Hybrid symbolic + embedding execution systems
• Probabilistic traversal as program semantics
• Minimal-diff graph transformation systems
• Emergent computation vs explicit orchestration
• Temporal semantics of deferred execution (“kairos time” models)

Risks

• Over-generation risk
• AI may fill lacunae incorrectly, hallucinating structure
• Semantic drift
• Intent graph may diverge from original meaning during completion
• Underdeterminism
• Too many lacunae → system cannot stabilize
• Non-falsifiability
• “Anything can be completed” can collapse rigor

Failure Modes

• Lacuna explosion (everything becomes a gap)
• Infinite inference loops in completion phase
• Over-resonant matching (false structural analogies)
• Execution deadlocks due to unresolved constraints

Open Questions

• What formal guarantees define a “valid completion”?
• How is safety enforced in a partially specified system?
• When should lacunae not be filled?
• Can resonance-based execution be made deterministic enough for production systems?

• Cities that “run programs” by resolving architectural gaps
• AI systems that refuse execution until semantic coherence emerges
• Living software ecosystems where missing functions are biological growth sites
• Programming as a form of ecological gardening of incomplete systems
• Debugging as “cultivating lacunae until they stabilize”
• Software that “dreams” missing modules into existence via resonance fields

EXAMPLES AND SCENARIOS

• Missing function execution
• A node exists with intent + constraints, but no implementation
• AI resolves it into a compatible transformation at runtime

• Graph traversal instead of API calls
• Request = pathfinding problem across semantic nodes

• Partial system that still runs
• System executes via fallback routes through lacuna nodes

• Intent → completion pipeline
• “Make this true” expands into graph traversal + minimal diff resolution

• Self-expanding graph
• Missing edges spawn candidate nodes based on structural similarity

• Execution as equilibrium
• System behaves like a field settling into a stable configuration

Authority, Consent, and Delegated Resolution

SUMMARY

Defines who may resolve, activate, promote, bypass, or retire a lacuna and how scoped or revoked authority changes graph eligibility.

DETAIL

Technical capability does not imply authority. A resolver may be able to generate a structurally valid completion while lacking permission to access inputs, commit effects, allocate resources, bind an organization, schedule labor, or replace a protected human decision.

Authority should be represented as scoped delegation attached to graph regions, effect classes, resource ceilings, purposes, time intervals, and approval requirements. A capability may permit reading one subgraph without permitting mutation, permit simulation without activation, or permit temporary activation without durable promotion.

Different lifecycle transitions can require different authority. Candidate proposal may be broadly delegated. Validation may require a qualified reviewer or independent system. Activation may require an operational owner. Promotion into durable intent may require collective or organizational approval. Retirement may require the authority that owns the affected requirement rather than the resolver that last implemented it.

Consent is architectural rather than a static checkbox. It may be individual or collective, purpose-bound, revocable, conditional, time-limited, and dependent on workload or health conditions. The graph should expose what data, effects, and decisions a consent relation covers. Resolution outside that scope is invalid even when the resulting behavior appears beneficial.

Revocation or expiry invalidates dependent overlays. The runtime follows authority and consent dependencies, disables affected effects, and reopens the corresponding lacunae. Previously accepted structure may remain available for inspection or simulation, but it cannot continue acting under expired delegation.

Collective governance introduces plural intents. A system may need quorum rules, representative delegation, appeal paths, contestability, and explicit treatment of dissent. It should not collapse disagreement into a synthetic consensus merely because one technically coherent completion can be generated.

The optimistic form of delegated resolution combines adaptive automation with transparent scope, reversible authority, workload limits, health signals, review, resilience, and mechanisms through which affected people can alter the graph's governing constraints.

WHY THIS EXISTS

Supports permissions, organizational automation, consent-sensitive systems, labor allocation, public governance, and effectful execution.

SOURCE CONTEXT POINTERS

• /concepts/lacunar-code/PRODUCT_BUSINESS.txt
• /concepts/lacunar-code/RISKS_AND_CONTRADICTIONS.txt
• /concepts/lacunar-code/details/completion-validity.txt
• /concepts/lacunar-code/details/nonresolution-policy.txt
• /concepts/lacunar-code/details/intent-resolution-overlays.txt

EVIDENCE QUESTIONS

• No evidence query recorded

Validity Conditions for Semantic Completion

SUMMARY

Defines the obligations that distinguish a structurally plausible proposal from a completion that may participate in execution.

DETAIL

A completion is valid only relative to a declared intent, a bounded graph region, an execution context, and an explicit set of obligations. Semantic similarity, fluent generation, historical reuse, or local type compatibility may justify retrieval, but none independently authorizes activation.

Validity is layered. Structural validity checks node roles, edge direction, input and output shapes, cardinality, dependency order, and graph invariants. Semantic validity checks that the completion preserves the meaning of the affected intent rather than merely producing compatible data. Contract validity checks preconditions, postconditions, effect boundaries, interface commitments, and prohibited behavior. Behavioral validity checks observable outcomes against assertions, examples, simulations, tests, or monitored tolerances. Safety validity excludes paths that violate physical, privacy, security, financial, organizational, or governance boundaries. Resource validity bounds latency, inference depth, memory, external calls, monetary cost, and energy use. Authority validity checks that the resolver and resulting effects remain inside delegated powers. Temporal validity identifies the versions, environments, jurisdictions, permissions, and operating conditions under which the completion remains admissible.

Where obligations are compositional, they should be attached to graph boundaries. A transformation edge can expose its preconditions, postconditions, effect set, and preservation claims. Adjacent witnesses can then be stitched into a path-level justification when outputs and assumptions align. This makes correctness inspectable as a finite structural spine rather than an opaque claim about a generated implementation.

Composition has limits. Global invariants, cumulative resource effects, cycles, nonlocal safety properties, stakeholder conflicts, and semantic drift may not be detectable from adjacent edges alone. A path can therefore possess a complete chain of local witnesses while still failing a graph-level obligation. Lacunar Code should treat local proof composition as a validation layer, not as a universal replacement for global review.

Validation returns an obligation map rather than one confidence score. A candidate may pass structural and resource checks while failing authority or semantic preservation. Production activation requires every mandatory obligation. Sandboxed exploration may admit weaker candidates only when isolation, reversibility, and effect constraints are explicit.

Every accepted completion declares a dependency cone: the smallest set of intents, assumptions, constraints, inputs, versions, permissions, and environmental facts on which its validity depends. Changes inside that cone reopen the affected resolution rather than forcing indiscriminate global recomputation.

WHY THIS EXISTS

Supports semantic compilers, repair systems, execution gates, test frameworks, and safety reviews that must decide whether a proposed completion is admissible.

SOURCE CONTEXT POINTERS

• /concepts/lacunar-code/DEEP.txt
• /concepts/lacunar-code/PATTERNS.txt
• /concepts/lacunar-code/RESEARCH_DIRECTIONS.txt
• /concepts/lacunar-code/RISKS_AND_CONTRADICTIONS.txt

EVIDENCE QUESTIONS

• No evidence query recorded

Intent Graphs, Resolution Overlays, and Invalidation

SUMMARY

Separates durable declarations of desired structure from provisional execution structure and defines how contextual resolutions are composed, promoted, revoked, and reopened.

DETAIL

Lacunar Code distinguishes what the system means from how that meaning is provisionally realized.

The intent graph is the durable semantic layer. It contains desired conditions, known transformations, constraints, permissions, prohibitions, and explicit lacunae. It states what must remain true without requiring every implementation choice to be fixed in advance.

A resolution overlay is a contextual graph delta containing candidate nodes, edges, bindings, routes, assumptions, versions, and activation conditions for a bounded execution. It does not erase or silently rewrite the intent graph. Several overlays may coexist over one intent structure: one optimized for latency, another for cost, another for stricter data residency, and another for simulation under relaxed side-effect rules.

An overlay identifies the intent region it covers, the lacunae it fills or bypasses, the structure it introduces, its external dependencies, its validation witnesses, its validity interval, its authority and resource bounds, and its rollback conditions. The delta should be readable independently of unrelated graph history so that a consuming runtime can load only the relevant operational context.

Overlay composition detects contradictions before activation. Two overlays conflict when they assign incompatible meanings to the same relation, depend on mutually exclusive assumptions, compete for a non-shareable resource, exceed combined effect limits, introduce an impermissible cycle, or invalidate each other's witnesses. Compatible overlays may compose when their dependency cones and effects remain mutually admissible.

Activation and promotion are different. Activation allows a validated overlay to participate in one bounded execution. Promotion moves reusable structure into the durable graph. Promotion requires broader testing, stronger semantic review, and authority from the owners of the affected intent because it changes the substrate used by future executions.

Invalidation is dependency-directed. Each overlay declares the intents, constraints, data versions, permissions, environmental facts, resolver versions, and external services on which it relies. When one changes, the runtime invalidates only the dependent overlay region and reopens the corresponding lacunae. The prior completion may remain a candidate, but it must be revalidated. Revoked consent, expired authority, changed workload limits, altered health signals, jurisdiction changes, or new safety rules can reopen an overlay even when its local implementation remains technically unchanged.

Deleting or invalidating an overlay must not delete the original lacuna. The unresolved intent remains visible for another context, resolver, or future condition.

WHY THIS EXISTS

Supports contextual execution, rollback, versioning, multiple implementations, incremental recomputation, revocation, and protection against semantic drift.

SOURCE CONTEXT POINTERS

• /concepts/lacunar-code/PRIMITIVES.txt
• /concepts/lacunar-code/PATTERNS.txt
• /concepts/lacunar-code/RISKS_AND_CONTRADICTIONS.txt

EVIDENCE QUESTIONS

• No evidence query recorded

Lifecycle and Topological State of a Lacuna

SUMMARY

Defines a lacuna as a persistent graph object whose operational state is derived from relationships, events, and unmet conditions.

DETAIL

A lacuna is not an empty slot that disappears when code is generated. It is a persistent computational object recording an acknowledged absence, the intent affected by that absence, the conditions for attempting resolution, and the history of prior attempts.

A useful lifecycle distinguishes declared, blocked, eligible, proposed, validated, activated, bypassed, deferred, rejected, invalidated, and retired conditions. Declared means the absence has been attached to an intent, edge, transform, or required condition. Blocked means a prerequisite, permission, input, resource, or decision is missing. Eligible means the bounded neighborhood contains enough context to search for candidates. Proposed means candidate structure exists but cannot yet affect execution. Validated means a candidate has discharged its applicable obligations. Activated means the candidate participates in one execution overlay. Bypassed means another path satisfies the active intent without claiming to resolve the gap. Deferred means the gap remains relevant but current timing, evidence, cost, authority, or risk conditions do not permit action. Rejected applies to a failed candidate, not to the lacuna itself. Invalidated means a previously accepted completion no longer satisfies its dependency cone. Retired means the surrounding intent or topology no longer requires the gap.

State should be represented primarily through topology and event relations rather than mutable labels alone. A proposal edge, validation witness, activation relation, unmet-prerequisite edge, bypass path, timeout event, or invalidation dependency makes the condition inspectable. The graph becomes the authoritative state description: processing is visible because the expected relations exist, and stuckness is localized where a required relation fails to materialize.

Derived topological state does not eliminate compact status projections. Runtimes may cache labels for indexing or user interfaces, but those labels should be recomputable from durable relations and event history. This prevents a stale enum from contradicting the actual graph.

Resolution is not terminal. An activated completion may later be invalidated. A bypassed lacuna may remain necessary for another intent. A deferred gap may become eligible when evidence or authority arrives. The runtime therefore preserves the lacuna and transition history rather than overwriting absence with the latest proposed implementation.

Candidate generation moves a lacuna only to Proposed. Correctness requires a distinct validation transition. Temporary activation and durable promotion are separate decisions, with promotion requiring wider evidence and explicit authority because it changes the structure against which future resolutions will be interpreted.

WHY THIS EXISTS

Supports graph schemas, runtimes, event systems, IDEs, queues, and debuggers that must distinguish absence, attempted resolution, activation, bypass, and persistence.

SOURCE CONTEXT POINTERS

• /concepts/lacunar-code/PRIMITIVES.txt
• /concepts/lacunar-code/PATTERNS.txt
• /concepts/lacunar-code/RISKS_AND_CONTRADICTIONS.txt

EVIDENCE QUESTIONS

• No evidence query recorded

Minimum Viable Path Selection

SUMMARY

Defines execution as selection of the smallest justified subgraph capable of satisfying a bounded intent.

DETAIL

The Minimum Viable Path is the smallest admissible execution subgraph that can satisfy the active intent under current constraints. Its purpose is to prevent a local request from triggering global graph completion.

Path construction begins with the target attractor: the conditions that must become true for the intent to count as satisfied. The runtime traverses backward through compatible transformations, identifying required dependencies, already available inputs, candidate branches, and lacunae whose resolution would be necessary. The immediately executable transformations form a ready frontier.

Smallest does not mean fewest edges. A path objective may combine the amount of newly activated structure, number of lacunae requiring resolution, semantic uncertainty, irreversible side effects, inference depth, authority escalation, dependency breadth, latency, cost, reversibility, and validation strength. A longer path through existing validated structure may be preferable to a shorter speculative path.

Hard constraints prune the search space before ranking. Paths are excluded when they violate safety boundaries, require unavailable authority, cross protected lacunae, depend on inaccessible data, exceed budgets, or fail mandatory contracts. Remaining paths are ranked by minimal justified change: reuse accepted structure, localize assumptions, minimize generation, preserve rollback options, and expose strong validation witnesses.

Branching belongs in the graph rather than inside opaque nodes. Alternative paths should expose guards, preconditions, effect sets, and expected outputs so admissibility can be determined without executing every branch. Graph-local navigation also permits iterative retrieval: inspect the current neighborhood, choose the next bounded expansion, and avoid loading unrelated structure.

A path may bypass a lacuna instead of filling it. Bypass is valid only when another route satisfies the target predicates while preserving the intent associated with the missing structure. The bypass does not claim that the unresolved question has been answered.

Several paths may remain active when redundancy, resilience, comparative evaluation, or plural valid outcomes are part of the intent. Where repeatability is required, declared tie-breaking rules select one admissible path without pretending that alternatives are invalid.

The Minimum Viable Path turns AI completion into bounded graph repair. The resolver receives a specific unmet obligation within a constrained traversal rather than an invitation to generate the surrounding system.

WHY THIS EXISTS

Supports graph execution engines, planners, bounded synthesis systems, inference budgeting, and minimal-diff repair.

SOURCE CONTEXT POINTERS

• /concepts/lacunar-code/DEEP.txt
• /concepts/lacunar-code/PRIMITIVES.txt
• /concepts/lacunar-code/PATTERNS.txt

EVIDENCE QUESTIONS

• No evidence query recorded

Policies for Preserving or Refusing a Lacuna

SUMMARY

Defines conditions under which absence should remain visible because completion would conceal missing evidence, authority, consent, or value judgment.

DETAIL

A lacuna does not imply permission to generate. Some absences represent incomplete implementation, while others represent uncertainty or disagreement that should remain structurally visible.

A lacuna may encode missing evidence, missing authority, unavailable consent, stakeholder conflict, a protected human decision, an intentionally deferred choice, an unavailable resource, a legal restriction, or a future event whose timing matters. A nonresolution policy determines when the runtime must refuse, defer, bypass, or escalate rather than fill the gap.

Resolution should be refused or escalated when consequences are irreversible, relevant authority is absent, affected parties have not consented, observability is too weak to detect harm, candidate paths rely on undeclared assumptions, or stakeholder intents cannot be reconciled by the encoded constraints.

Candidate multiplicity can itself reveal a lacuna. When several incompatible completions satisfy the technical constraints, the missing element may be a value judgment, priority, or collective decision rather than code. Selecting one candidate by model preference would hide the unresolved governance question.

A preserved lacuna remains operationally informative. It identifies the blocked intent, unmet conditions, affected paths, available bypasses, escalation authority, and the event or evidence that would restore eligibility. Unresolved structure is useful when it states precisely what the system cannot legitimately decide.

Bypass differs from resolution. A bypass path satisfies the active intent through another route without claiming to answer the missing question. It is admissible only when it preserves relevant guarantees and does not erase the continuing significance of the original lacuna.

In labor and organizational systems, explicit nonresolution can prevent automation from converting ambiguity into hidden work, involuntary allocation, or unreviewed policy. The optimistic systemic case is a constrained design in which consent, workload limits, health signals, transparency, resilience, and collective long-run benefit shape what may be automated and what must remain a visible human or collective decision.

Abstention is therefore a valid computational outcome. It is not evidence that the resolver failed when the graph correctly identifies that no authorized or sufficiently justified completion exists.

WHY THIS EXISTS

Supports abstention, escalation, human agency, safety-critical workflows, and governance-sensitive automation.

SOURCE CONTEXT POINTERS

• /concepts/lacunar-code/PATTERNS.txt
• /concepts/lacunar-code/PRODUCT_BUSINESS.txt
• /concepts/lacunar-code/RISKS_AND_CONTRADICTIONS.txt

EVIDENCE QUESTIONS

• No evidence query recorded

Resonance Matching Under Structural Constraints

SUMMARY

Limits resonance to candidate discovery and places structural and semantic validation after retrieval.

DETAIL

Resonance is a retrieval and proposal mechanism. It finds structures that may fit a lacuna because they resemble the local intent, topology, behavior, or prior successful resolutions. It is not a correctness criterion and must not directly authorize execution.

Candidate discovery may combine several signals:

• semantic embedding similarity
• graph-neighborhood similarity
• repeated subgraph motifs
• compatible input and output types
• shared preconditions or postconditions
• behavioral signatures
• effect profiles
• domain labels
• prior success under comparable constraints

The graph should constrain retrieval before or during ranking. A candidate that cannot connect to the required node roles, violates dependency direction, introduces forbidden effects, or fails authority boundaries should be excluded even when its textual similarity is high.

The search context should be local to the lacuna. Broad thematic similarity encourages false analogies across domains. Retrieval should weight the nearby intent, active constraints, edge roles, required contracts, and target attractor more heavily than general conceptual resemblance.

Resonance can operate in stages. A semantic search first retrieves a broad candidate set. Structural filters remove incompatible nodes. Contract and safety checks eliminate inadmissible candidates. Path-level validation then tests whether the candidate participates in a coherent Minimum Viable Path.

Candidate diversity matters. A retrieval system that returns many near-duplicate suggestions creates the appearance of confidence without exploring meaningfully different solutions. The resolver should preserve distinct candidate families when several structural strategies are possible.

A candidate with low semantic similarity may still be correct if it satisfies the graph's obligations. A highly resonant candidate may still be invalid. This asymmetry is essential: resonance reduces search cost, while explicit constraints determine admissibility.

Historical reuse should remain contextual. A completion that succeeded elsewhere is evidence for retrieval, not proof that changed inputs, permissions, or environments preserve validity.

WHY THIS EXISTS

Supports hybrid symbolic-neural retrieval, candidate ranking, cross-domain reuse, and prevention of similarity-driven hallucinated structure.

SOURCE CONTEXT POINTERS

• /concepts/lacunar-code/PATTERNS.txt
• /concepts/lacunar-code/RISKS_AND_CONTRADICTIONS.txt
• /concepts/lacunar-code/RELATED_TERMS.txt

EVIDENCE QUESTIONS

• hybrid graph constraint vector retrieval candidate generation semantic similarity structural compatibility (semantic): Further evidence could refine whether graph constraints should filter retrieval before ranking or validate candidates afterward

Observability, Counterfactual Debugging, and Replay

SUMMARY

Defines path-level traces, structural failure classification, counterfactual queries, and reproducible replay for incomplete execution.

DETAIL

Debugging a Lacunar Code system means inspecting graph decisions, obligations, and transitions rather than reconstructing hidden procedural control flow.

An execution trace exposes the active intent, intent-graph version, selected Minimum Viable Path, ready frontiers, lacuna transitions, proposed candidates, validation outcomes, assumptions, external dependencies, bypasses, refusals, overlay composition, invalidations, and the structural condition that ended execution. Durable intent and generated overlay structure must remain visually and semantically distinct.

Failure classification should be structural. The runtime distinguishes no candidate retrieved, candidate topology mismatch, semantic or behavioral contract failure, safety rejection, authority rejection, unavailable prerequisite, overlay conflict, exhausted budget, oscillation, divergence, dependency deadlock, invalidation, and false quiescence. Localizing stuckness as a graph leaf or blocking cut prevents one unresolved branch from becoming an undifferentiated system-wide failure.

The most useful explanations are bounded. A developer usually needs the cone of relevant causes, the first failed obligation, the smallest blocking cut, the minimal path witness, or the assumptions supporting a selected edge. Full provenance dumps obscure these structures and may expose sensitive data without improving diagnosis.

Counterfactual queries should answer which constraint excluded a candidate, why a lacuna was bypassed, what smallest change would make another path admissible, which outputs depend on an invalidated completion, and what prevented the ready frontier from advancing. These queries make graph shape an executable explanation surface.

Replay requires durable execution state because a nondeterministic resolver cannot reconstruct prior behavior from intent alone. A replay record preserves the graph version, active constraints, accepted overlay, external observations, resolver version, ranking and tie-breaking policy, randomness controls, and validation witnesses.

Strict replay reuses the accepted overlay and identical inputs. Regenerative replay reruns resolution under frozen retrieval and policy boundaries to test solver stability. Comparative replay varies one declared dimension, such as resolver version or cost policy, while holding the dependency cone fixed. Changed safety, authority, consent, or environmental facts invalidate strict reproduction before effects are recommitted.

Observability remains bounded by privacy and security. The runtime can expose decisions, obligations, and structural witnesses without revealing unrestricted internal model reasoning or sensitive source material.

WHY THIS EXISTS

Supports IDEs, incident response, audit, causal explanation, replay, regression testing, and controlled upgrades of probabilistic resolvers.

SOURCE CONTEXT POINTERS

• /concepts/lacunar-code/PATTERNS.txt
• /concepts/lacunar-code/PRODUCT_BUSINESS.txt
• /concepts/lacunar-code/RISKS_AND_CONTRADICTIONS.txt

EVIDENCE QUESTIONS

• No evidence query recorded

Semantic Settling, Convergence, and Termination

SUMMARY

Defines settling as a bounded fixed-point process and distinguishes successful convergence from localized stuckness, exhaustion, oscillation, divergence, and deadlock.

DETAIL

Semantic settling is the iterative revision of candidate paths, bindings, and overlays until the active graph reaches an acceptable stable configuration. Stability is scoped to a particular intent, context, and active subgraph.

A graph is settled when every hard constraint on the selected path is satisfied, mandatory dependencies are discharged or terminally classified, active nodes have produced admissible outputs, and no remaining bounded local transformation can improve or invalidate the accepted result under the declared objective. Soft-constraint violations must remain inside explicit tolerances.

The ready frontier provides an operational termination surface. When no admissible transformation remains, execution has structurally stopped. This is a success witness only when every required condition is satisfied or explicitly terminal. Otherwise the empty frontier identifies localized stuckness: a missing edge, blocked prerequisite, protected lacuna, expired permission, or unresolved dependency prevented continuation.

Several non-success outcomes must remain distinct. Exhaustion occurs when time, cost, depth, or model-call budgets end before stability is established. Oscillation occurs when alternatives repeatedly replace one another without improving a declared measure. Divergence occurs when each attempted resolution introduces additional mandatory lacunae or expands the dependency cone without bound. Deadlock occurs when unresolved elements depend cyclically on one another becoming eligible first. False quiescence occurs when nothing is active even though a required transition is absent or invisible.

Termination can be supported by monotonic measures attached to admissible transitions. A transition may be required to discharge an obligation, reduce a finite rank, narrow uncertainty, decrease the unresolved dependency set, or descend a well-founded order. Local descending measures can compose along an acyclic path. Intentional cycles require an invariant plus a stopping, persistence, or resource policy; they cannot rely on descent alone.

Fixed-point checks, repeated-state detection, graph-growth limits, inference-depth bounds, budget limits, and escalation rules should be combined. Reaching a resource limit produces Deferred or Blocked, not Settled.

A settled overlay remains conditional. New evidence, changed constraints, altered permissions, revoked consent, or invalidated dependencies reopen the affected region. Settling is therefore a temporal validity claim, not a declaration of permanent completeness.

WHY THIS EXISTS

Supports stopping rules, loop detection, localized failure diagnosis, fixed-point semantics, and production safeguards against unbounded inference.

SOURCE CONTEXT POINTERS

• /concepts/lacunar-code/DEEP.txt
• /concepts/lacunar-code/PRIMITIVES.txt
• /concepts/lacunar-code/RESEARCH_DIRECTIONS.txt
• /concepts/lacunar-code/RISKS_AND_CONTRADICTIONS.txt

EVIDENCE QUESTIONS

• No evidence query recorded