Skip to content
Skills Library
Science & research · Tool integration

knowledge-ingest-source

/knowledge-ingest-source

Standalone single-source ingest for cogni-knowledge — deposit ONE source directly into the bound wiki with no research run: a web page or PDF URL, a local file (.docx/.html/.txt), pasted text, a local PDF, or a local interview note. Lands one wiki/sources/<slug>.md page (or wiki/interviews/<slug>.md with type: interview for an interview note) carrying pre_extracted_claims: and the same diff-before-write + citation discipline as the research path; local inputs deposit honestly via fetch_method: direct. Use whenever the user says 'ingest this URL into my wiki', 'add this file/source to the knowl

Licence
Apache-2.0
Last repository change
19.09.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 19.09.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Standalone single-source ingest for cogni-knowledge — deposit ONE source directly into the bound wiki with no research run: a web page or PDF URL, a local file (.docx/.html/.txt), pasted text, a local PDF, or a local interview note. Lands one wiki/sources/<slug>.md page (or wiki/interviews/<slug>.md with type: interview for an interview note) carrying pre_extracted_claims: and the same diff-before-write + citation discipline as the research path; local inputs deposit honestly via fetch_method: direct. Use whenever the user says 'ingest this URL into my wiki', 'add this file/source to the knowl

Triggers from the description

ingest this URL into my wiki
Original author description

Standalone single-source ingest for cogni-knowledge — deposit ONE source directly into the bound wiki with no research run: a web page or PDF URL, a local file (.docx/.html/.txt), pasted text, a local PDF, or a local interview note. Lands one wiki/sources/<slug>.md page (or wiki/interviews/<slug>.md with type: interview for an interview note) carrying pre_extracted_claims: and the same diff-before-write + citation discipline as the research path; local inputs deposit honestly via fetch_method: direct. Use whenever the user says 'ingest this URL into my wiki', 'add this file/source to the knowl

How it works

  1. Parameters
  2. When to run
  3. Never run when
  4. Out of scope (deferred)
  5. Workflow
Original SKILL.md headings · 399 lines, 3,136 words
SKILL.md preview
---
name: knowledge-ingest-source
description: "Standalone single-source ingest for cogni-knowledge — deposit ONE source directly into the bound wiki with no research run: a web page or PDF URL, a local file (.docx/.html/.txt), pasted text, a local PDF, or a local interview note. Lands one wiki/sources/<slug>.md page (or wiki/interviews/<slug>.md with type: interview for an interview note) carrying pre_extracted_claims: and the same diff-before-write + citation discipline as the research path; local inputs deposit honestly via fetch_method: direct. Use whenever the user says 'ingest this URL into my wiki', 'add this file/source to the knowledge base', 'ingest this interview note', 'paste this into my wiki', or 'single-source ingest'. For batch research-fetched sources use knowledge-ingest instead."
allowed-tools: Read, Write, Bash, Task, WebFetch
---

# Knowledge Ingest — Single Source

The **standalone** single-source surface: deposit ONE source directly into the
bound wiki, with **no research run** (no `knowledge-plan` → `knowledge-curate`
→ `knowledge-fetch` scaffold, no `fetch-manifest.json`). A user drops one
input — a **URL** (web page or PDF), a **local file** (`.docx`/`.html`/`.txt`),
**pasted text**, a **local PDF**, or a **local interview note** — into their
bound base and it lands as a `type: source` page (or a `type: interview` page in
`wiki/interviews/` for an interview note) carrying `pre_extracted_claims:`,
indexed and backlinked exactly like a research-ingested source. A URL stores
via `fetch_method: webfetch`; every local input stores honestly via
`fetch_method: direct` (the additive non-web method in `fetch-cache.py`'s
`VALID_FETCH_METHODS`) — see Step 1 for why a local source is never stored as a
`webfetch` lie.

The mechanism **reuses the research write path byte-for-byte**: it populates
the shared fetch-cache, then dispatches the `source-ingester` agent (which reads
the cached body via `fetch-cache.py fetch`, dispatches `claim-extractor`, and
writes the page atomically with its Phase-3 pre-write integrity assertion),
then runs the same `backlink_audit.py` + `wiki_index_update.py` +
`config_bump.py` post-write lockstep `knowledge-ingest` Step 4 runs. The
`source-ingester` takes an additive `PAGE_TYPE` parameter (default `source`, so
a URL / file deposit is byte-identical to the research path; `interview` for a
local interview note → `wiki/interviews/`). The only single-source-specific
work is **before** the ingester: acquire the source body into the cache —
fetching a URL, or **normalizing a local file** (`.docx`/`.html`/`.txt` via the
vendored `convert_to_md.py`) / reading a local PDF (Read tool) / capturing
pasted text, all stored via `fetch_method: direct` — and dedup the source
against existing wiki pages so a collision routes to diff-before-write instead
of a blind overwrite.

Read `${CLAUDE_PLUGIN_ROOT}/references/inverted-pipeline.md` §"Phase 4 —
`knowledge-ingest`" and `references/claim-at-ingest.md` once if you have not —
the claim-shape and write contracts are shared.

## Parameters

Exactly **one** input mode is required — `--url`, `--file`, `--paste`, or
`--interview` (the `--type interview` form). They are mutually exclusive; supplying
more than one is an error.

| Parameter | Required | Description |
|-----------|----------|-------------|
| `--url` | One-of | A source URL to ingest (a web page, or a direct PDF URL). The original, un-normalized URL — it becomes the page's single `sources:` entry. Stored with `fetch_method: webfetch`. |
| `--file` | One-of | Path to a **local file** to ingest: `.txt` / `.html`/`.htm` (stdlib normalization) or `.docx` (via the optional `markitdown` external tool), or a local `.pdf` (read via the Read-tool page loop, with the optional `pypdf` text-layer extractor as fallback when available — see Step 1). Normalized to markdown via the vendored `convert_to_md.py`, then stored with `fetch_method: direct`. The `sources:` entry is a `file://<abspath>` provenance URI. |
| `--paste` | One-of | Path to a tempfile holding **pasted text** to ingest verbatim (the orchestrator writes the user's pasted block to a tempfile and passes its path — never interpolate the text into a shell literal). Stored with `fetch_method: direct`; `sources:` is a `paste:<sha256-prefix>` provenance URI. |
| `--interview` | One-of | Path to a local **interview note** file (markdown / `.txt`). Ingested like `--file` but lands as a `type: interview` page in `wiki/interviews/` (implies `--type interview`). Stored with `fetch_method: direct`. |
| `--type` | No | The wiki page type. Defaults to `source` for `--url`/`--file`/`--paste`; pass `--type interview` (or use `--interview`) to land the page in `wiki/interviews/` as `type: interview`. Threaded to `source-ingester` as `PAGE_TYPE`. Only `source` and `interview` are supported here. |
| `--queue` | No | Queue mode: instead of ingesting now, **enqueue** the resolved source for later draining via the vendored `wiki_queue.py --enqueue` (and report the job id). Useful for batching several local notes. Omitted = ingest immediately. |
| `--knowledge-slug` | No | Slug of the bound knowledge base (for display / disambiguation when several bases share a parent dir). |
| `--knowledge-root` | No | Override the knowledge-base directory (the dir containing `.cogni-knowledge/`). Defaults to the resolved knowledge root, same logic as `knowledge-ingest`. |
| `--title` | No | Title hint for the page (`title:` frontmatter + `# <title>` body header). Falls back to a body-derived title when absent. |
| `--publisher` | No | Registered-domain publisher (`europa.eu`, not `eur-lex.europa.eu`). Carried into the page frontmatter when present. |
| `--sub-question-refs` | No | Comma-separated `sq-NN` ids to tag the page (carried to `claim-extractor` and the page frontmatter). Defaults to a single synthetic `sq-00` so the claim-extractor contract is satisfied; the standalone surface has no plan. |
| `--theme` | No | Thematic index category (the `## <theme>` heading the source is filed under in `wiki/index.md`). Defaults to `Sources`. |
| `--dry-run` | No | Print the resolved plan (URL, slug, dedup verdict) without fetching, writing, or indexing. |
| `--normalize-pdf-body` | No | Opt-in: when the PDF text-layer fallback (`pdf-extract.py`, Step 1) runs, append `--normalize-pdf-body` to it so the stored body is cleaned (NFKC-fold ligatures, map smart quotes/dashes to ASCII, rejoin hyphenated column-wrap breaks). Default off — the flag is not appended, so the stored body / `content_hash` stay byte-identical. Applies only to the `pdf-extract.py` fallback path; the Read-tool page-loop path is unaffected. Enabling this on an **existing** base needs the affected raw-body PDF cache entries evicted first — see `references/normalize-pdf-body-runbook.md`. |

## When to run

- The user wants to deposit a single source directly into a bound knowledge
  base without running the research pipeline.
- A `binding.json` exists at the resolved knowledge root and its `wiki_path`
  resolves to a directory containing `.cogni-wiki/config.json`.

## Never run when

- No `binding.json` exists at the resolved knowledge root — offer
  `knowledge-setup` first.
- `binding.wiki_path` does not resolve to a directory containing
  `.cogni-wiki/config.json` — the binding is stale.
- No input mode is supplied, or more than one of `--url` / `--file` /
  `--paste` / `--interview` is supplied — exactly one is required.

## Out of scope (deferred)

This surface accepts a **URL, a local file, pasted text, a local PDF, or a
local interview note** → `type: source` (or `type: interview`), reusing existing
primitives end-to-end. Still deferred to follow-ups:

- **Cross-lingual** single-source handling (a DE↔EN claim merge on a single
  deposited source — the Phase-4.5 `cross-lingual-claim-merger` operates on the
  distilled layer, not the single-source ingest path).

## Workflow

### 0. Pre-flight

**Required engine + script dir.** Resolve the vendored `wiki-ingest` script dir
exactly as `knowledge-ingest` Step 0 does (vendored-only — `cogni-wiki` is
retired, so there is no external engine source to fall back to), so this skill's
Step 5 post-write lockstep
(mirroring `knowledge-ingest`'s Step 4) can call `backlink_audit.py` /
`wiki_index_update.py` / `config_bump.py`:

```
. "${CLAUDE_PLUGIN_ROOT}/scripts/resolve-wiki-scripts.sh"
WIKI_INGEST_SCRIPTS=$(resolve_wiki_scripts wiki-ingest backlink_audit.py) || abort "cogni-knowledge's vendored wiki-ingest scripts are missing. Reinstall cogni-knowledge, then retry."
```

The vendored `convert_to_md.py` (local-file → markdown normalization) and
`wiki_queue.py` (queue mode) live in the **same** `wiki-ingest` script dir, so
they resolve through the same probe — `$WIKI_INGEST_SCRIPTS/convert_to_md.py`
and `$WIKI_INGEST_SCRIPTS/wiki_queue.py`. No separate resolution is needed
(resolve them only when the chosen input mode / `--queue` actually requires
them).

**Binding + wiki root.** Resolve `knowledge_root` (same logic as
`knowledge-ingest` / `knowledge-fetch`) and read the binding:

```
python3 ${CLAUDE_PLUGIN_ROOT}/scripts/knowledge-binding.py read \
    --knowledge-root <knowledge_root>
```

On `success: false` → abort, offer `knowledge-setup`. Parse
`data.binding.wiki_path` as `WIKI_ROOT`; confirm `<WIKI_ROOT>/.cogni-wiki/config.json`
exists and `<WIKI_ROOT>/wiki/` is writeable; abort otherwise.

### 1. Acquire the source body into the shared cache

The `source-ingester` reads its body via `fetch-cache.py fetch`, so the
source's body must be in the cache first, keyed by a stable `SOURCE_URL` (the
real URL for `--url`, or a `file://` / `paste:` provenance URI for a local
input). **Do not re-acquire if a fresh entry already exists** —
`fetch-cache.py fetch --knowledge-root <knowledge_root> --url <SOURCE_URL>`
returning `success: true` (with the cached entry's `data.entry.status == "ok"`)
means the body is already cached; skip to Step 2.

Otherwise branch on the chosen input mode. **A URL stores with
`--fetch-method webfetch`; every local input (`--file`/`--paste`/`--interview`)
stores with `--fetch-method direct`** — the honest non-web method already in
`fetch-cache.py`'s `VALID_FETCH_METHODS`. Never store a local input as
`webfetch` (dishonest provenance).

**`--url` (web page):** `SOURCE_URL` = the URL. `WebFetch` it. On success, write
the body to a tempfile and store it:
```
python3 ${CLAUDE_PLUGIN_ROOT}/scripts/fetch-cache.py store \
    --knowledge-root <knowledge_root> \
    --url "<SOURCE_URL>" \
    --fetch-method webfetch \
    --status ok \
    --body-file <tmp_body_file> \
    --publisher "<publisher, if known>"
```
On a fetch failure (4xx/5xx/timeout/empty): store
`--status unavailable --reason <webfetch_*>` and stop — nothing to ingest.

**`--url` (PDF URL) and `--file` of a local `.pdf`:** replicate the established
PDF posture (`agents/source-curator.md` PDF branch) — for a URL detect via
`_knowledge_lib.is_pdf_response`; for a local `.pdf`, read it **with the Read
tool's page loop** directly. Read in `1-20` windows (cap 200 pages), concatenate
the extracted text, then `fetch-cache.py store … --status ok` (`--fetch-method
webfetch` for a PDF URL; `--fetch-method direct` for a local `.pdf`, with
`SOURCE_URL` = `file://<abspath>`). **PDF text path:** the Read tool's page loop
is primary; when it cannot render the PDF in this runtime, fall back to the
pure-Python text-layer extractor (`scripts/pdf-extract.py` /
`_knowledge_lib.extract_pdf_text`, the **optional, workspace-provisioned** `pypdf`
dependency resolved via `_knowledge_lib.load_pypdf` — not vendored)
before recording any terminal outcome — exactly the `agents/source-curator.md`
PDF branch. **When `--normalize-pdf-body` was passed**, append `--normalize-pdf-body`
to that `pdf-extract.py` fallback call so the stored text layer is cleaned
(ligatures / smart quotes / column-wrap); default off ⇒ the flag is **not** appended
and the stored body / `content_hash` stay byte-identical to today. Only when **both** the Read tool and the text-layer extractor recover
no usable text (pypdf absent, or a genuinely image-only / scanned PDF) store `--status unavailable
--reason pdf_render_unavailable` (or `pdf_extraction_failed` when no PDF file was
surfaced at all) and stop with an honest message — do not fabricate a body. The
vendored `convert_to_md.py`'s `noop-pdf` backend still does **not** parse and is
not used for body text.

**`--file` of `.txt` / `.html`/`.htm` / `.docx`:** normalize to markdown via the
vendored `convert_to_md.py`, then store the converted text with
`--fetch-method direct` and `SOURCE_URL` = `file://<abspath>`:
```
python3 "$WIKI_INGEST_SCRIPTS/convert_to_md.py" --source "<abspath>"
# → {success, data: {converted_path, backend, ...}}  — read data.converted_path
python3 ${CLAUDE_PLUGIN_ROOT}/scripts/fetch-cache.py store \
    --knowledge-root <knowledge_root> \
    --url "file://<abspath>" \
    --fetch-method direct \
    --status ok \
    --body-file <data.converted_path>
```
`.txt` uses the `stdlib-passthrough` backend and `.html`/`.htm` the
`stdlib-html` backend (both stdlib-only). `.docx` uses the **optional external
`markitdown` CLI**: when `convert_to_md.py` returns `success: false` with a
`markitdown`-absent / `unsupported` backend, **degrade to an honest error**
(tell the user `.docx` ingest needs `markitdown` installed) — do **not** crash
and do **not** fabricate a body. An unsupported extension is an honest error,
not a guess.

**`--paste` (pasted text):** the orchestrator already holds the pasted block in
a tempfile (`--paste <tmpfile>`). `SOURCE_URL` = `paste:<first-12-hex of
sha256(body)>` — hash the body text (not the tempfile path, which is not stable
across runs) so re-pasting the same text dedups. Store the tempfile verbatim
with `--fetch-method direct --status ok --body-file <tmpfile>`.

**`--interview` (local interview note):** identical to `--file` (markdown/`.txt`
normalization, `--fetch-method direct`, `SOURCE_URL` = `file://<abspath>`), but
`PAGE_TYPE=interview` carries through Step 4 so the page lands in
`wiki/interviews/`.

**Retain the acquired body text in context** — Steps 2 (title fallback) and 3
(the grounding query) derive from the same body's first ~100 words / a
body-derived title. Reuse the body you just acquired; do not re-read it from the
cache or the tempfile (a 200-page PDF concatenation is expensive to re-load).

`--dry-run` stops here after printing the resolved `SOURCE_URL`, input mode,
slug (Step 2), and dedup verdict (Step 3) — no acquire, no store, no write.

**`--queue` short-circuit.** When `--queue` is set, do **not** ingest now —
after acquiring the body into the cache (above), enqueue the source for later
draining instead of dispatching the ingester:
```
python3 "$WIKI_INGEST_SCRIPTS/wiki_queue.py" --wiki-root <WIKI_ROOT> \
    --enqueue --source "<SOURCE_URL>" --type "<--type, default source>" \
    --title "<--title, if set>"
```
Report the enqueued job id — `data.job.id` from the response envelope
(`{success, data: {action: "enqueued", job: {id, ...}, path}}`) — and stop
(Steps 2–6 run when the queue is later drained). Omit `--queue` for the default
ingest-now path.

### 2. Resolve the slug

Single source of truth — `_knowledge_lib.slugify` (the same helper
`knowledge-ingest` Step 1.2 uses). Pass the title via env var (never
interpolate untrusted text into a Python literal):

```
KNOWLEDGE_SCRIPTS="${CLAUDE_PLUGIN_ROOT}/scripts" \
CANDIDATE_TITLE="<--title, or a body-derived title>" \
python3 -c '
import os, sys
sys.path.insert(0, os.environ["KNOWLEDGE_SCRIPTS"])
from _knowledge_lib import slugify
print(slugify(os.environ["CANDIDATE_TITLE"]) or "")
'
```

The resolved slug must match the anchored full-string guard
`^[a-z0-9][a-z0-9-]{0,79}$` (a lowercase-alnum lead + ≤79 more `[a-z0-9-]`,
≤80 chars total). When `slugify()` returns empty (title was non-alnum / missing)
**or a slug that fails that guard** (e.g. one that ran past the 80-char cap),
fall back to `src-<first-12-of-sha256(normalize_url(SOURCE_URL))>` via
`python3 ${CLAUDE_PLUGIN_ROOT}/scripts/fetch-cache.py key --url <SOURCE_URL> --bare`
(first 12 hex chars; the `src-<hash>` form is lowercase hex and ≤16 chars, so it
always satisfies the guard) rather than dispatching a slug the ingester will
reject. Candidate-title precedence: `--title` → a body-derived title (the note's
first heading / first line, for a local file with no `--title`, so an interview
note lands under a readable slug) → the `src-<hash>` fallback.

### 3. Dedup against existing wiki pages (diff-before-write gate)

Before writing, check whether the bound wiki already covers this source, via
the shared wiki-grounding discovery primitive (the same one `wiki-coverage.py`
and `wiki-source-manifest.py` resolve to):

```
python3 ${CLAUDE_PLUGIN_ROOT}/scripts/wiki-grounding.py rank \
    --wiki-root <WIKI_ROOT> \
    --question "<--title + first ~100 words of the body>" \
    --theme-label "<--theme, if set>" \
    [--include-interviews]   # add ONLY when depositing an interview note (--type interview)
```

Pass `--include-interviews` **only on the interview path** (`--type interview` /
`--interview`) so the walk also covers `wiki/interviews/`; omit it for a
`--url`/`--file`/`--paste` source deposit so source dedup keeps scoring against
the default `source`/`synthesis`/`concept`/`entity`/`person` set — no false cross-type
collisions, and byte-parity with the `wiki-coverage.py` / `wiki-source-manifest.py`
importers (which never pass the flag).

Read `data.pages[]` (ranked covering pages) and `data.coverage_verdict`:

- **A covering page resolves to an existing wiki page of the same type as this
  deposit** (`wiki/sources/<that-slug>.md` for a source deposit, or
  `wiki/interviews/<that-slug>.md` for an interview-note deposit under
  `--include-interviews`) — a genuine collision, the same artifact already on
  the wiki → **do not blind-write.** Surface the collision and hand to the
  **diff-before-write update path**: tell the user the existing page covers this
  source and offer to update it via `cogni-wiki:wiki-update` (or the re-homed
  equivalent) rather than creating a duplicate. Stop here unless the user
  confirms a forced re-ingest under a new slug. (A covering page of a *different*
  type — e.g. a `concept`/`synthesis` page surfacing for a source deposit — is a
  thematic neighbour, not a collision; treat it per the next bullet.)
- **No covering page (or only weak/partial thematic overlap)** → continue to
  Step 4. (Thematic neighbours are expected and are fine — they become
  backlink candidates in Step 5, not collisions.)

**Dedup coverage by page type.** `wiki-grounding.py rank` walks the indexed page
types `source` / `synthesis` / `concept` / `entity` / `person` by default (its `_TYPE_DIRS`),
covering a `--url`/`--file`/`--paste` deposit (which lands as `type: source` in
`wiki/sources/`). The opt-in `--include-interviews` flag additionally walks
`wiki/interviews/`, so an **interview-note** deposit gets the **same semantic
diff-before-write collision check** as a `type: source` deposit — an existing
`wiki/interviews/<slug>.md` covering the same content is surfaced as a collision
even when it would resolve to a *different* slug, closing the prior slug-only gap
(the `source-ingester` Phase-3 `slug_collision` exact-slug guard still backstops
it). The flag is deliberately opt-in and off for source deposits so the shared
primitive's default walk set is unchanged for `wiki-coverage.py` coverage scoring
and `wiki-source-manifest.py` wiki-only compose.

### 4. Dispatch source-ingester (single entry)

Dispatch the `source-ingester` agent via `Task` with one entry — the same
parameter shape `knowledge-ingest` Step 3 uses, **plus the additive `PAGE_TYPE`**
(default `source`; `interview` for an interview note). With `PAGE_TYPE=source`
this dispatch is byte-identical to the research path:

```
Task(source-ingester,
     KNOWLEDGE_ROOT=<knowledge_root>,
     WIKI_ROOT=<WIKI_ROOT>,
     URL=<SOURCE_URL>,
     SLUG=<resolved slug from Step 2>,
     PAGE_TYPE=<source | interview>,
     SUB_QUESTION_REFS=<--sub-question-refs, or sq-00>,
     PUBLISHER=<--publisher, if set>,
     TITLE_HINT=<--title, if set>,
     BATCH_OUTPUT_PATH=<tmp>/.ingest.single.<slug>.json)
```

The agent reads the cached body, runs `claim-extractor`, and writes
`<WIKI_ROOT>/wiki/<page-type-dir>/<slug>.md` (`wiki/sources/` for `source`,
`wiki/interviews/` for `interview`) atomically with its Phase-3 pre-write
integrity assertion (`id == SLUG`, first `sources:` URL normalizes to
`SOURCE_URL`, path stem == `SLUG`, `content_hash:` matches the cache). Read the
`BATCH_OUTPUT_PATH` envelope:

- `ok: true` → the page is on disk; continue to Step 5.
- `ok: false` (`cache_miss` / `invalid_slug` / `invalid_page_type` /
  `slug_collision` / `integrity_mismatch` / empty body) → surface the `reason`
  and stop. No index or backlink work for a page that was not written.

### 5. Post-write lockstep (same as knowledge-ingest Step 4)

For the one new slug, run the identical sequence `knowledge-ingest` Step 4 runs
(reuse `$WIKI_INGEST_SCRIPTS`):

1. **Backlink audit + apply** — `backlink_audit.py --new-page <slug> --top 8
   --min-confidence medium`, then curate a `targets[]` write-back plan (one
   `[[<slug>]]` trailer per genuinely-related sibling page) and apply it via
   `backlink_audit.py --new-page <slug> --apply-plan -`. Skip apply for a slug
   with no genuine relation — never invent a backlink.
2. **Index update** — sanitize the one-sentence summary via
   `_knowledge_lib.sanitize_summary` (env-var pattern), then
   `wiki_index_update.py --slug <slug> --summary "$CLEAN_SUMMARY" --category
   "<--theme, or the page-type default: Sources for a source, Interviews for an
   interview note>" --max-summary 240`. Capture the envelope; when
   `data.action == "inserted"` the index gained a new row.
3. **entries_count bump** — only when Step 5.2 inserted a new row:
   `config_bump.py --wiki-root "$WIKI_ROOT" --key entries_count --delta 1`.
   Non-fatal on failure (the page is already discoverable; surface in the
   summary, reconcilable via `wiki-lint --fix=entries_count_drift`).
4. **Flag dependent syntheses (evidence-aware refresh signal)** — a new source
   related to an existing synthesis's cited evidence may have outdated it. Scan
   for that, reusing the **Step-3 dedup neighborhood** (the `wiki-grounding.py
   rank` `data.pages[]` already in hand — its `slug` values, comma-joined) as
   `--related` so no second ranking pass runs:

   ```
   python3 ${CLAUDE_PLUGIN_ROOT}/scripts/synthesis-impact.py scan \
       --wiki-root "$WIKI_ROOT" \
       --new-page <slug> \
       --related "<comma-joined Step-3 data.pages[].slug>" \
     | python3 ${CLAUDE_PLUGIN_ROOT}/scripts/knowledge-binding.py add-refresh-candidates \
       --knowledge-root <knowledge_root> --records - --triggered-by <slug>
   ```

   `synthesis-impact.py scan` finds every `wiki/syntheses/<s>.md` whose cited
   slugs intersect the neighborhood AND whose `updated:` predates the new source's
   wiki-arrival `created:`, and `add-refresh-candidates` unions them into
   `binding.json::refresh_candidates[]` (dedup by `synthesis_slug`) for the next
   `knowledge-refresh` run to surface. Capture
   `data.refresh_candidates` length as `N_FLAGGED` for the Step-6 line.
   **Fail-soft** — a failure here is non-fatal and never rolls back the deposited
   page (the page landed in Step 4; this is pure observability). Only runs on the
   genuinely-new-page branch — a Step-3 collision already routed to update and
   stopped before this step. Interview-note deposits scan too (the `--new-page`
   resolver falls back to `wiki/interviews/`), but a synthesis rarely cites one,
   so the common result is empty.

### 6. Summary

Print a short summary: the deposited page path, claims extracted, the dedup
verdict (new / collision-routed-to-update), backlinks applied, and whether
`entries_count` bumped. One line, no follow-up question — the source is on the
wiki and future `knowledge-compose` / `knowledge-query` runs read it like any
research-ingested source.

When Step 5.4 flagged any dependent synthesis (`N_FLAGGED > 0`), add a second
conditional line:

> ⚠ `<N_FLAGGED>` existing synthesis(es) may be outdated by this source — run
> `knowledge-refresh` to fold it in.

Versions

The database has no other skills named knowledge-ingest-source.

Database snapshot: 13.11.2026 · package version ba4324d0b81a (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100knowledge-research
    Research a topic INTO a bound cogni-knowledge base — runs cogni-research on the topic and deposits the findings into the knowledge base's wiki in one prompt. Reads .cogni-knowledge/binding.json to resolve the wiki path so the user does not have to. Every deposited page is…
  • 100knowledge-report
    Compose a research report by reading the bound cogni-wiki knowledge base, then re-deposit the result back into the same wiki — the wiki-roundtrip primitive. Reads .cogni-knowledge/binding.json to resolve the wiki path so the user does not have to. Dispatches cogni-research with…
  • 100ingest
    File a source (URL, file path, or pasted text) into raw/ with provenance preserved. Trigger on "ingest this", "process this source", "file this article", "save this transcript", "add this thread to the OS" (or run /founder-os:ingest). Also fires when the user shares a source…
  • 100ingest
    Ingest one source (PDF, web page, or local markdown/text file) into the vault's LLM wiki — capture it into raw/, read it at the right cost, discuss it with the user, then write source/concept pages, update index, log and hot cache, and verify. Use when the user asks to ingest,…
  • 100wiki-ingest
    Use when adding a new source to a wiki — a paper, article, URL, file, transcript, or any document. One ingest may touch 10-15 wiki pages.
  • 100wiki-ingest
    Ingests a scientific paper into a markdown knowledge wiki (Obsidian-compatible). Creates or updates the paper note and propagates its findings to concept and method notes, with source-fidelity checks. Use when the user says "/wiki-ingest", "add this paper to the wiki", or…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.