원클릭으로 Manus에서 모든 스킬 실행

author-ingest

스타2

포크0

업데이트2026년 7월 13일 09:54

Ingest repo-local source material into un-id'd reference/ files plus grounding metadata, without touching the web. Handles both the `research` kind (a citable KB shaped as markdown + references.yaml + CONFIDENCE markers, e.g. from the deep-research workflow) and the `document` kind (any plain repo file — md/html/txt/yaml/csv/json). Distils the material's *facts and insights* (never its structure or verbatim prose) into reference/, tagging each with a resolvable grounding ref. Trigger when the user says "ingest", "bring in this source/material/corpus", "turn these docs into reference material", or "/author-ingest". Spawns material-extractor.

설치

Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.

Manus에서 실행

출처

mtrense

mtrense/skills

GitHub 저장소 열기 Creator 저장소 보기

다운로드

Manus에서 실행

author-ingest — source material → reference/ + grounding

You turn repo-local source material into the author-only reference/ layer the drafting skills draw on, and record where each fact came from as a grounding ref. This is the base layer of the research→bulk pipeline (AUTHORING_SKILLS.md §5.A).

Keep your own context lean — you never read the source yourself

The source corpus is read once, inside material-extractor, and stays in its context. It returns both the units manifest and the write-ready reference/ file bodies. You write those bodies verbatim; you do not open the source files in your own context to "check" or "enrich" them — that re-read is exactly what makes this skill blow past its token budget. If a returned body looks wrong, send the extractor back with a correction, don't pull the source in yourself. Your context holds only the manifest, the file bodies as you write them, and the ingest-state manifest.

Scope — read repo-local material, never the web

author-ingest reads files already in the repo and never fetches from the web. Any web work happened upstream, when the material was produced (e.g. by the deep-research skill). If the user wants a fresh online article folded in, that is the graft on-ramp (author-graft), not this.

Two kinds, one path — detect the metadata

Spawn material-extractor on the source root (pass the track goal if you have one — it lets the extractor scope the ingest). It reads the KB's INDEX.md first to triage against the goal and reads full chapter bodies only for the chapters in scope — it never slurps the whole tree. It classifies the corpus and returns, per file, the write-ready reference/ body plus a lightweight units index (candidate prerequisites, why-it-matters hooks, source line refs, grounding_ref + confidence per unit) and a provenance block for the ingest-state manifest.
- Small / goal-scoped corpus — one material-extractor call. Its cross-file dedup and candidate_prerequisites linking are strongest when it sees everything in scope at once.
- Large corpus (many in-scope chapters / subtrees) — fan out in parallel: split the in-scope tree (use the index to pick natural boundaries) into per-file or per-directory batches and issue one Agent call per batch in a single message. Each returns its own bodies + units index; write each batch's reference_files as they come back (don't hold them all), then merge only the lightweight units index in this session — concatenate the unit lists, dedup units that restate the same claim, and reconcile candidate_prerequisites across batches (a prereq named in one batch may be defined in another). Only the compact index is merged here, never the full bodies, so the merge stays cheap. Prefer directory-aligned batches so a batch's candidate_prerequisites mostly resolve within it. If the extractor reports chapters it skipped as out-of-goal-scope (in its notes), surface that list to the user before writing — a one-line "ingested X chapters, skipped these N as out-of-scope: …" — so they can pull any back in. Don't silently drop KB regions.
Set grounding.source from what it found (whether one call or a merged fan-out):
- research kind — the material carries references.yaml +  markers and heading anchors. Lift citations and confidence forward verbatim; refs are research:<path>#<heading-anchor>. This is the honest, high-credibility base layer.
- document kind — plain files with no citation metadata. Refs are doc:<path>@sha256:<hex>; assert an honest confidence (medium/low is legitimate — not every internal fact has a citable source, and the contract records that rather than faking one).

What to write

Write each reference_files body the extractor returned, verbatim, to its path (author-only — no id, so the CLI excludes it from the snapshot). The distillation, register change, and heading structure are already done inside the extractor; your job is to land them, not redo them. Do not re-open the source to "improve" a body — see the lean-context rule above.
Heading structure in those bodies already matches the anchors, so research:<path>#<anchor> refs resolve — the CLI existence-checks the anchor against a real heading (TRACK_STRUCTURE.md §5.6). For a verbatim_keep entry (a document-kind file kept for doc:@sha256 refs), leave the original file byte-for-byte (the hash must match) — write nothing.
Do not draft learner-facing nodes here, do not build the DAG, do not mint ids. Output is reference material + a manifest of units and their grounding refs for author-structure.
Record an ingest-state manifest at reference/.ingest-state.yaml so the delta-aware author-ingest-update can later tell what changed: source_root (where the ingested source lives), grounding_kind, ingested_through (git rev-parse HEAD — the source commit this ingest reflects, or (no git)), ingested_at, and a provenance list mapping each upstream source file → its distilled reference/ file → the grounding refs it produced. Assemble provenance from the provenance blocks the extractor returned (concatenated across batches), not by re-reading source. Skip only if the repo has no git.

Grounding refs you emit (must later validate — §5.6)

kind	grammar	CLI check downstream
research	`research:<path>#<heading-anchor>`	file + heading exist
document	`doc:<path>@sha256:<hex>`	file exists and bytes hash to `<hex>` (CLI computes hash — you leave a placeholder)

You do not compute hashes. Emit doc:<path>@sha256:<PLACEHOLDER>; the node's real hash is filled when the referenced file is stable, and author-selfcheck catches any mismatch.

Hand-off

Produce: (1) reference/ files, (2) a units manifest {claim, why_it_matters, candidate_prereqs, grounding_ref, confidence}, (3) reference/.ingest-state.yaml (above). Point the user at author-structure next. When the source material later changes, /author-ingest-update refreshes reference/ incrementally from a commit range rather than re-running this from scratch. Do not commit or push.

이 저장소의 다른 Skills

같은 저장소

architecture-foundation

mtrense/skills

Facilitate a Socratic session that defines a project's architectural foundation — the boundaries and guidelines every later task is built against — once vision.md, domain-model.md, and context-map.md exist. Opens the agenda with the domain model's still-open hotspots — the last gate where each must be resolved, explicitly parked, or reclassified before the build phase — then works general → specific: tech stack (languages/frameworks/runtimes), persistence/data stores, then communication & integration between contexts, testing principles, and cross-cutting concerns (error handling, observability, security, configuration, versioning, deployment). Seeds an agenda with the architecture-proposer subagent, then decides each item Socratically and records it as an ADR — which keeps the crisp per-topic summaries under architecture/ in sync. Where a decision is bound to a specific artifact, environment, or bounded context, makes that explicit. Closes a first run by proposing a walking-skeleton task — one thin vertical

2026-07-162

context-mapping

mtrense/skills

Draw the project's bounded contexts and the relationships between them, working from the aggregate clusters in domain-model.md. Produces context-map.md (the overview + relationship map) and one bounded-contexts/<context>.md per context (its responsibility, boundary, relationships, and ubiquitous language). Seeds a first-pass boundary proposal with the boundary-proposer subagent, then refines it with the human. Offers to record boundary/relationship decisions as ADRs. Re-entrant: when context-map.md already exists it runs in revision mode — folding in what implementation taught (the `deviated`-flagged tasks' closing records), and ending with a backlog ripple pass that rewires or flags the live tasks a boundary change touched. The third phase of the domain-driven workflow; its contexts are the domain-compliance referent for every task.

2026-07-162

domain-model

mtrense/skills

Run a big-picture EventStorming session over the project vision and produce a single `domain-model.md` at the project root: a chronological domain-event timeline, the commands/actors that trigger them, policies and external systems, the aggregates that own consistency, and a hotspots list of unresolved decisions. Seeds the first pass with the domain-seed-extractor subagent, then refines it Socratically with the human. Offers to turn hotspots into ADRs. Re-entrant: when domain-model.md already exists it runs in revision mode, folding in what implementation taught (the `deviated`-flagged tasks' closing records) instead of re-storming from scratch. The second phase of the domain-driven workflow — its clusters feed /context-mapping.

2026-07-162

whats-next

mtrense/skills

Assess the project's vision, domain model, and context map against the current backlog state, surface the coverage gaps, and propose a prioritized list of next tasks to work on. Reads the domain artifacts directly and the backlog through the tasks.sh helper (frontmatter only — never scanning task bodies). Gaps include an unvalidated architecture foundation (ADRs recorded but no landed task exercises them end-to-end — proposes a walking-skeleton vertical slice first) and drift (deviated tasks routed to a /domain-model, /context-mapping, or /architecture-foundation revision). Advisory: it proposes tasks and, on approval, hands each to /task-append as a draft — it never mints ids, wires dependencies, or refines (that is /task-append and /task-refine). The forward-looking companion to the read-only /task-status board.

2026-07-162

task-cycle

mtrense/skills

Drive ready `todo` tasks to `done`. Reads the dependency-respecting ready-set from the tasks.sh helper, claims each task (todo -> in progress), and delegates implementation to a task-worker subagent (strict TDD, verify, commit). With one worker it works in-place sequentially; with more it implements in parallel git worktrees and delegates sequential merge-back to the integrator subagent (bounce-on-conflict). The orchestrator owns every status write. Takes [<limit>|all][@<workers>] (default all@1); resumable and idempotent.

2026-07-162

task-status

mtrense/skills

Read-only progress report for the domain-driven backlog. Runs the bundled tasks.sh helper to print a board — counts per status, the ready-set (todo tasks whose dependencies are all done), and what is blocked on what — derived live from the task files' frontmatter, never by scanning their bodies. The human-facing front end to the tasks.sh query surface every other domain-driven skill uses.

2026-07-162

name

author-ingest

description

author-ingest — source material → reference/ + grounding

Keep your own context lean — you never read the source yourself

Scope — read repo-local material, never the web

Two kinds, one path — detect the metadata

Spawn material-extractor on the source root (pass the track goal if you have one — it lets the extractor scope the ingest). It reads the KB's INDEX.md first to triage against the goal and reads full chapter bodies only for the chapters in scope — it never slurps the whole tree. It classifies the corpus and returns, per file, the write-ready reference/ body plus a lightweight units index (candidate prerequisites, why-it-matters hooks, source line refs, grounding_ref + confidence per unit) and a provenance block for the ingest-state manifest.
- Small / goal-scoped corpus — one material-extractor call. Its cross-file dedup and candidate_prerequisites linking are strongest when it sees everything in scope at once.
- Large corpus (many in-scope chapters / subtrees) — fan out in parallel: split the in-scope tree (use the index to pick natural boundaries) into per-file or per-directory batches and issue one Agent call per batch in a single message. Each returns its own bodies + units index; write each batch's reference_files as they come back (don't hold them all), then merge only the lightweight units index in this session — concatenate the unit lists, dedup units that restate the same claim, and reconcile candidate_prerequisites across batches (a prereq named in one batch may be defined in another). Only the compact index is merged here, never the full bodies, so the merge stays cheap. Prefer directory-aligned batches so a batch's candidate_prerequisites mostly resolve within it. If the extractor reports chapters it skipped as out-of-goal-scope (in its notes), surface that list to the user before writing — a one-line "ingested X chapters, skipped these N as out-of-scope: …" — so they can pull any back in. Don't silently drop KB regions.
Set grounding.source from what it found (whether one call or a merged fan-out):
- research kind — the material carries references.yaml +  markers and heading anchors. Lift citations and confidence forward verbatim; refs are research:<path>#<heading-anchor>. This is the honest, high-credibility base layer.
- document kind — plain files with no citation metadata. Refs are doc:<path>@sha256:<hex>; assert an honest confidence (medium/low is legitimate — not every internal fact has a citable source, and the contract records that rather than faking one).

What to write

Write each reference_files body the extractor returned, verbatim, to its path (author-only — no id, so the CLI excludes it from the snapshot). The distillation, register change, and heading structure are already done inside the extractor; your job is to land them, not redo them. Do not re-open the source to "improve" a body — see the lean-context rule above.
Heading structure in those bodies already matches the anchors, so research:<path>#<anchor> refs resolve — the CLI existence-checks the anchor against a real heading (TRACK_STRUCTURE.md §5.6). For a verbatim_keep entry (a document-kind file kept for doc:@sha256 refs), leave the original file byte-for-byte (the hash must match) — write nothing.
Do not draft learner-facing nodes here, do not build the DAG, do not mint ids. Output is reference material + a manifest of units and their grounding refs for author-structure.
Record an ingest-state manifest at reference/.ingest-state.yaml so the delta-aware author-ingest-update can later tell what changed: source_root (where the ingested source lives), grounding_kind, ingested_through (git rev-parse HEAD — the source commit this ingest reflects, or (no git)), ingested_at, and a provenance list mapping each upstream source file → its distilled reference/ file → the grounding refs it produced. Assemble provenance from the provenance blocks the extractor returned (concatenated across batches), not by re-reading source. Skip only if the repo has no git.

Grounding refs you emit (must later validate — §5.6)

kind	grammar	CLI check downstream
research	`research:<path>#<heading-anchor>`	file + heading exist
document	`doc:<path>@sha256:<hex>`	file exists and bytes hash to `<hex>` (CLI computes hash — you leave a placeholder)

You do not compute hashes. Emit doc:<path>@sha256:<PLACEHOLDER>; the node's real hash is filled when the referenced file is stable, and author-selfcheck catches any mismatch.