Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@docs/internals/autonomy-jira.md`:
- Around line 262-266: Fix the minor typo in the sentence containing "dropped
due input close" by changing it to a grammatically correct phrase such as
"dropped due to input closing" (or "dropped due to input closure"); locate the
sentence that currently reads "Headless proactive and cron paths cancel any
already-created command that is dropped due input close." and replace that
fragment with "dropped due to input closing" to correct the grammar.

In
`@packages/builtin-tools/src/tools/RemoteTriggerTool/__tests__/RemoteTriggerTool.test.ts`:
- Around line 15-19: Replace the inline mock defined via
mock.module('src/utils/auth.js', ...) with the shared auth mock from
tests/mocks/, and if the test requires different exports
(checkAndRefreshOAuthTokenIfNeeded, getClaudeAIOAuthTokens,
isClaudeAISubscriber) update the shared mock file to include those
implementations; in practice remove the inline mock.module(...) block in
RemoteTriggerTool.test.ts and import/require the common mock from
tests/mocks/auth (extending that file to return the needed async stub and
token/subscriber helpers) so all tests reuse the single shared mock.
- Around line 33-43: Remove the full mock of 'src/constants/oauth.js' in
RemoteTriggerTool.test.ts and use the real constants module instead; locate the
mock.module(...) block that overrides ALL_OAUTH_SCOPES,
CLAUDE_AI_INFERENCE_SCOPE, CLAUDE_AI_OAUTH_SCOPES, CLAUDE_AI_PROFILE_SCOPE,
CONSOLE_OAUTH_SCOPES, MCP_CLIENT_METADATA_URL, OAUTH_BETA_HEADER,
fileSuffixForOauthConfig, and getOauthConfig and delete it so tests import the
actual constants, or if the real module has a side effect, replace the full mock
with a narrow mock only for the specific side-effectful exports (e.g., mock
getOauthConfig or fileSuffixForOauthConfig) while leaving the pure data exports
intact.

In `@src/cli/print.ts`:
- Around line 2841-2845: The code currently calls markAutonomyRunCancelled(...)
when inputClosed is true, which only updates run state and leaves the queued
command record; replace those calls so the queued command is cancelled instead
by invoking cancelQueuedAutonomyCommands({ commands: [command] }) wherever the
inputClosed branches currently call markAutonomyRunCancelled (e.g., in the
handlers using the local variable command); ensure you import/ensure
availability of cancelQueuedAutonomyCommands and remove or stop calling
markAutonomyRunCancelled in those branches so the queue-side record is
retracted.

In `@src/screens/REPL.tsx`:
- Around line 4859-4876: The code currently always finalizes
claim.claimedCommands as completed after calling onQuery, which is wrong if
onQuery returned via the concurrent-guard path; change the call to capture an
execution indicator (e.g., const executed = await onQuery([userMessage],
newAbortController, true, [], mainLoopModel) or have onQuery return a
boolean/enum) and only call finalizeAutonomyCommandsForTurn(..., outcome: {
type: 'completed' }) when executed is true; also move the completed-finalize
into its own try/catch so any error thrown by finalizeAutonomyCommandsForTurn
does not propagate into the outer catch and trigger a second finalize with
outcome: { type: 'failed' } — in the outer catch use the execution indicator to
decide whether to call finalizeAutonomyCommandsForTurn(..., outcome: { type:
'failed', error }) for claim.claimedCommands, and keep enqueue(nextCommand)
behavior unchanged when completed.
- Around line 4853-4855: The code is unsafely forcing command.value to string
when creating the userMessage; update the createUserMessage call (where
userMessage is constructed) to stop casting: use content: command.value instead,
or if you truly need a string-only path add a type guard (e.g., if (typeof
command.value !== 'string') return; ) before calling createUserMessage so
content is passed as a string safely; reference createUserMessage, command, and
userMessage when making the change.

In `@src/utils/autonomyAuthority.ts`:
- Around line 148-155: The fence toggling logic (matching only by character) can
prematurely close an outer fence when encountering a shorter inner fence like
```yaml, leaking in-fence config; fix by detecting multi-char fences and
tracking their length: change the regex to capture a run of the same fence char
(e.g., /^([`~])\1{2,}(.*)$/), compute fenceLen and trailing content from
trimmed, when opening set activeFenceChar and activeFenceLen, and when closing
only clear the fence if fenceChar matches AND fenceLen >= activeFenceLen AND
trailing.trim() === '' (then reset activeFenceLen to 0); keep the existing
masked[i] = '' and continue behavior.

In `@src/utils/autonomyRuns.ts`:
- Around line 254-264: The PID validity check in isValidOwnerProcessId wrongly
rejects the maximum valid Linux PID by using pid < 4_194_304; change the upper
bound to allow the maximum (use pid <= 4_194_304 or pid <= 4194304) so that a
live run owned by pid==4194304 is considered valid; update the numeric literal
(or replace with a named constant like MAX_PID) in isValidOwnerProcessId to
reflect the inclusive maximum.
- Around line 130-147: selectPersistedAutonomyRuns currently enforces
AUTONOMY_RUNS_MAX before preserving active runs, which can evict queued/running
records; change the logic in selectPersistedAutonomyRuns to first separate
cloned records into active (isAutonomyRunActive) and inactive lists, sort both
by createdAt descending, always retain all active runs, then append the most
recent inactive runs up to AUTONOMY_RUNS_MAX - active.length (if that remaining
budget is <= 0, keep only active), and finally return the combined list sorted
by createdAt descending; refer to the function selectPersistedAutonomyRuns,
helper cloneRunRecord, isAutonomyRunActive, and the AUTONOMY_RUNS_MAX constant
when making the change.

In `@src/utils/processUserInput/processSlashCommand.tsx`:
- Around line 203-216: In finalizeDeferredAutonomyRunCompleted, the follow-up
autonomy commands returned by finalizeAutonomyRunCompleted are being enqueued
before the worker's scheduled-task-result is queued, which can advance the flow
out of order; change the sequence so you first create/queue the
scheduled-task-result notification (the background result for
autonomy.runId/rootDir/spawnTimeWorkload) and only after that loop over
nextCommands and call enqueue(nextCommand). Apply the same fix to the other
occurrence mentioned (lines around the second finalizeAutonomyRunCompleted call)
so the result is always enqueued before any follow-up commands.

In `@tests/integration/dependency-overrides.test.ts`:
- Around line 94-96: Replace uses of
streamdownRequire.resolve('mermaid/package.json') with a filesystem-based
lookup: call streamdownRequire.resolve('mermaid') to get the package entrypoint,
compute the package root with path.dirname on that result, then read the
package.json via fs.readFileSync or fs.promises.readFile from
path.join(packageRoot, 'package.json'). Update the mermaidPackagePath usage (and
the similar occurrences around the other
streamdownRequire.resolve('mermaid/package.json') calls) to use this packageRoot
+ 'package.json' lookup so you avoid ERR_PACKAGE_PATH_NOT_EXPORTED in
environments that honor package exports.
- Line 2: The test currently imports readFileSync from node:fs and uses it to
read mermaid/package.json; replace that Node API usage with Bun's async file API
by removing the readFileSync import and changing the call at the
mermaidPackagePath usage to await Bun.file(mermaidPackagePath).text(); keep the
existing async test signature and leave other fs imports (mkdtempSync,
writeFileSync, rmSync) intact so only the read operation switches to
Bun.file(...).text() for compliance with Bun APIs.

---

Outside diff comments:
In `@src/cli/print.ts`:
- Around line 2827-2840: The onFire cron callback currently calls
prepareAutonomyTurnPrompt(...) and commitAutonomyQueuedPrompt(...), which can
enqueue duplicate scheduled prompts while a previous run is active; change this
flow to call createAutonomyQueuedPromptIfNoActiveSource(...) instead to enforce
active-source deduping, passing the prepared prompt (or the original prompt
string) as the source label and including currentDir: cwd() and workload:
WORKLOAD_CRON; remove or replace the commitAutonomyQueuedPrompt(...) invocation
and ensure you still call prepareAutonomyTurnPrompt(...) to build the prompt
before calling createAutonomyQueuedPromptIfNoActiveSource(...).

---

Nitpick comments:
In `@docs/agent/sur-skill-overflow-bugs.md`:
- Around line 81-89: Update the fenced code block that contains the bun commands
to include a language identifier for consistent rendering and linting; replace
the opening ``` with ```bash (or ```sh) so the block that starts with "bun run
typecheck   # 0 errors" becomes a bash-marked fenced block.

In `@src/services/compact/postCompactCleanup.ts`:
- Around line 31-74: runPostCompactCleanup currently returns void but launches
async work via import('../../utils/attributionHooks.js').then(...), which hides
completion ordering; change the function signature to async (export async
function runPostCompactCleanup(...): Promise<void>) and replace the .then(...)
call with an awaited dynamic import and awaited sweep (const m = await
import(...); await m.sweepFileContentCache()), ensuring the function only
returns after sweepFileContentCache completes so callers can await completion.

In `@src/services/skillLearning/featureCheck.ts`:
- Around line 11-14: The function isSkillLearningCompiledIn currently returns
true/false via an if statement; simplify it by returning the feature check
result directly (replace the if/return block in isSkillLearningCompiledIn with a
single return of the call to feature('SKILL_LEARNING') so it returns the boolean
from feature directly).

In `@src/services/skillSearch/featureCheck.ts`:
- Around line 11-14: The isSkillSearchCompiledIn function currently uses an
if-return-true pattern; simplify it by returning the boolean result of
feature('EXPERIMENTAL_SKILL_SEARCH') directly. Update the function
isSkillSearchCompiledIn to return feature('EXPERIMENTAL_SKILL_SEARCH') without
the conditional wrapper so the code is more concise and idiomatic.

In `@src/utils/__tests__/autonomyRuns.test.ts`:
- Around line 2-4: The test imports Node built-ins (existsSync, readFileSync,
mkdir, writeFile, join, resolvePath); replace those with Bun-compatible helpers
so the test runs in the Bun-only runtime: remove the Node fs/path imports and
use the repo's Bun test filesystem helpers or Bun APIs (e.g.,
Bun.file/Bun.read/Bun.write or the existing test helper functions) to
create/read/write files and dirs and to resolve/join paths; update references to
existsSync/readFileSync/mkdir/writeFile/join/resolvePath in this test to call
the chosen Bun helper functions or the repo test helpers so no Node built-ins
are imported or used.

In `@src/utils/autonomyFlows.ts`:
- Around line 170-187: The double-sort in selectPersistedAutonomyFlows is
non-obvious: first it sorts by active status (using isManagedFlowStatusActive)
then by updatedAt to pick the top AUTONOMY_FLOWS_MAX into retained, and then it
re-sorts retained by updatedAt for final ordering; add a concise comment above
selectPersistedAutonomyFlows (or immediately above the retained creation)
explaining this two-phase intent — i.e., prioritize active flows when selecting
the subset, then present the chosen subset sorted by most-recent updatedAt — and
reference the retained variable, AUTONOMY_FLOWS_MAX, and
isManagedFlowStatusActive in the comment.

In `@src/utils/processUserInput/__tests__/processSlashCommand.test.ts`:
- Around line 71-73: Replace the inline stubbed module mock for bun:bundle (the
call to mock.module('bun:bundle', () => ({ feature: (name: string) => name ===
'KAIROS', }))) with the shared mock from tests/mocks: remove this local
mock.module declaration and import/require the repository-wide bun:bundle mock
so the test uses the centralized feature-flag behavior; ensure the test file
references the shared mock (same contract exposing feature(name: string))
instead of redefining the KAIROS predicate locally.

In `@tests/integration/autonomy-lifecycle-user-flow.test.ts`:
- Around line 22-48: The test helper runAutonomyCli currently asserts stderr and
exitCode without surfacing the stderr content on failure; update the assertions
in runAutonomyCli to include stderr (and optionally exitCode) in the failure
message — e.g., use expect(stderr).toBe('', `autonomy CLI stderr: ${stderr}`) or
expect(...).withContext if supported, and similarly include stdout/exitCode in
messages or console.error(stderr) on failure so CI logs show the error output
for debugging; locate these changes in the runAutonomyCli function and adjust
the two expect calls that reference stderr and exitCode.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In
`@packages/builtin-tools/src/tools/RemoteTriggerTool/__tests__/RemoteTriggerTool.test.ts`:
- Line 2: Update the shared test mock import to include the .ts extension: in
the test that imports authMock (symbol authMock in RemoteTriggerTool.test.ts),
change the import path from '../../../../../../tests/mocks/auth' to
'../../../../../../tests/mocks/auth.ts' so the shared test mock uses the .ts
extension per the test import rule.

In `@src/utils/handlePromptSubmit.ts`:
- Around line 461-468: The early return after processing queued autonomy
commands leaves the freshly published abortController installed, which can leak
stale cancellation state; before returning when commands.length === 0 in
handlePromptSubmit, call the code-path that clears or resets the published
abortController (the same place that published the fresh controller earlier) so
the global/posted abortController is set to null/cleared; update the block that
handles queuedAutonomyClaim (returned from
claimConsumableQueuedAutonomyCommands) to clear abortController (or call
resetAbortController) immediately prior to the return to ensure no stale
controller persists for the next turn.
- Around line 621-649: The catch block is turning a post-success finalizer error
into a run-level failure and double-finalizing claimedAutonomyCommands; change
the flow so finalizer errors do not overwrite a successful turn outcome: keep
the successful-path call that awaits finalizeAutonomyCommandsForTurn(...) and
enqueue nextCommands as-is, and in the catch only mark commands failed when the
exception came from the turn body (not from a separate finalizer call) —
implement this by moving the finalization call(s) into their own try/catch
(referencing claimedAutonomyCommands, finalizeAutonomyCommandsForTurn,
deferredAutonomyRunIds, enqueue, and the outer catch) and on finalizer errors
log/handle the error without re-invoking finalizeAutonomyCommandsForTurn with
outcome {type: 'failed'} for commands that were already finalized by the success
path.

In `@tests/mocks/auth.ts`:
- Around line 13-14: Update the mock implementations so they match the
production contract in src/utils/auth.ts: change
checkAndRefreshOAuthTokenIfNeeded to return a Promise<boolean> (e.g., resolve
true/false as appropriate for tests) and expand getClaudeAIOAuthTokens to return
the full token shape (include accessToken, refreshToken, scopes,
subscriptionType, expiresAt or expiresIn, and any other fields the real function
returns) so tests that branch on these values behave like production.

---

Outside diff comments:
In `@src/utils/processUserInput/processSlashCommand.tsx`:
- Around line 228-276: The post-success finalization (await
finalizeDeferredAutonomyRunCompleted()) can throw and currently bubbles to the
outer catch, causing a conflicting failed result; wrap the
finalizeDeferredAutonomyRunCompleted() call in its own try/catch so errors are
logged but not rethrown (do not call enqueueResult or
finalizeDeferredAutonomyRunFailed on that path). Modify the async IIFE success
path (after enqueueResult(...) and before/around
finalizeDeferredAutonomyRunCompleted()) to use: try { await
finalizeDeferredAutonomyRunCompleted(); } catch (e) { logError(e); } ensuring
the outer .catch only reflects actual run failures from the agent/runAgent
logic.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/utils/processUserInput/processSlashCommand.tsx`:
- Around line 277-283: The detached catch currently calls
finalizeDeferredAutonomyRunFailed(err) directly which can throw and cause an
unhandled rejection; wrap the call to finalizeDeferredAutonomyRunFailed(err)
inside its own try/catch, log any error locally (e.g., via logError) and avoid
rethrowing so the detached promise cannot reject, and keep the existing
enqueueResult(...) and logError(err) behavior intact; reference
finalizeDeferredAutonomyRunFailed, logError, enqueueResult, and commandName when
making this change.

---

Nitpick comments:
In `@src/utils/processUserInput/processSlashCommand.tsx`:
- Around line 358-365: The code is using forced casts like "as AssistantMessage"
even though earlier type checks on message.type and normalizedMsg.type already
narrow the union; remove these unnecessary casts and rely on the narrowed types
so the compiler enforces correct shapes—update occurrences around
getAssistantMessageContentLength(message as AssistantMessage),
createProgressMessage(message as AssistantMessage) and
createProgressMessage(normalizedMsg as AssistantMessage) to pass
message/normalizedMsg directly after the runtime checks, and if needed adjust
the signatures of getAssistantMessageContentLength and createProgressMessage (or
add proper type predicates) so they accept the union but benefit from TypeScript
narrowing in processSlashCommand.tsx.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/cli/print.ts`:
- Around line 2299-2331: The code currently treats any non-explicit-error path
from ask() as a completed turn; modify the ask() handling around
finalizeAutonomyCommandsForTurn and the loop that enqueues nextCommands to track
whether a terminal result was observed (e.g., a boolean seenTerminalResult
initialized before iterating ask()), set it true only when you actually receive
a terminal result, and on iterator/abort/early-close paths call
finalizeAutonomyCommandsForTurn with outcome type 'cancelled' or 'failed' (not
'completed') using claimedAutonomyCommands and
currentDir/cmd.workload/options.workload; ensure the existing enqueue(...) +
randomUUID() logic runs only when seenTerminalResult is true and map caught
exceptions to the failed outcome as already done.

---

Nitpick comments:
In `@tests/integration/autonomy-lifecycle-user-flow.test.ts`:
- Around line 5-14: Replace the deep relative imports with the project's
tsconfig path alias by updating the import statements that reference
resetStateForTests, setOriginalCwd, setProjectRoot, listAutonomyRuns,
startManagedAutonomyFlowFromHeartbeatTask, and listAutonomyFlows to use the
src/* alias (e.g., import { resetStateForTests, setOriginalCwd, setProjectRoot }
from 'src/bootstrap/state' and import the autonomy utilities from
'src/utils/autonomyRuns' and 'src/utils/autonomyFlows') so the module resolution
uses the configured path alias instead of ../../src/ deep relative paths.