@joshuafolkken/kit 1.1229.0 → 1.1240.0

package/scripts/release/github-release-runs.ts

@@ -0,0 +1,115 @@
+import { z } from 'zod'
+
+// A job skipped by its `if:` (or neutral) belongs to a run that succeeded; counting it would skip a
+// lower tag whose release is still on its way.
+const FAILED_CONCLUSIONS = new Set(['failure', 'cancelled', 'timed_out', 'startup_failure'])
+const RELEASE_RUN_TITLE = 'GitHub Release '
+const RUN_SCHEMA = z.object({
+	id: z.number(),
+	display_title: z.string(),
+	status: z.string().optional(),
+	conclusion: z.string().nullable().optional(),
+})
+const JOB_SCHEMA = z.object({
+	name: z.string(),
+	status: z.string(),
+	conclusion: z.string().nullable(),
+})
+const RUNS_SCHEMA = z.object({ workflow_runs: z.array(RUN_SCHEMA) })
+const JOBS_SCHEMA = z.object({ jobs: z.array(JOB_SCHEMA) })
+
+type Run = z.infer<typeof RUN_SCHEMA>
+type PollState = 'ready' | 'failed' | 'pending'
+
+// `read` answers a GET on a repository API path. `workflow` is the publish workflow and `jobs` the
+// jobs in it whose failure counts (empty: every job). `release_run_workflow` is the workflow that
+// creates a tag's release — the publish workflow itself when its run creates the release.
+interface RunSource {
+	read: (path: string) => Promise<unknown>
+	workflow: string | undefined
+	jobs: ReadonlyArray<string>
+	release_run_workflow: string | undefined
+}
+
+function is_failed_job(job: z.infer<typeof JOB_SCHEMA>, names: ReadonlyArray<string>): boolean {
+	if (job.status !== 'completed' || !FAILED_CONCLUSIONS.has(job.conclusion ?? '')) return false
+	if (names.length === 0) return true
+
+	return names.some((name) => job.name === name || job.name.startsWith(`${name} /`))
+}
+
+async function list_runs(source: RunSource, workflow_name: string): Promise<ReadonlyArray<Run>> {
+	const workflow = encodeURIComponent(workflow_name)
+
+	return RUNS_SCHEMA.parse(await source.read(`/actions/workflows/${workflow}/runs?per_page=100`))
+		.workflow_runs
+}
+
+async function find_run(
+	source: RunSource,
+	workflow_name: string,
+	title: string,
+): Promise<Run | undefined> {
+	const runs = await list_runs(source, workflow_name)
+
+	return runs.find((item) => item.display_title === title)
+}
+
+async function has_failed_job(source: RunSource, run_id: number): Promise<boolean> {
+	const { jobs } = JOBS_SCHEMA.parse(
+		await source.read(`/actions/runs/${String(run_id)}/jobs?per_page=100`),
+	)
+
+	return jobs.some((job) => is_failed_job(job, source.jobs))
+}
+
+// A run started before its title named the tag may be at work on any tag.
+function may_release(run: Run, tag: string): boolean {
+	if (run.status === 'completed') return false
+
+	return (
+		run.display_title === `${RELEASE_RUN_TITLE}${tag}` ||
+		!run.display_title.startsWith(RELEASE_RUN_TITLE)
+	)
+}
+
+// Unset, nothing tells that a release is over, so the lower tag is waited for.
+async function is_release_over(source: RunSource, tag: string): Promise<boolean> {
+	const workflow = source.release_run_workflow
+	if (workflow === undefined) return false
+	if (workflow === source.workflow) return true
+
+	const runs = await list_runs(source, workflow)
+
+	return runs.every((run) => !may_release(run, tag))
+}
+
+// A lower tag whose publication failed, or finished while no release run is left at work on it,
+// never gains a release: a tag cut before joshuafolkken/kit#3138 was fixed would hold every later one.
+async function is_release_lost(source: RunSource, tag: string): Promise<boolean> {
+	if (source.workflow === undefined) return false
+
+	const run = await find_run(source, source.workflow, `Publish ${tag}`)
+	if (!run) return false
+	if (await has_failed_job(source, run.id)) return true
+
+	return run.status === 'completed' && (await is_release_over(source, tag))
+}
+
+// A run not listed yet is pending too: the announcement that starts this release also starts the
+// publication, so the release can ask before GitHub has queued that run.
+async function publication_state(
+	source: RunSource,
+	workflow: string,
+	tag: string,
+): Promise<PollState> {
+	const run = await find_run(source, workflow, `Publish ${tag}`)
+	if (run?.status !== 'completed') return 'pending'
+
+	return run.conclusion === 'success' ? 'ready' : 'failed'
+}
+
+const github_release_runs = { is_release_lost, publication_state }
+
+export type { PollState, RunSource }
+export { github_release_runs }

package/scripts/release/github-release.ts

@@ -1,6 +1,7 @@
 import { setTimeout } from 'node:timers/promises'
 import semver from 'semver'
 import { z } from 'zod'
+import { github_release_runs, type PollState, type RunSource } from './github-release-runs'
 
 const API_ROOT = 'https://api.github.com/repos'
 const LATEST_PATH = '/releases/latest'
@@ -8,42 +9,26 @@ const REPOSITORY_PATTERN = /^[\w.-]+\/[\w.-]+$/u
 const TAG_PATTERN = /^v\d+\.\d+\.\d+(?:[.-][0-9A-Za-z.-]+)?$/u
 const REQUEST_TIMEOUT_MS = 30_000
 const NOT_FOUND_STATUS = 404
-// A job skipped by its `if:` (or neutral) belongs to a run that succeeded; counting it would skip a
-// lower tag whose release is still on its way.
-const FAILED_CONCLUSIONS = new Set(['failure', 'cancelled', 'timed_out', 'startup_failure'])
 const POLL_INTERVAL_MS = 30_000
 const MAX_WAIT_ATTEMPTS = 120
 const RELEASE_SCHEMA = z.object({ tag_name: z.string().min(1) })
 const NOTES_SCHEMA = z.object({ name: z.string().min(1), body: z.string().min(1) })
-const RUN_SCHEMA = z.object({
-	id: z.number(),
-	display_title: z.string(),
-	status: z.string().optional(),
-	conclusion: z.string().nullable().optional(),
-})
-const JOB_SCHEMA = z.object({
-	name: z.string(),
-	status: z.string(),
-	conclusion: z.string().nullable(),
-})
-const RUNS_SCHEMA = z.object({ workflow_runs: z.array(RUN_SCHEMA) })
-const JOBS_SCHEMA = z.object({ jobs: z.array(JOB_SCHEMA) })
-
 type ReleaseRequest = (url: string, init: RequestInit) => Promise<Response>
 type Wait = () => Promise<void>
-type PollState = 'ready' | 'failed' | 'pending'
 
 // What differs between repositories. `start_tag` is the last tag that predates automatic releases;
 // without it the latest existing release is the floor. `workflow` names the publish workflow whose
 // failed run lets a lower tag be skipped, and `jobs` the jobs in it that count (empty: every job).
 // `await_publish` holds the tag's own release until its run in that workflow has succeeded, for a
-// release started beside the publication rather than from inside it.
+// release started beside the publication rather than from inside it. `release_run_workflow` names
+// the workflow whose run creates a tag's release, so a lower tag left without one can be told lost.
 interface ReleaseSettings {
 	repository: string
 	start_tag?: string | undefined
 	workflow?: string | undefined
 	jobs?: ReadonlyArray<string> | undefined
 	await_publish?: boolean | undefined
+	release_run_workflow?: string | undefined
 }
 
 interface PublishOptions extends ReleaseSettings {
@@ -51,12 +36,10 @@ interface PublishOptions extends ReleaseSettings {
 	wait?: Wait
 }
 
-interface Client {
+interface Client extends Omit<RunSource, 'read'> {
 	request: ReleaseRequest
 	token: string
 	url: string
-	workflow: string | undefined
-	jobs: ReadonlyArray<string>
 }
 
 // `fallback` answers when no tag sits between the floor and the target; without one the floor itself
@@ -139,59 +122,21 @@ function predecessor(
 		.toSorted((left, right) => semver.compare(right, left))[0]
 }
 
-function is_failed_job(job: z.infer<typeof JOB_SCHEMA>, names: ReadonlyArray<string>): boolean {
-	if (job.status !== 'completed' || !FAILED_CONCLUSIONS.has(job.conclusion ?? '')) return false
-	if (names.length === 0) return true
-
-	return names.some((name) => job.name === name || job.name.startsWith(`${name} /`))
-}
-
-async function publish_run(
-	client: Client,
-	workflow_name: string,
-	tag: string,
-): Promise<z.infer<typeof RUN_SCHEMA> | undefined> {
-	const workflow = encodeURIComponent(workflow_name)
-	const runs_response = await api_get(client, `/actions/workflows/${workflow}/runs?per_page=100`)
-	const runs = RUNS_SCHEMA.parse(await read_response(runs_response)).workflow_runs
-
-	return runs.find((item) => item.display_title === `Publish ${tag}`)
-}
-
-async function failed_publication(client: Client, tag: string): Promise<boolean> {
-	if (client.workflow === undefined) return false
-
-	const run = await publish_run(client, client.workflow, tag)
-	if (!run) return false
-
-	const jobs_response = await api_get(client, `/actions/runs/${String(run.id)}/jobs?per_page=100`)
-	const { jobs } = JOBS_SCHEMA.parse(await read_response(jobs_response))
-
-	return jobs.some((job) => is_failed_job(job, client.jobs))
+function run_source(client: Client): RunSource {
+	return { ...client, read: async (path) => await read_response(await api_get(client, path)) }
 }
 
 async function default_wait(): Promise<void> {
 	await setTimeout(POLL_INTERVAL_MS)
 }
 
+// The lost state is read before the release: a run completes only after creating the release, so a
+// run that completes between the two reads still shows its release to the second one.
 async function release_state(client: Client, tag: string): Promise<PollState> {
+	const is_lost = await github_release_runs.is_release_lost(run_source(client), tag)
 	if (await existing_release(client, tag)) return 'ready'
-	if (await failed_publication(client, tag)) return 'failed'
-
-	return 'pending'
-}
-
-// A run not listed yet is pending too: the announcement that starts this release also starts the
-// publication, so the release can ask before GitHub has queued that run.
-async function publication_state(
-	client: Client,
-	workflow: string,
-	tag: string,
-): Promise<PollState> {
-	const run = await publish_run(client, workflow, tag)
-	if (run?.status !== 'completed') return 'pending'
 
-	return run.conclusion === 'success' ? 'ready' : 'failed'
+	return is_lost ? 'failed' : 'pending'
 }
 
 async function poll(
@@ -225,7 +170,7 @@ async function wait_for_publication(client: Client, tag: string, budget: Budget)
 	if (workflow === undefined) throw new Error('Waiting for the publication needs RELEASE_WORKFLOW')
 
 	return await poll(
-		async () => await publication_state(client, workflow, tag),
+		async () => await github_release_runs.publication_state(run_source(client), workflow, tag),
 		budget,
 		`Publish ${tag}`,
 	)
@@ -325,6 +270,7 @@ function create_client(request: ReleaseRequest, token: string, settings: Release
 		url: `${API_ROOT}/${settings.repository}`,
 		workflow: settings.workflow,
 		jobs: settings.jobs ?? [],
+		release_run_workflow: settings.release_run_workflow,
 	}
 }
 

package/scripts/run/cut/run-cut-cli.ts

@@ -290,14 +290,27 @@ function announce_handoff(cut_record: RunCut): void {
 	}
 }
 
-function adopt(target: string, cut_record: RunCut): number {
+// **An implementation resume appends a `resume` event** (joshuafolkken/kit#3375). It clears the record
+// the `cut` event stood for, so the stream is what moves `run:step` back to implementation; a pre-gate
+// resume keeps its record and appends nothing. Best-effort, as the cut's own append is.
+async function emit_resume_event(issue: string, verdict: string): Promise<void> {
+	if (verdict !== RESUME_IMPL_VERDICT) return
+
+	await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.RESUME, `#${issue} resumed`)
+}
+
+async function adopt(target: string, cut_record: RunCut): Promise<number> {
 	const taken = take_over(target, cut_record)
 
 	if (taken === undefined) return report_busy(cut_record)
 
 	announce_handoff(cut_record)
 
-	return report(resume_verdict_for(cut_record), SUCCESS_EXIT_CODE)
+	const verdict = resume_verdict_for(cut_record)
+
+	await emit_resume_event(cut_record.issue, verdict)
+
+	return report(verdict, SUCCESS_EXIT_CODE)
 }
 
 // A relaunched lane child and a fresh session both measure `under`, so only the session that took an
@@ -329,7 +342,7 @@ async function verify_and_adopt(
 
 	if (is_over_threshold_resume(cut_record)) return report_over()
 
-	return adopt(target, cut_record)
+	return await adopt(target, cut_record)
 }
 
 async function resume(target: string, issue: string): Promise<number> {

package/scripts/run/event/run-event-render.ts

@@ -28,6 +28,7 @@ const KIND_LABELS: Readonly<Record<EventKind, KindLabel>> = {
 	split: { ja: '分割', en: 'split' },
 	outage: { ja: '障害', en: 'outage' },
 	cut: { ja: 'セッション交代', en: 'session cut' },
+	resume: { ja: '実装を再開', en: 'implementation resumed' },
 	drain: { ja: 'バックログが空', en: 'backlog drained' },
 	stop: { ja: '停止', en: 'stopped' },
 	'pr-opened': { ja: 'PR 作成', en: 'PR opened' },

package/scripts/run/event/run-event-stream.ts

@@ -48,6 +48,10 @@ const EVENT_KIND = {
 	SPLIT: 'split',
 	OUTAGE: 'outage',
 	CUT: 'cut',
+	// A fresh session adopted an implementation cut — `run:cut --resume` answered `resume-impl`
+	// (joshuafolkken/kit#3375). The resume clears the cut record, so without this the `cut` stayed the
+	// newest position and `run:step` kept answering the resume command it had just run.
+	RESUME: 'resume',
 	// The backlog emptied while nothing of the run's own was in flight — the drain
 	// (joshuafolkken/kit#2335). It marks the position at which the end-of-run retrospective is owed,
 	// *before* the idle watch opens, so `run:step` fires the retrospective at the drain rather than after

package/scripts/run/run-step.ts

@@ -236,9 +236,12 @@ function event_action(event: string, issue_number: string, is_lane_child: boolea
 }
 
 // A run that has planned but emitted nothing else is still at its pre-implementation position, so a
-// `plan` reads the same as an empty stream.
+// `plan` reads the same as an empty stream. A resume from an implementation cut is back at the same
+// position (joshuafolkken/kit#3375): read as the `cut` it follows, it pointed at the spent resume again.
+const IMPLEMENTATION_POSITIONS: ReadonlySet<string> = new Set([KIND.PLAN, KIND.RESUME])
+
 function is_pre_implementation(last_event: string | undefined): boolean {
-	return last_event === undefined || last_event === run_event_stream.EVENT_KIND.PLAN
+	return last_event === undefined || IMPLEMENTATION_POSITIONS.has(last_event)
 }
 
 // **No cut at the setup→implementation boundary** (joshuafolkken/kit#2489). A lane child's context is

package/scripts/run/wake/run-wake-cli.ts

@@ -74,9 +74,8 @@ const WARNING_RECOVERY = `Check the wake command, then restart with \`pnpm josh
 //
 // **`expired` and `unreadable` were silent until joshuafolkken/kit#1746, and that was the defect
 // rather than the design.** Both end the supervisor while a carry record is still sitting there handed
-// off, so the run is left asleep with nothing anywhere saying so — `run-wake.ts` →
-// `is_predecessor_exiting` names the `expired` one as a silent overnight failure in as many words, and
-// then only the `failed` reason was wired to the notification.
+// off, so the run is left asleep with nothing anywhere saying so — a silent overnight failure, while
+// only the `failed` reason was wired to the notification.
 // **Every reason is listed, and the silent two are listed as `undefined`.** A partial map would let a
 // sixth stop reason compile straight past this and reach nobody, which is the defect class this
 // section exists to close.

package/scripts/run/wake/run-wake-describe.ts

@@ -1,10 +1,10 @@
 import { agent_role_profile } from '#scripts/agent/agent-role-profile'
 import { gh_spawn } from '#scripts/gh/gh-spawn'
 import { issue_citation } from '#scripts/rules/issue-citation'
-import { run_carry, type CarryRead } from '#scripts/run/carry/run-carry'
+import { run_carry, type CarryRead, type RunCarry } from '#scripts/run/carry/run-carry'
 import { run_event_stream } from '#scripts/run/event/run-event-stream'
 import { run_liveness } from '#scripts/run/run-liveness'
-import { run_wake, type RunWake } from './run-wake'
+import { run_wake, type RunWake, type WakeDecision, type WakeDecisionInput } from './run-wake'
 
 // The `--list` presentation of a wake record (joshuafolkken/kit#2407 split it out of `run-wake-cli.ts`,
 // which had reached its line limit). What the command *does* stays in the CLI; how a supervisor's
@@ -13,6 +13,7 @@ import { run_wake, type RunWake } from './run-wake'
 const UNKNOWN_CUTS = 'an unreadable number of'
 const REPO_LOOKUP_TIMEOUT_MS = 10_000
 const STOP_COMMAND = 'pnpm josh run:wake --stop'
+const UNREADABLE_TIME = 'an unreadable time'
 
 // The three paths every verb needs: the carry record it reads, its own record, and the work tree a
 // woken session runs in. The work tree is the common git directory's parent, which is the *primary*
@@ -49,6 +50,55 @@ function outstanding_line(wake: RunWake): string | undefined {
 	return `${String(wake.attempts)} launch(es) outstanding for the current cut, none claimed yet`
 }
 
+// **Why the supervisor is not launching, and until when** (joshuafolkken/kit#3363). A supervisor that
+// waits writes nothing to its log, so before this `--list` showed a stalled run and a waiting one
+// alike. The state is `run_wake.decide`'s own answer rather than a second reading of the record: an
+// `idle_since` mark is the last pass having found no work, so it is fed back in as `has_work: false`.
+function wait_input(wake: RunWake, read: CarryRead, now: Date): WakeDecisionInput {
+	return {
+		read,
+		woke_at: wake.woke_at,
+		attempts: wake.attempts ?? 0,
+		is_owner_live: read.kind === 'carried' && run_carry.is_owner_live(read.carry, now),
+		has_work: wake.idle_since === undefined ? undefined : false,
+		idle_since: wake.idle_since,
+		now,
+	}
+}
+
+function deadline(marked_at: string | undefined, limit_ms: number): string {
+	const marked = Date.parse(marked_at ?? '')
+
+	return Number.isNaN(marked) ? UNREADABLE_TIME : new Date(marked + limit_ms).toISOString()
+}
+
+// A live owner that is this supervisor is its own driver at work; any other is a session spending the
+// budget, which has no deadline of its own short of the carry record's whole-run expiry.
+function owner_wait(wake: RunWake, carry: RunCarry): string {
+	if (carry.owner_pid === wake.pid) {
+		return 'waiting: the driver holds the carry record and is running'
+	}
+
+	const expiry = deadline(carry.started_at, run_carry.CARRY_MAX_AGE_MS)
+
+	return `waiting: process ${String(carry.owner_pid)} holds the carry record; the driver starts at its next cut or once it exits, and the record expires at ${expiry}`
+}
+
+const WAIT_LINES: Partial<Record<WakeDecision['kind'], (wake: RunWake) => string>> = {
+	pending: (wake) =>
+		`waiting: the woken session has until ${deadline(wake.woke_at, run_wake.WAKE_GRACE_MS)} to claim the carry record`,
+	idle: (wake) =>
+		`waiting: no runnable work; the driver starts anyway at ${deadline(wake.idle_since, run_wake.IDLE_CEILING_MS)}`,
+}
+
+function wait_line(wake: RunWake, read: CarryRead, now: Date): string | undefined {
+	const { kind } = run_wake.decide(wait_input(wake, read, now))
+
+	if (kind === 'wait' && read.kind === 'carried') return owner_wait(wake, read.carry)
+
+	return WAIT_LINES[kind]?.(wake)
+}
+
 // The run's stream, read here because a headless parent's progress reaches its own transcript alone —
 // after a cut, `--list` is the person's one window onto it (joshuafolkken/kit#1910). Two lines: the
 // newest event (the degenerate last-event read of the stream the watch pane follows, so `--list` and
@@ -73,16 +123,17 @@ function stream_lines(context: WakeContext): Array<string> {
 // **The outstanding line beside it is what makes a shortfall readable**: the count is observed at a
 // poll, so it lags a claim by up to one interval, and launches still outstanding are what say whether
 // a missing wake is one not yet seen or one that never arrived.
-function describe_wake(wake: RunWake, context: WakeContext): string {
+function describe_wake(wake: RunWake, context: WakeContext, now: Date = new Date()): string {
 	const live = run_wake.is_supervisor_live(wake) ? 'running' : 'not running'
-	const cuts = carry_cuts(run_carry.read_carry(context.carry_target))
+	const read = run_carry.read_carry(context.carry_target)
 
 	return [
 		`invocation: ${wake.invocation}`,
 		`profile: ${wake.profile === undefined ? 'unrecorded' : agent_role_profile.describe(wake.profile)}`,
 		`supervisor: process ${String(wake.pid)} (${live}), watching since ${wake.started_at}`,
-		`woke ${String(wake.woke)} session(s) across ${cuts} cut(s)`,
+		`woke ${String(wake.woke)} session(s) across ${carry_cuts(read)} cut(s)`,
 		outstanding_line(wake),
+		wait_line(wake, read, now),
 		run_liveness.describe_agent_state(context.log_target),
 		`output: ${context.log_target}`,
 		// How progress is seen without asking after the cut: the run's stream, followed from here

package/scripts/run/wake/run-wake-loop.ts

@@ -35,9 +35,8 @@ interface LoopPorts {
 	// The carry record, re-read every pass rather than cached: it is written by the parent loop of a
 	// different session, which is the whole point of reading it here.
 	read_carry: () => CarryRead
-	// Whether the process named on the carry record is still running. The cutting session writes
-	// `--cut` and then exits, so the two moments are not the same one and the supervisor has to wait
-	// out the second — `run-wake.ts` → `WakeDecisionInput.is_owner_live`.
+	// Whether the process named on the carry record is still running, which tells a session at work
+	// from a crashed one — `run-wake.ts` → `WakeDecisionInput.is_owner_live`.
 	is_owner_live: (read: CarryRead) => boolean
 	// A compatibility probe for the wake decision. Production lets the resident driver inspect work,
 	// including an empty idle watch, without starting an AI session.
@@ -110,17 +109,11 @@ async function wake_step(wake: RunWake, ports: LoopPorts): Promise<StepOutcome>
 // A `wait` means the woken session has claimed the carry record, so the wake mark is cleared and the
 // next cut starts the grace window afresh — **and it is the only pass on which `woke` may grow**
 // (joshuafolkken/kit#1746), because arriving here is the supervisor observing that a record it was
-// waiting on has been taken over. A `hold` starts the ceiling on a wait without launching
-// anything — the bounded wait on a predecessor that has cut but not yet exited, which ends the moment
-// that predecessor does. A `pending` keeps what is there, because the window it is measured from is
-// still open.
+// waiting on has been taken over. A `pending` keeps what is there, because the window it is measured
+// from is still open.
 function continue_step(wake: RunWake, decision: WakeDecision, ports: LoopPorts): StepOutcome {
 	if (decision.kind === 'wait') return { kind: 'continue', wake: run_wake.count_claim(wake) }
 
-	if (decision.kind === 'hold') {
-		return { kind: 'continue', wake: run_wake.mark_wait(wake, ports.now()) }
-	}
-
 	if (decision.kind === 'idle') {
 		return { kind: 'continue', wake: run_wake.mark_idle(wake, ports.now()) }
 	}
@@ -146,7 +139,6 @@ function decision_input(wake: RunWake, ports: LoopPorts): WakeDecisionInput {
 		woke_at: wake.woke_at,
 		attempts: wake.attempts ?? NO_ATTEMPTS,
 		is_owner_live: ports.is_owner_live(read),
-		held_at: wake.held_at,
 		has_work: undefined,
 		idle_since: wake.idle_since,
 		now: ports.now(),
@@ -155,7 +147,7 @@ function decision_input(wake: RunWake, ports: LoopPorts): WakeDecisionInput {
 
 // **Work is asked about only where the answer could change the decision** (joshuafolkken/kit#2417):
 // on a pass the record alone would launch from. Every other pass — the in-flight wait, the pending
-// grace window, the hold — decides from the record as before and costs no backlog read.
+// grace window — decides from the record as before and costs no backlog read.
 async function decide_pass(wake: RunWake, ports: LoopPorts): Promise<WakeDecision> {
 	const input = decision_input(wake, ports)
 	const decision = run_wake.decide(input)