kushi-agents 5.1.0 → 5.3.0

package/plugin/instructions/otel.instructions.md

@@ -0,0 +1,75 @@
+# OpenTelemetry export
+
+> Doctrine: `otel.instructions.md` — kushi v5.2.0+
+
+## Purpose
+
+Opt-in observability for kushi pipelines via OpenTelemetry Protocol (OTLP). Enables enterprise teams to trace kushi runs in their existing observability stack (Jaeger, Grafana Tempo, Azure Monitor, Datadog, etc.).
+
+## Opt-in activation
+
+Set the environment variable:
+
+```
+KUSHI_OTEL_ENDPOINT=http://localhost:4318/v1/traces
+```
+
+When unset or empty, all OTel helpers are **no-ops** with zero overhead (no HTTP calls, no object allocation beyond the guard check).
+
+## Events emitted
+
+| Span name | Fires during | Attributes |
+|-----------|-------------|------------|
+| `kushi.pull` | Each `pull-*` source | `project`, `alias`, `source`, `duration_ms`, `success`, `evidence_count` |
+| `kushi.build_state` | `build-state` | `project`, `alias`, `pages_written`, `contradictions_flagged`, `duration_ms`, `success` |
+| `kushi.lint` | `lint-state` | `project`, `alias`, `findings_count`, `duration_ms`, `success` |
+| `kushi.contradiction.flagged` | Inside `build-state` when a new contradiction is detected | `project`, `alias`, `entity`, `field`, `source` |
+| `kushi.hook.invoked` | Each hook invocation | `project`, `alias`, `event`, `hook_type`, `target`, `duration_ms`, `success` |
+
+## Wire format
+
+Uses the [OTLP/HTTP JSON](https://opentelemetry.io/docs/specs/otlp/#otlphttp) format:
+- Endpoint: `$KUSHI_OTEL_ENDPOINT` (must include path, e.g. `/v1/traces`)
+- Method: POST
+- Content-Type: `application/json`
+- No external dependencies — pure PowerShell via `Invoke-RestMethod`
+
+## Privacy contract
+
+**CRITICAL**: OTel spans carry ONLY:
+- Operation metadata (names, counts, durations, success/failure)
+- Project/alias identifiers
+
+OTel spans NEVER carry:
+- Evidence content (email bodies, meeting transcripts, etc.)
+- PII (user emails, file paths with usernames beyond alias)
+- Authentication tokens or secrets
+
+This is enforced structurally: `Emit-OtelSpan.ps1` accepts only a fixed set of attribute keys.
+
+## Implementation
+
+The shared helper `plugin/skills/_shared/Emit-OtelSpan.ps1`:
+1. Checks `$env:KUSHI_OTEL_ENDPOINT` — returns immediately if unset/empty.
+2. Constructs a minimal OTLP JSON payload with a single span.
+3. POSTs via `Invoke-RestMethod` with a 5s timeout.
+4. On failure: logs a warning to stderr, never throws, never blocks the pipeline.
+
+## Service identity
+
+```json
+{
+  "resource": {
+    "attributes": [
+      { "key": "service.name", "value": { "stringValue": "kushi" } },
+      { "key": "service.version", "value": { "stringValue": "<package.json version>" } }
+    ]
+  }
+}
+```
+
+## References
+
+- `Emit-OtelSpan.ps1` — shared helper (`plugin/skills/_shared/Emit-OtelSpan.ps1`)
+- `hooks.instructions.md` — hook invocations emit `kushi.hook.invoked` spans
+- `parallel-execution.instructions.md` — parallel pulls emit one span per worker

package/plugin/instructions/parallel-execution.instructions.md

@@ -0,0 +1,81 @@
+# Parallel execution
+
+> Doctrine: `parallel-execution.instructions.md` — kushi v5.2.0+
+
+## Purpose
+
+Defines when and how kushi parallelizes work. The primary use case is parallel `pull-*` dispatch during `refresh-project`, but the patterns apply to any future parallel workload.
+
+## When to parallelize
+
+| Scenario | Parallel? | Why |
+|----------|-----------|-----|
+| Multiple `pull-*` in a refresh | ✅ Yes | Sources are independent; each writes to its own `Evidence/<alias>/<source>/` subtree |
+| `build-state` page writes | ❌ No | Pages may reference each other; deterministic ordering required |
+| `lint-state` finding checks | ✅ Yes (future) | Read-only checks are embarrassingly parallel |
+| Hook dispatch | ❌ No | Sequential for predictable log ordering |
+
+## Configuration
+
+In `.kushi/config.yml` (project-level) or `~/.kushi/config.yml` (user-level):
+
+```yaml
+parallel:
+  max_workers: 4        # default; 1 = sequential
+  throttle_ms: 200      # minimum delay between worker starts (rate-limit courtesy)
+```
+
+Override at runtime: `kushi refresh <project> --sequential` forces `max_workers: 1`.
+
+## Throttling considerations
+
+M365 Graph (via WorkIQ) enforces per-user rate limits:
+- **429 Too Many Requests** — back off exponentially.
+- Kushi's `throttle_ms` provides a minimum inter-start delay (not a per-request throttle — individual pull-* skills handle their own retries via `auth-and-retry.instructions.md`).
+- Default 200ms is conservative; increase for tenants with aggressive throttling.
+
+## Error aggregation
+
+- Each worker runs independently. A failure in `pull-email` does NOT halt `pull-teams`.
+- Worker results are collected into a `Map<source, {status, items, duration, error?}>`.
+- After all workers complete, results are sorted in **canonical source order** (same order as sequential dispatch per `refresh-project/SKILL.md` Step 2).
+- The run summary and run-log entries are written in canonical order regardless of completion order.
+
+## Deterministic output ordering
+
+Despite parallel execution, all observable outputs (run-log entries, refresh report tables, State/log.md entries) are written in **canonical source order**:
+
+1. pull-email
+2. pull-teams
+3. pull-meetings
+4. pull-onenote
+5. pull-loop
+6. pull-sharepoint
+7. pull-crm
+8. pull-ado
+9. pull-misc
+
+This ensures `git diff` is stable across runs and self-check D38 passes.
+
+## Implementation pattern (PowerShell)
+
+```powershell
+# Worker pool using Start-ThreadJob (PowerShell 7+)
+$maxWorkers = $config.parallel.max_workers ?? 4
+$throttleMs = $config.parallel.throttle_ms ?? 200
+$jobs = @()
+foreach ($source in $enabledSources) {
+    while (($jobs | Where-Object { $_.State -eq 'Running' }).Count -ge $maxWorkers) {
+        Start-Sleep -Milliseconds 100
+    }
+    $jobs += Start-ThreadJob -ScriptBlock { param($s) & pull-$s ... } -ArgumentList $source
+    Start-Sleep -Milliseconds $throttleMs
+}
+$results = $jobs | Receive-Job -Wait -AutoRemoveJob
+```
+
+## References
+
+- `refresh-project/SKILL.md` — orchestrator that dispatches parallel pulls
+- `auth-and-retry.instructions.md` — per-request throttling within each worker
+- `hooks.instructions.md` — hooks fire AFTER parallel aggregation completes

package/plugin/instructions/schema-evolve.instructions.md

@@ -0,0 +1,73 @@
+# Schema evolve
+
+> Doctrine: `schema-evolve.instructions.md` — kushi v5.2.0+
+
+## Purpose
+
+Allows users to teach kushi project-specific conventions that persist across runs. When a user says "from now on always do X for this project," kushi captures the rule and applies it in all future operations.
+
+## Storage location
+
+Rules are stored in `Evidence/<alias>/State/CLAUDE.md` under the project's evidence tree.
+
+**Decision rationale**: `CLAUDE.md` is the Karpathy-pattern file for agent-specific conventions (already present in the State layout since v5.0.0). Placing rules here means:
+- They're versioned alongside evidence (git-tracked engagement roots get history).
+- They're co-located with the State pages that apply them.
+- They're readable by any agent (not kushi-specific format).
+
+## Rule format
+
+Rules are appended to `CLAUDE.md` with structure:
+
+```markdown
+## Rule: <short-title>
+
+- **Added**: 2026-05-29T14:30:00Z
+- **Scope**: project | alias | global
+- **Source**: user (natural language) | schema-evolve skill
+
+<rule text as stated by the user>
+```
+
+## Scope levels
+
+| Scope | Stored at | Applies to |
+|-------|-----------|------------|
+| `project` | `Evidence/<alias>/State/CLAUDE.md` | All operations on this project |
+| `alias` | `Evidence/<alias>/State/CLAUDE.md` | Only this contributor's operations |
+| `global` | `~/.kushi/conventions.md` | All projects (future — v5.3.0) |
+
+v5.2.0 implements `project` scope only. `alias` and `global` are documented for forward compatibility.
+
+## How rules are applied
+
+1. At the start of `build-state`, `ask-project`, and `refresh-project`, the skill reads `Evidence/<alias>/State/CLAUDE.md`.
+2. Rules are parsed into a list and included as context for the operation.
+3. Rules affect preferences (formatting, naming, emphasis) but NEVER override hard doctrine (WorkIQ-only, verbatim-by-default, CSC format).
+
+## Conflict resolution
+
+- Hard doctrine always wins over user rules.
+- Later rules override earlier rules on the same topic.
+- If a rule contradicts doctrine, it's logged as a warning but not applied.
+
+## CLI verb
+
+`kushi remember <rule>` — captures a rule at project scope.
+
+Auto-detection: when the user says "from now on...", "always...", "never...", "for this project..." in `ask-project`, the skill offers to persist it as a convention.
+
+## Examples
+
+```
+> kushi remember "always use 'HCA' not 'Healthcare Accelerator' in summaries"
+> kushi remember "treat John Smith as the primary EM for this project"
+> kushi remember "CRM entity 'opportunity' maps to our internal term 'deal'"
+```
+
+## References
+
+- `karpathy-state-layout.instructions.md` — CLAUDE.md file in State layout
+- `living-wiki.instructions.md` — rules interact with incremental State maintenance
+- `build-state` skill — reads rules at start of run
+- `ask-project` skill — reads rules + offers to capture new ones

package/plugin/skills/_shared/Emit-OtelSpan.ps1

@@ -0,0 +1,111 @@
+<#
+.SYNOPSIS
+Emits an OpenTelemetry span via OTLP/HTTP JSON.
+
+.DESCRIPTION
+Opt-in OTel export. If KUSHI_OTEL_ENDPOINT is unset or empty, this is a
+complete no-op (no HTTP calls, no allocations). Pure PowerShell — no
+external dependencies.
+
+.PARAMETER SpanName
+The span name (e.g., 'kushi.pull', 'kushi.build_state').
+
+.PARAMETER Attributes
+Hashtable of span attributes. Only metadata — never evidence content.
+
+.PARAMETER DurationMs
+Duration in milliseconds (optional — computed from Start if provided).
+
+.PARAMETER Start
+Optional start time [datetime]. Defaults to (now - DurationMs).
+#>
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory)][string]$SpanName,
+    [hashtable]$Attributes = @{},
+    [int]$DurationMs = 0,
+    [datetime]$Start = [datetime]::MinValue
+)
+
+# No-op guard — zero overhead when endpoint is unset
+$endpoint = $env:KUSHI_OTEL_ENDPOINT
+if (-not $endpoint) { return }
+
+$ErrorActionPreference = 'Continue'
+
+try {
+    # Compute timestamps (nanoseconds since epoch)
+    $now = [DateTimeOffset]::UtcNow
+    if ($Start -eq [datetime]::MinValue) {
+        $startOffset = $now.AddMilliseconds(-$DurationMs)
+    } else {
+        $startOffset = [DateTimeOffset]::new($Start.ToUniversalTime())
+    }
+    $endOffset = $now
+
+    $startNs = ($startOffset.ToUnixTimeMilliseconds() * 1000000).ToString()
+    $endNs = ($endOffset.ToUnixTimeMilliseconds() * 1000000).ToString()
+
+    # Generate trace/span IDs
+    $traceId = [System.Guid]::NewGuid().ToString('N')
+    $spanId = [System.Guid]::NewGuid().ToString('N').Substring(0, 16)
+
+    # Build attributes array
+    $attrArray = @()
+    # Allowed keys only (privacy contract)
+    $allowedKeys = @('project','alias','source','duration_ms','success','evidence_count',
+                     'pages_written','contradictions_flagged','findings_count','entity',
+                     'field','event','hook_type','target','report_path','items_pulled')
+    foreach ($key in $Attributes.Keys) {
+        if ($key -notin $allowedKeys) { continue }
+        $val = $Attributes[$key]
+        $valObj = if ($val -is [bool]) {
+            @{ boolValue = $val }
+        } elseif ($val -is [int] -or $val -is [long] -or $val -is [double]) {
+            @{ intValue = [string]$val }
+        } else {
+            @{ stringValue = [string]$val }
+        }
+        $attrArray += @{ key = $key; value = $valObj }
+    }
+
+    # Get service version
+    $version = '5.2.0'
+    $pkgJson = Join-Path $PSScriptRoot '..\..\..\..\package.json'
+    if (Test-Path $pkgJson) {
+        try { $version = (Get-Content -Raw $pkgJson | ConvertFrom-Json).version } catch {}
+    }
+
+    # Build OTLP payload
+    $payload = @{
+        resourceSpans = @(@{
+            resource = @{
+                attributes = @(
+                    @{ key = 'service.name'; value = @{ stringValue = 'kushi' } }
+                    @{ key = 'service.version'; value = @{ stringValue = $version } }
+                )
+            }
+            scopeSpans = @(@{
+                scope = @{ name = 'kushi'; version = $version }
+                spans = @(@{
+                    traceId = $traceId
+                    spanId = $spanId
+                    name = $SpanName
+                    kind = 1  # SPAN_KIND_INTERNAL
+                    startTimeUnixNano = $startNs
+                    endTimeUnixNano = $endNs
+                    attributes = $attrArray
+                    status = @{
+                        code = if ($Attributes['success'] -eq $false) { 2 } else { 1 }
+                    }
+                })
+            })
+        })
+    }
+
+    $json = $payload | ConvertTo-Json -Depth 20 -Compress
+    Invoke-RestMethod -Uri $endpoint -Method POST -Body $json `
+        -ContentType 'application/json' -TimeoutSec 5 -ErrorAction Stop | Out-Null
+} catch {
+    Write-Warning "OTel export failed (non-blocking): $($_.Exception.Message)"
+}

package/plugin/skills/_shared/Invoke-Hooks.ps1

@@ -0,0 +1,177 @@
+<#
+.SYNOPSIS
+Dispatches hooks for a kushi pipeline event.
+
+.DESCRIPTION
+Idempotent hook dispatcher. Reads .kushi/hooks.yml + .kushi/hooks/*.ps1,
+invokes each configured hook for the given event, captures output/duration,
+and logs results to Evidence/<alias>/State/hooks-log.md.
+
+Failures are warn-only — never blocks the pipeline.
+
+.PARAMETER ProjectRoot
+Path to the project root (contains .kushi/).
+
+.PARAMETER Event
+One of: post-pull, post-state, post-contradiction, post-lint.
+
+.PARAMETER Payload
+Hashtable of event data (serialized to JSON for hooks).
+
+.PARAMETER StateDir
+Path to Evidence/<alias>/State/ for logging.
+#>
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory)][string]$ProjectRoot,
+    [Parameter(Mandatory)][ValidateSet('post-pull','post-state','post-contradiction','post-lint')][string]$Event,
+    [Parameter(Mandatory)][hashtable]$Payload,
+    [string]$StateDir
+)
+
+$ErrorActionPreference = 'Continue'
+
+$hooksYml = Join-Path $ProjectRoot '.kushi/hooks.yml'
+$hooksDir = Join-Path $ProjectRoot '.kushi/hooks'
+$payloadJson = $Payload | ConvertTo-Json -Depth 10 -Compress
+
+# Collect hook definitions
+$hookDefs = @()
+
+# Parse hooks.yml if present
+if (Test-Path $hooksYml) {
+    $lines = Get-Content -Path $hooksYml -ErrorAction SilentlyContinue
+    $inEvent = $false
+    $eventIndent = 0
+    foreach ($line in $lines) {
+        if ($line -match "^\s*$Event\s*:") {
+            $inEvent = $true
+            $eventIndent = ($line -replace '[^\s].*','').Length
+            continue
+        }
+        if ($inEvent) {
+            # Determine current indent
+            $currentIndent = if ($line -match '^(\s*)') { $Matches[1].Length } else { 0 }
+            # Exit if we hit a line at same/lower indent that's not empty
+            if ($line.Trim() -ne '' -and $currentIndent -le $eventIndent -and $line -notmatch '^\s*#') {
+                $inEvent = $false
+                continue
+            }
+            if ($line -match '^\s*-\s*type:\s*(\w+)') { $currentType = $Matches[1]; continue }
+            if ($line -match '^\s*url:\s*(.+)') {
+                $hookDefs += @{ type = 'webhook'; target = $Matches[1].Trim() }
+            }
+            if ($line -match '^\s*path:\s*(.+)') {
+                $hookDefs += @{ type = 'script'; target = $Matches[1].Trim() }
+            }
+        }
+    }
+}
+
+# Also check for event-named script in hooks dir
+$eventScript = Join-Path $hooksDir "$Event.ps1"
+if ((Test-Path $eventScript) -and -not ($hookDefs | Where-Object { $_.target -eq $eventScript })) {
+    $hookDefs += @{ type = 'script'; target = $eventScript }
+}
+
+if ($hookDefs.Count -eq 0) {
+    Write-Verbose "No hooks configured for event '$Event'"
+    return
+}
+
+# Emit OTel span for each hook invocation
+$emitOtel = Join-Path $PSScriptRoot 'Emit-OtelSpan.ps1'
+
+$results = @()
+foreach ($hook in $hookDefs) {
+    $sw = [System.Diagnostics.Stopwatch]::StartNew()
+    $status = 'success'
+    $output = ''
+
+    try {
+        if ($hook.type -eq 'webhook') {
+            $resp = Invoke-RestMethod -Uri $hook.target -Method POST -Body $payloadJson `
+                -ContentType 'application/json' -TimeoutSec 5 -ErrorAction Stop
+        } elseif ($hook.type -eq 'script') {
+            $scriptPath = if ([System.IO.Path]::IsPathRooted($hook.target)) {
+                $hook.target
+            } else {
+                Join-Path (Resolve-Path $ProjectRoot).Path $hook.target
+            }
+            if (Test-Path $scriptPath) {
+                try {
+                    $output = $payloadJson | & pwsh -NoProfile -Command "try { & '$scriptPath' } catch { Write-Output `$_.Exception.Message; exit 1 }" 2>&1 | Out-String
+                    if ($LASTEXITCODE -ne 0) {
+                        $status = 'failed'
+                    }
+                } catch {
+                    $status = 'failed'
+                    $output = $_.Exception.Message
+                }
+            } else {
+                $status = 'skipped'
+                $output = "Script not found: $scriptPath"
+            }
+        }
+    } catch {
+        $status = 'failed'
+        $output = $_.Exception.Message
+    }
+
+    $sw.Stop()
+    $results += @{
+        hook = $hook
+        status = $status
+        duration_ms = $sw.ElapsedMilliseconds
+        output = $output
+    }
+
+    # Emit OTel span if helper exists
+    if (Test-Path $emitOtel) {
+        $otelAttrs = @{
+            project = $Payload.project ?? ''
+            alias = $Payload.alias ?? ''
+            event = $Event
+            hook_type = $hook.type
+            target = $hook.target
+            duration_ms = $sw.ElapsedMilliseconds
+            success = ($status -eq 'success')
+        }
+        & $emitOtel -SpanName 'kushi.hook.invoked' -Attributes $otelAttrs
+    }
+}
+
+# Write hooks-log.md
+if ($StateDir -and (Test-Path $StateDir)) {
+    $logFile = Join-Path $StateDir 'hooks-log.md'
+    $timestamp = Get-Date -Format 'yyyy-MM-dd HH:mm'
+
+    $entries = @()
+    foreach ($r in $results) {
+        $entry = @"
+
+## [$timestamp] $Event | hook: $($r.hook.target | Split-Path -Leaf)
+
+- status: $($r.status)
+- duration_ms: $($r.duration_ms)
+- target: $($r.hook.target)
+"@
+        if ($r.status -eq 'failed') {
+            $entry += "`n- error: $($r.output)"
+        }
+        $entries += $entry
+    }
+
+    $newContent = $entries -join "`n"
+
+    if (Test-Path $logFile) {
+        $existing = Get-Content -Raw $logFile
+        Set-Content -Path $logFile -Value ($existing + "`n" + $newContent) -Encoding utf8NoBOM
+    } else {
+        $header = "---`nkushi_hooks_log: true`n---`n`n# Hooks Log`n"
+        Set-Content -Path $logFile -Value ($header + $newContent) -Encoding utf8NoBOM
+    }
+}
+
+# Return results for caller inspection
+$results

package/plugin/skills/_shared/hook-templates/console-debug.ps1

@@ -0,0 +1,15 @@
+<#
+.SYNOPSIS
+Hook template: Debug output — prints event payload to console.
+
+.DESCRIPTION
+Copy this file to .kushi/hooks/<event>.ps1 for debugging.
+Prints the full event payload to stdout with timestamp.
+#>
+
+$payload = $input | Out-String
+$timestamp = Get-Date -Format 'yyyy-MM-dd HH:mm:ss'
+
+Write-Output "=== KUSHI HOOK DEBUG [$timestamp] ==="
+Write-Output $payload
+Write-Output "=== END HOOK DEBUG ==="

package/plugin/skills/_shared/hook-templates/teams-notify.ps1

@@ -0,0 +1,47 @@
+<#
+.SYNOPSIS
+Hook template: Posts event to a Microsoft Teams webhook.
+
+.DESCRIPTION
+Copy this file to .kushi/hooks/post-pull.ps1 (or any event name) and
+set $WebhookUrl to your Teams Incoming Webhook URL.
+
+Receives event payload as JSON on stdin.
+#>
+
+# === CONFIGURE THIS ===
+$WebhookUrl = $env:KUSHI_TEAMS_WEBHOOK_URL  # Or hard-code your URL
+
+if (-not $WebhookUrl) {
+    Write-Warning "KUSHI_TEAMS_WEBHOOK_URL not set — skipping Teams notification"
+    exit 0
+}
+
+# Read event payload from stdin
+$payload = $input | Out-String | ConvertFrom-Json
+
+# Build Teams Adaptive Card message
+$card = @{
+    type = 'message'
+    attachments = @(@{
+        contentType = 'application/vnd.microsoft.card.adaptive'
+        content = @{
+            '$schema' = 'http://adaptivecards.io/schemas/adaptive-card.json'
+            type = 'AdaptiveCard'
+            version = '1.4'
+            body = @(
+                @{ type = 'TextBlock'; text = "🔔 Kushi: $($payload.event ?? 'event')"; weight = 'Bolder'; size = 'Medium' }
+                @{ type = 'FactSet'; facts = @(
+                    @{ title = 'Project'; value = $payload.project ?? 'unknown' }
+                    @{ title = 'Source'; value = $payload.source ?? 'n/a' }
+                    @{ title = 'Status'; value = if ($payload.success) { '✅ Success' } else { '⚠️ Issue' } }
+                    @{ title = 'Duration'; value = "$($payload.duration_ms ?? 0)ms" }
+                )}
+            )
+        }
+    })
+}
+
+$json = $card | ConvertTo-Json -Depth 20 -Compress
+Invoke-RestMethod -Uri $WebhookUrl -Method POST -Body $json -ContentType 'application/json' | Out-Null
+Write-Output "Teams notification sent for $($payload.project)"

package/plugin/skills/ask-project/SKILL.md

@@ -72,6 +72,20 @@ When the user passes `--file-back` (or says "file this answer back", "save this
 
 The `--file-back` flag is OPTIONAL. Without it, ask-project behaves exactly as before (read-only, no writes).
 
+## --global / --project-only (v5.3.0+)
+
+Multi-wiki routing flags governed by `multi-wiki-routing.instructions.md`:
+
+| Flag | Behavior |
+|------|----------|
+| *(no flag)* | **Project-first.** Search project `Evidence/<alias>/State/` first; only fall back to the global wiki when project sources are missing/stale or no hit is found. Cite each hit with `[project: <alias>]` or `[global]`. |
+| `--global` | **Global-first.** Search `$KUSHI_GLOBAL_ROOT/State/answers/` first; fall back to the project. Use when you trust the cross-engagement note more than project state. |
+| `--project-only` | **Hard-suppress global.** Never read the global wiki for this question (privacy-sensitive or strictly project-internal). |
+
+Provenance is never silent. Every citation tags `[project: <alias>]` or `[global]`. If the answer mixes both, list each source with its provenance.
+
+The global wiki itself is opt-in (created via `kushi global init`). If it does not exist on disk, all three modes degrade silently to project-only.
+
 ## Inputs
 
 - `<project>` — fuzzy-matched project name. If multiple plausible matches, ask the user.

package/plugin/skills/global-wiki/.created-by-skill-creator

@@ -0,0 +1 @@
+global-wiki