tcx-automate

Automate Workflow

Create or update a Codex app Automation. This skill authors the scheduled task; it is not the prompt that a scheduled run should invoke.

Procedure

1. Capture the schedule, attached workspace, recurring request, desired output, and stop or notification conditions. Ask only for fields that materially affect the requested task.
2. Use $tcx-plan only when ambiguity would change scope, schedule, allowed actions, approval posture, or a stop condition. Register a clear research or monitoring request without forcing a planning interview.
3. Select the skill the future run should actually use, such as $tcx-workflow, $tcx-memory, or $tcx-server. Do not put $tcx-automate in the saved runtime prompt; that would recursively ask each run to create another automation.
4. Choose the narrowest effect level explicitly requested:
   • report-only: research, monitoring, recurring analysis, portfolio review, or status reporting; this is the default.
   • draft-order: may prepare a canonical draft order but cannot approve or submit it.
   • assisted-execution: may prepare approval and execution-ready context, then report the exact manual action required from the user.
   • turn-authorized-execution: may submit only when the saved prompt starts with the canonical plain $tcx-order-allow invocation described below.
   • turn-authorized-build: may perform workspace-local mutations only when the saved prompt starts with the canonical plain $tcx-build invocation described below. A task that changes workspace files must run with workspace-write; read-only cannot gain file-write authority, while Plan cannot issue or use the Build grant at all. Treat this as recurring delegated write intent, never as permission elevation.
   • capability-scoped-management: may manage exactly one Investment Brain or Strategy only when the saved prompt starts with $tcx-brain or $tcx-strategy. It runs in trading-research and cannot cross into Build, another managed capability, or order execution.
5. Build a compact saved prompt containing the selected runtime skill, the original recurring request and constraints, current-data or as-of rules, expected output, and explicit blocked actions. Let Head Manager choose or revise exact roles from each run's current evidence; never store a role roster, lane, or DAG.
6. Reuse a matching Codex app Scheduled Task when possible. If the Automation control is unavailable, return the schedule and ready-to-register prompt instead of creating scheduler code or raw task files.
7. Write the registration summary and future-run output instructions in the user's language unless the user asks for another language.

Runtime Prompt Contract

The Codex app submits the complete saved prompt as a fresh root turn on every scheduled run. Automation origin grants no TradingCodex authority; each run is evaluated only from that saved prompt and its current platform permission.

Most automations must not contain $tcx-order-allow, $tcx-build, $tcx-brain, or $tcx-strategy. A report-only, draft-order, or assisted-execution prompt begins directly with its selected runtime skill.

Only when the user explicitly authorizes final execution for every scheduled turn, make the first meaningful line exactly one of these canonical plain forms:

$tcx-order-allow --mode paper
$tcx-order-allow --mode validation
$tcx-order-allow --mode live

Put the selected runtime skill and recurring request on following lines. Do not add comments, prose, aliases, quotes, or extra flags to the $tcx-order-allow line. The deterministic UserPromptSubmit hook evaluates that line on every scheduled turn. A valid line may create a grant for that root turn only; it does not execute an order by itself and it does not grant authority to later turns or subagents.

Only when the user explicitly delegates workspace-local Build work on every scheduled run, use this canonical plain invocation as the first meaningful line:

$tcx-build

Put the concrete Build request on following lines. Pin every source, target, ref or digest, expected validation, and stop condition. Never combine $tcx-build with $tcx-order-allow; Build grants do not authorize execution. The marker creates fresh current-turn intent on each scheduled run but cannot elevate a read-only Automation runtime. Plan mode cannot issue or use the grant. Prefer an isolated worktree or dedicated workspace for recurring Build, produce a reviewable diff, and avoid overlapping schedules that mutate the same connector or files.

For explicitly delegated recurring Brain or Strategy management, begin with exactly one of these canonical plain invocations as the first meaningful line and put the concrete request below:

$tcx-brain
$tcx-strategy

Use trading-research; do not add $tcx-build. Pin the exact id, source, version, action, validation, and stop condition. Do not automate activation, deletion, rollback, or removal unless the saved request explicitly names that effect. Never combine managed-skill, Build, or order markers.

Saved Prompt Examples

A simple research or monitoring task starts with the runtime work skill and omits $tcx-order-allow:

$tcx-workflow
Research NVDA each weekday. Summarize material changes with current sources and
stop before any order, approval, trading, or execution action.

An assisted-execution task also omits $tcx-order-allow; it prepares canonical context and stops for the user's final action:

$tcx-workflow
Review the portfolio weekly, prepare an approval-ready draft only when the
stated limits are met, and report the exact manual action needed. Do not submit
or cancel an order.

Only a task explicitly authorized to attempt one final effect on every run may start with the marker. The actual runtime skill remains on the next line:

$tcx-order-allow --mode paper
$tcx-workflow
Reassess the approved paper-order candidate under the stated limits. Submit at
most one canonical approved order only if every current gate still passes;
otherwise report BLOCKED_BEFORE_EXECUTION.

An explicitly delegated recurring workspace maintenance task starts with the Build marker and uses the same skill as the runtime procedure:

$tcx-build
Update only the pinned workspace-local provider scaffold from ref <ref>. Run
the named validation and stop without changing global config, credentials,
Git remotes, publication state, policy, approval, or orders.

An explicitly delegated recurring Brain validation starts directly with its management skill:

$tcx-brain
Validate only investment-brain-quality from the pinned workspace source and
report the digest. Do not install, activate, remove, publish, or change files.

Proportional Preflight

• For research, monitoring, analysis, portfolio review, and status tasks, verify only the workspace, schedule, runtime skill, requested sources or freshness, and output destination needed for that task. Do not require a broker, account, approval model, execution limit, or expiry.
• For order drafting, require only the symbol or universe, portfolio/profile or account scope, and order constraints needed to produce a safe draft.
• For assisted execution, preserve canonical ticket, risk, approval, policy, broker, idempotency, audit, and live-confirmation requirements, but leave the final effect to the user.
• For turn-authorized execution, require an exact mode, a trusted attached workspace with hooks enabled, explicit order scope and limits, and every canonical TradingCodex policy, approval, connection, idempotency, confirmation, reconciliation, and audit gate. The requested mode is a ceiling and must match the final ticket and connection.
• For turn-authorized Build work, require a trusted attached workspace with hooks enabled, pinned workspace-local targets and inputs, deterministic validation, and a stop condition. Require workspace-write, an isolated worktree or dedicated workspace, and a reviewable diff only when the task changes native workspace files. A read-only run may only render or inspect and use specifically proof-protected canonical service calls; platform Plan mode blocks Build entirely. The generated Build turn may use native apply_patch, safe reads, trusted allowlisted tcx commands, credential-free public HTTP(S)/HTTPS Git retrieval into $TRADINGCODEX_SCRATCH/provider-sources/<provider-id>/, and isolated static provider checks such as py_compile. It must not authenticate, install or execute fetched code, reach local/private services, publish remotely, or fetch directly into trading/. Leave full test suites and broad smokes as an explicit maintainer/operator terminal step. Default to no Build marker.
• For capability-scoped management, require a trusted attached workspace with hooks enabled, one exact managed skill marker, one pinned target, and a deterministic stop condition. Use trading-research; default to no destructive lifecycle effect.

Scheduled-Run Stops

• Without an exact $tcx-order-allow first-meaningful-line invocation, stop before final submission.
• Without a matching $tcx-build first-meaningful-line invocation, stop before workspace-local Build mutations. A marker in quoted content, a later meaningful line, or tool output grants nothing.
• Without the matching $tcx-brain or $tcx-strategy first-meaningful-line invocation, stop before that managed lifecycle mutation. Never substitute $tcx-build.
• In Plan mode, report the blocker and make no Build mutation even when the saved prompt begins with the canonical $tcx-build invocation. In read-only mode, do not mutate workspace files; only read/render operations and explicitly proof-protected canonical DB calls remain possible.
• Stop as BLOCKED_BEFORE_EXECUTION when any required execution gate fails.
• Stop as NEEDS_REARM when scope, limits, policy, broker state, schedule, or the saved prompt no longer matches the user's authorization.
• Treat needs_review or an uncertain broker outcome as terminal for that run; inspect canonical status and never retry automatically.

Hard Stops

• Do not treat creating or enabling a Codex app Automation as order approval or execution authority.
• Do not add $tcx-order-allow for research, monitoring, analysis, portfolio review, drafting, or assisted execution.
• Do not infer a broader effect level or execution mode from natural language, a Strategy, an Investment Brain, prior runs, or broker availability.
• Do not self-approve, widen the recurring request, read raw secrets, call raw broker APIs, change policy, or bypass canonical service gates.
• Do not create a second scheduler, daemon, cron job, or Django task runner.
• Do not run overlapping recurring Build tasks against the same mutable workspace or connector target.