@interf/compiler 0.2.5 → 0.3.1

package/templates/interface/README.md

@@ -1,159 +0,0 @@
-# Interf Interface
-
-Focused local context shells on top of your knowledge base. Any coding agent can navigate them.
-
-## Architecture
-
-```text
-source-folder/
-  interf/
-    {knowledge-base-name}/          knowledge base
-      interfaces/
-        {name}/                     interface
-          interf.json               type: interface, workflow, knowledge_base.path
-          compile-plan.md              interface execution plan
-          AGENTS.md                 bootstrap
-          CLAUDE.md                 Claude Code bootstrap mirror
-          workflow/                 local workflow package
-          home.md                   entry point
-          .gitignore
-          .interf/                  hidden runtime state
-          knowledge/                local entities/claims/indexes
-          briefs/                   hero documents
-          summaries/                periodic summaries
-```
-
-Interfaces are usually created by `interf create interface` from the source folder for a knowledge base. The source folder is the human control plane. The interface is the generated workspace for one job.
-
-Contract model:
-- `type` = engine object kind in config/schema (`interface`)
-- `workflow` = user-facing methodology selection
-- `.interf/stage-contract.json` = generated per-run contract for the active stage
-- executor = the agent/runtime that implements the active stage
-
-## Compile flow
-
-```text
-interf compile:
-  Step 1/3: interface/retrieve   scan all summary frontmatter, prove coverage, compute delta
-  Step 2/3: interface/analyze    batch analysis, extract, refine runtime from evidence
-  Step 3/3: interface/compile    create local context shell, validate
-```
-
-State bridges between steps. If step 2 fails, the next run resumes from step 2.
-
-## Workflows
-
-Shipped built-in interface workflow:
-- `interf`
-
-The selected workflow is written to `interf.json` and can seed starter local `workflow/` docs.
-Use `compile-plan.md` for interface-specific direction such as target entities, years, metrics, chart families, and output focus.
-Create a reusable local workflow only when you want a named method variation you expect to reuse across multiple interfaces.
-
-## Bundled stage skills
-
-| Skill | Step | What |
-|---|---|---|
-| `interface/create` | — | Create interface, draft the initial runtime hypothesis |
-| `interface/retrieve` | 1/3 | Scan the full knowledge-base summary set, persist retrieval proof, compute delta |
-| `interface/analyze` | 2/3 | Batch analysis, subagents, extract entities/claims |
-| `interface/compile` | 3/3 | Build local outputs, validate, clean up |
-
-## interf.json
-
-Minimal. Source of truth for type and knowledge-base reference.
-
-```json
-{
-  "type": "interface",
-  "name": "weekly-briefing",
-  "workflow": "interf",
-  "knowledge_base": {
-    "path": "../.."
-  }
-}
-```
-
-`knowledge_base.path` points to the parent knowledge base. All interface-specific filter criteria, extraction goals, and output specs live in `compile-plan.md`.
-`workflow` records the selected reusable method. Interf generates per-run stage contracts from it for this interface.
-
-If you want to specialize this specific interface, refine `compile-plan.md`.
-If you want a reusable retrieval, ontology, or output method, use a workflow and local `workflow/`.
-If you want a different stage graph, proof model, or required artifacts, that is effectively a new workflow.
-
-`AGENTS.md` is the source of truth. `CLAUDE.md` is a generated mirror so Claude Code picks up the same interface instructions automatically.
-
-`workflow/` is where you can edit interface-local instruction docs:
-- `workflow/README.md`
-- `workflow/create/SKILL.md`
-- `workflow/use/query/SKILL.md`
-- `workflow/compile/stages/retrieve/SKILL.md`
-- `workflow/compile/stages/analyze/SKILL.md`
-- `workflow/compile/stages/compile/SKILL.md`
-
-Simplest pattern:
-- edit `workflow/compile/stages/retrieve/SKILL.md` to change retrieval logic
-- edit `workflow/compile/stages/analyze/SKILL.md` to change ontology/extraction logic
-- edit `workflow/compile/stages/compile/SKILL.md` to change output/navigation logic
-- edit `workflow/use/query/SKILL.md` to change the manual interface query loop
-
-Workflow seeds may already place starter docs in these folders. Treat them as editable local guidance, not as locked system files.
-Use `AGENTS.md` for navigation, command usage, and the manual access checklist. Use `workflow/` for query behavior and stage behavior.
-
-These are the local instruction layer for the interface. Add JSON frontmatter with `mode: extend` or `mode: override` when you want to declare whether a doc should add to or replace the bundled stage instructions for that stage.
-
-Interf still enforces the same coverage proof, artifact schema, and state flow either way.
-If you need a different stage chain, artifact contract, or verifier flow, create a new workflow in the SDK instead of encoding that in local skill docs.
-
-If your coding agent is sandboxed to the current directory tree, launch it from the source folder so the source root, knowledge base, and this interface all stay reachable.
-Use `../../.interf/source-access.json` to verify that raw files are actually reachable before you depend on raw fallback in a manual agent session. `suggested_checks` are canonical absolute file paths so they remain valid from inside the interface folder.
-
-Interfaces include minimal `.obsidian/graph.json` defaults. Open the parent knowledge-base folder in Obsidian so knowledge-base summaries, source links, and interface links remain navigable.
-
-## Runtime files
-
-Interfaces maintain runtime artifacts under `.interf/`:
-- `state.json` — mutable runtime state
-- `health.json` — computed compile status and key metrics
-- `view-spec.json` — presentation contract for cards, graph scope, and navigation
-- `run.json` — current or last deterministic stage run
-- `stage-contract.json` — machine-readable contract for the active stage
-- `run-history.jsonl` — append-only history of completed runs
-- `relevant.json` — selected files for this interface
-- `coverage.json` — retrieval proof for this run
-
-`interf status` for an interface is read-only and deterministic. It checks config, knowledge-base path resolution, broken wikilinks, and retrieval coverage.
-`interf verify interface-plan --json` is the deterministic referee for the scaffold and `compile-plan.md`.
-`interf verify retrieve --json` is the deterministic referee for interface retrieval proof before analyze/build.
-
-See `docs/runtime-contract.md` for the human-readable contract and `src/lib/schema.ts` for the exact runtime schemas.
-
-## compile-plan.md
-
-Generated by `interface/create`. Defines:
-- Stage 1: filter criteria
-- Stage 2: extraction goals and allowed runtime refinements
-- Stage 3: output specs for the local context shell
-
-This is the interface-specific customization layer for the built-in `interf` workflow unless you choose a reusable local workflow instead.
-Compile can refine it when the evidence clearly demands better local structure.
-
-## Key principles
-
-**Local outputs only.** The parent knowledge base is read-only. The interface builds its own `knowledge/` and output folders.
-
-**No auto-cascade.** Knowledge-base compile and interface compile are separate commands.
-
-**Delta compile.** On subsequent runs, only changed files are processed.
-
-**Coverage-gated retrieval.** Retrieval is complete only when the system can prove the full summary set was scanned at the routing layer, candidate abstracts were reviewed, and selected plus rejected sets were persisted.
-
-**Local context shell.** The interface is not just a report folder. It should become the easiest place for an agent to enter, navigate, and understand the relevant slice of the knowledge base.
-
-## Reset
-
-```text
-interf reset compile remove knowledge/ + briefs/, keep summaries/ + config
-interf reset all     remove all generated content, preserve config files
-```

package/templates/interface/interfaces.md

@@ -1,102 +0,0 @@
-# Interface Patterns
-
-Interf currently ships one built-in interface workflow: `interf`.
-That workflow always runs retrieve -> analyze -> compile.
-
-What changes from interface to interface is the use case, the `compile-plan.md` customization, and any optional local workflow extension docs.
-
-Use the patterns below as planning lenses you can encode in `compile-plan.md` or a reusable local interface workflow. They are not built-in workflow ids.
-
-Benchmark queries exist today as validation prompts and expected behaviors. The automated benchmark runner and score logging loop are implemented separately from this shipped template reference.
-
----
-
-## Current-State Briefing Lens
-
-Current-state briefing. Best when you want the latest truth, recent changes, and immediate next steps.
-
-**Questions this interface answers:**
-- What is true right now?
-- What changed recently?
-- What should I focus on next?
-- Which decisions or risks are active?
-
-**Filter:** categories include current-state docs, changelogs, plans, updates, decisions
-
-**Outputs:**
-- Current-State.md — current truth with citations
-- Changes.md — recent changes and trend lines
-- Next-Steps.md — action-oriented follow-through
-
-**Summaries:** weekly, monthly, or milestone-based
-
-**Benchmark queries:**
-- "What is true right now?" — should prefer current, confirmed signals over stale material
-- "What changed recently?" — should compare recent vs prior, not show random old notes
-- "What should happen next?" — should surface evidence-linked actions, not generic advice
-
----
-
-## Research Synthesis Lens
-
-Research synthesis. Best when you want themes, contradictions, evidence strength, and open questions from a dense knowledge base.
-
-**Questions this interface answers:**
-- What are the dominant themes?
-- Which claims are well-supported?
-- Where do sources disagree?
-- What questions still need more evidence?
-
-**Filter:** categories include primary sources, papers, notes, experiments, datasets, repos
-
-**Outputs:**
-- Themes.md — recurring themes with evidence
-- Contradictions.md — disagreements, caveats, counterevidence
-- Open-Questions.md — unresolved questions and next reads
-
-**Summaries:** by topic cluster or period
-
-**Benchmark queries:**
-- "What are the strongest themes?" — should show themes with citations, not loose impressions
-- "Where do sources disagree?" — should show both sides and the evidence basis
-- "What should I read next?" — should turn gaps into concrete next-source suggestions
-
----
-
-## Gap Review Lens
-
-Audit and gap-finding. Best when you want to improve knowledge-base quality, spot stale areas, and surface missing or contradictory evidence.
-
-**Questions this interface answers:**
-- What is missing or weakly covered?
-- Which facts or claims look inconsistent?
-- Which outputs need verification or refresh?
-- What should be added to the knowledge base next?
-
-**Filter:** categories include canonical records, requirements, policies, status docs, recent changes
-
-**Outputs:**
-- Gaps.md — missing areas and thin coverage
-- Contradictions.md — inconsistent facts or claims
-- Follow-Ups.md — concrete verification or ingestion work
-
-**Benchmark queries:**
-- "What is missing?" — should identify concrete gaps, not generic advice
-- "What looks inconsistent?" — should cite the conflicting evidence explicitly
-- "What should we verify next?" — should turn issues into concrete follow-up work
-
----
-
-## Self-improving Loop
-
-Every interface can carry benchmark queries. The intended validation cycle is:
-
-1. Build the interface from its config and current compile plan
-2. Run benchmark queries against the compiled interface workspace
-3. Score: did each query return expected behavior?
-4. If score is below threshold:
-   - Analyze failures
-   - Adjust the interface plan and ontology in `compile-plan.md`
-   - Re-compile
-   - Re-benchmark
-5. Log scores per model per interface for comparison

package/templates/knowledge-base/README.md

@@ -1,137 +0,0 @@
-# Interf Knowledge Base
-
-Your local knowledge base for agents. Attach to any folder, then let Interf compile source files into summaries plus a cross-file knowledge layer.
-
-## Architecture
-
-```text
-source-folder/                  user's files (untouched)
-└── interf/
-    └── {knowledge-base-name}/  knowledge base
-        ├── interf.json         type: knowledge-base, workflow, name, source.path
-        ├── AGENTS.md           bootstrap
-        ├── CLAUDE.md           Claude Code bootstrap mirror
-        ├── workflow/           local workflow package
-        ├── home.md             entry point
-        ├── .interfignore       source exclusion patterns
-        ├── .gitignore
-        ├── .interf/            hidden runtime state
-        │   ├── state.json
-        │   ├── health.json
-        │   ├── source-access.json
-        │   └── view-spec.json
-        ├── summaries/          per-file evidence objects
-        ├── knowledge/
-        │   ├── entities/
-        │   ├── claims/
-        │   └── indexes/
-        └── interfaces/
-            └── {name}/         task-specific interfaces for specific jobs
-```
-
-Knowledge bases are created by `interf create knowledge-base` from the source folder. The source folder is the human control plane. The knowledge base is the generated workspace. One source folder can host multiple named knowledge bases under `interf/` when you want to compare workflows over the same folder.
-
-Contract model:
-- `type` = engine object kind in config/schema (`knowledge-base`)
-- `workflow` = user-facing methodology selection
-- `.interf/stage-contract.json` = generated per-run contract for the active stage
-- executor = the agent/runtime that implements the active stage
-
-## Processing flow
-
-```text
-cd source-folder
-interf create knowledge-base   → creates ./interf/<knowledge-base-name>/
-interf compile:
-  Step 1/2: summarize source files into evidence objects → summaries/
-  Step 2/2: compile cross-file knowledge + retrieval     → knowledge/ + home.md
-```
-
-## Workflows
-
-Shipped knowledge-base workflows:
-- `interf`
-- `karpathy`
-
-Create new reusable workflows from the wizard when you want a named local variation.
-
-The selected workflow is written to `interf.json` and can seed starter local `workflow/` docs.
-
-## Bundled stage skills
-
-| Skill | Step | What |
-|---|---|---|
-| `knowledge-base/summarize` | 1/2 | Generate source-grounded evidence objects for unprocessed source files |
-| `knowledge-base/compile` | 2/2 | Build the cross-file knowledge layer and retrieval structures |
-
-## interf.json
-
-Minimal config. Points to the source folder:
-
-```json
-{
-  "type": "knowledge-base",
-  "name": "my-notes",
-  "workflow": "interf",
-  "source": {
-    "path": "../.."
-  }
-}
-```
-
-`workflow` records the selected methodology. Interf generates per-run stage contracts from it for this knowledge base.
-
-If you want different stage behavior or domain bias, use a workflow and local `workflow/`.
-If you want a different stage graph, proof model, or required artifacts, that is effectively a new workflow.
-
-`AGENTS.md` is the source of truth. `CLAUDE.md` is a generated mirror so Claude Code picks up the same knowledge-base instructions automatically.
-
-`workflow/` is where you can edit knowledge-base-local instruction docs:
-- `workflow/README.md`
-- `workflow/create/SKILL.md`
-- `workflow/use/query/SKILL.md`
-- `workflow/compile/stages/summarize/SKILL.md`
-- `workflow/compile/stages/compile/SKILL.md`
-
-Simplest pattern:
-- edit `workflow/compile/stages/summarize/SKILL.md` to change summarize logic
-- edit `workflow/compile/stages/compile/SKILL.md` to change knowledge-base compile logic
-- edit `workflow/use/query/SKILL.md` to change the manual query loop
-
-Workflow seeds may already place starter docs in these folders. Treat them as editable local guidance, not as locked system files.
-Use `AGENTS.md` for navigation, command usage, and the manual access checklist. Use `workflow/` for query behavior and stage behavior.
-
-These are the local instruction layer for the knowledge base. Add JSON frontmatter with `mode: extend` or `mode: override` when you want to declare whether a doc should add to or replace the bundled stage instructions for that stage.
-
-Interf still enforces the same proof contract, artifact schema, and state flow either way.
-If you need a different stage chain, artifact contract, or verifier flow, create a new workflow in the SDK instead of encoding that in local skill docs.
-
-If your coding agent is sandboxed to the current directory tree, launch it from the source folder so both raw files and this knowledge base stay reachable.
-Use `.interf/source-access.json` to verify that raw files are actually reachable before you depend on raw fallback in a manual agent session. `suggested_checks` are canonical absolute file paths so they still work from nested interface folders.
-
-## Status
-
-Knowledge bases maintain runtime artifacts under `.interf/`:
-- `state.json` — mutable runtime state
-- `health.json` — computed trust surface for summarize/compile status
-- `source-access.json` — raw-file access quick check for manual sessions
-- `run.json` — current or last deterministic stage run
-- `stage-contract.json` — machine-readable contract for the active stage
-- `run-history.jsonl` — append-only history of completed runs
-- `view-spec.json` — viewer-neutral layout contract
-
-`interf status` is read-only and deterministic. It runs source discovery, checks config, summary frontmatter, abstract minimums, and broken wikilinks.
-Use `interf verify summarize --json` after summary generation and `interf verify compile --json` after knowledge-base compilation for explicit pass/fail checks when testing the workflow or driving it from an agent.
-
-See `docs/runtime-contract.md` for the human-readable contract and `src/lib/schema.ts` for the exact runtime schemas.
-
-## Scan accountability
-
-`knowledge-base/compile` writes an inventory of all `summaries/` files before scanning. The scanned count must equal the inventory count. If it does not, the skill stops and reports the gap.
-
-## Reset
-
-```text
-interf reset compile   remove knowledge/, keep summaries/
-interf reset all       remove all generated content, preserve source files
-```

package/templates/knowledge-base/interfignore

@@ -1,19 +0,0 @@
-# Files and directories to exclude from interf source discovery.
-# Same syntax as .gitignore.
-
-# Build artifacts
-dist/
-build/
-out/
-
-# Logs and temp files
-*.log
-*.tmp
-
-# Environment and secrets
-.env
-.env.*
-
-# OS files
-.DS_Store
-Thumbs.db

package/templates/knowledge-base/registry.md

@@ -1,118 +0,0 @@
-# Interf Registry
-
-The registry at `~/.interf/registry.json` tracks all knowledge bases and interfaces on this machine. The CLI and skills read it to list knowledge bases, show status, and navigate between them.
-
-## Format
-
-```json
-{
-  "version": 5,
-  "knowledgeBases": [
-    {
-      "name": "market-intel",
-      "path": "/path/to/market-intel",
-      "workflow": "interf",
-      "created": "2026-03-30T14:00:00Z"
-    },
-    {
-      "name": "ops",
-      "path": "/path/to/ops",
-      "workflow": "karpathy",
-      "created": "2026-03-30T15:00:00Z"
-    }
-  ],
-  "interfaces": [
-    {
-      "name": "q2-launch-brief",
-      "path": "/path/to/q2-launch-brief",
-      "knowledgeBase": "ops",
-      "knowledgeBasePath": "/path/to/ops",
-      "workflow": "interf",
-      "created": "2026-03-30T16:00:00Z"
-    },
-    {
-      "name": "pricing-gap-review",
-      "path": "/path/to/pricing-gap-review",
-      "knowledgeBase": "market-intel",
-      "knowledgeBasePath": "/path/to/market-intel",
-      "workflow": "interf",
-      "created": "2026-03-30T16:30:00Z"
-    }
-  ]
-}
-```
-
-## Fields
-
-**Knowledge-base entry:**
-- `name` — short identifier
-- `path` — absolute path to knowledge-base root
-- `workflow` — selected methodology
-- `created` — ISO timestamp
-
-**Interface entry:**
-- `name` — short identifier
-- `path` — absolute path to interface root
-- `knowledgeBase` — name of the connected knowledge base
-- `knowledgeBasePath` — absolute path to the connected knowledge base
-- `workflow` — selected methodology (`interf` for the shipped default, or a local workflow id)
-- `created` — ISO timestamp
-
-## When it's updated
-
-| Action | Registry change |
-|---|---|
-| `interf create knowledge-base` | Adds a knowledge-base entry |
-| `interf create interface` | Adds an interface entry |
-| `interf compile` | Does NOT update registry |
-| manual cleanup / future remove command | Removes entry (does not delete files) |
-
-The registry stores static info only: names, paths, connections. It never stores processing status.
-
-## How status is computed (live, not stored)
-
-Processing status is always computed on demand from the filesystem:
-
-```
-For each knowledge base:
-  source_count = discover source files from source.path
-  summary_count  = count files in {path}/summaries/
-  pending      = source_count - summary_count
-  status       = pending > 0 ? "pending" : "compiled"
-
-For each interface:
-  state       = read {path}/.interf/state.json
-  knowledge_base_summary = count files in {knowledgeBasePath}/summaries/
-  stale           = knowledge_base_summary > state.knowledge_base_summary_count_at_last_compile
-  status      = stale ? "stale" : "compiled"
-```
-
-This avoids cached status going stale. Always compute fresh.
-
-## CLI output
-
-```
-$ interf list
-
-  Knowledge Bases
-  ─────────────────────────────────
-  market-intel  1,240 files    compiled
-  ops             892 files    3 pending
-
-  Interfaces
-  ─────────────────────────────────
-  q2-launch-brief      → ops            compiled
-  pricing-gap-review   → market-intel   stale (12 new)
-```
-
-## Creation
-
-`interf create knowledge-base` or `interf create interface` creates `~/.interf/` and `registry.json` if they don't exist yet. The initial registry:
-
-```json
-{
-  "version": 5,
-  "knowledgeBases": [],
-  "interfaces": []
-}
-```

package/templates/workflow-package/README.md

@@ -1,16 +0,0 @@
-# {{workflow_label}}
-
-This is the local {{target_type}} workflow package. Interf uses it when you run `interf compile`.
-
-- `workflow.json` defines the stage graph and contract kinds for this workspace.
-- `create/` explains what the scaffold/setup step produces.
-- `compile/stages/` contains one stage folder per compile stage.
-- `use/query/` explains how to use the compiled knowledge base or interface in manual agent sessions.
-
-Workflow id: `{{workflow_id}}`
-Method: {{workflow_hint}}
-
-Compile stages:
-{{stage_lines}}
-
-Interf CLI remains the referee for contracts, proofs, validators, and runtime state under `.interf/`.

package/templates/workflow-package/create/SKILL.md

@@ -1,8 +0,0 @@
-# Create
-
-This doc explains what Interf scaffolded for the selected {{target_type}} workflow.
-
-- selected workflow: `{{workflow_id}}`
-- method: {{workflow_hint}}
-- the CLI owns create-time validation, folder creation, config writing, and bootstrap docs
-- edit this workflow package after scaffold if you want to refine how later compile/query behavior works

package/templates/workflow-package/interface-query/SKILL.md

@@ -1,29 +0,0 @@
-# Interface Query
-
-{{top_preflight}}
-Use this skill when answering questions from inside this interface in a manual agent session.
-AGENTS.md should route manual questions here before an agent starts browsing notes on its own.
-Treat this as the interface-local query layer, not a replacement for the parent knowledge-base query loop.
-This is a workspace-local query doc, not a required globally installed slash-command skill.
-
-Default loop:
-- start with `AGENTS.md`, then `home.md`
-- browse local `knowledge/`, `briefs/`, and local `summaries/` first
-- answer direct target questions from the hero brief before widening scope
-- follow wikilinks and backlinks outward before treating one note as complete
-- if local interface artifacts are insufficient, load and follow the parent knowledge-base query guidance at `../../workflow/use/query/SKILL.md` before going raw
-- use parent knowledge-base artifacts in this order: `../../home.md`, then `../../knowledge/`, then `../../summaries/`
-- when a caller asks for a trace, audit log, or `artifacts_consulted` list, record local `workflow/use/query/SKILL.md` after you inspect it
-- when you climb to the parent knowledge-base query loop, record `../../workflow/use/query/SKILL.md` after you inspect it
-
-First-reply rule:
-{{first_reply_rule}}
-
-Task bias:
-- reuse the exact metric and period words from the question
-- if the target ledger marks a value approximate, say the literal word `approximate`
-- if the target ledger marks a value chart-derived or table-derived, say that literally
-- prefer the target ledger's `bin_choice` when the question is bin-shaped, and the `value_display` when the question asks for the approximate reading itself
-- do not add raw-access commentary unless the question asks about raw access
-
-Keep the interface-specific routing here. Keep raw-source, PDF/chart, and general fallback policy in `../../workflow/use/query/SKILL.md`.

package/templates/workflow-package/interface-stage/SKILL.md

@@ -1,13 +0,0 @@
----
-{
-  "mode": "extend"
-}
----
-# {{stage_label}}
-
-This workflow stage customizes the built-in {{contract_type}} contract for the `{{workflow_id}}` interface workflow.
-
-- purpose: {{stage_description}}
-{{stage_notes}}
-
-Interf still enforces the same contract reads, writes, coverage proof rules, validators, and runtime reconciliation for this stage.

package/templates/workflow-package/knowledge-base-query/SKILL.md

@@ -1,36 +0,0 @@
-# Knowledge Base Query
-
-{{top_preflight}}
-Use this skill when answering questions from inside this knowledge base in a manual agent session.
-AGENTS.md should route manual questions here before an agent starts browsing notes on its own.
-This is the canonical parent-knowledge-base query loop that attached interfaces can inherit before raw fallback.
-This is a workspace-local query doc, not a required globally installed slash-command skill.
-
-Default loop:
-- start with `AGENTS.md`, then `home.md`
-- browse `knowledge/` indexes, entities, and claims first
-- follow wikilinks and backlinks outward before treating one note as complete
-- use `summaries/` for deeper evidence
-- use raw source files only when needed for verification, direct quotes, ambiguity, or missing context
-- when a caller asks for a trace, audit log, or `artifacts_consulted` list, record `workflow/use/query/SKILL.md` after you inspect it
-
-Raw-source gate:
-- inspect `.interf/source-access.json` before depending on raw files
-- actually open and inspect at least one `suggested_checks` path before claiming raw-file verification; a plain existence check is not enough
-- if raw files are not reachable, say the answer is based on compiled knowledge-base artifacts only
-- when the question depends on exact figures, direct quotes, chart values, table values, or image-derived evidence, raw inspection is required before answering confidently
-
-PDF / chart rule:
-- if the source is a PDF, deck, or report and the needed evidence may live in charts, tables, or figures, do not assume the default text layer or existing notes captured everything
-- if summaries do not preserve the needed numeric detail, inspect the raw source and say whether the value was text-derived, table-derived, or chart-derived
-- opening the PDF with `Read` is not enough for an exact-value chart question; take a machine-readable extraction path before answering
-- choose that extraction path from the local environment you actually have instead of assuming specific tools
-- verify the chosen local extraction path is actually available before depending on it; if it is missing, switch once to another available local path
-- if the first local extraction method misses the number, attempt another local recovery path before settling for a visual estimate
-- if the chart does not expose exact numbers as text, say that clearly instead of pretending the compiled notes were sufficient
-- if you can only estimate from the chart, label the answer `approximate` and keep the precision gap explicit
-
-First-reply rule:
-{{first_reply_rule}}
-
-You can edit this file to bias manual question-answering behavior without changing workflow stage logic.

package/templates/workflow-package/knowledge-base-stage/SKILL.md

@@ -1,13 +0,0 @@
----
-{
-  "mode": "extend"
-}
----
-# {{stage_label}}
-
-This workflow stage customizes the built-in {{contract_type}} contract for the `{{workflow_id}}` knowledge-base workflow.
-
-- purpose: {{stage_description}}
-{{stage_notes}}
-
-Interf still enforces the same contract reads, writes, proof rules, validators, and runtime reconciliation for this stage.

package/templates/workflow-starters/interface/interf/README.md

@@ -1,13 +0,0 @@
----
-{
-  "mode": "extend"
-}
----
-# Interf Interface Workflow
-
-Bias this interface toward the concrete user task, durable evidence routing, and answer-ready outputs.
-
-- turn the requested task into a bounded target set before broadening scope
-- preserve named entities, periods, metrics, units, and comparators instead of collapsing them into generic prose
-- when exact values matter, keep text-derived, table-derived, and chart-derived evidence distinct
-- prefer one concise hero brief and the smallest supporting note set that lets weaker agents answer reliably