Skip to content

Control Nocturnal from an agent

Everything the dashboard can do, a model can do. There is no second-class path: the Nocturnal UI, the phone app, the noc CLI, the MCP server and a plain HTTP request all send the same thing — a command to the engine on your machine.

That means you can hand this page to ChatGPT, Claude, or anything else that can call a tool or make a web request, and it can run your workspace: start an agent on a project, reply to it, set up a loop, run a script, restart a server, commit and push, open an issue, cut a release.

There are three ways in. Pick by where the model lives.

The model is…UseSetup
A coding agent or assistant (Claude, ChatGPT, Claude Code, Codex, Cursor)MCPAdd https://nocturnal.sh/mcp and sign in — see MCP
A shell, a script, a cron job, or CICLInoc is installed with the app
A hosted assistant that can call HTTP (a custom GPT, a webhook)HTTPGive it http://127.0.0.1:17410/api-docs/openapi.json

MCP

Every command is an MCP tool, named with an underscore instead of the dot: agent.new is the tool agent_new, proc.restart is proc_restart. Each one carries its own parameters and description, so a model picks the right tool without being told about Nocturnal first.

Add https://nocturnal.sh/mcp to your client and sign in with your Nocturnal account (MCP). It reaches every computer on your account; pass device to say which.

CLI

noc has short verbs for the things people type daily, and a generic one for everything else.

noc commands                  # every command, grouped, with its parameters
noc commands agent            # just the ones matching "agent"
noc commands --markdown       # the full reference, as markdown to paste into a prompt

noc cmd agent.new projectId=my-app prompt="fix the header spacing"
noc cmd proc.restart id=my-app-web
noc cmd settings.set key=agentDefaultModel value=claude-opus-5

noc cmd <command> key=value … reaches every command, including ones added after this page was written. Values are converted using the command's own types — times=3 is a number, weekdays=yes is a boolean, labels=bug,ui is a list — and a missing required parameter is caught before anything is sent.

Read state with noc topics:

noc topics                    # everything the dashboard renders
noc topics projects
noc topics agentsIndex

Full verb list: CLI.

HTTP

The engine listens on 127.0.0.1:17410. Two endpoints do everything:

GET  /api/topics              # all state — projects, sessions, processes, git, CI, issues
POST /cmd/<command>           # run a command, payload as the JSON body
curl -s http://127.0.0.1:17410/api/topics/projects

curl -s http://127.0.0.1:17410/cmd/agent.new \
  -H 'Content-Type: application/json' \
  -d '{"projectId":"my-app","prompt":"fix the header spacing"}'

Every command replies with the same envelope: { "ok": true, "data": … } or { "ok": false, "error": "…" }.

GET /api/commands returns the whole catalog as JSON — type, group, summary, parameters, and whether the command is read-only. A model that starts there needs no other documentation.

Give it to a custom GPT

The engine publishes its own OpenAPI document at /api-docs/openapi.json, with one operation per command. Import that into a GPT Action, an SDK generator, or Swagger UI at /api-docs.

Assistant builders cap how many operations they will import, so you can ask for a slice:

http://127.0.0.1:17410/api-docs/openapi.json?group=Agents,Projects,Processes

Groups are Agents, Plans, Projects, Processes, Scripts, Ports, Git, GitHub, Issues, Versions, Settings, System.

Reaching it from outside this machine

127.0.0.1 is deliberate: the engine binds to loopback and has no password, because anything that can reach it can run commands on your computer. A hosted assistant is not on your machine, so it cannot call that URL directly. To drive Nocturnal from somewhere else, sign in and use the dashboard, the phone app, or the MCP server, which all relay commands through your account. If you want a hosted model to reach the engine, put it behind a tunnel you authenticate — do not expose port 17410 to a network.

What to tell the model

Three sentences are usually enough:

Nocturnal runs my projects. Read state from GET /api/topics and change things with POST /cmd/<command> on http://127.0.0.1:17410. Call GET /api/commands first to see what exists.

Two habits worth adding: commands marked read-only in the catalog are safe to call while exploring, and Nocturnal never commits or branches on its own — if you want a commit, the model has to ask for git.commit.

Every command

Commands marked read-only change nothing. * marks a required parameter.

Agents

CommandMCP toolWhat it doesParameters
agent.newagent_newLaunch a new agent session on a project. Queues behind a running agent unless runNow is true.projectId, prompt, cwd, planId, runMode, planScope, model, personalityId, runNow
agent.continueagent_continueContinue an existing agent session with a follow-up prompt. Queues behind a running agent unless runNow is true.sessionId, prompt, runMode, planScope, model, personalityId, runNow
agent.loopagent_loopSend a prompt after each finish or on a schedule (every + unit). at / atHour / atMinute align to the clock (hourly :15, daily 09:00) and wait for the next slot. forever:true is schedule-only. stop:true cancels remaining repeats without killing the live run.sessionId, projectId, planId, prompt, times, mode, every, unit, weekdays, at, atHour, atMinute, forever, cwd, runMode, model, personalityId, stop
agent.compactagent_compactCompact an agent session context window via /compact. Queues behind a running agent unless the session is idle.sessionId*
agent.stopagent_stopStop a running agent session.sessionId*
agent.runNowagent_runNowStart a queued agent immediately, even if another agent is already running on the project.sessionId*
agent.queuePauseagent_queuePauseHold or resume a project queue without discarding the work waiting in it.projectId*, paused
agent.queueReorderagent_queueReorderSet the running order of everything waiting in one project queue.projectId, itemIds
agent.queueMoveagent_queueMoveMove one queued item up or down within its chat, or move its whole chat.itemId, delta, projectId
agent.archiveagent_archiveArchive or unarchive an agent session so it leaves the default sidebar list.sessionId*, archived
agent.archiveFromagent_archiveFromArchive an agent session plus every older one in the same project (pinned, running, and queued rows are kept).sessionId*
agent.forkagent_forkCopy a chat into a new idle session with the same transcript, model, and personality.sessionId*
agent.pinagent_pinPin or unpin an agent session (up to 15 pinned per project). A new pin goes to the top.sessionId*, pinned
agent.pinReorderagent_pinReorderSet a custom order for pinned agent sessions in one project.sessionIds*
agent.appearanceagent_appearanceSet or clear a custom icon and colour for an agent tab.sessionId*, icon, color
agent.renameagent_renameSet or clear the display name of an agent session.sessionId*, title
agent.pendingagent_pendingEdit or cancel a follow-up waiting in a session inbox.sessionId, at, prompt, remove
agent.seenagent_seenMark an agent session as read so it loses the unread dot, or with unread: true mark it unread again.sessionId*, at, unread
agent.dismissWaitingagent_dismissWaitingClear the "waiting for you" flag on a session without answering the question, so it stops showing as blocked.sessionId*
agent.setCloudagent_setCloudKeep a session on this Mac (cloud:false) or mirror it so a phone or collaborator can continue it.sessionId, cloud
agent.previewagent_previewDeploy this chat's branch to a temporary preview URL using the project's preview channel. Never touches production; the link lands in the chat.sessionId*
agent.resumeCommandagent_resumeCommandThe terminal command that continues this chat in its own CLI. Picks the CLI that answered last (claude --resume or codex resume), since a chat can move between Claude and Codex.sessionId*
job.createjob_createSchedule a recurring agent job on a project, separately from any plan.projectId, name, prompt, every, unit*, mode, branch, atHour, atMinute, weekdays, timezone, model, effort, maxRuntimeMinutes, maxRuns, maxSpendUsd
job.updatejob_updateChange a scheduled job, or turn it off without deleting it.jobId*, name, prompt, mode, branch, enabled, every, unit, atHour, atMinute, weekdays, maxRuns, maxSpendUsd
job.removejob_removeDelete a scheduled job and stop it running again.jobId*
job.runNowjob_runNowStart a scheduled job immediately without waiting for its next time.jobId*
job.listjob_listRead the scheduled jobs, their recent runs, and what each one costs.projectId
persona.generatepersona_generateStart a brief ask-mode session that drafts a persona name and instructions from a role description. Returns the sessionId; the draft appears in the transcript when the session finishes.projectId, role, model
template.summarisetemplate_summariseAsk a chat to distil itself into a draft agent template for review.sessionId*, name
template.savetemplate_saveSave a reviewed draft as a reusable agent template, or update one.name*, instructions, objective, decisions, context, id, model, personalityId, force
template.removetemplate_removeDelete a saved agent template. The original conversation is untouched.id*
template.starttemplate_startStart a fresh agent from a saved template with a new request.id, projectId, prompt*, cwd, runNow

Plans

CommandMCP toolWhat it doesParameters
plan.createplan_createAdd a plan to the project roadmap. By default an agent is started to write the plan body; pass start:false to store the text as-is.projectId*, prompt, title, issue, start, projectPath
plan.startplan_startStart (or restart) the planning agent that writes a plan body.planId*, projectId, projectPath
plan.buildplan_buildHand a ready plan to an agent to execute. This is the "run the plan" action.planId*, projectId, runMode, model, personalityId, runNow, stages, fromStageId, sessionMode
plan.updateplan_updateEdit a plan title, body, status, narrative summary, or structured overview.planId*, title, body, status, narrativeSummary, overview, overviewAuthor, projectId
plan.refreshOverviewplan_refreshOverviewRe-extract the structured overview from the plan body without launching an agent.planId*, projectId
plan.reviseplan_reviseUpdate plan content with revision tracking and conflict detection. Planning agents use this to publish drafts without writing implementation files.planId, body, baseRev, sessionId, title, summary
plan.archiveplan_archiveArchive or restore a plan.planId*, archived, projectId
plan.moveplan_moveMove a plan up or down the roadmap by one position.planId, delta, projectId
plan.reorderplan_reorderSet the full roadmap order for a project.planIds*, projectId
plan.removeplan_removeDelete a plan from the roadmap.planId*, projectId
plan.ensureFileplan_ensureFileWrite the plan body to a markdown file in the project so an agent can read it from disk.planId*, projectId
plan.stagesInferplan_stagesInferDetect the executable stages in a plan, previewing the change before writing it.planId*, apply
plan.stageAddplan_stageAddAdd a stage to a plan, or split an existing one by hand.planId, title, afterStageId, prompt, criteria
plan.stageUpdateplan_stageUpdateChange one stage: its title, instructions, checks, agent, or whether it runs.planId, stageId, title, prompt, criteria, model, effort, personalityId, runMode, include, completionNote
plan.stageRemoveplan_stageRemoveDelete a stage from a plan, along with its place in the running order.planId, stageId
plan.stageMoveplan_stageMoveMove one stage earlier or later in a plan running order.planId, stageId, delta*
plan.stageStatusplan_stageStatusMark a stage done, blocked, or skipped by hand, and optionally carry on.planId, stageId, status*, advance, note
plan.stageCompleteplan_stageCompleteSubmit a validated structured result for a stage run, replacing marker inference.runId, planId, stageId, sessionId, planRev, outcome, evidence, reason, checkResults
plan.stageRetryplan_stageRetryRe-dispatch a blocked, failed, or stopped stage as a fresh run.planId, stageId, runNow
plan.stageBulkUpdateplan_stageBulkUpdateApply the same change to several stages at once.planId, stageIds, model, effort, personalityId, include
plan.runsplan_runsList stage execution runs for a plan.planId*
plan.ideaAddplan_ideaAddCapture an idea for a project without committing to build it.projectId, title, notes, status, source, accepted
plan.ideaUpdateplan_ideaUpdateChange an idea title, notes, status, or whether it has been accepted.projectId, ideaId, title, notes, status, accepted
plan.ideaRemoveplan_ideaRemoveDelete an idea from a project planning list entirely.projectId, ideaId
plan.ideaPromoteplan_ideaPromoteTurn an idea into a roadmap item, keeping the original idea as its source.projectId, ideaId, title, outcome, horizon
plan.roadmapAddplan_roadmapAddAdd a desired outcome to a project roadmap with a rough time horizon.projectId, title, outcome, horizon, targetDate, dateIsCommitment, source
plan.roadmapUpdateplan_roadmapUpdateChange a roadmap item outcome, horizon, date, or completion.projectId, itemId, title, outcome, horizon, targetDate, dateIsCommitment, done, planIds
plan.roadmapRemoveplan_roadmapRemoveDelete a roadmap item from a project planning list.projectId, itemId
plan.roadmapMoveplan_roadmapMoveMove a roadmap item up or down the project priority order.projectId, itemId, delta*
plan.challengeAddplan_challengeAddRecord an unresolved question or constraint that needs investigation.projectId, question, status, affects, candidateApproaches, dependencies, planId, stageId, source
plan.challengeUpdateplan_challengeUpdateChange a challenge, or resolve it by recording the decision that was made.projectId, challengeId, question, status, decision, dependencies, affects, candidateApproaches
plan.challengeRemoveplan_challengeRemoveDelete a recorded challenge from a project planning list.projectId, challengeId
plan.queueRefineplan_queueRefineQueue a planning pass against a plan. The pass runs in plan mode with the latest plan body. Multiple passes with different personas refine the same plan in order.planId, action, model, effort, personalityId, instructions, projectId
plan.refineUpdateplan_refineUpdateEdit the model, effort, persona, or action on a pending refine queue entry.planId, entryId, action, model, effort, personalityId
plan.refineRunplan_refineRunResume the next pending refinement pass for a plan.planId*
plan.refineRemoveplan_refineRemoveRemove a pending refine queue entry from a plan.planId, entryId
plan.refineReorderplan_refineReorderSet the order of the refine queue entries for a plan.planId, entryIds
plan.refreshplan_refreshRe-read every project planning file and republish the planning topic.—
plan.focusplan_focusPoint the dashboard's Preview pane at something — a plan, the Inbox, the roadmap, the open questions, or a pending proposal. Showing a plan's execution view is how an agent offers to build: it opens the phases and the run button for the user to press. It starts nothing.projectId, subject, planId, proposalId, view, sessionId
plan.listplan_listList this project's plans — id, title, status and stage counts. The read behind "what plans do I have?", and where a planId for plan.brief or plan.focus comes from.projectId*, includeArchived
plan.suggestImprovementsplan_suggestImprovementsAsk an agent to survey the project and propose work as unaccepted ideas.projectId*, count
plan.planSelectedplan_planSelectedTurn selected ideas and roadmap items into one coherent implementation plan.projectId*, ideaIds, itemIds
plan.checkAddplan_checkAddAdd a verification requirement to one stage of a plan.planId, stageId, coverage, description, tool, manual, required
plan.checkRemoveplan_checkRemoveRemove a verification requirement from a stage of a plan.planId, stageId, checkId*
plan.checkRecordplan_checkRecordRecord what a verification check actually did, with its evidence.planId, checkId, outcome*, stageId, evidence, buildRev, tool
plan.reviewplan_reviewRead what was built, what was checked, and what is still outstanding.planId*
plan.briefplan_briefThe one-minute brief for a plan: what it is, its stages, what could go wrong, and what the brief cannot tell you.planId*, outline
plan.setEnvironmentplan_setEnvironmentRecord the revision of a plan that reached staging or production.planId, environment, rev*
plan.morningSummaryplan_morningSummaryAssemble what moved overnight, grouped by what it means for the plan.projectId
plan.clientSummaryplan_clientSummaryDraft a client-readable summary of what reached staging or live.projectId*, environment, whereToTry
plan.documentAddplan_documentAddAdd a document to a plan bundle (note, reference, link or asset list).planId, title, content, role, format, url
plan.documentUpdateplan_documentUpdateUpdate a document in a plan bundle.planId, docId, title, content, role, format, url
plan.documentRemoveplan_documentRemoveRemove a document from a plan bundle.planId, docId
plan.cloudReadplan_cloudReadRead a plan from the shared record, even when the linked Mac is offline.projectId, planId
plan.cloudListplan_cloudListList plan IDs in the shared record for a project.projectId*
sync.statussync_statusRead how each shared artifact stands: synced, pending, offline, or conflicted.—
sync.pushsync_pushOffer this project plan content to the shared record straight away.projectId*
sync.resolvesync_resolveSettle a conflicted artifact by choosing which side becomes the new revision.projectId, kind, artifactId, keep
sync.deletePlansync_deletePlanDelete a plan artifact from the shared record when the plan is removed locally.projectId, planId
planRequest.createplanRequest_createCreate a scoped planning conversation to share with a client. Planning only: it cannot change the project.projectId, title, objective, background, constraints, questions, sources, model, personalityId
planRequest.updateplanRequest_updateChange the brief on a plan request before or during the conversation.requestId, projectId, title, objective, background, constraints, questions, sources, model, personalityId
planRequest.shareplanRequest_shareGive a client access to one plan request. Grants the narrowest role there is: that conversation and nothing else on this machine.requestId, projectId, clientUid*
planRequest.revokeplanRequest_revokeWithdraw a client's access to a plan request. The record and its history stay.requestId, projectId
planRequest.clarifyplanRequest_clarifySend questions back to the client on a submitted scope.requestId, projectId, questions*
planRequest.acceptplanRequest_acceptAccept a submitted scope and turn it into a draft plan. This does not start any work — building the plan is a separate action.requestId, projectId
planRequest.listplanRequest_listList plan requests on a project. A client sees only their own, and only its brief.projectId*
planRequest.openplanRequest_openStart or rejoin the planning conversation on a plan request. Read-only: it cannot edit files, run commands or deploy.requestId, projectId
planRequest.sayplanRequest_saySend a message into a plan request conversation.requestId, projectId, prompt*
planRequest.reviseplanRequest_reviseAdd a revision of the scope. Revisions append — an already submitted one is never rewritten underneath the developer.requestId, projectId, body*, author
planRequest.submitplanRequest_submitMark the newest revision as the scope the client agrees to. Agreement is not approval, and nothing starts.requestId, projectId
planRequest.claimplanRequest_claimRecord something the scope asserts, and whether the client stated it or the agent inferred it.requestId, projectId, text, origin, sourceQuote
proposal.listproposal_listList pending roadmap change proposals for a project.projectId
proposal.acceptproposal_acceptAccept a roadmap change proposal, applying its approved changes. Requires the confirmation ID.proposalId, confirmationId, changeIds, projectId
proposal.rejectproposal_rejectReject a roadmap change proposal or specific items within it.proposalId*, changeIds, projectId
proposal.editproposal_editEdit the data on a pending proposed change before accepting it.proposalId, changeId, data*
proposal.retryproposal_retryRetry only the failed changes from a partially applied proposal.proposalId, confirmationId

Projects

CommandMCP toolWhat it doesParameters
project.stopAllproject_stopAllStop every process-manager row for a project and kill its attributed ports (skips 17410/17411).projectId*
project.rescanproject_rescanRescan the projects directory for new or changed projects.—
project.createproject_createCreate a new project under the projects folder. Writes .nocturnal/ and AGENTS.md. Does not run adoption.name*, id
project.importproject_importRegister an existing folder with Nocturnal. Does not create .nocturnal until the project is onboarded. Omit path to open the native folder picker.path
project.chooseBaseproject_chooseBaseOpen a native folder picker and save the choice as this computer's projects directory.—
project.adoptproject_adoptRun the deep scan on a folder: writes .nocturnal/project.json with services, scripts, processes and the intelligence section, and appends the Nocturnal block to AGENTS.md. This is the "Rescan" / onboarding action and it runs an agent.path*
project.readmeproject_readmeRead the local README file for a project (from disk, not GitHub).path, projectId, file
project.activityproject_activityRecord a human opening a project plan, chat or version.projectId, view, planId, sessionId, version
project.docsproject_docsList markdown files in a project (skips node_modules and other vendor trees).path, projectId
project.docproject_docRead one markdown file from a project (path must stay inside the project).file*, path, projectId
project.searchFilesproject_searchFilesSearch project files by name for composer @ mentions (skips vendor trees).query, path, projectId, limit
project.renameproject_renameSet or clear a display-name override for a project (shown instead of the project.json name).projectId*, name
project.addLinkproject_addLinkAppend a named URL to the project.json links list used by the dashboard bookmarks sidebar.projectId, name, url*
project.revealproject_revealReveal a project folder in Finder on the machine running the engine.projectId*
project.archiveproject_archiveArchive or unarchive a project so it leaves the default rail list.projectId*, archived
sidebar.setsidebar_setReplace the project rail folder layout and custom order.layout*
sidebar.folder.createsidebar_folder_createCreate a folder in the project rail.name, icon
sidebar.folder.deletesidebar_folder_deleteDelete a project rail folder. Projects inside it move back to the top level.id*
sidebar.movesidebar_moveMove a project or folder in the rail — the drag-and-drop action behind the sidebar.move, drop

Processes

CommandMCP toolWhat it doesParameters
proc.startproc_startStart a supervised long-running process.projectId, command, cwd, defId, name
proc.stopproc_stopStop a supervised process.id*
proc.restartproc_restartRestart a Nocturnal-managed process.id*
proc.deleteproc_deleteRemove a process row from the Nocturnal registry.id*
proc.listproc_listList Nocturnal-managed processes with status, pid, and project.—
proc.logsproc_logsRead the tail of a process log.id*, lines
proc.saveproc_saveSnapshot the currently running process set so it can be restored later.—
proc.resurrectproc_resurrectRestart the last saved process set.—
proc.startGroupproc_startGroupStart every process in a named project group (skips members already running).projectId, groupId
proc.stopGroupproc_stopGroupStop every running process in a named project group.projectId, groupId
proc.groupSaveproc_groupSaveReplace the processGroups list in a project's project.json.projectId, groups

Scripts

CommandMCP toolWhat it doesParameters
script.logsscript_logsRead the log for a script run.projectId, scriptId, runId
script.stopscript_stopCancel a running one-shot script.projectId, scriptId
script.runscript_runRun a one-shot project script (command defaults to the script in project.json).projectId, scriptId, command, cwd

Ports

CommandMCP toolWhat it doesParameters
ports.killports_killKill whatever process is holding a TCP port.port*
port.fixConflictsport_fixConflictsLaunch an agent to remap a project off ports that overlap another adopted project.projectId*
port.rotateport_rotateLaunch an agent to move every declared service in a project onto free ports from the registry, even when nothing currently conflicts.projectId*
port.suggestport_suggestSuggest free replacement ports for a project: conflicting and common-default ports by default, every declared service with all. Changes nothing.projectId*, all
registry.claimregistry_claimReserve a port for a project service in the Nocturnal port registry.port, projectId, service*
registry.releaseregistry_releaseRelease a port claim so another project can take it.port*

Git

CommandMCP toolWhat it doesParameters
git.commitgit_commitStage everything and create a git commit.cwd, message
git.suggestCommitgit_suggestCommitDraft a short commit message from the current working-tree diff.cwd*
git.publishRepogit_publishRepoInitialise git if needed, create a GitHub repository with gh, and push.name*, cwd, projectId, visibility
git.createBranchgit_createBranchCreate and switch to a new local git branch.cwd, name
git.checkoutgit_checkoutSwitch to an existing local git branch.cwd, name
git.pushgit_pushPush a branch to origin, creating upstream if needed.cwd*, name
git.branchDetailgit_branchDetailLoad commits and ahead/behind counts for a local branch.cwd, name, base
git.graphgit_graphLoad a commit graph of recent history across all branches.cwd*
git.commitDetailgit_commitDetailLoad the message and changed files for a single commit.cwd, sha
git.refreshgit_refreshRe-read git status for a project and publish gitIndex immediately.cwd*
git.fetchgit_fetchUpdate remote-tracking refs so ahead and behind are current. Changes nothing locally.cwd*
git.pullgit_pullBring remote commits into this workspace, setting local changes aside and back.cwd*, strategy
git.integrationStatusgit_integrationStatusRead whether remote changes can be brought in, and what stands in the way.cwd*
git.resolveMergegit_resolveMergeStart an agent to settle merge conflicts, run the checks, and report what happened.cwd, projectId, branch, verifyCommand
git.removeLockgit_removeLockDelete a stale .git/index.lock left behind by a crashed git process, so commits work again.cwd*
git.mergegit_mergeMerge a local branch into the current branch.cwd, name

GitHub

CommandMCP toolWhat it doesParameters
ci.refreshci_refreshRefresh CI status from GitHub Actions.owner, repo
ci.detailci_detailLoad jobs, failed steps, annotations, and a log tail for a GitHub Actions run.owner, repo, runId*
ci.workflowsci_workflowsList GitHub Actions workflows for a repo, including dispatch inputs and latest run status.owner, repo
ci.triggerWorkflowci_triggerWorkflowTrigger a workflow_dispatch GitHub Actions workflow.owner, repo, workflowId, ref, inputs
github.overviewgithub_overviewFetch open pull requests and local branches for a project repo.owner, repo, cwd
github.createPRgithub_createPRPush the branch if needed and open a GitHub pull request.owner, repo, title, head, base*, body, draft, cwd, push
github.prDetailgithub_prDetailLoad a pull request with files, commits, reviews, and checks.owner, repo, number*
github.mergePRgithub_mergePRMerge a GitHub pull request.owner, repo, number*
deploy.overviewdeploy_overviewFetch GitHub environments and recent deployments for a repo.owner, repo, projectId

Issues

CommandMCP toolWhat it doesParameters
issue.overviewissue_overviewList GitHub issues plus labels, milestones, and assignees for a project.projectPath, projectId, owner, repo, state, labels, milestone, assignee
issue.detailissue_detailLoad one GitHub issue and its comments.number*, projectPath
issue.createissue_createCreate a GitHub issue on the project repository.title*, projectPath, body, labels, assignees, milestone, after
issue.updateissue_updateUpdate a GitHub issue (title, body, state, labels, assignees, milestone).number*, projectPath, title, body, state, stateReason, labels, assignees, milestone
issue.commentissue_commentAdd a comment on a GitHub issue.number, body, projectPath
issue.reorderissue_reorderSave a custom Issues-tab order for a repository (device-local, not GitHub).numbers*, projectPath

Versions

CommandMCP toolWhat it doesParameters
version.cutversion_cutStart cutting a new version — drafts a changelog from commits since the last baseline.projectPath*, projectId, bumpType
version.saveversion_saveSave a drafted version entry to versions.json.projectPath, version, summary, toCommit, fromCommit*, projectId, sections, issueIds
version.markDeployedversion_markDeployedMark a version as deployed.projectPath, version, projectId, ciRunUrl
workingChanges.refreshworkingChanges_refreshRecompute the working-changes summary for a project (agent one-liners and files since the last version).projectId*, projectPath

Deploy

CommandMCP toolWhat it doesParameters
release.planrelease_planRead what a release would carry, where it would go, and what blocks it.projectId*, componentId, target, planId
release.runrelease_runRun a project release script for one component and record what happened.projectId, scriptId, target*, componentId, production, planId
release.recordrelease_recordRecord a release that happened outside Nocturnal, such as a store submission.projectId, sourceRev, action, target, componentId, version, artifact, production, outcome, installKnowledge, detail
release.historyrelease_historyRead the release log for a project, with recovery options and their limits.projectId*, componentId
release.policyrelease_policyRead or change what a project requires before a production release.projectId*, requireStaging, requireChecks, requireAcceptance, autoStageOnVersion, dataNote
release.componentrelease_componentDeclare a releasable component so its version shows separately.projectId, name, kind, defaultTarget

Settings

CommandMCP toolWhat it doesParameters
settings.getsettings_getRead every engine setting (the public settings object; never secrets).—
settings.setsettings_setChange one engine setting. Keys: agentPermissionMode, agentDefaultMode, agentDefaultModel, agentDefaultEffort, agentPersonalities, agentDefaultPersonality, deviceName, projectsBase, processAutostart, workingChangesEnabled, planAskQuestions, agentClaudeChrome, mirrorAgents, editAgentsMd, completionTonesEnabled, completionToneId, completionToneByProject, mutedNotificationsByProject, scriptLabelsByProject, voiceInputEnabled, voiceHoldEnabled, voiceProvider, voiceModel.key, value
tokens.statustokens_statusReport which API keys and tokens are stored on this machine, as booleans and hints. Never returns a secret.—
tokens.settokens_setStore an API key or token on this machine (written 0600 to ~/.nocturnal/secrets.json, never mirrored to the cloud).kind, value
tokens.cleartokens_clearDelete a stored API key or token from this machine.kind*
keepAwake.setkeepAwake_setPrevent the computer from sleeping. duration 0 = indefinite, 60 = one hour, 300 = five hours. Pass off:true to allow sleep again.duration, off
keepAwake.getkeepAwake_getReturn the current keep-awake state (active, duration, expiry).—

System

CommandMCP toolWhat it doesParameters
terminal.openterminal_openOpen a system terminal at a project folder, or tail a process log in one.cwd, logPath
ide.openide_openOpen a project folder in Nocturnal IDE and optionally reveal a file in that workbench (never a lone file window).folder, file, line, column, cwd, path
voice.transcribevoice_transcribeTranscribe a recorded audio clip to text for the voice composer.audio, mime, provider, model, remote, durationMs