singularity-forge/copilot-thoughts.md

Copilot CLI Autopilot Notes For SF

Sources checked 2026-05-08:

• GitHub Docs, "Allowing GitHub Copilot CLI to work autonomously" https://docs.github.com/en/copilot/concepts/agents/copilot-cli/autopilot
• GitHub Docs, "GitHub Copilot CLI command reference" https://docs.github.com/en/copilot/reference/copilot-cli-reference/cli-command-reference
• GitHub Changelog, "GitHub Copilot CLI is now generally available" https://github.blog/changelog/2026-02-25-github-copilot-cli-is-now-generally-available/
• GitHub Copilot CLI product page https://github.com/features/copilot/cli
• GitHub Changelog, "Copilot CLI now supports BYOK and local models" https://github.blog/changelog/2026-04-07-copilot-cli-now-supports-byok-and-local-models/

Useful Pattern

Copilot CLI keeps three concepts separate:

• --autopilot controls whether the agent keeps continuing through multiple model/tool turns until completion, a blocker, interruption, or a continuation limit.
• --allow-all / --yolo expands permission to use tools, paths, and URLs.
• --no-ask-user suppresses clarifying questions, but does not itself create a multi-turn continuation loop.

That separation is the part SF should copy.

GitHub's documented programmatic autopilot example is:

copilot --autopilot --yolo --max-autopilot-continues 10 -p "YOUR PROMPT HERE"

So the important shape is not the word "autopilot"; it is the explicit split between continuation (--autopilot), permission expansion (--yolo / --allow-all), and a runaway-loop limiter (--max-autopilot-continues).

GitHub also presents a strong interactive handoff: plan first, then accept the plan and build on autopilot. SF's equivalent should be "accept plan and run autonomously", backed by UOK state rather than a separate mode.

Copilot CLI Capabilities Worth Tracking

• Plan mode can transition directly into autopilot.
• /fleet runs parallel subagents.
• /remote supports steering from another device.
• /tasks exposes background tasks.
• /session exposes session info, checkpoints, files, plans, cleanup, and pruning.
• /skills, /plugin, /mcp, and /agent customize behavior and tool access.
• BYOK/local-model/offline mode exists; built-in subagents inherit the selected provider configuration.

SF Competitive Read

Copilot CLI's public autopilot story is polished: plan, approve, continue without step-by-step approval, cap continuation, steer remotely, inspect tasks and sessions. SF already has deeper autonomous machinery: UOK policy gates, DB-backed state, recovery, verification, scheduling, captures, forensics, projections, and self-reporting.

The gap to close is presentation and control surface clarity, not core autonomous capability.

SF Names

SF should not import Copilot's autopilot product name. In SF, run control is:

• manual
• assisted
• autonomous

SF permission profile is separate:

• restricted
• normal
• trusted
• unrestricted

SF surfaces and encodings are also separate:

• Surface: TUI, CLI, web, editor, machine surface.
• Output format: text, json, stream-json.
• Protocol: RPC, stdio JSON-RPC, ACP, HTTP/RPC, wire.

Decisions

• Use /autonomous for continuous run control.
• Use sf headless only for the machine surface command name.
• Use --autonomous to chain milestone creation into autonomous mode.
• Reject --auto, --full, and --auto-dispatch instead of silently mapping them.
• Do not use "autopilot" as SF product copy. Keep it as competitor context only; the SF product term is autonomous mode.
• Keep question behavior driven by run control and policy gates, not by the word headless.
• Keep permission expansion driven by permission profile, not by autonomous run control.

Implementation Pull-Through

• UOK lifecycle records carry runControl.
• UOK lifecycle records and execution-policy decisions carry permissionProfile.
• Schedule command state uses autonomous_dispatch.
• Human docs describe docs/specs as exports from .sf/SQLite working state.
• User-facing planning should offer an obvious "accept plan and run autonomously" route.
• Status surfaces should make autonomous background work as inspectable as Copilot's /tasks and /session surfaces.
• Continuation limits should be explicit in autonomous settings and status.

The target model is simple: same flow, different surfaces; same run-control names, different permission profiles; same output, different encodings.