scrum-settings

Files (1)

• SKILL.md

SKILL.md (first lines)

Use `project_settings(project)` to read settings unless session context already has them. Defaults: max_active_per_agent=1, require_evidence=true, workspace_root set to the registered project folder.

- Apply changes only when requested by the human. Use the intended existing human profile as actor; resolve an ambiguous profile rather than inventing one or treating an agent profile as human. Call `project_settings(project,actor,...changed fields)` once, preserving other fields.
- `max_active_per_agent` accepts 1..20. It counts unexpired In Progress task claims per agent in this project; humans are exempt. Renewing a current task does not consume another slot. Lowering below existing live usage fails; coordinate completion/release first rather than interrupting another worker.
- `workspace_root` is the registered absolute project folder and is read-only in folder mode. To move a project, release its claims, move its folder, forget the old panel entry and open the new location. Legacy SCRUM_DB mode still permits human root changes after releasing live files.
- `require_evidence` controls fresh verification evidence and a complete checklist on transitions to Done. Preserve it unless the user requests a change; an agent must not weaken policy to finish its own work.
- Retain returned `settings_version` and pass it as `settings_seen` to subsequent `next_work` calls. Report the applied values briefly. The web exposes the same controls under Settings.

Rulesets: task_sizing=Small|Balanced|Unrestricted (defaultSmall); session_stop_percent=92 and weekly_stop_percent=94 (consumed account quotas, configurable1..100); usage_guard=true pauses on unknown/stale quota; usage_check_seconds=60 (1..300). Change only for the human through project_settings and retain its settings_version. Explain that provider refresh delay and cooperative safe-stop latency prevent a strict provider-level hard cap. See scrum-rules and scrum-usage for execution.

auto_resume_session_quota=false by default. Only a human-requested opt-in permits a connected CLI supervisor to continue previously authorized work after a recorded five-hour quota pause and a fresh verified new provider window below both stop thresholds. Manual pause/Stop, profile deletion and disabling the option cancel pending resume. Missing, stale or ambiguous telemetry keeps work paused even if usage_guard is off. A desktop chat or telemetry-only monitor cannot launch work; agent status reports that a compatible connected supervisor is required. Never enable this setting yourself or start a monitor solely because the option exists.

workflow_mode=Auto|Light|Standard (default Auto), configurable by the human via project_settings or web Settings. Auto prefers Light for bounded Small single-agent tasks; Light expresses the same preference but never overrides eligibility. Both fall back to Standard for larger scope, dependencies/blockers or concurrent work. Standard always uses explicit selection/claim. workflow_status reports configured, effective and reason; the website shows the same operation status, recomputed from current task/project state. Empty projects show Standard / No actionable task, not proof of an active session. Do not poll it or change mode to bypass ownership/quota.

Cost control: project_settings(max_parallel_agents=1..20) is human-only, default one. Atomic startup offers and actual claims share this project capacity; the same actor may resume its current work. Additional workers defer without model inference. Lowering the limit leaves active work intact and prevents new actors until capacity is free. The supervisor holds/renews its slot until process-exit cleanup, even if the worker has released its task. Existing quota/WIP/file ownership rules still apply. Never increase this limit to bypass a hold without human authorization.

Git automation (human-only, default off): `git_mode=Off|Branches|Worktrees`. With Branches the server, not the agent, runs git in local code: at claim it moves the checkout to `git_branch_prefix + <context group slug>` (tasks without a group: `prefix + <code>-<title slug>`), created from `git_base_branch` (empty = current HEAD) when missing, and refuses the claim with `branch_busy` while uncommitted work of another branch is present. At Done it commits per `git_commit=Task|Group` (task code and title as message, planned files only) and pushes `git push -u git_remote <branch>` per `git_push=Group|Task|Never` (Group: when every task of the context group is Done/Cancelled; tasks without a group push at Done). Never forced; commit/push failures are recorded on the task and in the response and never undo Done under legacy Off/Group merge policies. Task merge instead retains In Review until delivery succeeds. Change these only for the human and report the applied values.

Git automation never changes branches under another active task. Commits require explicit file plans (Group uses only Done members), preserve unrelated staging, and refuse a changed destination branch or staged planned files. Dependency outcomes must be integrated before dependent tasks; optional native merge follows git_merge below. Git operations run after verification is saved; Task merge defers Done until delivery succeeds.

Per-project MCP selection is machine-local and independent for Codex/Claude: `mcp_servers(project)` lists names/availability only; human `mcp_servers(project, action="update", actor, client, mode="inherit"|"selected", servers=[names])` saves the next managed launch policy. SCRUM is always included. Inherit preserves client configuration; selected filters discovered CLI configuration-file servers. Unavailable selections stop a launch with a clear error. No server probes, model calls, running-worker restart or credentials in responses. Desktop/plugin-managed integrations may be controlled separately. The web Settings offers the same operation.

Git merge: human-only `project_settings(git_merge="Off"|"Group"|"Task")`; Group requires Git branches. The destination is the recorded origin of the work branch; later base-setting changes never redirect it. Existing branches without recorded origin require agent review, never a guessed destination. Native merge/push needs no model. Failures queue scoped Git recovery work for an authorized connected supervisor under normal Stop/quota/reservation rules; absent workers leave TODO.

Human-only git_mode="Worktrees" enables native task/context-group workspaces under .scrum/local/worktrees. It preserves the canonical checkout and staging. Distinct tasks can run in parallel, while a shared context branch remains sequential and file reservations stay central. Pause/finish active work before changing modes. Workspaces are reused for recovery. Optional native cleanup is described below.

Human-only project_settings(git_cleanup=true|false), default false: after successful integration, queue removal of the local branch and clean managed worktree, executed by the existing supervisor offline checkpoint after CLI exit. No AI turn or polling is added. Remote branches, dirty/ignored files, checked-out unmanaged branches and branches needed as origins are retained. Do not manually delete active or unfinished workspaces. Cleanup skips are reported separately from merge failure and never launch a recovery model.

Before cleanup, native code rechecks the task dependency/context component and defers while any related task is not Done/Cancelled, including newly added work. Deferred candidates are reconsidered at later existing CLI-exit events, without polling or model turns. Prefer Branches for one worker when the canonical checkout can be used safely; Worktrees provides optional isolation for parallel workers or a human checkout. Never migrate active/saved workspaces automatically when worker count changes.

Human-only agent_approval_mode="Auto review"|"Ask in chat"|"Full access" (default Auto review, matching prior Codex behavior). Auto review uses the native Codex reviewer with on-request and the existing sandbox; it is not unconditional approval or full access. Ask in chat routes live Codex native approval callbacks to project Chat buttons. Changes apply to the next managed launch. Claude retains its own CLI permission policy; this setting does not silently bypass it.

Codex project permission modes: `Auto review` reviews sandbox escalation requests; `Ask in chat` routes real requests to human buttons; human-selected `Full access` launches workers without local sandbox restrictions or permission prompts. Full access does not override organization/OS restrictions, Stop, quota policy, task dependencies or reservations. Do not change a project to Full access without explicit human authorization. If a blocked task leaves dirty files on its branch, preserve them: do not stash, discard or commit unrelated edits to switch branches. Use isolated Worktrees when authorized, or report the checkout blocker with the saved continuity. Only checked prerequisites count; Done prerequisites permit execution.

Worktrees transition recovery: if the task branch is already checked out in the canonical project folder and no managed mapping exists, claim preparation can reuse that folder without switching branches or creating a duplicate checkout. Dependencies and live claims still apply. The canonical folder is never registered for managed-worktree cleanup. Preserve existing edits/staging; do not force a duplicate branch checkout. New branches continue to use isolated worktrees.

Human-only agent_followup_tasks=true enables necessary autonomous recovery/prerequisite planning within the authorized outcome (default false). The web exposes the same option. The supervisor can register/reuse one scoped Git recovery task when real checkout or Git preparation errors prevent any model launch; it does not start models while idle, bypass Stop/quota, overwrite human changes or retry an unchanged failure endlessly. Use the same context_group for a prerequisite that must reuse the current branch and partial edits.

Human-only `git_pause_blocked=true` (default false) enables private local checkpoints in Branches mode at existing supervisor launch boundaries. With no live claims/reservations, the server can preserve only files planned by that worker's blocked tasks and free the checkout for ready work elsewhere. Resume restores them before the model starts, without push, merge, new task or model call. Staged/unrelated edits, large snapshots and real restore conflicts require scoped reconciliation; byte backups/private refs are retained and cleanup cannot delete a pending checkpoint branch. Do not manually stash/discard to reproduce this operation. Disabling the option stops new checkpoints; existing ones still restore.


Recommended `git_merge="Task"`: one branch per task regardless of context_group; task-scoped commit and immediate merge into its recorded parent. Done requires successful integration and publication unless git_push=Never. In Review preserves verification on failure; a scoped recovery finalizes the original without reimplementation. git_commit=Group does not defer commits in this mode. Use git_pause_blocked=true to preserve blocked partial files privately and let unrelated tasks proceed; saved work restores after refreshing its branch from its recorded parent. This uses native Git, not extra model turns. Group mode remains available for legacy grouped delivery. Changing between Task and legacy policies refuses active/dirty/parked work and unfinished managed workspaces; reconcile existing work first. Do not recreate tasks or discard their evidence to migrate.

Human-only run_advisory_minutes=20, run_advisory_tools=60 and run_advisory_output_tokens=30000 configure native run-cost advisories (0 disables a threshold; max1000000). Web Settings exposes the same fields. They apply at the next supervisor launch, deliver at most once at an existing worker MCP boundary, and never interrupt/relaunch work or override mandatory acceptance. Token counts may be unavailable until provider completion. Metrics audits show last local observations; no model or extra polling is used.


Human project setting `coordination_channel` selects `mcp` (default) or `cli` for the next managed launch. Both enforce identical workflow rules; CLI disables only Scrum MCP. Do not change transport while a worker is active.


Human-only `autonomy_mode`: `Standard` (default) or `Autonomous`. Autonomous delegates routine decisions and permits only specific typed human questions, parked natively so other work can continue. It never grants permissions, bypasses Stop/quota or certifies unverified work.

Human-only `execution_instructions` (text, max4000) supplies standing project instructions once at each managed launch. Defaults empty; no added worker context when unused. Honor them without duplicating the same contract on every task; they do not grant permissions or override native workflow guards.

From martiin3d/scrumstudio, MIT.

More from martiin3d/scrumstudio