Search the memory bank for facts matching a query. Uses FTS5/BM25 — instant, zero cost. Falls back to the deep-memory backend (expensive, deep) only if no local results and that backend is available. Returns ranked facts with bank attribution and match scores.

Superseded facts (those replaced via gc_retain supersedes) are EXCLUDED by default — you get current truth only. Each returned fact may include a "superseded_by" field pointing to the fact that replaced it (only visible when include_superseded: true). Use include_superseded: true for historical audits.

Store a fact in the memory bank. Auto-routes to the best bank by keyword matching, or specify a bank.

Deduplication:

• Fingerprint dedup only (exact normalized-content match). Fuzzy/BM25 dedup removed — it was silently rejecting corrections.

• Supersedes bypasses even fingerprint dedup — an explicit replacement signal always stores.

Response contract (READ THIS):

• { stored: true, duplicate: false, id, bank } → fact was stored

• { stored: false, duplicate: true, existing_id } → fact was NOT stored; same fingerprint already in DB ALWAYS check 'stored' to know whether your content was persisted. 'ok: true' only means the call succeeded, not that storage happened.

Supersedes + recall: when you pass supersedes: [], the old fact is marked as replaced and won't show up in default recall results. Use recall with include_superseded: true to see historical versions.

Analyze coverage for a topic across all memory banks. Shows: which banks have relevant facts, tag distribution, coverage gaps, stale facts.

Manage memory banks: list all banks with stats, or create new banks. Actions: "list" = show all banks, "create" = new bank, "stats" = detailed statistics.

Obsidian vault knowledge-base indexing. Indexes Obsidian vault .md files into the memory bank for fast retrieval via gc_recall. Actions: "reindex" = enqueue a full reindex now, "status" = show vault config and indexed chunk count.

Query the packaged gc_daemon user manual. Use this whenever you need authoritative help with daemon setup, configuration, workflows, templates, or troubleshooting. Actions:

• search: keyword search over doc titles, ids, and tags

• get: retrieve a doc body by id or path

• list: list docs, templates, workflows, or checklists

• guide: return a ranked guide (docs + checklists + templates) for a topic

• template: return the raw contents of a starter template by name

• validate: check that the manual package is intact

Emergency rebuild of the memory-bank FTS5 index. Use when recall/search is returning stale or incomplete results despite facts existing in the bank. This is a maintenance operation, not a daily tool.

Execute any daemon tool by name through the uniform tool-call surface (GC-2632). Useful when you know the exact tool name and want to dispatch it without a dedicated MCP tool. Handler tools (gc_*) are always available. Code tools (bash, read_file, etc.) require server-side code-tool execution to be enabled.

Merge-field templating (GC-2774).

• placeholders: list available {{ }} placeholders for a context

• fill: render a template block with explicit values

Deterministic dual-path controls (Story 3.1). Direct, LLM-free execution of approved operations.

• manifest: list control-reachable operations and their risk metadata

• execute: run one control; may return held: true if the gate requires approval

Onboarding DAG orchestration and setup generation. Key actions:

• setup_degree: current readiness state (ready | setup-required | degraded)

• bootstrap_apex: minimal pre-apex bootstrap (credential one provider)

• recommended_action: server-authoritative next step

• begin/expand/advance: companion-driven guided flow

• state/summary/show/list/ready/next/node: inspect DAG state

• launch_node/update_node/submit_answers: drive the DAG

• create/create_template/template: build onboarding DAGs

• catalog/admin_overview/readiness: administration views

Reflected capability-state snapshot (features-light-up). Returns the current capability snapshot the front-end uses to decide which features are available.

Beat accumulation: ingest turns, check status, flush buffers, report durability. Actions: ingest, status, flush, report.

Provider cost ceilings and circuit-breaker (Story 3.3, AD-26). Actions: set_ceiling, get_ceilings, status, spend, check, reset, estimate.

Operator-tunable trust posture (Story 3.6, FR-6). Actions: get, set_global, set_tool_trust, clear_tool_trust.

Orchestration trees: create + seat-switch for agent hierarchies (Story 2.11, FR-21). Actions: plant, launch, seat, tree, node, list.

Local MLX model provisioning and offline operation status (Story 2.10, AD-34). Actions: provision, status, offline, connectivity.

Direct proxy to the deep-memory backend (Hindsight today; Foresight expected to succeed it). Actions: health, recall, reflect, retain.

Telegram bot poller status. Returns whether the poller is running and connected.

Interactive AI conversation sessions (backend-neutral). Actions:

• spawn: create a new session (persona/agent_name, optional config, make_apex)

• turn: send a message and get the assistant response

• submit_tool_results: provide results for pending tool calls

• cut_in: inject an operator message into a running session

• get/list/delete: inspect or close sessions

• diagnostics: persona/path resolution diagnostics

• apex_status: show the active apex session

• activate_apex: bind a session as the apex

Chat-style sessions with local GC agents. Actions: spawn, turn, get, list, delete.

Aden conversation instances. Actions: spawn, turn, get, list, delete.

Observable run control and event history. Actions:

• events: durable event log since a seq (non-SSE history read)

• control: operator control (abort)

• watch: SSE live tail (collects events until terminal or timeout)

Approval checkpoints (Story 3.5a).

• get: fetch a held action's render payload + risk dot

• resolve: approve or reject a checkpoint; edited_args supports edit-then-approve

Relay ingress for external peers (e.g. Pluto). Sends a message to an existing agent session or creates a new one. Defaults to the daemon-owned ingress agent (charon).

Live SSE watch of a workflow execution. Collects status events until the execution settles, times out, or the client aborts. Use gc_workflow action=wait for a simpler polling alternative.

Live SSE watch of capability-state changes. Returns the initial snapshot plus any capability state changes until timeout.

Manage behavioral directives using the @always/@never/@stop/@pin/@until vocabulary. Directives are injected into agent context automatically. Scoped to specific agents or global (*). Actions: "add" — create, "remove" — hard delete by ID (confirm: true required for pinned), "deactivate" — soft disable (can reactivate later), "reactivate" — re-enable a deactivated directive, "list" — show active, "inject" — formatted for context injection.

GC-native procedural skill registry. Use this when you want to know whether GC already has a reusable procedure for a task before inventing a new workflow or doing ad-hoc work.

Key actions:

• suggest: rank candidate skills for a task. Returns suggestions plus a recommended top match.

• resolve: like suggest, but only sets resolved when one skill clearly dominates; use this when you need a safe yes/no pick.

• list/show: inspect existing skills and their metadata.

• create/update/deprecate: maintain the skill registry itself.

Matching behavior:

• task text is scored against aliases, skill name, slug, and intent tags

• project-scoped skills are strongly preferred when project matches

• mode can bias toward skills that explicitly support baseline or deep execution

Work coordination with dependency DAG. Actions: create, list, search, ready, show, update, done, cancel, block, unblock, claim, release, comment, plan, tree, stale, focus, backfill_projects, rebuild_search_index. Use action=search to check if an issue about a topic already exists (FTS, ranked, matches title+description regardless of project_id tagging) instead of listing the whole DAG. Issues have dependencies (DAG), assignments, locks, labels. Use 'ready' to see what's unblocked. 'plan' for critical path.

Manage timeline events — deadlines, appointments, blocks, milestones. Links events to Bee issues and other entities. Actions: create_event, update_event, delete_event, get, link, unlink, query, today, upcoming_deadlines, slipped.

Track actual time spent on work. Timers, manual logging, agent job capture, duration models. Actions: start_timer, stop_timer, log, log_agent_job, delete, running, query, aggregate, capacity, duration_estimate.

Reconstruct engaged-attention hours from Timing presence plus project-touch events across Claude Code, pi, Codex, and Bee. Screen-first by default. File output only when target=file|both. Actions: compute, per_day, audit, sensitivity, projects, timesheet_export.

Session ingestion ops — scanner status, attribution repair, manual scans, and knowledge backlog control. Actions: status, scan, pending_knowledge, enqueue_pending_knowledge, backfill_project_ids, backfill_attributions, enqueue_attribution_backfill, review_attributions, next_review_item, apply_review_decision, work_item_summary, process_session_file.

Track money in/out. Runway, forecasts, drift detection. Actions: add, update, delete, get, query, runway, monthly, forecast, drift.

Content dissemination metrics. Track pieces, platform posts, and performance over time. Actions: create (piece), post (distribution), snapshot (manual metrics), ingest (parse platform export), list, report, compare, trend, funnel.

Runtime record definitions and instances. Actions: types, get_type, define_type, create, get, list, update, delete, transition. Use definition for define_type and data for create/update. Use params for Records query filters, sort, temporal constraints, and pagination.

Resource-constrained scheduler. "What should I work on next?" Actions: next, replan, profile, switch_profile, list_profiles, upsert_profile, resources, upsert_resource, capacity, conflicts, simulate, simulate_single, scenarios, solve, solve_and_validate.

Strategic vector tracking — the Fosferon evaluation model. Actions: report, vectors, get_vector, create_vector, update_vector, link, unlink, vectors_for, score, leverage, set_leverage, backfill, vitality, snapshot, snapshots, events, log_event, record_outcome, outcomes, correlation, invest, update_investment, investments, causal_chain, project, projections, expected_value, resolve_projection, accuracy_trend, retrofit, roi, horizon_score.

Canonical project registry for Grand Central. Actions:

• list: list all registered projects

• get: fetch one project by id

• upsert: create or update one project (supports partial payloads; metadata is merged)

• sync: sync projects from ~/.config/gc/registry.toml into the registry DB

• repos: list registered git repos

Use this as the source of truth for project metadata such as repo paths, canonical docs, related projects, and strategy-sync metadata. Prefer this over maintaining sidecar maps.

Persistent chat-style sessions with external A2A peers such as Pluto. Use this for dialogue, clarification, synthesis, and back-and-forth coordination. Do NOT use gc_dispatch for conversational turns; gc_dispatch is for job assignments.

Actions:

• create: open a new peer conversation session and bind it to a registered A2A peer

• turn: send one user message into an existing session and get the peer's reply

• get: fetch the full current state of one session, including transcript and remote threading metadata

• list: list all peer conversation sessions

• delete: destroy one peer conversation session

Important semantics:

• Sessions are persistent and conversation-oriented, not job-oriented.

• Turns create no dispatch jobs and no dispatch audit rows.

• The daemon preserves transcript locally and reuses remote A2A context/threading under the hood.

• peer_agent must be the name of a registered A2A peer (for example: "pluto").

Typical flow:

1. action="create", peer_agent="pluto"

2. action="turn", session_id="", message="..."

3. action="get" or action="list" to inspect session state later

Legacy alias for gc_peer_conversation. Actions: spawn, turn, get, list, destroy.

Legacy alias for gc_ticker/get. Returns the latest ecosystem status snapshot.

Find documents by metadata — domain, type, project, or title.

On-demand agent dispatch. Spawn an agent with a task, inspect dispatchable targets, inspect provider/model availability, preview dispatch resolution, check job status, retrieve output. Actions: dispatch (spawn agent), list_agents (local markdown agents only), list_providers (show valid provider overrides and availability), list_models (show provider model inventories with authoritative vs hint provenance), resolve_dispatch (preview what provider/model/mode GC would use for one target), list_targets (all dispatchable targets, optionally filtered by kind), status (check job), output (get result), list (query jobs), dismiss (hide noisy job), delete (remove one), prune (bulk cleanup), repair_stale (reconcile ghost running jobs after crashes/redeploys). Default is fire-and-forget (returns job_id immediately). Set wait=true to block until done.

Use gc_dispatch for assignments and runnable work. If you want an ongoing dialogue with an external A2A peer (for example Pluto), use gc_peer_conversation instead — that path preserves session/thread semantics and avoids creating one job per turn. Do not inspect past sessions to guess provider/model defaults. Use list_agents, list_providers, list_models, and especially resolve_dispatch instead.

Semantics:

• provider = GC dispatch route, not upstream vendor and not CLI binary name

• model = real provider-native model id only

• resolve_dispatch shows provider_type, binary, model_source, and model_resolution so you can see exactly what GC will do

Provider selection (dispatch backend / route):

• Default: omit provider and let the daemon resolve from the agent's declared provider/model fields plus configured fallback order

• provider: "native" — explicit in-process/native dispatch route

• provider: "native:" — explicit native backend pin, for example provider: "native:zai"

• provider: "claude" | "droid" | "pi" — explicit built-in CLI route override

• provider: "kimi" — explicit dynamic CLI route override when kimi is installed

• provider: "" — any other installed CLI route label or alias accepted by the daemon

• action=list_providers — inspect the currently valid native + CLI route strings before choosing one

Model selection:

• For CLI providers with model_resolution=provider_runtime, omit model unless you know a valid provider-native model id

• Never pass transport labels such as "kimi-cli" or "claude-code-cli" as model values

• action=list_models shows exact live inventories where GC can verify them, and clearly labeled hints otherwise

Claude-specific permission controls:

• permission_mode: default|auto|dontAsk|acceptEdits|plan|bypassPermissions

• dangerously_skip_permissions: true adds --dangerously-skip-permissions

• allow_dangerously_skip_permissions: true adds --allow-dangerously-skip-permissions

Manage scheduled agent dispatches. Actions: list, create, enable, disable, delete, history, fire (manual trigger), tick (force check). Trigger types: cron, interval, session_start, once.

CRON: pass a standard 5-field expression via 'cron' (preferred): "min hour day-of-month month day-of-week" Examples: "0 9 * * mon-fri" — weekdays at 09:00 "0 10 1 * *" — 1st of every month at 10:00 "0 10 1 1,4,7,10 " — 1st of Jan/Apr/Jul/Oct at 10:00 "/15 9-17 * * 1-5" — every 15 min, 9am-5pm, weekdays

The legacy 'hour'/'minute'/'days' params are deprecated but still accepted (the server converts them to a cron expression). They cannot express day-of-month, month-of-year, or ranges — use 'cron' for those.

Human reminders. Simple, managed by Eve or directly. Actions: add (create reminder), list (show pending/fired), dismiss (mark as handled), snooze (delay), delete. Due accepts: ISO timestamps, relative times.

Run deterministic workflows from ~/.config/gc/workflows/. Workflows are YAML pipelines with step types: tool, prompt, dispatch, shell, each, branch, halt.

Actions:

• run (sync by default, or async: true)

• list_workflows — list YAML definitions (defaults to summary: name/file/description/size)

• list_executions — list past runs (defaults to summary: no runtime blob)

• list — alias for list_executions (backward compat)

• show (alias: get_execution) — one execution with full runtime

• report — reliability summary, stale-running detection, recent failures

• detail — per-step breakdown for an execution

• context — inspect runtime context/keys for an execution

• resume — re-run from a checkpoint

• wait — bounded poll until terminal state or timeout

• watch — stream daemon SSE continuity through MCP progress notifications, then return the terminal event

• cancel — stop one execution and cancel any backing Oban workflow job

• dismiss — hide an execution from default listings

• delete — remove one execution (and checkpoint)

• prune — bulk-delete old terminal executions

• repair_stale — mark stale running executions failed and clear checkpoints

Response shaping:

run (sync): - Default shape: { execution_id, status: "complete", last_step, result }. result carries the last MEANINGFUL step's output — the shaper walks the trace backwards and skips nil-returning tail steps (gc.retain / gc.notify side-effects). last_step names whichever step produced result. If every step returns nil, result is null but last_step still names the actual final step. - select: "step_id" — return one specific step's result (bypasses the walk-past-nil default; use when you want an intermediate step or a specific side-effect's receipt). - select: "step_a,step_b" — return multiple specific steps (selected map + result unset). - return: "full" — everything (all step results + trace). - return: "steps" — all step results keyed by step_id, no trace. - return: "trace" — trace only, no results.

run (async: true): - Returns { ok: true, status: "started", execution_id } immediately. - Goes through Oban; survives daemon restart (idempotent resume — crash mid-run → row marked failed with reason "crashed-resume").

list_workflows: - Default: summary — name, file, description, size_bytes (no YAML body) - return: "full" — includes the YAML 'body' field for every workflow - select: "name1,name2" — return full bodies for the named workflows only

list_executions: - Default: summary — id, workflow, status, started_at, updated_at (no runtime blob) - return: "full" — includes 'runtime' JSON for every row (can be large) - select: "id,status" — return only the named fields per row

Use timeout to control client-side HTTP deadline, or "none" for no timeout.

Query email state, financial data, and inbox summary from the mail transceiver. Actions: summary, burn_rate, financial, messages, endpoints, scan, extract_financials, ocr, add_endpoint, remove_endpoint, enable_endpoint, disable_endpoint, update_endpoint, seed_rules, sender_queue, classify_sender, dismiss_sender, ignore_sender, backfill_senders.

Generic HTTP client for external API calls. Actions: get, post, put, delete. Supports bearer, basic, and header auth.

Read-only queries against macOS Timing.app SQLite database. Actions: summary (project totals), capacity (daily hours), duration (estimate from labels), hours_by_label.

Reconciliation engine for data hygiene. Actions: status (last runs, pending reviews), run (trigger sync), rules (list rule files), reviews (pending items), classify (resolve item), dismiss (dismiss item).

General-purpose MCP client proxy. Connect to any MCP server once, use from any agent. Supports all transports: streamable_http (default), sse (e.g. Tidewave), stdio, websocket. Actions: connect (register + connect), disconnect, remove, servers (list registered), tools (list tools), call (invoke a tool), scan (health-check all).

Situational awareness snapshot. Returns the latest ticker state from gc_daemon. Actions: "get" (default) = latest snapshot, "tick" = force a fresh tick.

Notification mailbox for durable consumer polling. Actions: "push" = append a mailbox event, "drain" = fetch unread items and mark them read, "list" = inspect mailbox contents by status/checkpoint.

Recommended integration pattern:

• Persist a per-consumer checkpoint

• Poll gc_notify with action: "drain", since:

• Handle returned events

• Advance the checkpoint to the newest handled created_at

Daemon guarantees durable mailbox creation plus unread/read semantics. Harnesses decide how to surface drained events.

Runtime config reload control plane for YAML/TOML-backed operator config. Supports status, preview, apply, selective targets, safe bulk reload, and legacy section-based requests.

Actions:

• status: Show current reload targets and their live-safe status.

• preview: Dry-run — show what would change without applying.

• apply: Apply the reload for the specified target(s).

Targets (examples): providers, api_keys, env, paths, telegram_routing, telegram_bot_token, vault, a2a_auth, mcp_client, llm_core_providers, llm_core_routing, workflows, personas, session_registry, sync_rules, project_registry

Use after: editing secrets.toml or YAML config, swapping models in LM Studio, rotating API keys, updating workflow definitions, or reloading llm_core.toml provider definitions such as custom CLI providers.

Legacy section names (providers, api, env, paths, telegram, vault, a2a, mcp, llm_core) are still accepted via the section parameter for backward compatibility.

Control DaVinci Resolve Studio via scripting API. Requires Resolve to be running. Actions: status, list_projects, open_project, save_project, list_timelines, get_timeline, set_timeline, get_clips, get_markers, add_marker, delete_markers, set_playhead, open_page, media_pool, clip_metadata, render_setup, add_render_job, render_queue, start_render, stop_render, render_status, render_formats, delete_render_jobs, export_timeline, grab_still, export_frame, project_settings, timeline_settings, create_timeline, import_media, create_subtitles, detect_scene_cuts, transcribe_audio, node_graph, set_lut, copy_grades, quick_export, media_storage.

Search and retrieve documents from DEVONthink. Actions: search (full-text search), similar (find similar documents), read (get plain text by UUID), databases (list all).

List GitHub issues. Filter by state, assignee, labels. Repo falls back to $GH_DEFAULT_REPO when omitted.

Create a GitHub issue. Returns the issue URL.

View a single GitHub issue with full body and comments.

Edit a GitHub issue — change assignee, labels, title, or state.

Add a comment to a GitHub issue.