@shenlee/devcrew 0.1.2 → 0.1.4

package/packages/core/src/lock.ts

@@ -0,0 +1,104 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+
+import { devcrewDir, repositoryLockPath } from "./paths.js";
+
+interface RepositoryLockMetadata {
+  ownerId: string;
+  pid: number;
+  createdAt: string;
+}
+
+function metadataPath(cwd: string): string {
+  return `${repositoryLockPath(cwd)}/lock.json`;
+}
+
+async function readMetadata(cwd: string): Promise<RepositoryLockMetadata | undefined> {
+  try {
+    const parsed = JSON.parse(await readFile(metadataPath(cwd), "utf8")) as Partial<RepositoryLockMetadata>;
+    const pid = parsed.pid;
+    if (
+      typeof parsed.ownerId !== "string" ||
+      typeof pid !== "number" ||
+      !Number.isInteger(pid) ||
+      typeof parsed.createdAt !== "string"
+    ) {
+      return undefined;
+    }
+    return {
+      ownerId: parsed.ownerId,
+      pid,
+      createdAt: parsed.createdAt,
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+function processIsLive(pid: number): boolean {
+  if (pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code === "EPERM";
+  }
+}
+
+async function releaseRepositoryLock(cwd: string, ownerId: string): Promise<void> {
+  const metadata = await readMetadata(cwd);
+  if (metadata?.ownerId === ownerId) {
+    await rm(repositoryLockPath(cwd), { recursive: true, force: true });
+  }
+}
+
+export async function withRepositoryLock<T>(cwd: string, action: () => Promise<T>): Promise<T> {
+  await mkdir(devcrewDir(cwd), { recursive: true });
+  const ownerId = randomUUID();
+  try {
+    await mkdir(repositoryLockPath(cwd));
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "EEXIST") {
+      throw error;
+    }
+    const metadata = await readMetadata(cwd);
+    if (metadata && processIsLive(metadata.pid)) {
+      throw new Error("A DevCrew operation is already in progress for this repository");
+    }
+    throw new Error("A stale DevCrew repository lock exists; use devcrew_recover for explicit recovery");
+  }
+
+  await writeFile(
+    metadataPath(cwd),
+    `${JSON.stringify({ ownerId, pid: process.pid, createdAt: new Date().toISOString() } satisfies RepositoryLockMetadata, null, 2)}\n`,
+    "utf8",
+  );
+  try {
+    return await action();
+  } finally {
+    await releaseRepositoryLock(cwd, ownerId);
+  }
+}
+
+export async function recoverRepositoryLock(cwd: string): Promise<boolean> {
+  const lockPath = repositoryLockPath(cwd);
+  const metadata = await readMetadata(cwd);
+  if (!metadata) {
+    try {
+      await rm(lockPath, { recursive: true, force: false });
+      return true;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+        return false;
+      }
+      throw error;
+    }
+  }
+  if (processIsLive(metadata.pid)) {
+    throw new Error("Cannot recover a DevCrew repository lock held by a live process");
+  }
+  await rm(lockPath, { recursive: true, force: true });
+  return true;
+}

package/packages/core/src/paths.ts

@@ -31,28 +31,33 @@ export function activeRunPath(cwd: string): string {
   return join(devcrewDir(cwd), "active-run.json");
 }
 
+export function repositoryLockPath(cwd: string): string {
+  return join(devcrewDir(cwd), "lock");
+}
+
 export function standardsPath(cwd: string): string {
   return join(devcrewDir(cwd), "standards.md");
 }
 
-export function docsRoot(cwd: string): string {
-  return join(cwd, "docs", "devcrew");
+export function docsRoot(cwd: string, artifactDirectory: string = "docs/devcrew"): string {
+  return join(cwd, artifactDirectory);
 }
 
-export function docsRunDir(cwd: string, runId: string): string {
-  return join(docsRoot(cwd), runId);
+export function docsRunDir(cwd: string, runId: string, artifactDirectory: string = "docs/devcrew"): string {
+  return join(docsRoot(cwd, artifactDirectory), runId);
 }
 
-export function artifactPath(cwd: string, runId: string, artifact: ArtifactName): string {
+export function artifactPath(cwd: string, runId: string, artifact: ArtifactName, artifactDirectory: string = "docs/devcrew"): string {
   const filenameByArtifact: Record<ArtifactName, string> = {
     requirements: "requirements.md",
     architecture: "architecture.md",
     "implementation-plan": "implementation-plan.md",
     "implementation-review": "implementation-review.md",
+    "architecture-review": "architecture-review.md",
     "test-report": "test-report.md",
     acceptance: "acceptance.md",
   };
-  return join(docsRunDir(cwd, runId), filenameByArtifact[artifact]);
+  return join(docsRunDir(cwd, runId, artifactDirectory), filenameByArtifact[artifact]);
 }
 
 export async function ensureRunDirectories(cwd: string, runId: string): Promise<void> {

package/packages/core/src/store.ts

@@ -2,7 +2,24 @@ import { readFile, rename, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 
 import { ensureRunDirectories, statePath } from "./paths.js";
-import type { RunState } from "./types.js";
+import { GATES, type GateName, type RoleResult, type RunState } from "./types.js";
+
+function enabledGatesFromState(value: unknown): GateName[] {
+  const configured = Array.isArray(value)
+    ? value.filter((gate): gate is GateName => typeof gate === "string" && GATES.includes(gate as GateName))
+    : [...GATES];
+  return [...new Set<GateName>([...configured, "implementation-review", "testing"])];
+}
+
+function roleResultsFromState(value: unknown): RoleResult[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((role): role is RoleResult => typeof role === "object" && role !== null).map((role) => ({
+    ...role,
+    format: role.format === "structured" ? "structured" : "legacy",
+  }));
+}
 
 export async function saveState(state: RunState): Promise<RunState> {
   state.updatedAt = new Date().toISOString();
@@ -18,18 +35,45 @@ export async function loadState(cwd: string, runId: string): Promise<RunState> {
   const raw = await readFile(statePath(cwd, runId), "utf8");
   const parsed = JSON.parse(raw) as RunState;
   const executionWorkspace = parsed.executionWorkspace;
+  const executionInstruction = parsed.executionInstruction;
+  const verificationWaiver = parsed.verificationWaiver;
   return {
     ...parsed,
     executionMode: parsed.executionMode ?? "plan",
+    executionPolicy: parsed.executionPolicy ?? "interactive-host",
+    roles: roleResultsFromState(parsed.roles),
+    enabledGates: enabledGatesFromState(parsed.enabledGates),
+    artifactDirectory: typeof parsed.artifactDirectory === "string" && parsed.artifactDirectory.trim().length > 0
+      ? parsed.artifactDirectory
+      : "docs/devcrew",
     executionWorkspace:
       executionWorkspace &&
       typeof executionWorkspace.path === "string" &&
       typeof executionWorkspace.baseCommit === "string"
         ? executionWorkspace
         : undefined,
+    executionInstruction:
+      executionInstruction &&
+      (executionInstruction.phase === "execution" || executionInstruction.phase === "testing") &&
+      typeof executionInstruction.workspacePath === "string" &&
+      typeof executionInstruction.instructions === "string" &&
+      typeof executionInstruction.createdAt === "string"
+        ? executionInstruction
+        : undefined,
     changedFiles: Array.isArray(parsed.changedFiles) ? parsed.changedFiles : [],
+    pendingQuestions: Array.isArray(parsed.pendingQuestions)
+      ? parsed.pendingQuestions.filter((question): question is string => typeof question === "string" && question.trim().length > 0)
+      : [],
     implementationDiff: typeof parsed.implementationDiff === "string" ? parsed.implementationDiff : "",
     verification: Array.isArray(parsed.verification) ? parsed.verification : [],
+    verificationStatus:
+      parsed.verificationStatus === "passed" || parsed.verificationStatus === "failed" ? parsed.verificationStatus : "not_run",
+    verificationWaiver:
+      verificationWaiver &&
+      typeof verificationWaiver.reason === "string" &&
+      typeof verificationWaiver.createdAt === "string"
+        ? verificationWaiver
+        : undefined,
     lintResults: Array.isArray(parsed.lintResults) ? parsed.lintResults : [],
   };
 }

package/packages/core/src/types.ts

@@ -1,5 +1,6 @@
 export const WORKFLOW_MODES = ["feature", "greenfield"] as const;
 export const EXECUTION_MODES = ["plan", "apply"] as const;
+export const EXECUTION_POLICIES = ["interactive-host", "headless-restricted", "headless-unattended"] as const;
 export const HOSTS = ["codex", "claude"] as const;
 export const BACKENDS = ["codex", "claude", "local"] as const;
 export const PHASES = [
@@ -7,35 +8,74 @@ export const PHASES = [
   "architecture",
   "implementation",
   "execution",
+  "review",
   "testing",
   "acceptance",
   "complete",
 ] as const;
-export const GATES = ["requirements", "architecture", "implementation", "testing"] as const;
+export const GATES = ["requirements", "architecture", "implementation", "implementation-review", "testing"] as const;
 export const ARTIFACTS = [
   "requirements",
   "architecture",
   "implementation-plan",
   "implementation-review",
+  "architecture-review",
   "test-report",
   "acceptance",
 ] as const;
 
 export type WorkflowMode = (typeof WORKFLOW_MODES)[number];
 export type ExecutionMode = (typeof EXECUTION_MODES)[number];
+export type ExecutionPolicy = (typeof EXECUTION_POLICIES)[number];
+export type VerificationStatus = "not_run" | "passed" | "failed";
+export type ArchitectureReviewDecision = "approved" | "changes_required";
 export type Host = (typeof HOSTS)[number];
 export type BackendName = (typeof BACKENDS)[number];
 export type Phase = (typeof PHASES)[number];
 export type GateName = (typeof GATES)[number];
 export type ArtifactName = (typeof ARTIFACTS)[number];
 export type GateStatus = "not_started" | "pending" | "approved" | "rejected";
-export type RunStatus = "ready" | "awaiting_input" | "awaiting_approval" | "complete";
+export type RunStatus = "ready" | "awaiting_input" | "awaiting_approval" | "awaiting_execution" | "complete" | "aborted";
 
 export interface RoleSection {
   heading: string;
   description: string;
 }
 
+export type RoleResultFormat = "legacy" | "structured";
+
+export interface CommandEvidence {
+  command: string;
+  exitCode: number;
+  output?: string;
+}
+
+export interface RoleQuestion {
+  id: string;
+  prompt: string;
+  context?: string;
+}
+
+export interface TestCaseEvidence {
+  id: string;
+  scenario: string;
+  type: "happy" | "edge" | "failure" | "regression";
+  expected: string;
+}
+
+export interface StructuredRoleData {
+  schemaVersion: 1;
+  role: "pm" | "architect" | "implementer" | "tester";
+  summary: string;
+  risks: string[];
+  evidence: CommandEvidence[];
+  questions?: RoleQuestion[];
+  decisions?: string[];
+  reviewDecision?: ArchitectureReviewDecision;
+  changedFiles?: string[];
+  testCases?: TestCaseEvidence[];
+}
+
 export const ROLE_SECTIONS: Record<Exclude<RoleResult["role"], "conductor">, RoleSection[]> = {
   pm: [
     { heading: "Functional Scope", description: "explicit In Scope and Out of Scope lists" },
@@ -88,6 +128,16 @@ export interface RoleResult {
   summary: string;
   markdown: string;
   usedFallback: boolean;
+  format: RoleResultFormat;
+  structured?: StructuredRoleData;
+  questions?: string[];
+  reviewDecision?: ArchitectureReviewDecision;
+}
+
+export interface ArchitectureReview {
+  decision: ArchitectureReviewDecision;
+  summary: string;
+  reviewedAt: string;
 }
 
 export interface WorkflowFeedback {
@@ -107,6 +157,16 @@ export interface WorkflowAnswer {
   createdAt: string;
 }
 
+export interface VerificationWaiver {
+  reason: string;
+  createdAt: string;
+}
+
+export interface RunAbort {
+  reason: string;
+  abortedAt: string;
+}
+
 // Reused for both verification and lint results — the command shape is identical.
 export interface VerificationResult {
   command: string;
@@ -121,6 +181,13 @@ export interface ExecutionWorkspace {
   baseCommit: string;
 }
 
+export interface ExecutionInstruction {
+  phase: "execution" | "testing";
+  workspacePath: string;
+  instructions: string;
+  createdAt: string;
+}
+
 export interface RunState {
   version: 1;
   runId: string;
@@ -128,7 +195,11 @@ export interface RunState {
   host: Host;
   mode: WorkflowMode;
   executionMode: ExecutionMode;
+  executionPolicy: ExecutionPolicy;
+  enabledGates: GateName[];
+  artifactDirectory: string;
   executionWorkspace?: ExecutionWorkspace;
+  executionInstruction?: ExecutionInstruction;
   backend: BackendName;
   request: string;
   phase: Phase;
@@ -138,6 +209,8 @@ export interface RunState {
   gates: Record<GateName, GateStatus>;
   artifacts: Partial<Record<ArtifactName, string>>;
   roles: RoleResult[];
+  architectureReview?: ArchitectureReview;
+  pendingQuestions: string[];
   answers: WorkflowAnswer[];
   approvals: WorkflowApproval[];
   feedback: WorkflowFeedback[];
@@ -145,6 +218,9 @@ export interface RunState {
   changedFiles: string[];
   implementationDiff: string;
   verification: VerificationResult[];
+  verificationStatus: VerificationStatus;
+  verificationWaiver?: VerificationWaiver;
+  abort?: RunAbort;
   // VerificationResult is reused for lint output — same shape, different semantics.
   lintResults: VerificationResult[];
 }
@@ -156,6 +232,7 @@ export interface StartWorkflowInput {
   request: string;
   backend?: BackendName;
   executionMode?: ExecutionMode;
+  executionPolicy?: ExecutionPolicy;
 }
 
 export interface RunRef {
@@ -177,6 +254,19 @@ export interface AnswerWorkflowInput extends RunRef {
   answer: string;
 }
 
+export interface WaiveVerificationInput extends RunRef {
+  reason: string;
+}
+
+export interface AbortWorkflowInput extends RunRef {
+  reason: string;
+}
+
+export interface CompleteExecutionInput extends RunRef {
+  summary: string;
+  verification?: VerificationResult[];
+}
+
 export interface ArtifactRef extends RunRef {
   name: ArtifactName;
 }

package/packages/core/src/validation.ts

@@ -2,12 +2,14 @@ import {
   ARTIFACTS,
   BACKENDS,
   EXECUTION_MODES,
+  EXECUTION_POLICIES,
   GATES,
   HOSTS,
   WORKFLOW_MODES,
   type ArtifactName,
   type BackendName,
   type ExecutionMode,
+  type ExecutionPolicy,
   type GateName,
   type Host,
   type WorkflowMode,
@@ -35,6 +37,10 @@ export function parseExecutionMode(value: unknown): ExecutionMode {
   return oneOf(value, "executionMode", EXECUTION_MODES);
 }
 
+export function parseExecutionPolicy(value: unknown): ExecutionPolicy {
+  return oneOf(value, "executionPolicy", EXECUTION_POLICIES);
+}
+
 export function parseHost(value: unknown): Host {
   return oneOf(value, "host", HOSTS);
 }
@@ -77,3 +83,7 @@ export function parseFeedback(value: unknown): string {
 export function parseAnswer(value: unknown): string {
   return assertString(value, "answer");
 }
+
+export function parseWaiverReason(value: unknown): string {
+  return assertString(value, "reason");
+}

package/packages/core/src/version.ts

@@ -1,2 +1,2 @@
-export const DEVCREW_VERSION = "0.1.2";
+export const DEVCREW_VERSION = "0.1.4";
 export const DEVCREW_NPM_PACKAGE = "@shenlee/devcrew";

package/packages/core/src/workflow.ts

@@ -10,16 +10,19 @@ import {
   parseBackend,
   parseCwd,
   parseExecutionMode,
+  parseExecutionPolicy,
   parseFeedback,
   parseGate,
   parseHost,
   parseOptionalNote,
   parseRequest,
   parseRunId,
+  parseWaiverReason,
   parseWorkflowMode,
 } from "./validation.js";
 import type {
   AnswerWorkflowInput,
+  AbortWorkflowInput,
   ApproveWorkflowInput,
   ArtifactName,
   ArtifactReadResult,
@@ -29,7 +32,9 @@ import type {
   RunRef,
   RunState,
   StartWorkflowInput,
+  WaiveVerificationInput,
 } from "./types.js";
+import { GATES } from "./types.js";
 
 function now(): string {
   return new Date().toISOString();
@@ -47,6 +52,8 @@ export function nextPhaseAfterGate(state: RunState, gate: GateName): RunState["p
       return "implementation";
     case "implementation":
       return state.executionMode === "apply" ? "execution" : "testing";
+    case "implementation-review":
+      return "testing";
     case "testing":
       return "acceptance";
   }
@@ -58,6 +65,7 @@ export function artifactForPhase(phase: RunState["phase"]): ArtifactName {
     architecture: "architecture",
     implementation: "implementation-plan",
     execution: "implementation-review",
+    review: "architecture-review",
     testing: "test-report",
     acceptance: "acceptance",
     complete: "acceptance",
@@ -65,15 +73,31 @@ export function artifactForPhase(phase: RunState["phase"]): ArtifactName {
   return artifactByPhase[phase];
 }
 
-export function gateForPhase(phase: RunState["phase"]): GateName | undefined {
-  if (phase === "requirements" || phase === "architecture" || phase === "implementation" || phase === "testing") {
-    return phase;
-  }
-  return undefined;
+export function gateForPhase(phase: RunState["phase"], enabledGates?: readonly GateName[]): GateName | undefined {
+  const gate = phase === "review"
+    ? "implementation-review"
+    : (
+    phase === "requirements" ||
+    phase === "architecture" ||
+    phase === "implementation" ||
+    phase === "testing"
+      ? phase
+      : undefined
+    );
+  return gate && (!enabledGates || enabledGates.includes(gate)) ? gate : undefined;
+}
+
+function configuredGates(gates: readonly GateName[]): GateName[] {
+  const configured = new Set(
+    gates.filter((gate): gate is GateName => GATES.includes(gate)),
+  );
+  configured.add("implementation-review");
+  configured.add("testing");
+  return [...configured];
 }
 
 function assertPendingCurrentGate(state: RunState, gate: GateName): void {
-  const expected = gateForPhase(state.phase);
+  const expected = gateForPhase(state.phase, state.enabledGates);
   if (expected !== gate) {
     throw new Error(
       expected
@@ -105,6 +129,8 @@ export async function startWorkflow(input: StartWorkflowInput, options: Workflow
   const config = await ensureConfig(cwd);
   const backend = input.backend ? parseBackend(input.backend) : config.defaultBackend === "host-preferred" ? host : config.defaultBackend;
   const executionMode = input.executionMode ? parseExecutionMode(input.executionMode) : config.executionMode;
+  const executionPolicy = input.executionPolicy ? parseExecutionPolicy(input.executionPolicy) : "interactive-host";
+  const enabledGates = configuredGates(config.workflow.gates);
   if (executionMode === "apply" && backend === "local") {
     throw new Error("DevCrew apply mode requires a codex or claude backend; local is plan-only");
   }
@@ -116,20 +142,25 @@ export async function startWorkflow(input: StartWorkflowInput, options: Workflow
     host,
     mode,
     executionMode,
+    executionPolicy,
+    enabledGates,
+    artifactDirectory: config.workflow.artifactDirectory,
     backend,
     request,
     phase: "requirements",
-    status: "awaiting_approval",
+    status: enabledGates.includes("requirements") ? "awaiting_approval" : "ready",
     createdAt,
     updatedAt: createdAt,
     gates: {
-      requirements: "pending",
+      requirements: enabledGates.includes("requirements") ? "pending" : "not_started",
       architecture: "not_started",
       implementation: "not_started",
+      "implementation-review": "not_started",
       testing: "not_started",
     },
     artifacts: {},
     roles: [],
+    pendingQuestions: [],
     answers: [],
     approvals: [],
     feedback: [],
@@ -137,6 +168,7 @@ export async function startWorkflow(input: StartWorkflowInput, options: Workflow
     changedFiles: [],
     implementationDiff: "",
     verification: [],
+    verificationStatus: "not_run",
     lintResults: [],
   };
 
@@ -152,7 +184,13 @@ export async function getWorkflowStatus(input: RunRef): Promise<RunState> {
 
 export async function continueWorkflow(input: RunRef): Promise<RunState> {
   const state = await getWorkflowStatus(input);
-  if (state.status === "awaiting_approval" || state.status === "awaiting_input" || state.status === "complete") {
+  if (
+    state.status === "awaiting_approval" ||
+    state.status === "awaiting_input" ||
+    state.status === "awaiting_execution" ||
+    state.status === "complete" ||
+    state.status === "aborted"
+  ) {
     return state;
   }
 
@@ -167,8 +205,14 @@ export async function continueWorkflow(input: RunRef): Promise<RunState> {
     throw new Error("DevCrew execution phase requires orchestrated continuation");
   }
 
-  const gate = gateForPhase(state.phase);
+  const configuredGate = gateForPhase(state.phase);
+  const gate = gateForPhase(state.phase, state.enabledGates);
   if (!gate) {
+    if (configuredGate) {
+      state.phase = nextPhaseAfterGate(state, configuredGate);
+      state.status = "ready";
+      return saveState(state);
+    }
     state.status = "complete";
     return saveState(state);
   }
@@ -178,6 +222,23 @@ export async function continueWorkflow(input: RunRef): Promise<RunState> {
   return saveState(state);
 }
 
+export async function abortWorkflow(input: AbortWorkflowInput): Promise<RunState> {
+  const state = await getWorkflowStatus(input);
+  if (state.status === "aborted") {
+    return state;
+  }
+  if (state.status === "complete") {
+    throw new Error("Completed DevCrew runs cannot be aborted");
+  }
+  state.abort = {
+    reason: parseWaiverReason(input.reason),
+    abortedAt: now(),
+  };
+  delete state.executionInstruction;
+  state.status = "aborted";
+  return saveState(state);
+}
+
 export async function validateWorkflowApproval(input: ApproveWorkflowInput): Promise<RunState> {
   const state = await getWorkflowStatus(input);
   const gate = parseGate(input.gate);
@@ -227,7 +288,16 @@ export async function rejectWorkflow(input: RejectWorkflowInput): Promise<RunSta
 
 export async function answerWorkflow(input: AnswerWorkflowInput, options: WorkflowMutationOptions = {}): Promise<RunState> {
   const state = await getWorkflowStatus(input);
-  const gate = gateForPhase(state.phase);
+  const gate = gateForPhase(state.phase, state.enabledGates);
+  if (state.status === "awaiting_input" && state.pendingQuestions.length > 0 && state.phase === "requirements") {
+    state.answers.push({
+      answer: parseAnswer(input.answer),
+      createdAt: now(),
+    });
+    state.pendingQuestions = [];
+    state.status = "ready";
+    return saveState(state);
+  }
   if (state.status !== "awaiting_input" || !gate || state.gates[gate] !== "rejected") {
     throw new Error("Workflow must be awaiting_input at a rejected current gate before recording an answer");
   }
@@ -243,6 +313,26 @@ export async function answerWorkflow(input: AnswerWorkflowInput, options: Workfl
   return saveState(state);
 }
 
+export async function waiveVerificationWorkflow(input: WaiveVerificationInput): Promise<RunState> {
+  const state = await getWorkflowStatus(input);
+  if (
+    state.executionMode !== "apply" ||
+    state.phase !== "testing" ||
+    state.status !== "awaiting_input" ||
+    state.gates.testing !== "rejected" ||
+    (state.verificationStatus !== "failed" && state.verificationStatus !== "not_run")
+  ) {
+    throw new Error("A verification waiver is only available after failed or missing apply-mode verification");
+  }
+  state.verificationWaiver = {
+    reason: parseWaiverReason(input.reason),
+    createdAt: now(),
+  };
+  state.gates.testing = "pending";
+  state.status = "awaiting_approval";
+  return saveState(state);
+}
+
 export async function getArtifact(input: ArtifactRef): Promise<ArtifactReadResult> {
   const state = await getWorkflowStatus(input);
   return readArtifact(state, parseArtifactName(input.name));