skillwiki 0.9.61 → 0.9.63

package/skills/wiki-archive/SKILL.md

@@ -18,23 +18,36 @@ Run `skillwiki lang` at the start. Generate log entries in the resolved language
 
 Standard four reads (SCHEMA, index, log, project context if applicable).
 
-## Steps
+## Probe
+
+Same matrix as `using-skillwiki` → **CLI probe and failsafe**: PRIMARY (`skillwiki archive`), FAILSAFE-GIT (hand tombstone + `git mv` to `_archive/` + push), or FAIL CLOSED.
+
+## Steps (PRIMARY)
 
 0. Resolve vault: `skillwiki path` and `skillwiki lang`.
 1. Identify the target page. Confirm with the user which page to archive (show full relPath).
-2. Run `skillwiki archive <page> [vault]`. On a vault-sync leaf host where S3 stale originals must be pruned, use `skillwiki archive <page> [vault] --remote seaweed-wiki:cloud/wiki --remote-delete --max-remote-deletes 1` only when that remote path deletion is explicitly intended. Read the JSON output.
+2. Run `skillwiki archive <page> [vault]`. On a vault-sync leaf host where S3 stale originals must be pruned, use `skillwiki archive <page> [vault] --remote seaweed-wiki:cloud/wiki --remote-delete --max-remote-deletes 1` only when that remote path deletion is explicitly intended. Read the JSON output. Successful archive **always** writes a live-path tombstone under `meta/delete-intents/` so snapshot cannot resurrect the live key.
 3. Verify with `skillwiki index-check [vault]` — confirm no ghost entries remain.
 4. Run `skillwiki lint [vault]` — check for broken wikilinks from other pages that still reference the archived page. If found, update those pages to point to the replacement or remove the stale link.
 5. **Raw file archiving (N9 Reingest Protocol only):** When archiving a `raw/` file due to content drift, update ALL `^[raw/...]` citation markers and `sources:` frontmatter entries that reference the old path. Change `raw/articles/foo.md` to `_archive/raw/articles/foo.md` in every referencing page. Verify with `skillwiki audit` that no broken markers remain.
 6. Append a `log.md` entry: `## [{date}] archive | {relPath} → _archive/{subdir}/`.
+7. Commit/push so tombstone + archive land on private `main`.
+
+## FAILSAFE-GIT (no skillwiki)
+
+1. Confirm path. Write `meta/delete-intents/<slug>.json` with `action: "archive"`, `source: "failsafe-git"`, schema `vault-delete-intent/v1`.
+2. `git mv` live path → `_archive/<same relPath>` (create dirs as needed); update `index.md` if typed.
+3. Commit with `Delete-Intent` / `Delete-Source: failsafe-git` trailers; push to private `main`.
+4. Optional single-path `rclone deletefile` for the **live** path if remote configured.
 
 ## Reversibility
 
-Archiving is locally reversible: move the file back from `_archive/` to its original directory and re-add the wikilink entry to `index.md`. If `--remote-delete` was used, the stale active-path object is pruned from the remote after the archive move, but the archived copy remains and a restore will republish the active path on the next push.
+Archiving is locally reversible: move the file back from `_archive/` to its original directory, re-add the wikilink entry to `index.md`, and **delete the matching tombstone** under `meta/delete-intents/`. If `--remote-delete` was used, the stale active-path object is pruned from the remote after the archive move, but the archived copy remains and a restore will republish the active path on the next push once the tombstone is cleared.
 
 ## Stop conditions
 
 - `skillwiki archive` returns non-zero exit code (page not found, already archived, invalid vault).
+- FAIL CLOSED when neither CLI nor private git/gh access is available.
 - User declines to proceed.
 
 ## Forbidden
@@ -42,4 +55,5 @@ Archiving is locally reversible: move the file back from `_archive/` to its orig
 - Archiving `raw/` files outside the N9 Reingest Protocol (raw is immutable except during content-drift reingestion).
 - Archiving raw files without updating all `^[raw/...]` citation markers that reference them.
 - Archiving without user confirmation.
-- Deleting local vault files directly (archive moves locally; remote stale-path pruning is only allowed through the explicit `skillwiki archive --remote ... --remote-delete --max-remote-deletes 1` path).
+- Deleting local vault files with bare `rm` / bare `git rm` without a delete-intent tombstone (causes snapshot resurrection).
+- Remote stale-path pruning only via explicit `skillwiki archive --remote ... --remote-delete` (PRIMARY) or bounded single-path rclone in FAILSAFE-GIT.

package/skills/wiki-ingest/SKILL.md

@@ -14,29 +14,26 @@ Run `skillwiki lang` at the start. Generate page-body prose, narrative sections,
 2. `index.md`
 3. Last 20–30 entries of `log.md`
 4. (Project context only) `projects/{slug}/README.md` and last ~5 work-item logs.
-## Steps (in order — N6, N7, N8)
+## Steps (in order — deterministic raw capture and shared publication)
 0. **Resolve vault and language.** Run `skillwiki path` (fail if NO_VAULT_CONFIGURED) and `skillwiki lang`. Use the resolved vault path for all writes; use the canonical language for all generated prose.
 1. **Guard.** For each URL: run `skillwiki fetch-guard <url>`. If exit ≠ 0, STOP and surface the error. Do not retry.
 2. **Fetch.** Use `web_fetch` (or read local file) under Layer 2 controls (the CLI Layer 2 fetcher applies in tests; in skill runtime use `web_fetch` directly and treat any error as STOP).
    - **Portable local-source rule:** follow `using-skillwiki` → Portable Source References. Do not use `source_url: file:///...` as the canonical durable reference; prefer commit-pinned GitHub `blob/<commit>/<path>` when resolvable, else empty `source_url` plus portable repo-relative prose.
-3. **Identity guard.** Before writing raw files, ensure the target raw filename/title, `source_url`, fetched H1/title, and early body subject agree. If `skillwiki ingest` reports `INGEST_VALIDATION_FAILED` with `source identity conflict`, STOP. Do not fix by renaming after the fact; choose the correct title/source pair or ask the user.
-4. **Sensitive content guard.** Before writing or filing any vault page, scan the source and generated body for live credentials, access keys, tokens, passwords, cookies, bearer headers, or private keys. Redact generated prose before writing. If the source itself must remain raw and contains a live secret, STOP instead of preserving it.
-5. **Hash.** Write the raw file (frontmatter + body). Run `skillwiki hash <raw-file>` and embed the result in raw frontmatter `sha256:`.
-6. **Generate page(s).** Compose typed-knowledge page(s) with citations pre-attached (`^[raw/...]` markers). Every page MUST include:
-- `> **TL;DR:**` blockquote as the first content after the title heading — a one-sentence summary of the page's key takeaway (under 200 chars). See SCHEMA.md `## TL;DR Convention`.
-- For pages tagged `architecture` or explaining workflows/systems: include a Mermaid diagram (`graph TB` or `sequenceDiagram`) in the body. Follow Obsidian-compatible Mermaid rules (see SCHEMA.md `## Mermaid Diagrams`).
-For generated `comparisons/` pages or evaluation-style `queries/` pages, end the body with:
-```markdown
-## Decision Closeout
-
-Disposition: no-op | concept | ADR | work-item | evidence-needed
-Reason: ...
-Follow-up: ...
-```
-Use exactly one disposition. Keep this as a prompt convention, not a validator rule.
-7. **Validate.** For each generated page: run `skillwiki validate <page>`. If exit ≠ 0, STOP — do not write index/log.
-8. **Apply writes in order.** raw → page(s) → `index.md` → `log.md`.
-9. **Confidence flag.** If only one source is cited, set `confidence: low`.
+3. **Stage pasted text as a file source.** `skillwiki ingest` accepts a readable local source file or HTTP(S) URL; it does **not** accept literal pasted text. For a paste, stage the exact text in a temporary file outside the vault, then pass its path to the normal command:
+   ```bash
+   skillwiki ingest <staged-paste-path> \
+     --vault <resolved-vault> \
+     --type <entity|concept|comparison|query> \
+     --title "<title>" \
+     --tags "<tag1,tag2>" \
+     --provenance <research|project>
+   ```
+   Record the staged path and exact command inputs before execution. If ingestion or typed-page publication fails, retain the staged source and exact command inputs for retry. Remove the staged file only after `skillwiki ingest` exits 0 after typed-page publication; confirm the non-dry-run result reports its raw path, typed path, and publisher operation. Do not stage pasted text inside the vault.
+4. **Identity guard.** Before writing raw files, ensure the target raw filename/title, `source_url`, fetched H1/title, and early body subject agree. If `skillwiki ingest` reports `INGEST_VALIDATION_FAILED` with `source identity conflict`, STOP. Do not fix by renaming after the fact; choose the correct title/source pair or ask the user.
+5. **Sensitive content guard.** Before writing or filing any vault page, scan the source and generated body for live credentials, access keys, tokens, passwords, cookies, bearer headers, or private keys. Redact generated prose before writing. If the source itself must remain raw and contains a live secret, STOP instead of preserving it.
+6. **Feature-detect publication.** Run `skillwiki page publish --help`. If unavailable, fail closed and leave typed output unpublished; update the active SkillWiki CLI/plugin channel first.
+7. **Ingest and publish.** Use `skillwiki ingest` for deterministic source capture and typed-page publication. The command writes an immutable raw source first and delegates the typed page, taxonomy, index, and structural log entry to the shared page publisher. Supply the resolved vault, type, title, tags, and provenance through the command options.
+8. **Recovery.** Never create the final typed page or edit index.md/log.md directly. A raw-only result after publication failure is valid recovery state. Keep the exact command inputs and retry; do not delete or overwrite the raw source.
 ## Provenance defaults
 - Default `provenance: research`.
 - If cwd is inside `projects/{slug}/`, set `provenance: project` and add `provenance_projects: ["[[slug]]"]`.
@@ -50,20 +47,19 @@ Raw ephemeral data (market feeds, logs, transient JSON) must be written to the *
 - Fetch timeout / size limit exceeded.
 - `INGEST_VALIDATION_FAILED` with `source identity conflict`.
 - Source or generated content contains unredacted live credentials or other authenticating secrets.
-- `validate` non-zero on any page.
+- `skillwiki page publish --help` is unavailable.
+- `skillwiki ingest` returns nonzero; retain any raw-only result for retry.
 - sha256 already exists in vault for the same source.
 ## Forbidden
 - Skipping `fetch-guard`.
-- Updating `index.md` or `log.md` before all pages validate.
+- Creating a final typed page or editing `index.md`/`log.md` directly.
 - Modifying any existing file in `raw/`.
 - Writing raw ephemeral data directly to cloud-mounted wiki paths (`~/wiki/`).
 - Writing host-local absolute paths as canonical durable source references (see `using-skillwiki` → Portable Source References).
 - Writing `[[wikilinks]]` to pages that don't exist in the vault. Before linking, verify the target exists: check `index.md` or `ls` the target directory. If the target doesn't exist yet, use plain text instead of a wikilink.
 ## Batch Mode
 When the user provides multiple sources (a directory of files, a list of URLs, or a multi-document input):
-1. **Loop per source.** Execute steps 1–7 for each source individually (guard → fetch → identity guard → sensitive content guard → hash → generate → validate).
-2. **Accumulate, don't write yet.** Collect all raw files and pages in memory. Do not write `index.md` or `log.md` until every source has validated.
-3. **Fail fast.** If any page fails validation, STOP. Report all failures. Do not write index/log for any source.
-4. **Deduplication.** Before writing each raw file, check `sha256` against existing vault raw sources. Skip sources whose content is already present.
-5. **Single index/log update.** After all sources validate, write all raw files and pages, then update `index.md` and `log.md` once.
-6. **Progress.** After each source completes validation, report progress (e.g., "Validated 3/10 sources").
+1. **Loop per source.** Execute steps 1–8 for each source individually, using one `skillwiki ingest` command per source.
+2. **Fail fast.** If an ingest command returns nonzero, STOP and report the retained raw-only state, if any, with its exact retry inputs.
+3. **Deduplication.** Let `skillwiki ingest` preserve immutable raw capture and skip sources whose content is already present.
+4. **Progress.** After each source completes, report the raw path, typed path or recovery state, and publisher operation ID.

package/skills/wiki-query/SKILL.md

@@ -23,7 +23,15 @@ Standard four reads (SCHEMA, index, log, project context if applicable).
 5. **Read top candidates** in full (frontmatter + body).
 6. **Synthesize answer** with explicit citations to the candidate pages.
 7. **Sensitive content guard.** Before filing any query or comparison page, scan the generated body for live credentials, access keys, tokens, passwords, cookies, bearer headers, or private keys. Redact before writing. If the answer depends on preserving a live secret, STOP and ask for a redacted source or explicit rotation/remediation direction.
-8. **Optional file.** If user accepts: write to `queries/<slug>.md` or `comparisons/<slug>.md` with full frontmatter, validate, then update `index.md` then `log.md`. If the filed page is a research/evaluation answer, recommendation, or comparison, end it with:
+8. **Optional file.** If the user accepts, first run `skillwiki page publish --help`. If it is unavailable, fail closed and leave the result unpublished. Otherwise:
+   1. Resolve the vault and create a temporary directory outside the vault.
+   2. Write the complete query/comparison page to `<temp>/page.md`, including final frontmatter, citations, Sources footer, and Decision Closeout.
+   3. Run `skillwiki page publish <temp>/page.md <vault> --target queries/<slug>.md` (or `comparisons/<slug>.md`) and inspect the dry-run.
+   4. Run the identical command with `--write` only when dry-run succeeds.
+   5. On any nonzero result, retain the draft path and STOP; do not edit the final target, index.md, or log.md directly.
+   6. Remove the temporary directory only after the publisher returns complete success.
+
+   If the filed page is a research/evaluation answer, recommendation, or comparison, end it with:
 ```markdown
 ## Decision Closeout
 
@@ -41,6 +49,7 @@ Use exactly one disposition. This is a prompt convention only; do not add CLI en
 When a wiki page (especially a work item `tasks.md`) claims that fixes were applied, features were completed, or files were removed — **verify on disk before accepting the claim**. In one incident, a `tasks.md` marked 6 items DONE but 5 were not actually applied: a script claimed "removed" was still 2020 bytes on disk, a crontab claimed "updated to 30min" was still `*/10`, and a build target claimed "verified has consumers" had no web server serving it.
 **Rule**: After reading a work item that declares completion, run at least one verification command per critical claim (check file existence, grep a config, inspect a crontab). Documents can drift from reality — the filesystem is the source of truth.
 ## Forbidden
-- Filing without `validate` passing.
+- Filing without the `skillwiki page publish` dry-run passing.
+- Directly creating a final typed page or separately editing `index.md` or `log.md` for its publication.
 - Skipping the orientation reads even for "quick" queries.
 - Writing live credentials, access keys, tokens, passwords, cookies, bearer headers, private keys, or other authenticating secrets to the vault.

package/skills/wiki-remove/SKILL.md

@@ -0,0 +1,96 @@
+---
+name: wiki-remove
+description: Hard-delete a vault path with a durable delete-intent tombstone so S3+snapshot cannot resurrect it. Prefer skillwiki remove; if CLI missing, failsafe-git via private GitHub.
+---
+
+# wiki-remove
+
+## When This Skill Activates
+
+- User wants to permanently remove a vault path (not archive-for-reference).
+- Cleanup of stale pages that should not return via snapshot resurrection.
+- User says hard delete, remove for real, stop resurrecting.
+
+## Output language
+
+If `skillwiki` is available: run `skillwiki lang` at the start. Otherwise default to English log prose.
+
+## Pre-orientation
+
+Read SCHEMA/index only as needed. Confirm full vault-relative path with the user before delete.
+
+## Probe (required)
+
+1. `command -v skillwiki && skillwiki remove --help`
+2. `git -C <vault> rev-parse --is-inside-work-tree` and `git remote get-url origin` (expect private `karlorz/wiki` / fleet `vault_remote`)
+3. Auth: `gh auth status` **or** `git ls-remote origin HEAD`
+
+| Result | Mode |
+|--------|------|
+| skillwiki OK | **PRIMARY** |
+| skillwiki fail, git/gh + private repo OK | **FAILSAFE-GIT** |
+| neither | **FAIL CLOSED** — stop; never bare `rm` for fleet effect |
+
+Do not auto `npm install -g skillwiki` in headless/goal/satellite sessions.
+
+## PRIMARY steps
+
+1. Resolve vault: `skillwiki path`.
+2. Confirm path with user.
+3. On a vault-sync leaf when S3 prune is intentional:
+   `skillwiki remove <page> [vault] --remote seaweed-wiki:cloud/wiki --remote-delete --max-remote-deletes 1 --reason "<text>"`
+   Otherwise: `skillwiki remove <page> [vault] --reason "<text>"`
+4. Read JSON: expect `tombstone_path` under `meta/delete-intents/`, `removed` set.
+5. Commit + push via normal wiki-sync / git (tombstone + deletion must reach private `main` for durability).
+6. Report MODE=primary, paths, and whether remote-delete ran.
+
+## FAILSAFE-GIT steps (no skillwiki CLI)
+
+Agent **must** have git (and preferably gh) access to private vault remote.
+
+1. Confirm path with user. Set `PATH_REL` (vault-relative, no `..`).
+2. Write tombstone `meta/delete-intents/<slug>.json` where slug is path with `/` → `__`, e.g. `summaries/foo.md` → `summaries__foo.md.json`:
+
+```json
+{
+  "schema": "vault-delete-intent/v1",
+  "path": "PATH_REL",
+  "action": "remove",
+  "created": "ISO-8601-UTC",
+  "host": "SKILLWIKI_HOST_ID-or-unknown",
+  "actor": "agent-failsafe-git",
+  "reason": "user requested remove; skillwiki CLI unavailable",
+  "source": "failsafe-git",
+  "expires": null
+}
+```
+
+3. Delete local file at `PATH_REL` (and index line for `[[slug]]` if typed page).
+4. `git add` tombstone + path change; commit with trailers:
+
+```text
+Delete-Intent: PATH_REL
+Delete-Source: failsafe-git
+```
+
+5. `git pull --rebase origin main` (or merge fallback per vault-sync ADR) then **`git push origin HEAD:main`**. Require successful push before claiming durable success.
+6. Optional: if `rclone` and `WIKI_REMOTE` exist: `rclone deletefile "$WIKI_REMOTE/PATH_REL"` (single path only).
+7. Report `MODE=failsafe-git`, commit SHA, `S3_PRUNE=done|deferred`.
+
+## Stop conditions
+
+- User declines.
+- FAIL CLOSED (no CLI and no private git access).
+- Push to private wiki fails.
+- Path invalid or under `_archive/` without explicit restore/remove policy.
+
+## Forbidden
+
+- Bare `rm` / bare `git rm` without tombstone.
+- Force-push.
+- Unbounded `rclone sync` / mass remote delete.
+- Claiming fleet delete complete without tombstone on `origin/main` (and push success).
+
+## Reversibility
+
+Hard remove is not locally reversible from `_archive`. Restore requires re-authoring content and deleting the tombstone file under `meta/delete-intents/`, then normal push.