[feat] Default workflows a team can override, starting with session-close #1388

Example

teamai ships session-close. A team that writes workflows/session-close.yaml replaces it.

$ teamai list workflows

=== REPO WORKFLOWS ===
  review-and-fix  (team)
  session-close  (default)

# after the team adds workflows/session-close.yaml and runs teamai pull
$ teamai list workflows

=== REPO WORKFLOWS ===
  review-and-fix  (team)
  session-close  (team)

A workflow from the user-scope team also shows team. For one name the order is project workflow > user-scope workflow > teamai default.

The default definition. It parses with parseWorkflow as written, on a teamai that reads invoke (#1304):

schemaVersion: v1alpha1
name: session-close
description: Close out this session with the person - share what it taught as a team learning, publish its transcript to the team, score it with the team's scorers. Use when the person asks to close the session, share a learning, publish or archive the session, or score or judge it.
invoke: ask
inputs: { session: string, source: string, publish: boolean, scorers: [string], judge: here | driver }
steps:
  - id: learning
    interactive: true
    prompt: "Run `teamai skill get share` and follow it with the person for the {{ inputs.source }} session {{ inputs.session }}. If the person finds nothing worth sharing, return verdict skip. Otherwise write the learning to a file outside the repository and return verdict share, its path, its title, and the learnings namespace (an empty string for the shared root)."
    output: { verdict: share | skip, title: string, file: string, namespace: string }
  - id: contribute
    needs: [learning]
    if: steps.learning.outputs.verdict == 'share'
    approve: Share "{{ steps.learning.outputs.title }}" with the team?
    command: teamai contribute --file "$FILE" --title "$TITLE" --namespace "$NS" --session-id "$SESSION"
    env: { FILE: "{{ steps.learning.outputs.file }}", TITLE: "{{ steps.learning.outputs.title }}", NS: "{{ steps.learning.outputs.namespace }}", SESSION: "{{ inputs.session }}" }
  - id: publish
    needs: []
    if: inputs.publish
    approve: { message: "Publish this session, scrubbed, to the team?", required: true }
    command: teamai session push --scrub --session "$SESSION" --source "$SOURCE"
    env: { SESSION: "{{ inputs.session }}", SOURCE: "{{ inputs.source }}" }
  - id: score
    needs: []
    if: inputs.judge == 'here'
    for_each: inputs.scorers
    command: teamai score --session "$SESSION" --source "$SOURCE" --scorer "$SCORER"
    env: { SESSION: "{{ inputs.session }}", SOURCE: "{{ inputs.source }}", SCORER: "{{ item }}" }
  - id: score-driver
    needs: []
    if: inputs.judge == 'driver'
    for_each: inputs.scorers
    prompt: |
      Judge the {{ inputs.source }} session {{ inputs.session }} with the scorer {{ item }}. Take the judge work with
      teamai score --scorer {{ item }} --session {{ inputs.session }} --source {{ inputs.source }} --json '{"driver":{"kind":"{{ inputs.source }}","machine":"local","workspace":".","can":{"judge":{"isolation":"best-effort","access":"read","tools":["<your tool>"]}}}}'
      Read only the lease's prompt file and evidence directory, answer with the lease's answer schema, and send the answer with the lease's submit command and the same driver. Return the label it stored.
      In tools, declare the id of your own tool (claude, codex, cursor, …), not the session's platform. If teamai answers isolation_unmet, judge_model_unavailable or busy, return an empty label.
    output: { label: string }

judge picks how a session is scored, and the hook decides it when it offers the workflow:

a judge tool teamai runs is installed here (claude, codex, opencode, codebuddy)  → judge: here    → score: teamai's own judge, as today
none is installed (a member who only has Cursor, for example)                   → judge: driver  → score-driver: the step's agent takes
                                                                                                  #1386's lease and judges it, best-effort

publish and scorers are offers the person confirms in the start question. publish also asks once more, from the person's own terminal or the dashboard, because no one reviews a transcript after it is published. auto publishing and scoring never run here; they are #1385's.

The learning step ends in one of two answers. Only share reaches contribute:

person: nothing worth sharing   → { verdict: skip }                                              → contribute skipped
person: share it under k8s      → { verdict: share, title: "Pod startup timeouts",
                                    file: "<outside the repo>/pod-startup.md", namespace: "k8s" } → contribute asks, then
                                                                                                    teamai contribute … --namespace "k8s"
person: share it at the root    → { verdict: share, …, namespace: "" }                            → contribute … --namespace ""

What offers it, at the Stop hook of an attended session. The friction reminder decides; publishing and scoring only ride along with it:

launchedBy is set (#1384)                        → nothing   # a workflow step or a judge; also stops session-close offering itself
nestedStart(env, cwd) is set (#1304)             → nothing   # a child in a workflow worktree or on a teamai/<run>/… branch
runMode is unattended                            → nothing   # attended only
this session drives a skill-driven run not done  → nothing   # a not-done skill state on this machine has orchestrator.session = this session
adapter  = the session's platform has a session adapter (#1221 F `sessions`, today platform-facts.ts)
resolved = session-close as this checkout resolves it (project > user > default)
offer    = resolved.invoke is ask or allow ? sessionCloseOffer(config, {platform, sessionId}) : none
           # sessionCloseOffer:
           #   judge    = installedJudgeTools([]) is not empty ? here : driver
           #   publish  = adapter and sessions.publish.attended is ask (#1385)
           #   scorers  = adapter and scoring sessions.attended is ask (#1385) ? sampledScorers(config, {platform, sessionId}) : []
           #              with judge: driver, minus the scorers whose required isolation is verified: the strictest of
           #              scorers/scoring.yaml isolation, the scorer's isolation and config.yaml scoring.isolation, as the
           #              judge lease computes it (requiredIsolation, src/scorers/isolation.ts)
contributeCheckForSession(sessionId, …, offer)
    # today's friction reminder, unchanged: contributeHintAllowed, smartScore, thresholds,
    # sharing.contributeHint.enabled, contributeHintEnabled, share gate, TEAMAI_CONTRIBUTE_HINT_DISABLED, hinted, contributed
    no friction reminder                         → nothing   # no publish or score offer either
    reminder fires, offer is none                → today's reminder text (`skill get share`), no offered state
    reminder fires                               → the reminder names session-close and carries no inputs
                                                   one state write sets hinted, offered: {publish, scorers} and, for a tool
                                                   whose Stop cannot print, pendingHint with that same text

sampledScorers is the per-session rule the background session judge already applies in entries (src/session-flow/session-work.ts), moved into one function both call:

for each scorer teamai pull cached (sessionScorers)
  scorer has no `sessions: true`                                   → dropped
  scorer lives in a namespace the session was not delivered        → dropped
  isSampled(scorer, {platform, sessionId}, samplingRate) is false  → dropped   # a hash: same answer on every machine and every read
  a label or a settled attempt exists for (scorer, rubric, session) → dropped
  otherwise                                                        → returned with its state: open, or leased while a judge holds it
entries keeps open and leased; sessionCloseOffer offers only open

scorer           samplingRate   isSampled(…, cursor/7c1e…)   offered
review-quality   25             true                          yes
style            25             false                         no
secure-review    100            true                          yes

So with samplingRate: 25 a scorer is offered on about a quarter of the sessions that reach the reminder, always the same ones, and those are the sessions the background judge would pick under auto. The 6 hours idle rule of the background judge does not apply: the offer comes at Stop, while the person is there.

So a team sees the reminder on exactly the Stops it sees it on today, at most once per session, and a person can always start session-close by hand to publish or score a session the reminder never fired on.

The reminder text:

This session hit friction worth sharing. Offer the person the session-close workflow: run
teamai workflow start --describe session-close --driver skill
and start it with the inputs it proposes, once the person confirms them.

describe proposes the inputs, computed for the calling session by the same sessionCloseOffer:

$ teamai workflow start --describe session-close --driver skill
{"data":{"describe":{"workflow":{…},"judging":{"kind":"none"},"ask":{"kind":"ask","question":{"text":"…","inputs":[
  {"name":"session","type":{"type":"string"},"value":"7c1e…","why":"The session to close: this one."},
  {"name":"source","type":{"type":"string"},"value":"cursor","why":"This session's tool, as teamai session list names it."},
  {"name":"publish","type":{"type":"boolean"},"value":true,
   "why":"Archive this session's transcript, scrubbed, for the team. Proposed because the team's attended publish policy is ask. You confirm it again from your own terminal or the dashboard before it runs."},
  {"name":"scorers","type":{"type":"array","items":{"type":"string"}},"value":["review-quality"],
   "why":"Scorers that judge this session now. review-quality samples this session (samplingRate 25). [] skips scoring."},
  {"name":"judge","type":{"type":"enum","values":["here","driver"]},"value":"driver",
   "why":"No judge tool teamai runs is installed here, so this session's agent judges, best-effort."}],"options":[…]}}}}}

Each proposed input carries a why: what the input does, and why describe proposed that value or none. The agent shows the person every input with its value and why, and the person may change or empty any of them before confirming:

describe of the resolved session-close, called from an agent shell
  agentSessionFromEnv() finds no agent session       → no value on any input; the agent asks the person for each
  for each declared input
    name and type are in the contract below          → value and why from sessionCloseOffer(config, {platform, sessionId})
    otherwise                                        → no value and no why; the person gives it

The contract: session: string, source: string, publish: boolean, scorers: [string], judge: here | driver. A declared input matches when its parsed type (OutputSchema) equals the contract's: [string] is {"type":"array","items":{"type":"string"}}, and here | driver is that enum in any order. describe keeps today's type encoding. A team override that keeps these names and types gets them filled:

Starting it by hand

A person can ask their agent to close the session at any time, for example with the friction reminder off. The agent finds it through the workflow-session-close skill that teamai pull generates from the definition's description (#1304), which names those requests, and through skill-data/share, which points at it. It runs the same describe and gets the same proposal; the person can change any value before confirming, for example to name a scorer sampling did not pick. An explicit choice is not sampled: the run judges the scorers it was started with.

person: close this session and score it with style
agent:  teamai workflow start --describe session-close --driver skill
        proposal {"session":"7c1e…","source":"cursor","publish":false,"scorers":[],"judge":"driver"}
person: add style
agent:  starts with {"session":"7c1e…","source":"cursor","publish":false,"scorers":["style"],"judge":"driver"}

Sharing and publishing without scoring:

agent:  proposal {"session":"7c1e…","source":"cursor","publish":true,"scorers":["review-quality"],"judge":"driver"}
person: share the learning and publish it, but don't score it
agent:  starts with {"session":"7c1e…","source":"cursor","publish":true,"scorers":[],"judge":"driver"}
        learning → share → contribute; publish → required approval → session push; score-driver over [] succeeds at once

Behavior

learning, publish and score / score-driver have no needs between them, so they run side by side as the start's parallel answer allows. publish and score read the session as it stands when they run: the close-out turns after that are not published or judged, as with #1385's drain from inside a session.

Gates live in the definition, not in prompts, so the engine records each answer (choice, channel, whether an agent sent it) and the dashboard shows it. contribute keeps an optional approval: a learning still reaches the team's review, so the tool session may answer it under the recommended start, and a person who wants to answer it picks "ask me at optional approvals". The scorers are an input the person confirms at start and the run state keeps, so no approval asks again. Publishing a transcript leaves nothing for the team to review, so it alone is required: the person answers it from their own terminal or the dashboard, and an answer relayed from the tool session is refused (agent_in_path). workflows.auto_approve does not answer these approvals: under the skill driver, #1304's next ignores it for a driver with HITL. The third start describe offers, "Same, but answer optional approvals automatically" (--auto-approve), answers contribute yes on channel auto_approve. It never answers publish, which is required.

Acceptance criteria

• No team sees the friction reminder in more or fewer cases than today. Covered by tests that replay today's contributeCheck cases, also with sessions.publish.attended: ask: the reminder fires on the same Stops, and a Stop where it does not fire offers nothing.
• session-close is offered at most once per session within 30 days, on the Stop where the friction reminder fires, with every artifact that applies on that Stop. A session resumed after its offer record expired (below) can be offered again; that is the accepted bound.
• The offer is computed before contributeCheckForSession and passed into it; the function builds the reminder text and writes hinted, offered and pendingHint in its one state write (src/contribute-check.ts:611-650). A caller never post-processes its result: for a tool whose Stop hook cannot print (codex, codebuddy, workbuddy: the tools outside STOP_STDOUT_TOOLS in src/utils/tool-names.ts) it returns { hint: null } even when the reminder fires. Covered by a hook test with codex: the stashed reminder names the describe command and carries no inputs, and offered is in the write that sets hinted and pendingHint.
• readContributeState, which today drops every field it does not know, reads the new offered: { publish: boolean, scorers: string[] }.
• The offer facts (hinted, offered, contributed) outlive the 24 hours cleanup of the state file: cleanupStaleSessions replaces a stale file with a record of only those facts, removed after 30 days. Resuming a session more than 24 hours later, after a cleanup, never repeats an offer. [feat] Show scorer results in the dashboard #1182 needs the same record for its reminder table; whichever of the two issues lands first adds it, and the other reuses it.
• Use only launchedBy ([feat] Run mode: tell attended runs from unattended ones #1384) and nestedStart(env, cwd) (feat(workflow): add session discovery and managed public leases #1304) for where the session was launched; add no other launch-marker reader. Covered by hook tests with TEAMAI_LAUNCHED_BY=workflow, with TEAMAI_WORKFLOW_ATTEMPT set, and with a teamai/<run>/… branch. A host child with neither a marker nor a workflow place is not recognized, [feat] Run mode: tell attended runs from unattended ones #1384's documented limitation. The unattended and driving-run guards below are separate.
• Never offered while this session drives a skill-driven run that is not done, its own session-close included. A session drives a run when a not-done skill state in this machine's data homes has orchestrator.session equal to it. A state without orchestrator.session blocks nothing.
• Never offered in an unattended session. An unattended --describe of session-close answers denied anyway, since invoke: ask needs a person (feat(workflow): add session discovery and managed public leases #1304).
• The offered scorers come from sampledScorers, one function that SessionWork.entries also calls, so the offer and the background session judge pick the same (scorer, session) pairs. Covered by a test: a scorer with samplingRate: 0 is never offered, one with 100 is offered unless already labelled, one without sessions: true is never offered, and a scorer in a namespace the session was not delivered is not offered.
• skill-data/share, which points at session-close (Definition of done), says to start it with describe's proposed inputs once the person confirms them.
• publish and scorers are offered only for a session whose platform has a session adapter, since session push --session and score --session cannot read the others.
• skill get share keeps working on its own and stays the single source of the learning instructions; the default has no prompt_file.
• One function, sessionCloseOffer, computes the offer for the hook and the values describe proposes. Covered by a test: for one session, the reminder's offered and describe's proposed publish and scorers are equal.
• describe adds value and why to each entry of ask.question.inputs, and of inputs on kind: start, whose name and type are in the contract, when the caller has an agent session (agentSessionFromEnv). Other inputs get neither. why follows the table above, also for publish: false and scorers: []; tests cover each row. Covered by tests: an override that adds ticket: string gets the five values and none for ticket; one that renames session gets no value for it; a call with no agent session variable gets no values.
• The reminder names session-close only while the resolved definition's invoke is ask or allow. With deny it is today's text, and no offered state is written. Covered by a hook test with a project override that sets invoke: deny.
• sessionCloseOffer sets judge: here when installedJudgeTools([]) finds a judge tool on this machine, and judge: driver otherwise. Covered by tests for both values: here runs score, driver runs score-driver, and the other step is skipped.
• The default parses with parseWorkflow, with invoke: ask, interactive: true on learning, the learning output { verdict: share | skip, title, file, namespace }, contribute guarded by if: steps.learning.outputs.verdict == 'share', required: true on the publish approval, an optional approval on contribute, and none on score and score-driver.
• A learning step that returns verdict: skip skips contribute and asks nothing more about the learning. Covered by a test. A run started with scorers: [] runs no judge, and its score or score-driver step succeeds with no results. A scorer whose required isolation is verified (from the scorer, scorers/scoring.yaml or config.yaml) is never proposed with judge: driver; covered by a test with isolation: verified in scorers/scoring.yaml only. A scorer whose lease teamai score refuses with isolation_unmet, judge_model_unavailable or busy ends its score-driver item with an empty label, and the run still succeeds; covered by a test with a model-pinned scorer whose alias has no mapping for the declared tool. The why rows for publish: false and scorers: [] cover off, auto and a tool teamai reads no sessions from, each with a test. learning always runs: a person who only wants to publish or score answers it with nothing to share.
• contribute stays a read-only command step, in self mode too. It may call migrateSelfModeGitignore, which rewrites .teamai/.gitignore only when the file is out of date; teamai pull already runs it, so after a pull it writes nothing. Covered by a test: a self-mode session-close run, after teamai pull, shares a learning and ends without read_only_dirty.
• Defaults resolve behind loadCachedWorkflow and inside listCachedWorkflows (feat(workflow): add session discovery and managed public leases #1304), the one seam feat(workflow): add session discovery and managed public leases #1304 keeps for listing and loading. For one name the order is project workflow > user-scope workflow > teamai default. Defaults are never written to the workflow cache or the team repo. So start, sub-workflows, bundles, handoff, review --branch and feat(workflow): add session discovery and managed public leases #1304's discovery see them, and invoke: ask gets a generated workflow-session-close skill.
• readyStartConfig (src/workflow-commands.ts, feat(workflow): add session discovery and managed public leases #1304) picks the run's scope by asking the project scope's loadCachedWorkflow first. Its project probe must not return the teamai default before the user scope is checked: resolve scope and definition in project > user > default order, then use that scope's configuration. Covered by a test with a project install and a user-scope session-close override.
• teamai list workflows, which lists through scanTeamForPull, and workflow start --describe (feat(workflow): add session discovery and managed public leases #1304) show each workflow's source (describe adds source: 'team' | 'default' to data.describe.workflow, WorkflowDescription in src/workflow/describe.ts): team for a valid cached team definition (project or user scope), default otherwise. No new command.
• A run of a default records definition: { source: 'default', teamaiVersion: '<version>' } on the run state, the snapshot and the run records, and no teamRevision. A team definition records definition: { source: 'team' } beside teamRevision, as today. A default run continued on another machine whose teamai version differs refuses with definition_mismatch, naming both versions.
• A session-close run is recorded and listed like any run. Its record names the closed session in inputs.session and inputs.source. contribute runs inside the attempt with --session-id, so [feat] Record what a session, step or run delivered #1387 records the learning twice: on the contribute pass, and as a learning outcome of the closed session, which is the member's own session and has no launchedBy. Covered by a test.
• Learnings are shared with teamai contribute --session-id to teamai-learnings, as today.

Definition of done

• docs/guide/workflow.md (default workflows and overriding them, with the session-close input contract), docs/guide/knowledge.md (sharing a learning through session-close, and who answers each offer) and their zh-CN pages, with the examples above.
• skill-data/workflow/SKILL.md (feat(workflow): add session discovery and managed public leases #1304), the ask line: give the person each entry of ask.question.inputs with its proposed value and why, and say they may change or empty any of them.
• skill-data/share: points at session-close, since the share workflow changes. skill-data/setup/references/setup-admin.md (the paragraph on the end-of-session prompt and the share workflow): the prompt now offers session-close. skills/teamai/SKILL.md keeps feat(workflow): add session discovery and managed public leases #1304's lines and nothing more.
• The friction reminder text names session-close.
• CHANGELOG.md, under ## [Unreleased] › ### Changed: the friction reminder offers the session-close workflow, which teams can override with workflows/session-close.yaml.
• list help text says workflows show their source; skill-data/core/references/commands.md regenerated with npx vitest run commands-reference -u.
• Real-CLI record: one attended session that triggers the reminder and shares a learning through session-close.

Out of scope

• session-to-task, a second default workflow that turns a session's bug fix into a benchmark task: [feat] session-to-task: turn a session's bug fix into a benchmark task #1402. It reuses this issue's default-workflow resolution and describe value and why seam.
• teamai ships no default workflow for MR learnings or learning promotion. ci extract-mr must keep running in a bare CI checkout, and a team can wrap it in its own workflow ([feat] One launcher for every AI call, from the tool descriptor #1389 shows how).
• auto publishing and scoring ([feat] Publish and score sessions by run mode #1385).
• Learnings from unattended runs. Nothing starts session-close there.
• Learnings through pull requests.

Notes

• Reminder: src/contribute-check.ts (flow comment at the top), contributeCheckForSession (:509), handler contributeCheckHandler at src/hook-handlers.ts:486-511, contributeHintAllowed in src/skill-content.ts:180. The handler's early return on contributeHintAllowed (:494) stays: no offer goes out without the friction reminder.
• Per-session state: the file getSessionPath returns (src/contribute-check.ts:120-128). readContributeState reads only the fields it knows (:138-160). ContributeState: src/types.ts:2156. Cleanup: cleanupStaleSessions deletes state files older than 24 hours (STALE_SESSION_MS, :183-208) whenever another session writes its state.
• Config keys: sharing.contributeHint.enabled (team) and contributeHintEnabled (member), src/types.ts:124-132, :850, resolved by isContributeHintEnabled (:282-290).
• Guards: readLaunch (src/launch-context.ts), which [feat] Run mode: tell attended runs from unattended ones #1384's launchedBy extends to any TEAMAI_LAUNCHED_BY value and to the skill driver's TEAMAI_WORKFLOW_ATTEMPT. nestedStart is on main since feat(workflow): add session discovery and managed public leases #1304 (src/workflow/attempt-marker.ts); a start inside a workflow place is refused nested_workflow anyway, so the reminder must not offer one. The driving-run lookup reads orchestrator.session in the skill state (src/workflow/drivers/skill/skill-state.ts, feat(workflow): add session discovery and managed public leases #1304).
• invoke: the default deny refuses a start from any tool session, the Stop hook's included. ask folds the person's consent into the one question --describe asks, so a tool session never starts a close-out on its own from the generated skill. allow would. A team that wants that overrides with allow. The host also asks once before start, since feat(workflow): add session discovery and managed public leases #1304 pre-approves only start --describe, next, report and respond. A team file that sets invoke needs a teamai that reads it.
• interactive: true steps are worked by the current tool session with the person (feat(workflow): add session discovery and managed public leases #1304). A child session would get only a brief, none of the closed session's context, and a read-only step that leaves a file fails read_only_dirty.
• Approvals under the skill driver: feat(workflow): add session discovery and managed public leases #1304's HITL choices at start are person, recommend and auto-approve (src/workflow/drivers/skill/preflight.ts), asked only when a step has an optional gate (neededAnswers); with recommend, the tool session answers those gates. contribute's is session-close's only one. A required gate is handed to the person, who answers with teamai workflow respond in their own terminal or in the dashboard; respond from the tool session's shell is refused agent_in_path (feat(workflow): add session discovery and managed public leases #1304, src/workflow/run-controls.ts). next ignores workflows.auto_approve for a driver with HITL (src/workflow/engine.ts, the comment above answerOptionalGates); answerWithoutHitl applies it only to drivers without HITL.
• Workflow resolution: loadCachedWorkflow (src/workflow/cache.ts), used by loadWorkflowTree, loadWorkflowBundle, the engine's startRun (src/workflow/engine.ts), review --branch (src/review-branch.ts:696) and readyStartConfig (src/workflow-commands.ts, feat(workflow): add session discovery and managed public leases #1304). dropUnsettled (src/workflow/cache.ts) would delete a default written into the cache. feat(workflow): add session discovery and managed public leases #1304 added listCachedWorkflows, aliases, advertisedWorkflows (src/workflow/discovery/workflow-skills.ts) and --describe. Precedent for package-served content: src/builtin-skills.ts.
• Listing: teamai list workflows exists (workflows in RESOURCE_TYPES, src/types.ts:1649-1664). It lists the team repo's files through the handler's scanTeamForPull (src/status.ts:419-432), valid or not, so it needs the cache's view to tell team from default.
• Run state fields: BodySchema (src/workflow/snapshot.ts) holds teamRevision today. A claimed run without a team revision: definitionsOf (src/workflow/handoff.ts) today tells the member to run teamai pull.
• This issue lands after [feat] Add the session skill driver and invocable workflows #1086. A tool whose Stop hook cannot print gets the reminder stashed for its next prompt, as today (stopStdoutUnsupported, src/hook-handlers.ts:505-508).
• session push --session <id> comes from [feat] Publish and score sessions by run mode #1385. teamai score --session --source --scorer exists today and runs teamai's own judge (src/session-flow/scoring.ts); --scorer is repeatable, and for_each gives one call per scorer. Its choice of judge tool is installedJudgeTools([]) and chooseJudgeModel (src/session-flow/scoring.ts:124-132); the hook's judge uses the same list. score --session with --json and can.judge, which score-driver runs, comes from [feat] Judge a session with the driver's own tool #1386.
• Input types: TYPE_NAMES and parseOutput in src/workflow/parse.ts ([string] is an array of strings; a bare array is not a type; share | skip is an enum). approve without required is optional (parseHitl, src/workflow/parse-hitl.ts). A step that needs a skipped step is skipped (skipUnreachable, src/workflow/engine.ts), so contribute is skipped with learning. contribute is also skipped when its if is false, on verdict: skip. A for_each over an empty list succeeds at once with results [] (docs/guide/workflow-advanced.md), so scorers: [] needs no guard.
• In self mode contribute calls migrateSelfModeGitignore (src/contribute.ts:219-225, src/init.ts:1057). It writes only when migrateSelfModeGitignoreContent reports a change, and teamai pull runs it first (src/pull.ts:187-188), so the contribute step leaves the checkout as it found it.
• describe's input list: inputsOf (src/workflow/drivers/skill/preflight.ts, feat(workflow): add session discovery and managed public leases #1304), used for ask.question.inputs and start.inputs. This issue adds value and why, keyed by the resolved workflow's name. Today the question shows only each input's name and type (factsOf), and the workflow's description is not in it. The caller's session: agentSessionFromEnv (src/utils/session-id.ts) gives its id and agent family; source is the platform name teamai session list uses (src/session-flow/adapters/platform-facts.ts), mapped from that family.
• No step uses choose: each offer is a yes or no on an artifact the hook already picked, so options would only restate the inputs.