control-surface // _INDEX project template

_INDEX-<project> // GPT Source Index (template)

templates/_INDEX-project.template.md · 12806 B · source sha256 cdb8ccec493f

This is a copyable master for a project's source index / path map — the retrieval map an advisor surface fetches live at the exact locator its mounted bootstrap declares. Adapt it per project. The template lives in the protocol repo.

Mount posture. In healthy connector mode this file is not mounted. The advisor Project's single standing Markdown Source is that surface's bootstrap (templates/advisor-project-bootstrap.template.md); the bootstrap carries this index's exact locator and fetches it live, so an ordinary index revision needs no remount. Mount a copy only as connector-failure fallback, and retire it when live access returns. A mount receipt proves identity from the mounted body, and the fields available depend on which carrier is mounted: three operating modes across two carrier families — carrier families bootstrap-mounted and index-mounted; operating modes healthy bootstrap, connector-failure fallback, and A10 rollback. Healthy mode (bootstrap receipt): standing-source cardinality (exactly one, and this index not among the mounts); expected surface identity read from the mounted bootstrap — its expected H1 / role and the exact INDEX_CANONICAL_LOCATOR naming this index, since another surface's current bootstrap satisfies count and version while pointing at a different index; and the intended revision, proven by in-body version and a distinguishing clause, in a fresh thread. In either of the two mounted-index modes below this file is the mounted carrier, and it holds neither an INDEX_CANONICAL_LOCATOR field nor a bootstrap version banner — so verify it by what it does carry. The two modes are different operating states and must not be merged. Connector-failure fallback (temporary): the thin Instructions field is unchanged and the bootstrap stays mounted, so the expected Source set is bootstrap + this fallback copy. Prove this index's own H1 / surface / role plus one distinguishing mapped path or clause in a fresh thread; no full Instructions canonical is repasted and no rollback is invoked or inferred; retire the copy once live access returns. A10 rollback (architecture change): the frozen full Instructions canonical is repasted and the frozen index mounted, and both evidence planes are required — operator-side installation evidence: the expected rollback Source set and cardinality, the exact frozen full Instructions canonical identity, and the exact frozen index identity where byte identity is load-bearing; fresh-thread evidence: this index's own H1 / surface / role plus one distinguishing mapped path or clause, and the restored behavior. A fresh thread cannot establish what was pasted into the Instructions field — a behavioral pass is never proof of the repasted canonical's bytes. Mounted-source display labels are inspection metadata, not source identity: supporting evidence for selection only in any mode, never sufficient for cardinality, expected identity, or revision, and a host-added (N) decoration proves neither duplication nor wrong bytes. The placement contract is owned by docs/advisor-project-surface-architecture.md.

Instantiate as (angle brackets resolve to real names — do not keep them in the actual filename):

<project>-EXTERNAL/_INDEX-<project>.md

For role-specific advisor surfaces (e.g. an operator-facing vs. a domain-reviewer-facing project), instantiate one per role:

<project>-EXTERNAL/_INDEX-<project>-<role>.md

Keep this file generic when adapting: fill the tables with the project's own canonical paths, delete the example rows, keep the read-path hierarchy + wall rules. Do not copy another project's full path set in.

on this page

A map, not a mirror

This index maps canonicals — it does not carry copies of them. The canonicals stay live in Dropbox; the advisor fetches the current file at its exact path. Mounted or uploaded copies of canonicals, if any remain, are fallback only (connector-failure resilience) — never the live truth.

The same rule now applies to this file itself. It is fetched, not mounted: the mounted bootstrap declares its exact locator, and the advisor retrieves the current version each thread. That removes the last mount-refresh obligation — an ordinary path or status change here reaches every advisor surface with no UI operation at all.

Read-path hierarchy

Repo truth → GitHub / local git (authoritative; unchanged).
Operator-side canonicals (*-EXTERNAL/ root notes · trackers · scratch/ · the surface's current intent inbox) → the Dropbox connector by exact path, when available (preferred live read path).
Uploads / mounted copies → fallback only, when the connector is absent or a file is unreachable.
Web → public external sources only.

Dropbox bases / aliases

Define short aliases so the path tables stay readable. Typical bases (adapt to the project):

S/ = /studio/studio ASK/                                    (studio-side, shared)
P/ = /Andrew Klug/personal-ASK/inheritable/                 (wall-safe inheritable layer — ONLY if the surface is authorized for it)

Add or remove bases per project. A cross-user surface may reach only a subset (e.g. a shared /studio/… tree but not another user's private namespace) — name only the bases this surface can actually resolve.

Canonical path table

List only the paths this surface is authorized to read. Give each a status class so the advisor knows what it may treat the file as.

File	Path	Status class
File<project> grounding note	Path`S/<project>-EXTERNAL/<project>_grounding-note.md`	Status classroot canonical
File<project> article / domain tracker	Path`S/<project>-EXTERNAL/<project>-articles.md`	Status classroot canonical (example — delete if N/A)
Fileworking index / corpus-state	Path`S/<project>-EXTERNAL/scratch/…_<project>_<index>.md`	Status classworking index (resolve-latest by glob, not a pinned date)
Fileintent inbox (intake)	Path`S/<project>-EXTERNAL/<the surface's current live intake path>`	Status classcandidate / ingestion — two axes: the underlying filename carries role plus the primary durable-state marker (`-ingested` read-but-not-closed · terminal disposition suffix · `-supersededA` retired before ingestion · `-supersededP` ingested-then-displaced), while terminal `-TBI` is independent feed-obligation evidence — not a disposition, and excluded from the disposition-agreement check. A disposition or lineage record must agree with the underlying durable-state marker, never with terminal `-TBI`. The folder alone does not establish queue membership. Post-cutover convention is `intent-INbox/`; the live path above governs until this surface's cutover is recorded
Fileinbox state (post-cutover only)	Path`S/<project>-EXTERNAL/intent-INbox/_STATE.md`	Status classstructural — not routed intent: no lifecycle suffix, excluded from queue counts, updated in place, read immediately before ingestion. `OPEN` = no additional hold, ordinary governed ingestion proceeds · `FROZEN` = no routed artifact ingested unless its exact filename is an exception · `PARTIAL-HOLD` = the named held scope is blocked absent exact-filename exceptions, unrelated scope stays governed normally. Exceptions are exact filenames or explicitly `NONE`; the record also carries scope, the ASK authorization locator, effective time, and a review trigger. A structural artifact is exempt only where this contract names it — a leading `_` alone confers nothing. Before cutover its absence is not nonconformance; once declared active, unreachable or malformed state fails closed for ingestion
Filescratch	Path`S/<project>-EXTERNAL/scratch/`	Status classfetch named artifacts only (`-PROPOSED` review objects/bundles, `_vN` snapshots, absorption/closure memos)

Status classes: root canonical · candidate / intake · working index · scratch / snapshot · reference-only (available cross-domain context the project has not absorbed — consult if a task needs it; not this project's doctrine). The shared-protocol rows below additionally use owner canonical · normative registry · coordinator canonical.

(Add cross-system masters, inheritable/brand paths, or shared protocol files only if this surface is authorized for them and the project actually consumes them. Mark consumed vs. reference-only explicitly.)

Shared execution-protocol architecture

(Required when the project's AGENTS.md resolves the ASK shared execution protocol. Delete this subsection only for a project that does not.)

File	Path	Status class
Fileshared-protocol owner model	Path`apexSolarKiss/control-surface/protocol/README.md`	Status classowner canonical
Fileshared execution-protocol body	Path`apexSolarKiss/control-surface/protocol/AGENTS.shared.md`	Status classowner canonical
Filenormative protocol manifest	Path`apexSolarKiss/control-surface/protocol/manifest.json`	Status classnormative registry
Filecross-repo propagation runbook	Path`apexSolarKiss/control-surface/prompts/cross-repo-propagation-wave.md`	Status classcoordinator canonical
Filelive protocol-consumer state	Path`<authorized operator-side path>/control-surface_protocol-consumer-ledger.md`	Status classroot canonical — live state

These rows are mandatory for a project whose AGENTS.md resolves the shared ASK carrier. The advisor instructions require these files for any question about rule placement, AGENTS.md / CLAUDE.md, private agent memory, learning disposition, grants, or propagation; an index without the rows leaves the advisor no route to them.
The four repo canonicals are fetched from GitHub / local git, not Dropbox.
Instantiate the ledger row only where this advisor surface is authorized to read that operator-side path. Omit the row rather than naming a path the surface cannot resolve.
Manifest is normative; the ledger is live state. Do not read either as the other.
This stays a map: fetch this index live at the bootstrap-declared locator; do not mount copies of the mapped files as current sources.

Wall + search-hygiene rules

Fetch only the paths named here, by ASK, by a grounding note, or by the active task.
Prefer fetch-by-exact-path; reserve keyword/connector search for genuine discovery. A broad connector search surfaces filenames from private / archive trees (a directory-listing leak) even where content reads are blocked — it can expose a private filename manifest. Default to the exact paths above; use search only to discover something not already mapped.
Any P/ (inheritable/) or other personal-side paths named above are the only authorized personal-side paths. Do not browse the personal root or any other private personal path — inheritable/ is wall-safe; the rest is not. On a cross-user surface, never point into another user's private namespace (a cross-namespace path resolves to not-found, which is the wall behaving correctly — read the user's own twin instead).
Path resolution ≠ content read. Successful content read into active context is ingestion. Ingestion ≠ disposition / absorption / canonicalization / promotion. Content read ≠ exact-byte identity proven. Header + path govern status (scratch stays scratch, a root canonical is canonical only in its owning surface). For a fresh routed handoff awaiting first ingestion, -TBI remains until successful content read is recorded by -ingested, or ASK retires the artifact before ingestion through -supersededA; for anything else the same read removes -TBI only, leaving the underlying filename unchanged. Establish governed role and prior lifecycle state before feeding — where either is unresolved, stop rather than resolve either branch. A metadata-only retrieval is not a content read; a lossy or normalized view may be a content read under a bounded-fidelity claim, but never counts as exact-byte evidence and is not adequate where the omitted portion could affect classification.
Connector access is read / verify only — capability is not authorization. A connector may expose write actions (a GitHub connector: commit / branch / open-close-merge PR / comment / auto-merge; a Dropbox connector: file save / move / routing); none are authorized on an advisor surface. Use connectors only to fetch named files, read exact PRs / diffs / state, and verify relayed claims; every write routes through the executor on the operator's relay (see the advisor Project Instructions §Connector boundary).
If a path is unreachable, say so and stop — never substitute a weaker source while calling it verified.