export function getStatusPluginLifecycleSource(): string[] {
  return [
    'async function handleLifecycleEvent(client, event, factoryID) {',
    '  const sessionID = event.properties?.sessionID;',
    '  const statusType = getStatusType(event);',
    '  const isResolutionEvent =',
    '    event.type === "permission.replied" ||',
    '    event.type === "question.replied" ||',
    '    event.type === "question.rejected";',
    '  if (isResolutionEvent) {',
    '    // Stored owners let replies clear blockers without waiting for SDK lookup.',
    '    const rootSessionID = clearAttentionForResolution(event, sessionID, factoryID);',
    '    if (rootSessionID) await publishOwnershipChange(factoryID, rootSessionID);',
    '    return;',
    '  }',
    '  const isAttentionEvent =',
    '    event.type === "permission.asked" ||',
    '    event.type === "question.asked";',
    '  // Without a session ID, attention cannot be retired by a matching reply/Idle.',
    '  if (isAttentionEvent && !sessionID) return;',
    '  const canFailOpen =',
    '    statusType === "busy" || statusType === "retry" || isAttentionEvent;',
    '  const rootSessionID = sessionID ? await resolveRootSessionID(client, sessionID) : null;',
    '  const childState = rootSessionID === null ? null : rootSessionID !== sessionID;',
    '  const isIdleEvent = event.type === "session.idle" || statusType === "idle";',
    '  const resolvedProvisionalBusy =',
    '    childState === false || (childState === true && isIdleEvent)',
    '      ? clearProvisionalBusy(sessionID, factoryID)',
    '      : false;',
    '  if (resolvedProvisionalBusy && childState === false) {',
    '    busyRootOwnerBySessionID.delete(sessionID);',
    '    busyRootOwnerBySessionID.set(sessionID, factoryID);',
    '  }',
    '  // Roll child blockers up to the pane while ignoring non-authoritative child lifecycle events.',
    '  if (childState === true && !isAttentionEvent) {',
    '    let attentionRootSessionID = null;',
    '    let childBusyChanged = false;',
    '    if (isIdleEvent) {',
    '      attentionRootSessionID = clearAttentionForSession(sessionID, factoryID);',
    '      childBusyChanged = clearBusyChild(sessionID, factoryID);',
    '    } else if (statusType === "busy" || statusType === "retry") {',
    '      childBusyChanged = rememberBusyChild(sessionID, rootSessionID, factoryID);',
    '    }',
    '    if (resolvedProvisionalBusy || attentionRootSessionID || childBusyChanged) {',
    '      await publishOwnershipChange(factoryID, attentionRootSessionID || rootSessionID);',
    '    }',
    '    return;',
    '  }',
    '  if (childState === null && !canFailOpen) {',
    '    if (isIdleEvent) {',
    '      // Stored ownership permits exact retirement during SDK outages without trusting unknown Idle.',
    '      const attentionRootSessionID = clearAttentionForSession(sessionID, factoryID);',
    '      const clearedProvisionalBusy = clearProvisionalBusy(sessionID, factoryID);',
    '      const clearedKnownBusyRoot = clearKnownBusyRoot(sessionID, factoryID);',
    '      // Retire exact child activity during SDK outages so Busy cannot remain pinned.',
    '      const clearedBusyChild = clearBusyChild(sessionID, factoryID);',
    '      if (',
    '        attentionRootSessionID ||',
    '        clearedProvisionalBusy ||',
    '        clearedKnownBusyRoot ||',
    '        clearedBusyChild',
    '      ) {',
    '        await publishOwnershipChange(factoryID, attentionRootSessionID || sessionID);',
    '      }',
    '    }',
    '    return;',
    '  }',
    '  if (childState === null && (statusType === "busy" || statusType === "retry")) {',
    '    // Keep unresolved Busy ownership provisional until matching Idle/disposal; blockers outrank it.',
    '    clearAttentionForSession(sessionID, factoryID);',
    '    rememberProvisionalBusy(sessionID, factoryID);',
    '    await publishAggregateStatus(factoryID, sessionID);',
    '    return;',
    '  }',
    '  if (event.type === "permission.asked" || event.type === "question.asked") {',
    '    stateArrivalRevision += 1;',
    '    // Queue attention with lifecycle delivery so delayed Busy cannot overwrite newer blockers.',
    '    const hookEventName =',
    '      event.type === "permission.asked" ? "PermissionRequest" : "AskUserQuestion";',
    '    // Display on the root while retaining child ownership for exact cleanup.',
    '    const properties = { ...(event.properties || {}), sessionID: rootSessionID || sessionID };',
    '    const requestID = properties.id || sessionID || "";',
    '    const key = attentionKey(factoryID, hookEventName, requestID, sessionID);',
    '    // Unresolved blockers are live authority; retire explicitly, never by cache eviction.',
    '    pendingAttentionByKey.set(key, {',
    '      hookEventName,',
    '      properties,',
    '      factoryID,',
    '      sourceSessionID: sessionID,',
    '    });',
    '    await publishAggregateStatus(factoryID, rootSessionID || sessionID);',
    '    return;',
    '  }',
    '  if (isIdleEvent) {',
    '    stateArrivalRevision += 1;',
    '    const idleKey = "idle:" + (sessionID || "");',
    '    // Deprecated idle follows canonical idle; preserve failed-post backoff.',
    '    if (',
    '      event.type === "session.idle" &&',
    '      desiredStatusKey === idleKey &&',
    '      statusDeliveryDirty &&',
    '      statusRetryTimer',
    '    ) return;',
    '    // Flush final reply previews before Idle so Done includes the completed text.',
    '    await flushPendingAssistantPart(true);',
    '    clearAttentionForTurnEnd(sessionID, factoryID);',
    '    if (busyRootOwnerBySessionID.get(sessionID) === factoryID) {',
    '      busyRootOwnerBySessionID.delete(sessionID);',
    '    }',
    '    await publishAggregateStatus(factoryID, sessionID);',
    '    return;',
    '  }',
    '  // Recoverable compaction errors can continue; canonical session.status decides completion.',
    '  if (event.type === "session.error") return;',
    '  if (statusType === "busy" || statusType === "retry") {',
    '    clearAttentionForSession(sessionID, factoryID);',
    '    busyRootOwnerBySessionID.delete(sessionID);',
    '    busyRootOwnerBySessionID.set(sessionID, factoryID);',
    '    await publishAggregateStatus(factoryID, sessionID);',
    '  }',
    '}',
    ''
  ]
}