Vc Init

Invocation for vc-init (launcher init)

Same three-path shape as the fleet, with this skill's literals — see the canonical Delegation Matrix:

• Shared three paths
• Launcher catalogue
• Per-launcher rule
• Native vs external

Path	Literal for this skill
1. User-launched worker	vibecrafted init [agent] / vc-init
2. Interactive	/vc-init — execute in this session; use native subagents when required; do not externalize merely because a launcher exists
3. Agent-operator	may dispatch the worker form above via vc-dispatch / operator lines while preserving this skill's identity

Note: Orientation gate, not a write pipeline. Worker form is vibecrafted init [agent].

Freer native on some runs ≠ abandon external fleet. vc-dispatch and vc-ship keep their own identities.

vc-init — Technical Due Diligence

Due diligence is the investor's move: before you commit capital to an asset, you investigate it on evidence — surface hidden liabilities, verify the pitch, grade the risk — so the decision is priced, not hoped. Here the pitch is the README and the founder's belief that it works; the asset is the live code. vc-init is that investigation at session entry: see what the code IS now, recover why it became that, find what is taped together, and grade the risk — so every later move is priced. It is read-only orientation, the entrypoint to all repo work.

vc-init (DD on the asset, at entry) and vc-dou (DD on the product, at exit, from the buyer's frame) are the same discipline at the two ends.

[HARD GATE] — materialize the atlas and READ IT TO THE END

The cheapest, fastest recon that exists is the Loctree context atlas read whole — empirically far cheaper than a recon agent and instant. Agents under-read; this gate exists because reading cannot be skipped.

1. Materialize the atlas: MCP context() (or loct context). It writes .loctree/context-atlas/ — a manifest.md plus cards.
2. Read manifest.md — it is the reading path (per-card why + saves-you-from) and the completeness rule.
3. Read the cards to the end, along the path. The manifest's own bar: a repo-level answer is INCOMPLETE until 00-core-map.md (synthesis: identity, risk, authority, safe commands), 01-structural-map.md (files/symbols/ imports/consumers), and 02-runtime-map.md (runtime/env/reachability) are read. Also read 05-risk-register.md (hotspots/fan-in/health). Cards are separate files precisely so none overflows — read each whole.

Do NOT stop at the first card or the first screen. The synthesis and the risk register are distinct cards; a partial read is a blind start. You have not run init until the completeness bar is met.

CLI fallback when MCP is unavailable: loct context --full --markdown and read the WHOLE pack (its synthesis is at the end — read past the tables).

Scope drill-down — same budget, concentrated

The whole-repo atlas is recency-weighted on a fixed ~800-line budget, so stale or peripheral subsystems get cut. Before working inside a specific subsystem X, read its scoped pack — this is not narrowing, it is deeper coverage of X at the same cost:

loct context --scope 'path:<X>' --task '<what you are doing>' --markdown
# pre-baked shelf, when present:
cat .loctree/context/scopes/path/<X>/context-compact.md

Reading the right scoped pill recovers exactly the surfaces the whole-repo atlas dropped — at ~12s and near-zero tokens, instead of dispatching a recon agent.

The Triad of Diligence

Perception — over memory

The atlas is primary perception. Read authority labels before trusting a claim: repo_verified (snapshot fact) > loctree_derived (analyzer inference) > aicx_operator / aicx_agent (prior intent/outcome) > aicx_failure (a path that already failed — don't repeat) > semantic_guess (heuristic — verify) > stale_or_unknown (re-check). Drill with slice (before edit), impact (before delete), find --literal / occurrences / body (reference truth), follow (dead/cycles/twins/hotspots). Pass project= explicitly per repo — the MCP default is not your cwd.

Intentions — retrieval, not RAG

aicx intents -p <project> + aicx_search/aicx_steer: recover why the architecture is shaped this way and what duct-tape was applied late at night. Retrieve the decision context, then verify its current truth against perception.

The fleet's paid-for experience is part of this sense: before dispatching, resuming, or recovering external runs, check the Runtime Feedback Ledger for the commands you are about to use (aicx search -p vetcoders/vibecrafted '<command>' reaches the same doctrine as retrieval). Repeating a mistake the ledger already prices is a process failure, not bad luck.

Ground truth — over intuition

• Git history: vc-git (or git log --graph -n 15 + git status -sb).
• Read .claude/CLAUDE.md / .codex/AGENTS.md / AGENTS.md; if a config contradicts the code, trust the code.
• Due-diligence red flags: god tables with no indexes; auth where everyone is admin/user with no row-level security; .env tracked in git; silent failures.

Output — grade the risk

Init's deliverable is a priced picture: what is load-bearing (hubs/fan-in), what is fragile, what is a landmine — so the next action is taken with eyes open.

.env policy

Never commit .env* (gitignored; pre-commit blocks it). Report leaks → revoke fast. Work with .env locally without anxiety — hesitating to use it locally is itself a future vulnerability.

Anti-Patterns

• Acting before the atlas is read to the completeness bar (blind start).
• Stopping at the first card/screen — the risk register is a later card.
• Trusting the MCP default project instead of passing it (silent wrong-repo).
• Reflex grep/find before context()/find — you lose authority labels and reverse deps.
• Dispatching a recon agent for what a scoped context --scope answers for free.
• Claiming "production-ready" off a green test on an unexamined architecture.
• Writing "ran the tests" without running them.

Living Tree

Run in the operator's current checkout and branch; no worktree unless asked. Re-read before editing; if the tree moved under you (doctor() fingerprint), re-issue context(fresh: true). If the substrate is too poisoned to continue, stop and report it.

"See the asset. Recover the intent. Verify the ground. Grade the risk. Then act."

𝚅𝚒𝚋𝚎𝚌𝚛𝚊𝚏𝚝𝚎𝚍. with AI Agents by Vetcoders (c)2024-2026 LibraxisAI