lockedin-capture

name: lockedin-capture description: | Converts in-session capture intents ("save this", "log this", "track this", "absorb this") into structured vault entries via a two-turn writer/reviewer pattern with duplicate detection and reconciliation. Writer proposes entity/edge structure; reviewer scores against five rubric dimensions and surfaces duplicate candidates for user decision.

Activate when the user signals explicit capture intent from their current work session, or after a successful ingest where new entities are being proposed. Also activate when the user says "remember this", "capture this", "add this to my vault", or describes something they just shipped, learned, decided, or discussed.

Dedicated capture skill for in-session work moments. Promotes capture from an implicit sub-role of the main lockedin skill into a first-class calibrated flow with its own writer/reviewer contract, matching the rigor of lockedin-render-jaso and lockedin-render-resume-en.

Capture quality determines vault quality. Vault quality determines render quality. This skill owns that first link.

Use this skill when

The user says "save this", "log this", "track this", "absorb this", "remember this", "capture this", or "add this to my vault".
The user describes a thing they just did: shipped a feature, attended a meeting, made a decision, learned something, completed a project milestone.
The user pastes notes, a git log excerpt, a PR description, a Slack summary, or any short text and says to save it.
The main lockedin skill detects capture intent during a session and routes here.

Do NOT use this skill when

The user is doing coding, debugging, or writing without any signal that they want to persist the work moment to the vault.
The user asks to render an artifact (resume, jaso, ideas) — route to the appropriate render skill instead.
The user wants to query their vault without adding anything — use the main lockedin skill's query flow.
The user wants to audit a document — use lockedin-audit.

Execution model

User input
    │
    ▼
1. Writer turn (prompt-writer.md)
   - Read user input + any provided context
   - Propose entity types, fields, edge structure
   - Run _infer_edges() mentally from EDGE_SCHEMAS domain/range
   - Quote source phrases from user input
   - Output: structured proposal (markdown table)
    │
    ▼
2. ValidatorDeterm (lockedin validate --dry-run)
   - Deterministic field-type and required-field check
   - Catches schema errors before LLM reviewer sees the proposal
    │
    ▼
3. Reviewer turn (prompt-reviewer.md) — SEPARATE Claude context
   - Re-load RUBRIC.md fresh (not from writer-turn memory)
   - Score 5 dimensions independently
   - Query vault for duplicate candidates (slug similarity, alias match)
   - Output: JSON score + candidates + suggested revisions
    │
    ▼
4. ReconcileNegotiator (if duplicates surfaced)
   - Present candidates to user as a numbered list
   - Ask one question: merge / update / create new
   - Never auto-merge, never auto-create-duplicate
    │
    ▼
5. write-before-confirm
   - State what will be written: "Saving 2 entries — meeting X, decision Y. OK?"
   - On confirmation: call write_entity for each proposed entity
   - Edges written atomically with entities

The write-before-confirm step applies even if the user has granted write permission earlier in the session. No silent vault mutations.

Rubric dimensions

Full definitions and score bands in RUBRIC.md. Summary:

Schema conformance — required fields populated correctly.
Edge completeness — all inferable edges from EDGE_SCHEMAS present.
Field specificity — values carry concrete information; no placeholders.
Semantic accuracy — entity types match the user's stated intent.
Duplicate detection + reconciliation — candidates surfaced and resolved with user; never silent-merge or silent-create-duplicate.

Pass criterion: every dimension >= 4, no silent duplicate creation.

Reconciliation policy

Never silent-merge: do not fold a new entity into an existing one without presenting the match and asking the user.
Never silent-create-duplicate: do not write a new entity when a candidate with matching slug, name, or aliases already exists in the vault without asking the user first.
Surface candidates: when the vault has a likely duplicate (slug-distance <= 2, same type, matching name or alias), present it as: "I found a possible match: [[type/slug]] — same project? Merge into it, update it, or create a separate entry?"
One question, one candidate at a time: if multiple duplicates exist, handle them sequentially.

Output

After the writer/reviewer cycle and user confirmation:

Confirmed vault entries, one markdown file per entity under <vault>/experience/<type>/<slug>.md.
Edges encoded in each entity file's links: frontmatter block.
EXPERIENCE.md regenerated at the vault root (auto via write_entity).
Reviewer JSON score stored at <vault>/metrics/capture/<iso-timestamp>.json for drift tracking.

Files in this directory

SKILL.md            (this file)
RUBRIC.md           5 dimensions; score bands; fixture authoring guide
prompt-writer.md    writer-turn instruction
prompt-reviewer.md  reviewer-turn instruction (separate Claude context)
AGENTS.md           four agents: Writer, ValidatorDeterm, Reviewer, ReconcileNegotiator
TOOLS.md            deterministic tools the skill uses
banned_phrases.json phrases that indicate low-quality field values
research-notes.md   sources informing capture design rationale