Tracked source ingestion for research agents

Where this fits

You ask an agent to read a URL and summarize it. The answer lands in chat and evaporates. cp-skill-ingest fixes that by making source ingestion a tracked artifact: it writes a kb/sources/*.ingest.md report with a stable slug, so the same source can be re-ingested later without losing the analytical thread. It fits teams building research pipelines where every source a reading agent touches must leave a durable, diffable record. For more context on how this skill fits the wider ecosystem, see the listing at https://www.openagentskill.com/skills/zby-cp-skill-ingest.

Why agents benefit

• Bounded re-ingest requests. The skill only acts on explicit re-ingest requests, so an agent won't silently re-read every URL on each run — it updates only what the user asked for.
• Contract clarity. Direct output is exactly one .ingest.md file. The agent knows where the report lives, and the parent agent handles snapshotting, checksums, and handoff verification. No orphan artifacts.
• Focused tool scope. Allowed tools are Read, Write, Grep, Glob, Bash, Skill, Task — enough to do the job, few enough to keep the agent on rails.
• Useful defaults. No argument lists recent snapshots; a URL or path starts a new ingestion. Predictable for the agent and for the user.
• Separation of concerns. This skill ingests; cp-skill-ground retains quotes. Each skill stays small and composable.

Practical scenarios

Re-ingesting a changed source

A docs page your agent ingested last week was updated. You send a bounded re-ingest request; the agent re-reads the snapshot, diffs against the existing .ingest.md, and updates only what changed — no full pipeline rerun.

Working from a local snapshot

The target URL is flaky or firewalled. You point the agent at a local Markdown snapshot under kb/sources/.snapshots/, and the skill ingests that reading copy deterministically, using the snapshot's slug for the report.

Forking a research pipeline

You dispatch multiple worker agents, each forked from a parent, to ingest different sources in parallel. Because each worker only writes its own .ingest.md, you can merge results without merge conflicts.

Add it to your agent workflow

Install with:

npx skills add zby/commonplace --skill cp-skill-ingest

Then ask your agent:

ingest https://example.com/docs

The agent resolves the URL, snapshots it, and writes kb/sources/example-com.ingest.md. A bounded re-ingest request looks like re-ingest https://example.com/docs — the agent updates the existing report instead of creating a new one.

Compare before adopting

Before adopting, compare against alternatives. Look at quality signals: does the skill actually produce diffable, tracked reports, or just a fancy summarizer? Check maintenance freshness — when was the last commit, and is it tied to a living repo (commonplace by zby, 88 stars)? Compare with manual approaches, like telling your agent to "save a note" with no enforced contract — you'll lose consistency. And assess workflow fit: are you already organizing knowledge under kb/sources/? If you use a different structure, the skill's value drops.

Why it is worth tracking

This skill is worth tracking because it encodes a real workflow constraint — bounded, tracked source ingestion — that most agent setups lack. With 88 stars and a clearly specified contract, it shows the author is thinking about agent skill design as engineering, not prompts. The separation between ingest and ground (quote retention) is a strong architectural signal. Evaluate it when you notice your agents are re-reading sources without leaving a trace; that's the moment this skill proves its value.