@gajae-code/coding-agent 0.13.3 → 0.14.0

package/src/config/skill-settings-defaults.ts

@@ -4,21 +4,59 @@ export interface SkillDiscoverySettings {
 	enableCodexUser?: boolean;
 	enableClaudeUser?: boolean;
 	enableClaudeProject?: boolean;
+	/**
+	 * User-facing trust controls for filesystem-discovered skills. Discovery is
+	 * on by default: a valid skill placed in a documented project or user
+	 * location is loaded without extra configuration ceremony. Setting either of
+	 * these to `false` disables that scope while leaving the other scope (and
+	 * the `skills.enabled` master switch) intact.
+	 *
+	 * `enablePiUser` / `enablePiProject` are deprecated legacy aliases for the
+	 * same effective setting: an explicitly configured legacy value is honored
+	 * only when the corresponding trust flag is not configured.
+	 */
+	trustProjectSkills?: boolean;
+	trustUserSkills?: boolean;
+	/** @deprecated Legacy alias for `trustUserSkills`. */
 	enablePiUser?: boolean;
+	/** @deprecated Legacy alias for `trustProjectSkills`. */
 	enablePiProject?: boolean;
 	customDirectories?: string[];
 	ignoredSkills?: string[];
 	includeSkills?: string[];
 }
 
+/** Default trust for a skill scope when neither the trust flag nor its legacy alias is configured. */
+export const DEFAULT_SKILL_SCOPE_TRUST = true;
+
+/**
+ * Resolve whether a skill scope is trusted, honoring the user-facing trust flag
+ * first and the deprecated `enablePiUser` / `enablePiProject` aliases second.
+ *
+ * Because both settings are optional (`undefined` when unconfigured), an
+ * explicitly configured legacy value keeps working, and a fresh install with no
+ * configuration resolves to the zero-config default (`true`).
+ */
+export function resolveSkillScopeTrust(
+	settings: Pick<
+		SkillDiscoverySettings,
+		"trustProjectSkills" | "trustUserSkills" | "enablePiUser" | "enablePiProject"
+	>,
+	scope: "project" | "user",
+): boolean {
+	const trust = scope === "project" ? settings.trustProjectSkills : settings.trustUserSkills;
+	if (trust !== undefined) return trust;
+	const legacy = scope === "project" ? settings.enablePiProject : settings.enablePiUser;
+	if (legacy !== undefined) return legacy;
+	return DEFAULT_SKILL_SCOPE_TRUST;
+}
+
 export const DEFAULT_SKILL_DISCOVERY_SETTINGS: SkillDiscoverySettings = {
-	enabled: false,
+	enabled: true,
 	enableSkillCommands: true,
 	enableCodexUser: false,
 	enableClaudeUser: false,
 	enableClaudeProject: false,
-	enablePiUser: false,
-	enablePiProject: false,
 	customDirectories: [],
 	ignoredSkills: [],
 	includeSkills: [],

package/src/config/task-delegation.ts

@@ -0,0 +1,87 @@
+/**
+ * Vendor-separated delegation policy.
+ *
+ * A model profile that pins worker roles (`executor`, `planner`) to a provider
+ * other than the main `default` role exists to move heavy implementation onto
+ * that other provider's quota. That only pays off when the main agent actually
+ * delegates, and the strong delegation directive is gated behind `task.eager`,
+ * whose schema default is `false`. Such a layout therefore used to run
+ * everything on the main provider with no signal at all.
+ *
+ * Vendor separation now implies eager delegation unless `task.eager` is
+ * configured explicitly, in which case the user's value always wins.
+ */
+
+import type { ModelProfileDefinition, ModelProfileRole } from "./model-profiles";
+import { type ModelSelectorValue, normalizeModelSelectorValue } from "./model-selector-value";
+import type { Settings } from "./settings";
+
+/** Worker roles whose provider separation expresses delegation intent. */
+export const VENDOR_SEPARATION_WORKER_ROLES = ["executor", "planner"] as const satisfies readonly ModelProfileRole[];
+
+export type VendorSeparationWorkerRole = (typeof VENDOR_SEPARATION_WORKER_ROLES)[number];
+
+export type RoleSelectorMap = Partial<Record<ModelProfileRole, ModelSelectorValue>>;
+
+/**
+ * Provider of a role's primary selector. Bare aliases (`glm-5.2:medium`) resolve
+ * their provider at request time and are deliberately not treated as pinned.
+ */
+function primarySelectorProvider(value: ModelSelectorValue | undefined): string | undefined {
+	if (value === undefined) return undefined;
+	const [primary] = normalizeModelSelectorValue(value);
+	if (primary === undefined) return undefined;
+	const separator = primary.indexOf("/");
+	return separator > 0 ? primary.slice(0, separator) : undefined;
+}
+
+/** Worker roles pinned to a provider other than the `default` role's provider. */
+export function findVendorSeparatedWorkerRoles(mapping: RoleSelectorMap): VendorSeparationWorkerRole[] {
+	const defaultProvider = primarySelectorProvider(mapping.default);
+	if (defaultProvider === undefined) return [];
+	return VENDOR_SEPARATION_WORKER_ROLES.filter(role => {
+		const provider = primarySelectorProvider(mapping[role]);
+		return provider !== undefined && provider !== defaultProvider;
+	});
+}
+
+export interface EagerTaskDelegationInput {
+	settings: Settings;
+	/** Active profile, when its bindings are not (yet) installed into settings. */
+	profile?: ModelProfileDefinition;
+}
+
+/**
+ * Effective role selectors: profile mapping as the baseline, installed settings
+ * bindings on top, since profile activation writes into those same settings.
+ */
+export function collectEffectiveRoleSelectors(input: EagerTaskDelegationInput): RoleSelectorMap {
+	const mapping: RoleSelectorMap = { ...input.profile?.modelMapping };
+	const defaultRole = input.settings.getModelRole("default");
+	if (defaultRole !== undefined) mapping.default = defaultRole;
+	const agentModelOverrides = input.settings.get("task.agentModelOverrides");
+	for (const role of VENDOR_SEPARATION_WORKER_ROLES) {
+		const override = agentModelOverrides[role];
+		if (override !== undefined) mapping[role] = override;
+	}
+	return mapping;
+}
+
+export interface EagerTaskDelegation {
+	eagerTasks: boolean;
+	vendorSeparatedRoles: VendorSeparationWorkerRole[];
+	/** Vendor-separated workers that an explicit `task.eager false` keeps unused. */
+	suppressedByExplicitSetting: boolean;
+}
+
+export function resolveEagerTaskDelegation(input: EagerTaskDelegationInput): EagerTaskDelegation {
+	const configured = input.settings.get("task.eager");
+	const configuredExplicitly = input.settings.has("task.eager");
+	const vendorSeparatedRoles = findVendorSeparatedWorkerRoles(collectEffectiveRoleSelectors(input));
+	const eagerTasks = configured || (!configuredExplicitly && vendorSeparatedRoles.length > 0);
+	return {
+		eagerTasks,
+		vendorSeparatedRoles,
+		suppressedByExplicitSetting: !eagerTasks && vendorSeparatedRoles.length > 0,
+	};
+}

package/src/config/update-channel.ts

@@ -6,6 +6,8 @@
  * startup path in main.ts can resolve the channel without pulling in the
  * updater implementation.
  */
+import type { Settings } from "./settings";
+
 export const UPDATE_CHANNELS = ["stable", "nightly"] as const;
 export type UpdateChannel = (typeof UPDATE_CHANNELS)[number];
 
@@ -17,3 +19,24 @@ export function isUpdateChannel(value: string): value is UpdateChannel {
 export function distTagForChannel(channel: UpdateChannel): string {
 	return channel === "nightly" ? "nightly" : "latest";
 }
+
+/**
+ * Resolve the machine-local update channel: read the user/global layer only (a
+ * project `.gjc/config.yml` `startup.updateChannel` override must never pick
+ * the global release channel) and fall back to the stable schema default when
+ * the global value is unset or invalid. Used by both the `gjc update` command
+ * and the startup update check so a nightly notification can always be
+ * satisfied by the same default invocation.
+ */
+export function resolveMachineLocalUpdateChannel(settings: Settings): UpdateChannel {
+	const configured = settings.getGlobal("startup.updateChannel");
+	if (configured !== undefined && isUpdateChannel(configured)) return configured;
+	if (configured !== undefined) {
+		// A hand-edited invalid global value degrades to the schema default
+		// instead of leaking into output or the registry lookup.
+		process.stderr.write(
+			`Ignoring invalid startup.updateChannel "${configured}". Expected one of: ${UPDATE_CHANNELS.join(", ")}; using stable.\n`,
+		);
+	}
+	return "stable";
+}